/*------------------------------------------------------------------------- * * gist.h * The public API for GiST indexes. This API is exposed to * individuals implementing GiST indexes, so backward-incompatible * changes should be made with care. * * * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California * * src/include/access/gist.h * *------------------------------------------------------------------------- */ #ifndef GIST_H #define GIST_H #include "access/itup.h" #include "access/transam.h" #include "access/xlog.h" #include "access/xlogdefs.h" #include "storage/block.h" #include "storage/bufpage.h" #include "utils/relcache.h" /* * amproc indexes for GiST indexes. */ #define GIST_CONSISTENT_PROC 1 #define GIST_UNION_PROC 2 #define GIST_COMPRESS_PROC 3 #define GIST_DECOMPRESS_PROC 4 #define GIST_PENALTY_PROC 5 #define GIST_PICKSPLIT_PROC 6 #define GIST_EQUAL_PROC 7 #define GIST_DISTANCE_PROC 8 #define GIST_FETCH_PROC 9 #define GIST_OPTIONS_PROC 10 #define GIST_SORTSUPPORT_PROC 11 #define GISTNProcs 11 /* * Page opaque data in a GiST index page. */ #define F_LEAF (1 << 0) /* leaf page */ #define F_DELETED (1 << 1) /* the page has been deleted */ #define F_TUPLES_DELETED (1 << 2) /* some tuples on the page were * deleted */ #define F_FOLLOW_RIGHT (1 << 3) /* page to the right has no downlink */ #define F_HAS_GARBAGE (1 << 4) /* some tuples on the page are dead, * but not deleted yet */ /* * NSN (node sequence number) is a special-purpose LSN which is stored on each * index page in GISTPageOpaqueData and updated only during page splits. By * recording the parent's LSN in GISTSearchItem.parentlsn, it is possible to * detect concurrent child page splits by checking if parentlsn < child's NSN, * and handle them properly. The child page's LSN is insufficient for this * purpose since it is updated for every page change. */ typedef XLogRecPtr GistNSN; /* * A fake LSN / NSN value used during index builds. Must be smaller than any * real or fake (unlogged) LSN generated after the index build completes so * that all splits are considered complete. */ #define GistBuildLSN ((XLogRecPtr) 1) /* * For on-disk compatibility with pre-9.3 servers, NSN is stored as two * 32-bit fields on disk, same as LSNs. */ typedef PageXLogRecPtr PageGistNSN; typedef struct GISTPageOpaqueData { PageGistNSN nsn; /* this value must change on page split */ BlockNumber rightlink; /* next page if any */ uint16 flags; /* see bit definitions above */ uint16 gist_page_id; /* for identification of GiST indexes */ } GISTPageOpaqueData; typedef GISTPageOpaqueData *GISTPageOpaque; /* * Maximum possible sizes for GiST index tuple and index key. Calculation is * based on assumption that GiST page should fit at least 4 tuples. In theory, * GiST index can be functional when page can fit 3 tuples. But that seems * rather inefficient, so we use a bit conservative estimate. * * The maximum size of index key is true for unicolumn index. Therefore, this * estimation should be used to figure out which maximum size of GiST index key * makes sense at all. For multicolumn indexes, user might be able to tune * key size using opclass parameters. */ #define GISTMaxIndexTupleSize \ MAXALIGN_DOWN((BLCKSZ - SizeOfPageHeaderData - sizeof(GISTPageOpaqueData)) / \ 4 - sizeof(ItemIdData)) #define GISTMaxIndexKeySize \ (GISTMaxIndexTupleSize - MAXALIGN(sizeof(IndexTupleData))) /* * The page ID is for the convenience of pg_filedump and similar utilities, * which otherwise would have a hard time telling pages of different index * types apart. It should be the last 2 bytes on the page. This is more or * less "free" due to alignment considerations. */ #define GIST_PAGE_ID 0xFF81 /* * This is the Split Vector to be returned by the PickSplit method. * PickSplit should fill the indexes of tuples to go to the left side into * spl_left[], and those to go to the right into spl_right[] (note the method * is responsible for palloc'ing both of these arrays!). The tuple counts * go into spl_nleft/spl_nright, and spl_ldatum/spl_rdatum must be set to * the union keys for each side. * * If spl_ldatum_exists and spl_rdatum_exists are true, then we are performing * a "secondary split" using a non-first index column. In this case some * decisions have already been made about a page split, and the set of tuples * being passed to PickSplit is just the tuples about which we are undecided. * spl_ldatum/spl_rdatum then contain the union keys for the tuples already * chosen to go left or right. Ideally the PickSplit method should take those * keys into account while deciding what to do with the remaining tuples, ie * it should try to "build out" from those unions so as to minimally expand * them. If it does so, it should union the given tuples' keys into the * existing spl_ldatum/spl_rdatum values rather than just setting those values * from scratch, and then set spl_ldatum_exists/spl_rdatum_exists to false to * show it has done this. * * If the PickSplit method fails to clear spl_ldatum_exists/spl_rdatum_exists, * the core GiST code will make its own decision about how to merge the * secondary-split results with the previously-chosen tuples, and will then * recompute the union keys from scratch. This is a workable though often not * optimal approach. */ typedef struct GIST_SPLITVEC { OffsetNumber *spl_left; /* array of entries that go left */ int spl_nleft; /* size of this array */ Datum spl_ldatum; /* Union of keys in spl_left */ bool spl_ldatum_exists; /* true, if spl_ldatum already exists. */ OffsetNumber *spl_right; /* array of entries that go right */ int spl_nright; /* size of the array */ Datum spl_rdatum; /* Union of keys in spl_right */ bool spl_rdatum_exists; /* true, if spl_rdatum already exists. */ } GIST_SPLITVEC; /* * An entry on a GiST node. Contains the key, as well as its own * location (rel,page,offset) which can supply the matching pointer. * leafkey is a flag to tell us if the entry is in a leaf node. */ typedef struct GISTENTRY { Datum key; Relation rel; Page page; OffsetNumber offset; bool leafkey; } GISTENTRY; #define GistPageGetOpaque(page) ( (GISTPageOpaque) PageGetSpecialPointer(page) ) #define GistPageIsLeaf(page) ( GistPageGetOpaque(page)->flags & F_LEAF) #define GIST_LEAF(entry) (GistPageIsLeaf((entry)->page)) #define GistPageIsDeleted(page) ( GistPageGetOpaque(page)->flags & F_DELETED) #define GistTuplesDeleted(page) ( GistPageGetOpaque(page)->flags & F_TUPLES_DELETED) #define GistMarkTuplesDeleted(page) ( GistPageGetOpaque(page)->flags |= F_TUPLES_DELETED) #define GistClearTuplesDeleted(page) ( GistPageGetOpaque(page)->flags &= ~F_TUPLES_DELETED) #define GistPageHasGarbage(page) ( GistPageGetOpaque(page)->flags & F_HAS_GARBAGE) #define GistMarkPageHasGarbage(page) ( GistPageGetOpaque(page)->flags |= F_HAS_GARBAGE) #define GistClearPageHasGarbage(page) ( GistPageGetOpaque(page)->flags &= ~F_HAS_GARBAGE) #define GistFollowRight(page) ( GistPageGetOpaque(page)->flags & F_FOLLOW_RIGHT) #define GistMarkFollowRight(page) ( GistPageGetOpaque(page)->flags |= F_FOLLOW_RIGHT) #define GistClearFollowRight(page) ( GistPageGetOpaque(page)->flags &= ~F_FOLLOW_RIGHT) #define GistPageGetNSN(page) ( PageXLogRecPtrGet(GistPageGetOpaque(page)->nsn)) #define GistPageSetNSN(page, val) ( PageXLogRecPtrSet(GistPageGetOpaque(page)->nsn, val)) /* * On a deleted page, we store this struct. A deleted page doesn't contain any * tuples, so we don't use the normal page layout with line pointers. Instead, * this struct is stored right after the standard page header. pd_lower points * to the end of this struct. If we add fields to this struct in the future, we * can distinguish the old and new formats by pd_lower. */ typedef struct GISTDeletedPageContents { /* last xid which could see the page in a scan */ FullTransactionId deleteXid; } GISTDeletedPageContents; static inline void GistPageSetDeleted(Page page, FullTransactionId deletexid) { Assert(PageIsEmpty(page)); GistPageGetOpaque(page)->flags |= F_DELETED; ((PageHeader) page)->pd_lower = MAXALIGN(SizeOfPageHeaderData) + sizeof(GISTDeletedPageContents); ((GISTDeletedPageContents *) PageGetContents(page))->deleteXid = deletexid; } static inline FullTransactionId GistPageGetDeleteXid(Page page) { Assert(GistPageIsDeleted(page)); /* Is the deleteXid field present? */ if (((PageHeader) page)->pd_lower >= MAXALIGN(SizeOfPageHeaderData) + offsetof(GISTDeletedPageContents, deleteXid) + sizeof(FullTransactionId)) { return ((GISTDeletedPageContents *) PageGetContents(page))->deleteXid; } else return FullTransactionIdFromEpochAndXid(0, FirstNormalTransactionId); } /* * Vector of GISTENTRY structs; user-defined methods union and picksplit * take it as one of their arguments */ typedef struct { int32 n; /* number of elements */ GISTENTRY vector[FLEXIBLE_ARRAY_MEMBER]; } GistEntryVector; #define GEVHDRSZ (offsetof(GistEntryVector, vector)) /* * macro to initialize a GISTENTRY */ #define gistentryinit(e, k, r, pg, o, l) \ do { (e).key = (k); (e).rel = (r); (e).page = (pg); \ (e).offset = (o); (e).leafkey = (l); } while (0) #endif /* GIST_H */