spgxlog.h File Reference

#include "access/xlogreader.h"
#include "lib/stringinfo.h"
#include "storage/off.h"

Include dependency graph for spgxlog.h:

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

Go to the source code of this file.

Data Structures
struct	spgxlogState
struct	spgxlogAddLeaf
struct	spgxlogMoveLeafs
struct	spgxlogAddNode
struct	spgxlogSplitTuple
struct	spgxlogPickSplit
struct	spgxlogVacuumLeaf
struct	spgxlogVacuumRoot
struct	spgxlogVacuumRedirect

Macros
#define	XLOG_SPGIST_ADD_LEAF   0x10
#define	XLOG_SPGIST_MOVE_LEAFS   0x20
#define	XLOG_SPGIST_ADD_NODE   0x30
#define	XLOG_SPGIST_SPLIT_TUPLE   0x40
#define	XLOG_SPGIST_PICKSPLIT   0x50
#define	XLOG_SPGIST_VACUUM_LEAF   0x60
#define	XLOG_SPGIST_VACUUM_ROOT   0x70
#define	XLOG_SPGIST_VACUUM_REDIRECT   0x80
#define	SizeOfSpgxlogMoveLeafs   offsetof(spgxlogMoveLeafs, offsets)
#define	SizeOfSpgxlogPickSplit   offsetof(spgxlogPickSplit, offsets)
#define	SizeOfSpgxlogVacuumLeaf   offsetof(spgxlogVacuumLeaf, offsets)
#define	SizeOfSpgxlogVacuumRoot   offsetof(spgxlogVacuumRoot, offsets)
#define	SizeOfSpgxlogVacuumRedirect   offsetof(spgxlogVacuumRedirect, offsets)

Typedefs
typedef struct spgxlogState	spgxlogState
typedef struct spgxlogAddLeaf	spgxlogAddLeaf
typedef struct spgxlogMoveLeafs	spgxlogMoveLeafs
typedef struct spgxlogAddNode	spgxlogAddNode
typedef struct spgxlogSplitTuple	spgxlogSplitTuple
typedef struct spgxlogPickSplit	spgxlogPickSplit
typedef struct spgxlogVacuumLeaf	spgxlogVacuumLeaf
typedef struct spgxlogVacuumRoot	spgxlogVacuumRoot
typedef struct spgxlogVacuumRedirect	spgxlogVacuumRedirect

Functions
void	spg_redo (XLogReaderState *record)
void	spg_desc (StringInfo buf, XLogReaderState *record)
const char *	spg_identify (uint8 info)
void	spg_xlog_startup (void)
void	spg_xlog_cleanup (void)
void	spg_mask (char *pagedata, BlockNumber blkno)

Macro Definition Documentation

SizeOfSpgxlogMoveLeafs

#define SizeOfSpgxlogMoveLeafs   offsetof(spgxlogMoveLeafs, offsets)

Definition at line 91 of file spgxlog.h.

SizeOfSpgxlogPickSplit

#define SizeOfSpgxlogPickSplit   offsetof(spgxlogPickSplit, offsets)

Definition at line 199 of file spgxlog.h.

SizeOfSpgxlogVacuumLeaf

#define SizeOfSpgxlogVacuumLeaf   offsetof(spgxlogVacuumLeaf, offsets)

Definition at line 223 of file spgxlog.h.

SizeOfSpgxlogVacuumRedirect

#define SizeOfSpgxlogVacuumRedirect   offsetof(spgxlogVacuumRedirect, offsets)

Definition at line 248 of file spgxlog.h.

SizeOfSpgxlogVacuumRoot

#define SizeOfSpgxlogVacuumRoot   offsetof(spgxlogVacuumRoot, offsets)

Definition at line 236 of file spgxlog.h.

XLOG_SPGIST_ADD_LEAF

#define XLOG_SPGIST_ADD_LEAF   0x10

Definition at line 22 of file spgxlog.h.

XLOG_SPGIST_ADD_NODE

#define XLOG_SPGIST_ADD_NODE   0x30

Definition at line 24 of file spgxlog.h.

XLOG_SPGIST_MOVE_LEAFS

#define XLOG_SPGIST_MOVE_LEAFS   0x20

Definition at line 23 of file spgxlog.h.

XLOG_SPGIST_PICKSPLIT

#define XLOG_SPGIST_PICKSPLIT   0x50

Definition at line 26 of file spgxlog.h.

XLOG_SPGIST_SPLIT_TUPLE

#define XLOG_SPGIST_SPLIT_TUPLE   0x40

