260 lines
7.5 KiB
C
260 lines
7.5 KiB
C
/*-------------------------------------------------------------------------
|
|
*
|
|
* spgxlog.h
|
|
* xlog declarations for SP-GiST access method.
|
|
*
|
|
* Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
|
*
|
|
* src/include/access/spgxlog.h
|
|
*
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
#ifndef SPGXLOG_H
|
|
#define SPGXLOG_H
|
|
|
|
#include "access/xlogreader.h"
|
|
#include "lib/stringinfo.h"
|
|
#include "storage/off.h"
|
|
|
|
/* XLOG record types for SPGiST */
|
|
/* #define XLOG_SPGIST_CREATE_INDEX 0x00 */ /* not used anymore */
|
|
#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
|
|
|
|
/*
|
|
* Some redo functions need an SpGistState, although only a few of its fields
|
|
* need to be valid. spgxlogState carries the required info in xlog records.
|
|
* (See fillFakeState in spgxlog.c for more comments.)
|
|
*/
|
|
typedef struct spgxlogState
|
|
{
|
|
TransactionId myXid;
|
|
bool isBuild;
|
|
} spgxlogState;
|
|
|
|
/*
|
|
* Backup Blk 0: destination page for leaf tuple
|
|
* Backup Blk 1: parent page (if any)
|
|
*/
|
|
typedef struct spgxlogAddLeaf
|
|
{
|
|
bool newPage; /* init dest page? */
|
|
bool storesNulls; /* page is in the nulls tree? */
|
|
OffsetNumber offnumLeaf; /* offset where leaf tuple gets placed */
|
|
OffsetNumber offnumHeadLeaf; /* offset of head tuple in chain, if any */
|
|
|
|
OffsetNumber offnumParent; /* where the parent downlink is, if any */
|
|
uint16 nodeI;
|
|
|
|
/* new leaf tuple follows (unaligned!) */
|
|
} spgxlogAddLeaf;
|
|
|
|
/*
|
|
* Backup Blk 0: source leaf page
|
|
* Backup Blk 1: destination leaf page
|
|
* Backup Blk 2: parent page
|
|
*/
|
|
typedef struct spgxlogMoveLeafs
|
|
{
|
|
uint16 nMoves; /* number of tuples moved from source page */
|
|
bool newPage; /* init dest page? */
|
|
bool replaceDead; /* are we replacing a DEAD source tuple? */
|
|
bool storesNulls; /* pages are in the nulls tree? */
|
|
|
|
/* where the parent downlink is */
|
|
OffsetNumber offnumParent;
|
|
uint16 nodeI;
|
|
|
|
spgxlogState stateSrc;
|
|
|
|
/*----------
|
|
* data follows:
|
|
* array of deleted tuple numbers, length nMoves
|
|
* array of inserted tuple numbers, length nMoves + 1 or 1
|
|
* list of leaf tuples, length nMoves + 1 or 1 (unaligned!)
|
|
*
|
|
* Note: if replaceDead is true then there is only one inserted tuple
|
|
* number and only one leaf tuple in the data, because we are not copying
|
|
* the dead tuple from the source
|
|
*----------
|
|
*/
|
|
OffsetNumber offsets[FLEXIBLE_ARRAY_MEMBER];
|
|
} spgxlogMoveLeafs;
|
|
|
|
#define SizeOfSpgxlogMoveLeafs offsetof(spgxlogMoveLeafs, offsets)
|
|
|
|
/*
|
|
* Backup Blk 0: original page
|
|
* Backup Blk 1: where new tuple goes, if not same place
|
|
* Backup Blk 2: where parent downlink is, if updated and different from
|
|
* the old and new
|
|
*/
|
|
typedef struct spgxlogAddNode
|
|
{
|
|
/*
|
|
* Offset of the original inner tuple, in the original page (on backup
|
|
* block 0).
|
|
*/
|
|
OffsetNumber offnum;
|
|
|
|
/*
|
|
* Offset of the new tuple, on the new page (on backup block 1). Invalid,
|
|
* if we overwrote the old tuple in the original page).
|
|
*/
|
|
OffsetNumber offnumNew;
|
|
bool newPage; /* init new page? */
|
|
|
|
/*----
|
|
* Where is the parent downlink? parentBlk indicates which page it's on,
|
|
* and offnumParent is the offset within the page. The possible values for
|
|
* parentBlk are:
|
|
*
|
|
* 0: parent == original page
|
|
* 1: parent == new page
|
|
* 2: parent == different page (blk ref 2)
|
|
* -1: parent not updated
|
|
*----
|
|
*/
|
|
int8 parentBlk;
|
|
OffsetNumber offnumParent; /* offset within the parent page */
|
|
|
|
uint16 nodeI;
|
|
|
|
spgxlogState stateSrc;
|
|
|
|
/*
|
|
* updated inner tuple follows (unaligned!)
|
|
*/
|
|
} spgxlogAddNode;
|
|
|
|
/*
|
|
* Backup Blk 0: where the prefix tuple goes
|
|
* Backup Blk 1: where the postfix tuple goes (if different page)
|
|
*/
|
|
typedef struct spgxlogSplitTuple
|
|
{
|
|
/* where the prefix tuple goes */
|
|
OffsetNumber offnumPrefix;
|
|
|
|
/* where the postfix tuple goes */
|
|
OffsetNumber offnumPostfix;
|
|
bool newPage; /* need to init that page? */
|
|
bool postfixBlkSame; /* was postfix tuple put on same page as
|
|
* prefix? */
|
|
|
|
/*
|
|
* new prefix inner tuple follows, then new postfix inner tuple (both are
|
|
* unaligned!)
|
|
*/
|
|
} spgxlogSplitTuple;
|
|
|
|
/*
|
|
* Buffer references in the rdata array are:
|
|
* Backup Blk 0: Src page (only if not root)
|
|
* Backup Blk 1: Dest page (if used)
|
|
* Backup Blk 2: Inner page
|
|
* Backup Blk 3: Parent page (if any, and different from Inner)
|
|
*/
|
|
typedef struct spgxlogPickSplit
|
|
{
|
|
bool isRootSplit;
|
|
|
|
uint16 nDelete; /* n to delete from Src */
|
|
uint16 nInsert; /* n to insert on Src and/or Dest */
|
|
bool initSrc; /* re-init the Src page? */
|
|
bool initDest; /* re-init the Dest page? */
|
|
|
|
/* where to put new inner tuple */
|
|
OffsetNumber offnumInner;
|
|
bool initInner; /* re-init the Inner page? */
|
|
|
|
bool storesNulls; /* pages are in the nulls tree? */
|
|
|
|
/* where the parent downlink is, if any */
|
|
bool innerIsParent; /* is parent the same as inner page? */
|
|
OffsetNumber offnumParent;
|
|
uint16 nodeI;
|
|
|
|
spgxlogState stateSrc;
|
|
|
|
/*----------
|
|
* data follows:
|
|
* array of deleted tuple numbers, length nDelete
|
|
* array of inserted tuple numbers, length nInsert
|
|
* array of page selector bytes for inserted tuples, length nInsert
|
|
* new inner tuple (unaligned!)
|
|
* list of leaf tuples, length nInsert (unaligned!)
|
|
*----------
|
|
*/
|
|
OffsetNumber offsets[FLEXIBLE_ARRAY_MEMBER];
|
|
} spgxlogPickSplit;
|
|
|
|
#define SizeOfSpgxlogPickSplit offsetof(spgxlogPickSplit, offsets)
|
|
|
|
typedef struct spgxlogVacuumLeaf
|
|
{
|
|
uint16 nDead; /* number of tuples to become DEAD */
|
|
uint16 nPlaceholder; /* number of tuples to become PLACEHOLDER */
|
|
uint16 nMove; /* number of tuples to move */
|
|
uint16 nChain; /* number of tuples to re-chain */
|
|
|
|
spgxlogState stateSrc;
|
|
|
|
/*----------
|
|
* data follows:
|
|
* tuple numbers to become DEAD
|
|
* tuple numbers to become PLACEHOLDER
|
|
* tuple numbers to move from (and replace with PLACEHOLDER)
|
|
* tuple numbers to move to (replacing what is there)
|
|
* tuple numbers to update nextOffset links of
|
|
* tuple numbers to insert in nextOffset links
|
|
*----------
|
|
*/
|
|
OffsetNumber offsets[FLEXIBLE_ARRAY_MEMBER];
|
|
} spgxlogVacuumLeaf;
|
|
|
|
#define SizeOfSpgxlogVacuumLeaf offsetof(spgxlogVacuumLeaf, offsets)
|
|
|
|
typedef struct spgxlogVacuumRoot
|
|
{
|
|
/* vacuum a root page when it is also a leaf */
|
|
uint16 nDelete; /* number of tuples to delete */
|
|
|
|
spgxlogState stateSrc;
|
|
|
|
/* offsets of tuples to delete follow */
|
|
OffsetNumber offsets[FLEXIBLE_ARRAY_MEMBER];
|
|
} spgxlogVacuumRoot;
|
|
|
|
#define SizeOfSpgxlogVacuumRoot offsetof(spgxlogVacuumRoot, offsets)
|
|
|
|
typedef struct spgxlogVacuumRedirect
|
|
{
|
|
uint16 nToPlaceholder; /* number of redirects to make placeholders */
|
|
OffsetNumber firstPlaceholder; /* first placeholder tuple to remove */
|
|
TransactionId snapshotConflictHorizon; /* newest XID of removed redirects */
|
|
bool isCatalogRel; /* to handle recovery conflict during logical
|
|
* decoding on standby */
|
|
|
|
/* offsets of redirect tuples to make placeholders follow */
|
|
OffsetNumber offsets[FLEXIBLE_ARRAY_MEMBER];
|
|
} spgxlogVacuumRedirect;
|
|
|
|
#define SizeOfSpgxlogVacuumRedirect offsetof(spgxlogVacuumRedirect, offsets)
|
|
|
|
extern void spg_redo(XLogReaderState *record);
|
|
extern void spg_desc(StringInfo buf, XLogReaderState *record);
|
|
extern const char *spg_identify(uint8 info);
|
|
extern void spg_xlog_startup(void);
|
|
extern void spg_xlog_cleanup(void);
|
|
extern void spg_mask(char *pagedata, BlockNumber blkno);
|
|
|
|
#endif /* SPGXLOG_H */
|