Definition at line 25 of file spgxlog.h.

XLOG_SPGIST_VACUUM_LEAF

#define XLOG_SPGIST_VACUUM_LEAF   0x60

Definition at line 27 of file spgxlog.h.

XLOG_SPGIST_VACUUM_REDIRECT

#define XLOG_SPGIST_VACUUM_REDIRECT   0x80

Definition at line 29 of file spgxlog.h.

XLOG_SPGIST_VACUUM_ROOT

#define XLOG_SPGIST_VACUUM_ROOT   0x70

Definition at line 28 of file spgxlog.h.

Typedef Documentation

spgxlogAddLeaf

typedef struct spgxlogAddLeaf spgxlogAddLeaf

spgxlogAddNode

typedef struct spgxlogAddNode spgxlogAddNode

spgxlogMoveLeafs

typedef struct spgxlogMoveLeafs spgxlogMoveLeafs

spgxlogPickSplit

typedef struct spgxlogPickSplit spgxlogPickSplit

spgxlogSplitTuple

typedef struct spgxlogSplitTuple spgxlogSplitTuple

spgxlogState

typedef struct spgxlogState spgxlogState

spgxlogVacuumLeaf

typedef struct spgxlogVacuumLeaf spgxlogVacuumLeaf

spgxlogVacuumRedirect

typedef struct spgxlogVacuumRedirect spgxlogVacuumRedirect

spgxlogVacuumRoot

typedef struct spgxlogVacuumRoot spgxlogVacuumRoot

Function Documentation

spg_desc()

void spg_desc	(	StringInfo	buf,
		XLogReaderState *	record
	)

Definition at line 20 of file spgdesc.c.

{
    char       *rec = XLogRecGetData(record);
    uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
 
    switch (info)
    {
        case XLOG_SPGIST_ADD_LEAF:
            {
                spgxlogAddLeaf *xlrec = (spgxlogAddLeaf *) rec;
 
                appendStringInfo(buf, "off: %u, headoff: %u, parentoff: %u, nodeI: %u",
                                 xlrec->offnumLeaf, xlrec->offnumHeadLeaf,
                                 xlrec->offnumParent, xlrec->nodeI);
                if (xlrec->newPage)
                    appendStringInfoString(buf, " (newpage)");
                if (xlrec->storesNulls)
                    appendStringInfoString(buf, " (nulls)");
            }
            break;
        case XLOG_SPGIST_MOVE_LEAFS:
            {
                spgxlogMoveLeafs *xlrec = (spgxlogMoveLeafs *) rec;
 
                appendStringInfo(buf, "nmoves: %u, parentoff: %u, nodeI: %u",
                                 xlrec->nMoves,
                                 xlrec->offnumParent, xlrec->nodeI);
                if (xlrec->newPage)
                    appendStringInfoString(buf, " (newpage)");
                if (xlrec->replaceDead)
                    appendStringInfoString(buf, " (replacedead)");
                if (xlrec->storesNulls)
                    appendStringInfoString(buf, " (nulls)");
            }
            break;
        case XLOG_SPGIST_ADD_NODE:
            {
                spgxlogAddNode *xlrec = (spgxlogAddNode *) rec;
 
                appendStringInfo(buf, "off: %u, newoff: %u, parentBlk: %d, "
                                 "parentoff: %u, nodeI: %u",
                                 xlrec->offnum,
                                 xlrec->offnumNew,
                                 xlrec->parentBlk,
                                 xlrec->offnumParent,
                                 xlrec->nodeI);
                if (xlrec->newPage)
                    appendStringInfoString(buf, " (newpage)");
            }
            break;
        case XLOG_SPGIST_SPLIT_TUPLE:
            {
                spgxlogSplitTuple *xlrec = (spgxlogSplitTuple *) rec;
 
                appendStringInfo(buf, "prefixoff: %u, postfixoff: %u",
                                 xlrec->offnumPrefix,
                                 xlrec->offnumPostfix);
                if (xlrec->newPage)
                    appendStringInfoString(buf, " (newpage)");
                if (xlrec->postfixBlkSame)
                    appendStringInfoString(buf, " (same)");
            }
            break;
        case XLOG_SPGIST_PICKSPLIT:
            {
                spgxlogPickSplit *xlrec = (spgxlogPickSplit *) rec;
 
                appendStringInfo(buf, "ndelete: %u, ninsert: %u, inneroff: %u, "
                                 "parentoff: %u, nodeI: %u",
                                 xlrec->nDelete, xlrec->nInsert,
                                 xlrec->offnumInner,
                                 xlrec->offnumParent, xlrec->nodeI);
                if (xlrec->innerIsParent)
                    appendStringInfoString(buf, " (innerIsParent)");
                if (xlrec->storesNulls)
                    appendStringInfoString(buf, " (nulls)");
                if (xlrec->isRootSplit)
                    appendStringInfoString(buf, " (isRootSplit)");
            }
            break;
        case XLOG_SPGIST_VACUUM_LEAF:
            {
                spgxlogVacuumLeaf *xlrec = (spgxlogVacuumLeaf *) rec;
 
                appendStringInfo(buf, "ndead: %u, nplaceholder: %u, nmove: %u, nchain: %u",
                                 xlrec->nDead, xlrec->nPlaceholder,
                                 xlrec->nMove, xlrec->nChain);
            }
            break;
        case XLOG_SPGIST_VACUUM_ROOT:
            {
                spgxlogVacuumRoot *xlrec = (spgxlogVacuumRoot *) rec;
 
                appendStringInfo(buf, "ndelete: %u",
                                 xlrec->nDelete);
            }
            break;
        case XLOG_SPGIST_VACUUM_REDIRECT:
            {
                spgxlogVacuumRedirect *xlrec = (spgxlogVacuumRedirect *) rec;
 
                appendStringInfo(buf, "ntoplaceholder: %u, firstplaceholder: %u, newestredirectxid: %u",
                                 xlrec->nToPlaceholder,
                                 xlrec->firstPlaceholder,
                                 xlrec->newestRedirectXid);
            }
            break;
    }
}

References appendStringInfo(), appendStringInfoString(), buf, spgxlogVacuumRedirect::firstPlaceholder, spgxlogPickSplit::innerIsParent, spgxlogPickSplit::isRootSplit, spgxlogVacuumLeaf::nChain, spgxlogVacuumLeaf::nDead, spgxlogPickSplit::nDelete, spgxlogVacuumRoot::nDelete, spgxlogVacuumRedirect::newestRedirectXid, spgxlogAddLeaf::newPage, spgxlogMoveLeafs::newPage, spgxlogAddNode::newPage, spgxlogSplitTuple::newPage, spgxlogPickSplit::nInsert, spgxlogVacuumLeaf::nMove, spgxlogMoveLeafs::nMoves, spgxlogAddLeaf::nodeI, spgxlogMoveLeafs::nodeI, spgxlogAddNode::nodeI, spgxlogPickSplit::nodeI, spgxlogVacuumLeaf::nPlaceholder, spgxlogVacuumRedirect::nToPlaceholder, spgxlogAddNode::offnum, spgxlogAddLeaf::offnumHeadLeaf, spgxlogPickSplit::offnumInner, spgxlogAddLeaf::offnumLeaf, spgxlogAddNode::offnumNew, spgxlogAddLeaf::offnumParent, spgxlogMoveLeafs::offnumParent, spgxlogAddNode::offnumParent, spgxlogPickSplit::offnumParent, spgxlogSplitTuple::offnumPostfix, spgxlogSplitTuple::offnumPrefix, spgxlogAddNode::parentBlk, spgxlogSplitTuple::postfixBlkSame, spgxlogMoveLeafs::replaceDead, spgxlogAddLeaf::storesNulls, spgxlogMoveLeafs::storesNulls, spgxlogPickSplit::storesNulls, XLOG_SPGIST_ADD_LEAF, XLOG_SPGIST_ADD_NODE, XLOG_SPGIST_MOVE_LEAFS, XLOG_SPGIST_PICKSPLIT, XLOG_SPGIST_SPLIT_TUPLE, XLOG_SPGIST_VACUUM_LEAF, XLOG_SPGIST_VACUUM_REDIRECT, XLOG_SPGIST_VACUUM_ROOT, XLogRecGetData, XLogRecGetInfo, and XLR_INFO_MASK.

spg_identify()

const char* spg_identify

(

uint8

info

)

Definition at line 131 of file spgdesc.c.

{
    const char *id = NULL;
 
    switch (info & ~XLR_INFO_MASK)
    {
        case XLOG_SPGIST_ADD_LEAF:
            id = "ADD_LEAF";
            break;
        case XLOG_SPGIST_MOVE_LEAFS:
            id = "MOVE_LEAFS";
            break;
        case XLOG_SPGIST_ADD_NODE:
            id = "ADD_NODE";
            break;
        case XLOG_SPGIST_SPLIT_TUPLE:
            id = "SPLIT_TUPLE";
            break;
        case XLOG_SPGIST_PICKSPLIT:
            id = "PICKSPLIT";
            break;
        case XLOG_SPGIST_VACUUM_LEAF:
            id = "VACUUM_LEAF";
            break;
        case XLOG_SPGIST_VACUUM_ROOT:
            id = "VACUUM_ROOT";
            break;
        case XLOG_SPGIST_VACUUM_REDIRECT:
            id = "VACUUM_REDIRECT";
            break;
    }
 
    return id;
}

References XLOG_SPGIST_ADD_LEAF, XLOG_SPGIST_ADD_NODE, XLOG_SPGIST_MOVE_LEAFS, XLOG_SPGIST_PICKSPLIT, XLOG_SPGIST_SPLIT_TUPLE, XLOG_SPGIST_VACUUM_LEAF, XLOG_SPGIST_VACUUM_REDIRECT, XLOG_SPGIST_VACUUM_ROOT, and XLR_INFO_MASK.

spg_mask()

void spg_mask	(	char *	pagedata,
		BlockNumber	blkno
	)

Definition at line 998 of file spgxlog.c.

{
    Page        page = (Page) pagedata;
    PageHeader  pagehdr = (PageHeader) page;
 
    mask_page_lsn_and_checksum(page);
 
    mask_page_hint_bits(page);
 
    /*
     * Mask the unused space, but only if the page's pd_lower appears to have
     * been set correctly.
     */
    if (pagehdr->pd_lower >= SizeOfPageHeaderData)
        mask_unused_space(page);
}

References mask_page_hint_bits(), mask_page_lsn_and_checksum(), mask_unused_space(), PageHeaderData::pd_lower, and SizeOfPageHeaderData.

spg_redo()

void spg_redo

(

XLogReaderState *

record

)

Definition at line 939 of file spgxlog.c.

{
    uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
    MemoryContext oldCxt;
 
    oldCxt = MemoryContextSwitchTo(opCtx);
    switch (info)
    {
        case XLOG_SPGIST_ADD_LEAF:
            spgRedoAddLeaf(record);
            break;
        case XLOG_SPGIST_MOVE_LEAFS:
            spgRedoMoveLeafs(record);
            break;
        case XLOG_SPGIST_ADD_NODE:
            spgRedoAddNode(record);
            break;
        case XLOG_SPGIST_SPLIT_TUPLE:
            spgRedoSplitTuple(record);
            break;
        case XLOG_SPGIST_PICKSPLIT:
            spgRedoPickSplit(record);
            break;
        case XLOG_SPGIST_VACUUM_LEAF:
            spgRedoVacuumLeaf(record);
            break;
        case XLOG_SPGIST_VACUUM_ROOT:
            spgRedoVacuumRoot(record);
            break;
        case XLOG_SPGIST_VACUUM_REDIRECT:
            spgRedoVacuumRedirect(record);
            break;
        default:
            elog(PANIC, "spg_redo: unknown op code %u", info);
    }
 
    MemoryContextSwitchTo(oldCxt);
    MemoryContextReset(opCtx);
}

References elog, MemoryContextReset(), MemoryContextSwitchTo(), opCtx, PANIC, spgRedoAddLeaf(), spgRedoAddNode(), spgRedoMoveLeafs(), spgRedoPickSplit(), spgRedoSplitTuple(), spgRedoVacuumLeaf(), spgRedoVacuumRedirect(), spgRedoVacuumRoot(), XLOG_SPGIST_ADD_LEAF, XLOG_SPGIST_ADD_NODE, XLOG_SPGIST_MOVE_LEAFS, XLOG_SPGIST_PICKSPLIT, XLOG_SPGIST_SPLIT_TUPLE, XLOG_SPGIST_VACUUM_LEAF, XLOG_SPGIST_VACUUM_REDIRECT, XLOG_SPGIST_VACUUM_ROOT, XLogRecGetInfo, and XLR_INFO_MASK.

spg_xlog_cleanup()

void spg_xlog_cleanup

(

void

)

Definition at line 988 of file spgxlog.c.

{
    MemoryContextDelete(opCtx);
    opCtx = NULL;
}

References MemoryContextDelete(), and opCtx.

spg_xlog_startup()

void spg_xlog_startup

(

void

)

Definition at line 980 of file spgxlog.c.

{
    opCtx = AllocSetContextCreate(CurrentMemoryContext,
                                  "SP-GiST temporary context",
                                  ALLOCSET_DEFAULT_SIZES);
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, CurrentMemoryContext, and opCtx.