PostgreSQL Source Code git master
Data Structures | Macros | Typedefs | Functions
spgist_private.h File Reference
#include "access/itup.h"
#include "access/spgist.h"
#include "catalog/pg_am_d.h"
#include "nodes/tidbitmap.h"
#include "storage/buf.h"
#include "utils/geo_decls.h"
#include "utils/relcache.h"
Include dependency graph for spgist_private.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct   SpGistOptions
 
struct   SpGistPageOpaqueData
 
struct   SpGistLastUsedPage
 
struct   SpGistLUPCache
 
struct   SpGistMetaPageData
 
struct   SpGistTypeDesc
 
struct   SpGistState
 
struct   SpGistSearchItem
 
struct   SpGistScanOpaqueData
 
struct   SpGistCache
 
struct   SpGistInnerTupleData
 
struct   SpGistLeafTupleData
 
struct   SpGistDeadTupleData
 

Macros

#define  SpGistGetFillFactor(relation)
 
#define  SpGistGetTargetPageFreeSpace(relation)    (BLCKSZ * (100 - SpGistGetFillFactor(relation)) / 100)
 
#define  spgKeyColumn   0
 
#define  spgFirstIncludeColumn   1
 
#define  SPGIST_METAPAGE_BLKNO   (0) /* metapage */
 
#define  SPGIST_ROOT_BLKNO   (1) /* root for normal entries */
 
#define  SPGIST_NULL_BLKNO   (2) /* root for null-value entries */
 
#define  SPGIST_LAST_FIXED_BLKNO   SPGIST_NULL_BLKNO
 
#define  SpGistBlockIsRoot(blkno)    ((blkno) == SPGIST_ROOT_BLKNO || (blkno) == SPGIST_NULL_BLKNO)
 
#define  SpGistBlockIsFixed(blkno)    ((BlockNumber) (blkno) <= (BlockNumber) SPGIST_LAST_FIXED_BLKNO)
 
#define  SPGIST_META   (1<<0)
 
#define  SPGIST_DELETED
 
#define  SPGIST_LEAF   (1<<2)
 
#define  SPGIST_NULLS   (1<<3)
 
#define  SpGistPageGetOpaque(page)   ((SpGistPageOpaque) PageGetSpecialPointer(page))
 
#define  SpGistPageIsMeta(page)   (SpGistPageGetOpaque(page)->flags & SPGIST_META)
 
#define  SpGistPageIsDeleted(page)   (SpGistPageGetOpaque(page)->flags & SPGIST_DELETED)
 
#define  SpGistPageIsLeaf(page)   (SpGistPageGetOpaque(page)->flags & SPGIST_LEAF)
 
#define  SpGistPageStoresNulls(page)   (SpGistPageGetOpaque(page)->flags & SPGIST_NULLS)
 
#define  SPGIST_PAGE_ID   0xFF82
 
#define  SPGIST_CACHED_PAGES   8
 
#define  SPGIST_MAGIC_NUMBER   (0xBA0BABEE)
 
#define  SpGistPageGetMeta(p)    ((SpGistMetaPageData *) PageGetContents(p))
 
#define  SizeOfSpGistSearchItem(n_distances)    (offsetof(SpGistSearchItem, distances) + sizeof(double) * (n_distances))
 
#define  SPGIST_LIVE   0 /* normal live tuple (either inner or leaf) */
 
#define  SPGIST_REDIRECT   1 /* temporary redirection placeholder */
 
#define  SPGIST_DEAD   2 /* dead, cannot be removed because of links */
 
#define  SPGIST_PLACEHOLDER   3 /* placeholder, used to preserve offsets */
 
#define  SGITMAXNNODES   0x1FFF
 
#define  SGITMAXPREFIXSIZE   0xFFFF
 
#define  SGITMAXSIZE   0xFFFF
 
#define  SGITHDRSZ   MAXALIGN(sizeof(SpGistInnerTupleData))
 
#define  _SGITDATA(x)   (((char *) (x)) + SGITHDRSZ)
 
#define  SGITDATAPTR(x)   ((x)->prefixSize ? _SGITDATA(x) : NULL)
 
#define  SGITDATUM(x, s)
 
#define  SGITNODEPTR(x)   ((SpGistNodeTuple) (_SGITDATA(x) + (x)->prefixSize))
 
#define  SGITITERATE(x, i, nt)
 
#define  SGNTHDRSZ   MAXALIGN(sizeof(SpGistNodeTupleData))
 
#define  SGNTDATAPTR(x)   (((char *) (x)) + SGNTHDRSZ)
 
#define  SGNTDATUM(x, s)
 
#define  SGLT_GET_NEXTOFFSET(spgLeafTuple)    ((spgLeafTuple)->t_info & 0x3FFF)
 
#define  SGLT_GET_HASNULLMASK(spgLeafTuple)    (((spgLeafTuple)->t_info & 0x8000) ? true : false)
 
#define  SGLT_SET_NEXTOFFSET(spgLeafTuple, offsetNumber)
 
#define  SGLT_SET_HASNULLMASK(spgLeafTuple, hasnulls)
 
#define  SGLTHDRSZ(hasnulls)
 
#define  SGLTDATAPTR(x)   (((char *) (x)) + SGLTHDRSZ(SGLT_GET_HASNULLMASK(x)))
 
#define  SGLTDATUM(x, s)
 
#define  SGDTSIZE   MAXALIGN(sizeof(SpGistDeadTupleData))
 
#define  SPGIST_PAGE_CAPACITY
 
#define  SpGistPageGetFreeSpace(p, n)
 
#define  STORE_STATE(s, d)
 
#define  GBUF_LEAF   0x03
 
#define  GBUF_INNER_PARITY(x)   ((x) % 3)
 
#define  GBUF_NULLS   0x04
 
#define  GBUF_PARITY_MASK   0x03
 
#define  GBUF_REQ_LEAF(flags)   (((flags) & GBUF_PARITY_MASK) == GBUF_LEAF)
 
#define  GBUF_REQ_NULLS(flags)   ((flags) & GBUF_NULLS)
 
#define  SPGIST_MIN_FILLFACTOR   10
 
#define  SPGIST_DEFAULT_FILLFACTOR   80
 

Typedefs

typedef struct SpGistOptions  SpGistOptions
 
typedef struct SpGistPageOpaqueData  SpGistPageOpaqueData
 
typedef SpGistPageOpaqueData *  SpGistPageOpaque
 
typedef struct SpGistLastUsedPage  SpGistLastUsedPage
 
typedef struct SpGistLUPCache  SpGistLUPCache
 
typedef struct SpGistMetaPageData  SpGistMetaPageData
 
typedef struct SpGistLeafTupleData *  SpGistLeafTuple
 
typedef struct SpGistTypeDesc  SpGistTypeDesc
 
typedef struct SpGistState  SpGistState
 
typedef struct SpGistSearchItem  SpGistSearchItem
 
typedef struct SpGistScanOpaqueData  SpGistScanOpaqueData
 
typedef SpGistScanOpaqueData *  SpGistScanOpaque
 
typedef struct SpGistCache  SpGistCache
 
typedef struct SpGistInnerTupleData  SpGistInnerTupleData
 
typedef SpGistInnerTupleData *  SpGistInnerTuple
 
typedef IndexTupleData  SpGistNodeTupleData
 
typedef SpGistNodeTupleData *  SpGistNodeTuple
 
typedef struct SpGistLeafTupleData  SpGistLeafTupleData
 
typedef struct SpGistDeadTupleData  SpGistDeadTupleData
 
typedef SpGistDeadTupleData *  SpGistDeadTuple
 

Functions

SpGistCache *  spgGetCache (Relation index)
 
TupleDesc  getSpGistTupleDesc (Relation index, SpGistTypeDesc *keyType)
 
void  initSpGistState (SpGistState *state, Relation index)
 
Buffer  SpGistNewBuffer (Relation index)
 
void  SpGistUpdateMetaPage (Relation index)
 
Buffer  SpGistGetBuffer (Relation index, int flags, int needSpace, bool *isNew)
 
void  SpGistSetLastUsedPage (Relation index, Buffer buffer)
 
void  SpGistInitPage (Page page, uint16 f)
 
void  SpGistInitBuffer (Buffer b, uint16 f)
 
void  SpGistInitMetapage (Page page)
 
unsigned int  SpGistGetInnerTypeSize (SpGistTypeDesc *att, Datum datum)
 
Size  SpGistGetLeafTupleSize (TupleDesc tupleDescriptor, const Datum *datums, const bool *isnulls)
 
SpGistLeafTuple  spgFormLeafTuple (SpGistState *state, ItemPointer heapPtr, const Datum *datums, const bool *isnulls)
 
SpGistNodeTuple  spgFormNodeTuple (SpGistState *state, Datum label, bool isnull)
 
SpGistInnerTuple  spgFormInnerTuple (SpGistState *state, bool hasPrefix, Datum prefix, int nNodes, SpGistNodeTuple *nodes)
 
SpGistDeadTuple  spgFormDeadTuple (SpGistState *state, int tupstate, BlockNumber blkno, OffsetNumber offnum)
 
void  spgDeformLeafTuple (SpGistLeafTuple tup, TupleDesc tupleDescriptor, Datum *datums, bool *isnulls, bool keyColumnIsNull)
 
Datum *  spgExtractNodeLabels (SpGistState *state, SpGistInnerTuple innerTuple)
 
OffsetNumber  SpGistPageAddNewItem (SpGistState *state, Page page, Item item, Size size, OffsetNumber *startOffset, bool errorOK)
 
bool  spgproperty (Oid index_oid, int attno, IndexAMProperty prop, const char *propname, bool *res, bool *isnull)
 
void  spgUpdateNodeLink (SpGistInnerTuple tup, int nodeN, BlockNumber blkno, OffsetNumber offset)
 
void  spgPageIndexMultiDelete (SpGistState *state, Page page, OffsetNumber *itemnos, int nitems, int firststate, int reststate, BlockNumber blkno, OffsetNumber offnum)
 
bool  spgdoinsert (Relation index, SpGistState *state, ItemPointer heapPtr, Datum *datums, bool *isnulls)
 
double *  spg_key_orderbys_distances (Datum key, bool isLeaf, ScanKey orderbys, int norderbys)
 
BOX *  box_copy (BOX *orig)
 

Macro Definition Documentation

◆ _SGITDATA

#define _SGITDATA (   x )    (((char *) (x)) + SGITHDRSZ)

Definition at line 313 of file spgist_private.h.

◆ GBUF_INNER_PARITY

#define GBUF_INNER_PARITY (   x )    ((x) % 3)

Definition at line 485 of file spgist_private.h.

◆ GBUF_LEAF

#define GBUF_LEAF   0x03

Definition at line 484 of file spgist_private.h.

◆ GBUF_NULLS

#define GBUF_NULLS   0x04

Definition at line 486 of file spgist_private.h.

◆ GBUF_PARITY_MASK

#define GBUF_PARITY_MASK   0x03

Definition at line 488 of file spgist_private.h.

◆ GBUF_REQ_LEAF

#define GBUF_REQ_LEAF (   flags )    (((flags) & GBUF_PARITY_MASK) == GBUF_LEAF)

Definition at line 489 of file spgist_private.h.

◆ GBUF_REQ_NULLS

#define GBUF_REQ_NULLS (   flags )    ((flags) & GBUF_NULLS)

Definition at line 490 of file spgist_private.h.

◆ SGDTSIZE

#define SGDTSIZE   MAXALIGN(sizeof(SpGistDeadTupleData))

Definition at line 439 of file spgist_private.h.

◆ SGITDATAPTR

#define SGITDATAPTR (   x )    ((x)->prefixSize ? _SGITDATA(x) : NULL)

Definition at line 314 of file spgist_private.h.

◆ SGITDATUM

#define SGITDATUM (   x,
  s 
)
Value:
((x)->prefixSize ? \
((s)->attPrefixType.attbyval ? \
*(Datum *) _SGITDATA(x) : \
PointerGetDatum(_SGITDATA(x))) \
: (Datum) 0)
x
int x
Definition: isn.c:75
uint64_t Datum
Definition: postgres.h:70
#define _SGITDATA(x)

Definition at line 315 of file spgist_private.h.

◆ SGITHDRSZ

#define SGITHDRSZ   MAXALIGN(sizeof(SpGistInnerTupleData))

Definition at line 312 of file spgist_private.h.

◆ SGITITERATE

#define SGITITERATE (   x,
  i,
  nt 
)
Value:
for ((i) = 0, (nt) = SGITNODEPTR(x); \
(i) < (x)->nNodes; \
(i)++, (nt) = (SpGistNodeTuple) (((char *) (nt)) + IndexTupleSize(nt)))
i
int i
Definition: isn.c:77
static Size IndexTupleSize(const IndexTupleData *itup)
Definition: itup.h:71
SpGistNodeTupleData * SpGistNodeTuple
#define SGITNODEPTR(x)

Definition at line 323 of file spgist_private.h.

◆ SGITMAXNNODES

#define SGITMAXNNODES   0x1FFF

Definition at line 308 of file spgist_private.h.

◆ SGITMAXPREFIXSIZE

#define SGITMAXPREFIXSIZE   0xFFFF

Definition at line 309 of file spgist_private.h.

◆ SGITMAXSIZE

#define SGITMAXSIZE   0xFFFF

Definition at line 310 of file spgist_private.h.

◆ SGITNODEPTR

#define SGITNODEPTR (   x )    ((SpGistNodeTuple) (_SGITDATA(x) + (x)->prefixSize))

Definition at line 320 of file spgist_private.h.

◆ SGLT_GET_HASNULLMASK

#define SGLT_GET_HASNULLMASK (   spgLeafTuple )     (((spgLeafTuple)->t_info & 0x8000) ? true : false)

Definition at line 398 of file spgist_private.h.

◆ SGLT_GET_NEXTOFFSET

#define SGLT_GET_NEXTOFFSET (   spgLeafTuple )     ((spgLeafTuple)->t_info & 0x3FFF)

Definition at line 396 of file spgist_private.h.

◆ SGLT_SET_HASNULLMASK

#define SGLT_SET_HASNULLMASK (   spgLeafTuple,
  hasnulls 
)
Value:
((spgLeafTuple)->t_info = \
((spgLeafTuple)->t_info & 0x7FFF) | ((hasnulls) ? 0x8000 : 0))

Definition at line 403 of file spgist_private.h.

◆ SGLT_SET_NEXTOFFSET

#define SGLT_SET_NEXTOFFSET (   spgLeafTuple,
  offsetNumber 
)
Value:
((spgLeafTuple)->t_info = \
((spgLeafTuple)->t_info & 0xC000) | ((offsetNumber) & 0x3FFF))

Definition at line 400 of file spgist_private.h.

◆ SGLTDATAPTR

#define SGLTDATAPTR (   x )    (((char *) (x)) + SGLTHDRSZ(SGLT_GET_HASNULLMASK(x)))

Definition at line 411 of file spgist_private.h.

◆ SGLTDATUM

#define SGLTDATUM (   x,
  s 
)
Value:
(s)->attLeafType.attbyval, \
(s)->attLeafType.attlen)
#define SGLTDATAPTR(x)
static Datum fetch_att(const void *T, bool attbyval, int attlen)
Definition: tupmacs.h:50

Definition at line 412 of file spgist_private.h.

◆ SGLTHDRSZ

#define SGLTHDRSZ (   hasnulls )
Value:
((hasnulls) ? MAXALIGN(sizeof(SpGistLeafTupleData) + \
#define MAXALIGN(LEN)
Definition: c.h:810

Definition at line 407 of file spgist_private.h.

◆ SGNTDATAPTR

#define SGNTDATAPTR (   x )    (((char *) (x)) + SGNTHDRSZ)

Definition at line 342 of file spgist_private.h.

◆ SGNTDATUM

#define SGNTDATUM (   x,
  s 
)
Value:
((s)->attLabelType.attbyval ? \
*(Datum *) SGNTDATAPTR(x) : \
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:332
#define SGNTDATAPTR(x)

Definition at line 343 of file spgist_private.h.

◆ SGNTHDRSZ

#define SGNTHDRSZ   MAXALIGN(sizeof(SpGistNodeTupleData))

Definition at line 341 of file spgist_private.h.

◆ SizeOfSpGistSearchItem

#define SizeOfSpGistSearchItem (   n_distances )     (offsetof(SpGistSearchItem, distances) + sizeof(double) * (n_distances))

Definition at line 182 of file spgist_private.h.

◆ spgFirstIncludeColumn

#define spgFirstIncludeColumn   1

Definition at line 44 of file spgist_private.h.

◆ SPGIST_CACHED_PAGES

#define SPGIST_CACHED_PAGES   8

Definition at line 105 of file spgist_private.h.

◆ SPGIST_DEAD

#define SPGIST_DEAD   2 /* dead, cannot be removed because of links */

Definition at line 273 of file spgist_private.h.

◆ SPGIST_DEFAULT_FILLFACTOR

#define SPGIST_DEFAULT_FILLFACTOR   80

Definition at line 496 of file spgist_private.h.

◆ SPGIST_DELETED

#define SPGIST_DELETED
Value:
(1<<1) /* never set, but keep for backwards
* compatibility */

Definition at line 73 of file spgist_private.h.

◆ SPGIST_LAST_FIXED_BLKNO

#define SPGIST_LAST_FIXED_BLKNO   SPGIST_NULL_BLKNO

Definition at line 50 of file spgist_private.h.

◆ SPGIST_LEAF

#define SPGIST_LEAF   (1<<2)

Definition at line 74 of file spgist_private.h.

◆ SPGIST_LIVE

#define SPGIST_LIVE   0 /* normal live tuple (either inner or leaf) */

Definition at line 271 of file spgist_private.h.

◆ SPGIST_MAGIC_NUMBER

#define SPGIST_MAGIC_NUMBER   (0xBA0BABEE)

Definition at line 121 of file spgist_private.h.

◆ SPGIST_META

#define SPGIST_META   (1<<0)

Definition at line 72 of file spgist_private.h.

◆ SPGIST_METAPAGE_BLKNO

#define SPGIST_METAPAGE_BLKNO   (0) /* metapage */

Definition at line 47 of file spgist_private.h.

◆ SPGIST_MIN_FILLFACTOR

#define SPGIST_MIN_FILLFACTOR   10

Definition at line 495 of file spgist_private.h.

◆ SPGIST_NULL_BLKNO

#define SPGIST_NULL_BLKNO   (2) /* root for null-value entries */

Definition at line 49 of file spgist_private.h.

◆ SPGIST_NULLS

#define SPGIST_NULLS   (1<<3)

Definition at line 75 of file spgist_private.h.

◆ SPGIST_PAGE_CAPACITY

#define SPGIST_PAGE_CAPACITY
Value:
MAXALIGN_DOWN(BLCKSZ - \
#define SizeOfPageHeaderData
Definition: bufpage.h:217
#define MAXALIGN_DOWN(LEN)
Definition: c.h:822

Definition at line 449 of file spgist_private.h.

◆ SPGIST_PAGE_ID

#define SPGIST_PAGE_ID   0xFF82

Definition at line 91 of file spgist_private.h.

◆ SPGIST_PLACEHOLDER

#define SPGIST_PLACEHOLDER   3 /* placeholder, used to preserve offsets */

Definition at line 274 of file spgist_private.h.

◆ SPGIST_REDIRECT

#define SPGIST_REDIRECT   1 /* temporary redirection placeholder */

Definition at line 272 of file spgist_private.h.

◆ SPGIST_ROOT_BLKNO

#define SPGIST_ROOT_BLKNO   (1) /* root for normal entries */

Definition at line 48 of file spgist_private.h.

◆ SpGistBlockIsFixed

#define SpGistBlockIsFixed (   blkno )     ((BlockNumber) (blkno) <= (BlockNumber) SPGIST_LAST_FIXED_BLKNO)

Definition at line 54 of file spgist_private.h.

◆ SpGistBlockIsRoot

#define SpGistBlockIsRoot (   blkno )     ((blkno) == SPGIST_ROOT_BLKNO || (blkno) == SPGIST_NULL_BLKNO)

Definition at line 52 of file spgist_private.h.

◆ SpGistGetFillFactor

#define SpGistGetFillFactor (   relation )
Value:
(AssertMacro(relation->rd_rel->relkind == RELKIND_INDEX && \
relation->rd_rel->relam == SPGIST_AM_OID), \
(relation)->rd_options ? \
((SpGistOptions *) (relation)->rd_options)->fillfactor : \
SPGIST_DEFAULT_FILLFACTOR)
#define AssertMacro(condition)
Definition: c.h:858

Definition at line 32 of file spgist_private.h.

◆ SpGistGetTargetPageFreeSpace

#define SpGistGetTargetPageFreeSpace (   relation )     (BLCKSZ * (100 - SpGistGetFillFactor(relation)) / 100)

Definition at line 38 of file spgist_private.h.

◆ SpGistPageGetFreeSpace

#define SpGistPageGetFreeSpace (   p,
  n 
)
Value:
Min(SpGistPageGetOpaque(p)->nPlaceholder, n) * \
(SGDTSIZE + sizeof(ItemIdData)))
Size PageGetExactFreeSpace(const PageData *page)
Definition: bufpage.c:957
struct ItemIdData ItemIdData
#define SGDTSIZE
#define SpGistPageGetOpaque(page)
Definition: spgist_private.h:77

Definition at line 458 of file spgist_private.h.

◆ SpGistPageGetMeta

#define SpGistPageGetMeta (   p )     ((SpGistMetaPageData *) PageGetContents(p))

Definition at line 123 of file spgist_private.h.

◆ SpGistPageGetOpaque

#define SpGistPageGetOpaque (   page )    ((SpGistPageOpaque) PageGetSpecialPointer(page))

Definition at line 77 of file spgist_private.h.

◆ SpGistPageIsDeleted

#define SpGistPageIsDeleted (   page )    (SpGistPageGetOpaque(page)->flags & SPGIST_DELETED)

Definition at line 79 of file spgist_private.h.

◆ SpGistPageIsLeaf

#define SpGistPageIsLeaf (   page )    (SpGistPageGetOpaque(page)->flags & SPGIST_LEAF)

Definition at line 80 of file spgist_private.h.

◆ SpGistPageIsMeta

#define SpGistPageIsMeta (   page )    (SpGistPageGetOpaque(page)->flags & SPGIST_META)

Definition at line 78 of file spgist_private.h.

◆ SpGistPageStoresNulls

#define SpGistPageStoresNulls (   page )    (SpGistPageGetOpaque(page)->flags & SPGIST_NULLS)

Definition at line 81 of file spgist_private.h.

◆ spgKeyColumn

#define spgKeyColumn   0

Definition at line 43 of file spgist_private.h.

◆ STORE_STATE

#define STORE_STATE (   s,
  d 
)
Value:
do { \
(d).redirectXid = (s)->redirectXid; \
(d).isBuild = (s)->isBuild; \
} while(0)

Definition at line 467 of file spgist_private.h.

Typedef Documentation

◆ SpGistCache

typedef struct SpGistCache SpGistCache

◆ SpGistDeadTuple

typedef SpGistDeadTupleData* SpGistDeadTuple

Definition at line 437 of file spgist_private.h.

◆ SpGistDeadTupleData

typedef struct SpGistDeadTupleData SpGistDeadTupleData

◆ SpGistInnerTuple

typedef SpGistInnerTupleData* SpGistInnerTuple

Definition at line 305 of file spgist_private.h.

◆ SpGistInnerTupleData

typedef struct SpGistInnerTupleData SpGistInnerTupleData

◆ SpGistLastUsedPage

typedef struct SpGistLastUsedPage SpGistLastUsedPage

◆ SpGistLeafTuple

typedef struct SpGistLeafTupleData* SpGistLeafTuple

Definition at line 131 of file spgist_private.h.

◆ SpGistLeafTupleData

typedef struct SpGistLeafTupleData SpGistLeafTupleData

◆ SpGistLUPCache

typedef struct SpGistLUPCache SpGistLUPCache

◆ SpGistMetaPageData

typedef struct SpGistMetaPageData SpGistMetaPageData

◆ SpGistNodeTuple

typedef SpGistNodeTupleData* SpGistNodeTuple

Definition at line 339 of file spgist_private.h.

◆ SpGistNodeTupleData

typedef IndexTupleData SpGistNodeTupleData

Definition at line 337 of file spgist_private.h.

◆ SpGistOptions

typedef struct SpGistOptions SpGistOptions

◆ SpGistPageOpaque

typedef SpGistPageOpaqueData* SpGistPageOpaque

Definition at line 69 of file spgist_private.h.

◆ SpGistPageOpaqueData

typedef struct SpGistPageOpaqueData SpGistPageOpaqueData

◆ SpGistScanOpaque

typedef SpGistScanOpaqueData* SpGistScanOpaque

Definition at line 244 of file spgist_private.h.

◆ SpGistScanOpaqueData

typedef struct SpGistScanOpaqueData SpGistScanOpaqueData

◆ SpGistSearchItem

typedef struct SpGistSearchItem SpGistSearchItem

◆ SpGistState

typedef struct SpGistState SpGistState

◆ SpGistTypeDesc

typedef struct SpGistTypeDesc SpGistTypeDesc

Function Documentation

◆ box_copy()

BOX * box_copy ( BOX *  orig )

Definition at line 82 of file spgproc.c.

83{
84 BOX *result = palloc(sizeof(BOX));
85
86 *result = *orig;
87 return result;
88}
void * palloc(Size size)
Definition: mcxt.c:1365
Definition: geo_decls.h:141

References palloc().

Referenced by spg_kd_inner_consistent(), and spg_quad_inner_consistent().

◆ getSpGistTupleDesc()

TupleDesc getSpGistTupleDesc ( Relation  index,
SpGistTypeDesc *  keyType 
)

Definition at line 315 of file spgutils.c.

316{
317 TupleDesc outTupDesc;
319
320 if (keyType->type ==
322 outTupDesc = RelationGetDescr(index);
323 else
324 {
326 att = TupleDescAttr(outTupDesc, spgKeyColumn);
327 /* It's sufficient to update the type-dependent fields of the column */
328 att->atttypid = keyType->type;
329 att->atttypmod = -1;
330 att->attlen = keyType->attlen;
331 att->attbyval = keyType->attbyval;
332 att->attalign = keyType->attalign;
333 att->attstorage = keyType->attstorage;
334 /* We shouldn't need to bother with making these valid: */
335 att->attcompression = InvalidCompressionMethod;
336 att->attcollation = InvalidOid;
337 /* In case we changed typlen, we'd better reset following offsets */
338 for (int i = spgFirstIncludeColumn; i < outTupDesc->natts; i++)
339 TupleDescCompactAttr(outTupDesc, i)->attcacheoff = -1;
340
342 }
343 return outTupDesc;
344}
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:202
#define InvalidOid
Definition: postgres_ext.h:37
#define RelationGetDescr(relation)
Definition: rel.h:540
#define spgFirstIncludeColumn
Definition: spgist_private.h:44
#define spgKeyColumn
Definition: spgist_private.h:43
int32 attcacheoff
Definition: tupdesc.h:70
int natts
Definition: tupdesc.h:137
Definition: type.h:96
#define InvalidCompressionMethod
TupleDesc CreateTupleDescCopy(TupleDesc tupdesc)
Definition: tupdesc.c:252
void populate_compact_attribute(TupleDesc tupdesc, int attnum)
Definition: tupdesc.c:117
static FormData_pg_attribute * TupleDescAttr(TupleDesc tupdesc, int i)
Definition: tupdesc.h:160
static CompactAttribute * TupleDescCompactAttr(TupleDesc tupdesc, int i)
Definition: tupdesc.h:175

References SpGistTypeDesc::attalign, SpGistTypeDesc::attbyval, CompactAttribute::attcacheoff, SpGistTypeDesc::attlen, SpGistTypeDesc::attstorage, CreateTupleDescCopy(), i, InvalidCompressionMethod, InvalidOid, TupleDescData::natts, populate_compact_attribute(), RelationGetDescr, spgFirstIncludeColumn, spgKeyColumn, TupleDescAttr(), TupleDescCompactAttr(), and SpGistTypeDesc::type.

Referenced by initSpGistState(), and spgbeginscan().

◆ initSpGistState()

void initSpGistState ( SpGistState *  state,
Relation  index 
)

Definition at line 348 of file spgutils.c.

349{
350 SpGistCache *cache;
351
352 state->index = index;
353
354 /* Get cached static information about index */
355 cache = spgGetCache(index);
356
357 state->config = cache->config;
358 state->attType = cache->attType;
359 state->attLeafType = cache->attLeafType;
360 state->attPrefixType = cache->attPrefixType;
361 state->attLabelType = cache->attLabelType;
362
363 /* Ensure we have a valid descriptor for leaf tuples */
364 state->leafTupDesc = getSpGistTupleDesc(state->index, &state->attLeafType);
365
366 /* Make workspace for constructing dead tuples */
367 state->deadTupleStorage = palloc0(SGDTSIZE);
368
369 /*
370 * Set horizon XID to use in redirection tuples. Use our own XID if we
371 * have one, else use InvalidTransactionId. The latter case can happen in
372 * VACUUM or REINDEX CONCURRENTLY, and in neither case would it be okay to
373 * force an XID to be assigned. VACUUM won't create any redirection
374 * tuples anyway, but REINDEX CONCURRENTLY can. Fortunately, REINDEX
375 * CONCURRENTLY doesn't mark the index valid until the end, so there could
376 * never be any concurrent scans "in flight" to a redirection tuple it has
377 * inserted. And it locks out VACUUM until the end, too. So it's okay
378 * for VACUUM to immediately expire a redirection tuple that contains an
379 * invalid xid.
380 */
381 state->redirectXid = GetTopTransactionIdIfAny();
382
383 /* Assume we're not in an index build (spgbuild will override) */
384 state->isBuild = false;
385}
void * palloc0(Size size)
Definition: mcxt.c:1395
TupleDesc getSpGistTupleDesc(Relation index, SpGistTypeDesc *keyType)
Definition: spgutils.c:315
SpGistCache * spgGetCache(Relation index)
Definition: spgutils.c:188
SpGistTypeDesc attPrefixType
SpGistTypeDesc attLeafType
SpGistTypeDesc attType
spgConfigOut config
SpGistTypeDesc attLabelType
Definition: regguts.h:323
TransactionId GetTopTransactionIdIfAny(void)
Definition: xact.c:441

References SpGistCache::attLabelType, SpGistCache::attLeafType, SpGistCache::attPrefixType, SpGistCache::attType, SpGistCache::config, getSpGistTupleDesc(), GetTopTransactionIdIfAny(), palloc0(), SGDTSIZE, and spgGetCache().

Referenced by spgbeginscan(), spgbuild(), spginsert(), and spgvacuumscan().

◆ spg_key_orderbys_distances()

double * spg_key_orderbys_distances ( Datum  key,
bool  isLeaf,
ScanKey  orderbys,
int  norderbys 
)

Definition at line 63 of file spgproc.c.

65{
66 int sk_num;
67 double *distances = (double *) palloc(norderbys * sizeof(double)),
68 *distance = distances;
69
70 for (sk_num = 0; sk_num < norderbys; ++sk_num, ++orderbys, ++distance)
71 {
72 Point *point = DatumGetPointP(orderbys->sk_argument);
73
74 *distance = isLeaf ? point_point_distance(point, DatumGetPointP(key))
76 }
77
78 return distances;
79}
static Point * DatumGetPointP(Datum X)
Definition: geo_decls.h:176
static BOX * DatumGetBoxP(Datum X)
Definition: geo_decls.h:234
#define point_point_distance(p1, p2)
Definition: spgproc.c:25
static double point_box_distance(Point *point, BOX *box)
Definition: spgproc.c:31
Definition: geo_decls.h:97

References DatumGetBoxP(), DatumGetPointP(), sort-test::key, palloc(), point_box_distance(), point_point_distance, and ScanKeyData::sk_argument.

Referenced by spg_box_quad_leaf_consistent(), spg_kd_inner_consistent(), spg_quad_inner_consistent(), and spg_quad_leaf_consistent().

◆ spgDeformLeafTuple()

void spgDeformLeafTuple ( SpGistLeafTuple  tup,
TupleDesc  tupleDescriptor,
Datum *  datums,
bool *  isnulls,
bool  keyColumnIsNull 
)

Definition at line 1115 of file spgutils.c.

1117{
1118 bool hasNullsMask = SGLT_GET_HASNULLMASK(tup);
1119 char *tp; /* ptr to tuple data */
1120 bits8 *bp; /* ptr to null bitmap in tuple */
1121
1122 if (keyColumnIsNull && tupleDescriptor->natts == 1)
1123 {
1124 /*
1125 * Trivial case: there is only the key attribute and we're in a nulls
1126 * tree. The hasNullsMask bit in the tuple header should not be set
1127 * (and thus we can't use index_deform_tuple_internal), but
1128 * nonetheless the result is NULL.
1129 *
1130 * Note: currently this is dead code, because noplace calls this when
1131 * there is only the key attribute. But we should cover the case.
1132 */
1133 Assert(!hasNullsMask);
1134
1135 datums[spgKeyColumn] = (Datum) 0;
1136 isnulls[spgKeyColumn] = true;
1137 return;
1138 }
1139
1140 tp = (char *) tup + SGLTHDRSZ(hasNullsMask);
1141 bp = (bits8 *) ((char *) tup + sizeof(SpGistLeafTupleData));
1142
1143 index_deform_tuple_internal(tupleDescriptor,
1144 datums, isnulls,
1145 tp, bp, hasNullsMask);
1146
1147 /*
1148 * Key column isnull value from the tuple should be consistent with
1149 * keyColumnIsNull flag from the caller.
1150 */
1151 Assert(keyColumnIsNull == isnulls[spgKeyColumn]);
1152}
uint8 bits8
Definition: c.h:545
Assert(PointerIsAligned(start, uint64))
void index_deform_tuple_internal(TupleDesc tupleDescriptor, Datum *values, bool *isnull, char *tp, bits8 *bp, int hasnulls)
Definition: indextuple.c:479
#define SGLT_GET_HASNULLMASK(spgLeafTuple)
#define SGLTHDRSZ(hasnulls)
struct SpGistLeafTupleData SpGistLeafTupleData

References Assert(), index_deform_tuple_internal(), TupleDescData::natts, SGLT_GET_HASNULLMASK, SGLTHDRSZ, and spgKeyColumn.

Referenced by doPickSplit(), and storeGettuple().

◆ spgdoinsert()

bool spgdoinsert ( Relation  index,
SpGistState *  state,
ItemPointer  heapPtr,
Datum *  datums,
bool *  isnulls 
)

Definition at line 1914 of file spgdoinsert.c.

1916{
1917 bool result = true;
1918 TupleDesc leafDescriptor = state->leafTupDesc;
1919 bool isnull = isnulls[spgKeyColumn];
1920 int level = 0;
1921 Datum leafDatums[INDEX_MAX_KEYS];
1922 int leafSize;
1923 int bestLeafSize;
1924 int numNoProgressCycles = 0;
1925 SPPageDesc current,
1926 parent;
1927 FmgrInfo *procinfo = NULL;
1928
1929 /*
1930 * Look up FmgrInfo of the user-defined choose function once, to save
1931 * cycles in the loop below.
1932 */
1933 if (!isnull)
1935
1936 /*
1937 * Prepare the leaf datum to insert.
1938 *
1939 * If an optional "compress" method is provided, then call it to form the
1940 * leaf key datum from the input datum. Otherwise, store the input datum
1941 * as is. Since we don't use index_form_tuple in this AM, we have to make
1942 * sure value to be inserted is not toasted; FormIndexDatum doesn't
1943 * guarantee that. But we assume the "compress" method to return an
1944 * untoasted value.
1945 */
1946 if (!isnull)
1947 {
1949 {
1950 FmgrInfo *compressProcinfo = NULL;
1951
1952 compressProcinfo = index_getprocinfo(index, 1, SPGIST_COMPRESS_PROC);
1953 leafDatums[spgKeyColumn] =
1954 FunctionCall1Coll(compressProcinfo,
1955 index->rd_indcollation[spgKeyColumn],
1956 datums[spgKeyColumn]);
1957 }
1958 else
1959 {
1960 Assert(state->attLeafType.type == state->attType.type);
1961
1962 if (state->attType.attlen == -1)
1963 leafDatums[spgKeyColumn] =
1965 else
1966 leafDatums[spgKeyColumn] = datums[spgKeyColumn];
1967 }
1968 }
1969 else
1970 leafDatums[spgKeyColumn] = (Datum) 0;
1971
1972 /* Likewise, ensure that any INCLUDE values are not toasted */
1973 for (int i = spgFirstIncludeColumn; i < leafDescriptor->natts; i++)
1974 {
1975 if (!isnulls[i])
1976 {
1977 if (TupleDescCompactAttr(leafDescriptor, i)->attlen == -1)
1978 leafDatums[i] = PointerGetDatum(PG_DETOAST_DATUM(datums[i]));
1979 else
1980 leafDatums[i] = datums[i];
1981 }
1982 else
1983 leafDatums[i] = (Datum) 0;
1984 }
1985
1986 /*
1987 * Compute space needed for a leaf tuple containing the given data.
1988 */
1989 leafSize = SpGistGetLeafTupleSize(leafDescriptor, leafDatums, isnulls);
1990 /* Account for an item pointer, too */
1991 leafSize += sizeof(ItemIdData);
1992
1993 /*
1994 * If it isn't gonna fit, and the opclass can't reduce the datum size by
1995 * suffixing, bail out now rather than doing a lot of useless work.
1996 */
1997 if (leafSize > SPGIST_PAGE_CAPACITY &&
1998 (isnull || !state->config.longValuesOK))
1999 ereport(ERROR,
2000 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
2001 errmsg("index row size %zu exceeds maximum %zu for index \"%s\"",
2002 leafSize - sizeof(ItemIdData),
2005 errhint("Values larger than a buffer page cannot be indexed.")));
2006 bestLeafSize = leafSize;
2007
2008 /* Initialize "current" to the appropriate root page */
2009 current.blkno = isnull ? SPGIST_NULL_BLKNO : SPGIST_ROOT_BLKNO;
2010 current.buffer = InvalidBuffer;
2011 current.page = NULL;
2012 current.offnum = FirstOffsetNumber;
2013 current.node = -1;
2014
2015 /* "parent" is invalid for the moment */
2016 parent.blkno = InvalidBlockNumber;
2017 parent.buffer = InvalidBuffer;
2018 parent.page = NULL;
2019 parent.offnum = InvalidOffsetNumber;
2020 parent.node = -1;
2021
2022 /*
2023 * Before entering the loop, try to clear any pending interrupt condition.
2024 * If a query cancel is pending, we might as well accept it now not later;
2025 * while if a non-canceling condition is pending, servicing it here avoids
2026 * having to restart the insertion and redo all the work so far.
2027 */
2029
2030 for (;;)
2031 {
2032 bool isNew = false;
2033
2034 /*
2035 * Bail out if query cancel is pending. We must have this somewhere
2036 * in the loop since a broken opclass could produce an infinite
2037 * picksplit loop. However, because we'll be holding buffer lock(s)
2038 * after the first iteration, ProcessInterrupts() wouldn't be able to
2039 * throw a cancel error here. Hence, if we see that an interrupt is
2040 * pending, break out of the loop and deal with the situation below.
2041 * Set result = false because we must restart the insertion if the
2042 * interrupt isn't a query-cancel-or-die case.
2043 */
2045 {
2046 result = false;
2047 break;
2048 }
2049
2050 if (current.blkno == InvalidBlockNumber)
2051 {
2052 /*
2053 * Create a leaf page. If leafSize is too large to fit on a page,
2054 * we won't actually use the page yet, but it simplifies the API
2055 * for doPickSplit to always have a leaf page at hand; so just
2056 * quietly limit our request to a page size.
2057 */
2058 current.buffer =
2060 GBUF_LEAF | (isnull ? GBUF_NULLS : 0),
2061 Min(leafSize, SPGIST_PAGE_CAPACITY),
2062 &isNew);
2063 current.blkno = BufferGetBlockNumber(current.buffer);
2064 }
2065 else if (parent.buffer == InvalidBuffer)
2066 {
2067 /* we hold no parent-page lock, so no deadlock is possible */
2068 current.buffer = ReadBuffer(index, current.blkno);
2070 }
2071 else if (current.blkno != parent.blkno)
2072 {
2073 /* descend to a new child page */
2074 current.buffer = ReadBuffer(index, current.blkno);
2075
2076 /*
2077 * Attempt to acquire lock on child page. We must beware of
2078 * deadlock against another insertion process descending from that
2079 * page to our parent page (see README). If we fail to get lock,
2080 * abandon the insertion and tell our caller to start over.
2081 *
2082 * XXX this could be improved, because failing to get lock on a
2083 * buffer is not proof of a deadlock situation; the lock might be
2084 * held by a reader, or even just background writer/checkpointer
2085 * process. Perhaps it'd be worth retrying after sleeping a bit?
2086 */
2087 if (!ConditionalLockBuffer(current.buffer))
2088 {
2089 ReleaseBuffer(current.buffer);
2091 return false;
2092 }
2093 }
2094 else
2095 {
2096 /* inner tuple can be stored on the same page as parent one */
2097 current.buffer = parent.buffer;
2098 }
2099 current.page = BufferGetPage(current.buffer);
2100
2101 /* should not arrive at a page of the wrong type */
2102 if (isnull ? !SpGistPageStoresNulls(current.page) :
2103 SpGistPageStoresNulls(current.page))
2104 elog(ERROR, "SPGiST index page %u has wrong nulls flag",
2105 current.blkno);
2106
2107 if (SpGistPageIsLeaf(current.page))
2108 {
2109 SpGistLeafTuple leafTuple;
2110 int nToSplit,
2111 sizeToSplit;
2112
2113 leafTuple = spgFormLeafTuple(state, heapPtr, leafDatums, isnulls);
2114 if (leafTuple->size + sizeof(ItemIdData) <=
2115 SpGistPageGetFreeSpace(current.page, 1))
2116 {
2117 /* it fits on page, so insert it and we're done */
2118 addLeafTuple(index, state, leafTuple,
2119 &current, &parent, isnull, isNew);
2120 break;
2121 }
2122 else if ((sizeToSplit =
2123 checkSplitConditions(index, state, &current,
2124 &nToSplit)) < SPGIST_PAGE_CAPACITY / 2 &&
2125 nToSplit < 64 &&
2126 leafTuple->size + sizeof(ItemIdData) + sizeToSplit <= SPGIST_PAGE_CAPACITY)
2127 {
2128 /*
2129 * the amount of data is pretty small, so just move the whole
2130 * chain to another leaf page rather than splitting it.
2131 */
2132 Assert(!isNew);
2133 moveLeafs(index, state, &current, &parent, leafTuple, isnull);
2134 break; /* we're done */
2135 }
2136 else
2137 {
2138 /* picksplit */
2139 if (doPickSplit(index, state, &current, &parent,
2140 leafTuple, level, isnull, isNew))
2141 break; /* doPickSplit installed new tuples */
2142
2143 /* leaf tuple will not be inserted yet */
2144 pfree(leafTuple);
2145
2146 /*
2147 * current now describes new inner tuple, go insert into it
2148 */
2149 Assert(!SpGistPageIsLeaf(current.page));
2150 goto process_inner_tuple;
2151 }
2152 }
2153 else /* non-leaf page */
2154 {
2155 /*
2156 * Apply the opclass choose function to figure out how to insert
2157 * the given datum into the current inner tuple.
2158 */
2159 SpGistInnerTuple innerTuple;
2160 spgChooseIn in;
2161 spgChooseOut out;
2162
2163 /*
2164 * spgAddNode and spgSplitTuple cases will loop back to here to
2165 * complete the insertion operation. Just in case the choose
2166 * function is broken and produces add or split requests
2167 * repeatedly, check for query cancel (see comments above).
2168 */
2169 process_inner_tuple:
2171 {
2172 result = false;
2173 break;
2174 }
2175
2176 innerTuple = (SpGistInnerTuple) PageGetItem(current.page,
2177 PageGetItemId(current.page, current.offnum));
2178
2179 in.datum = datums[spgKeyColumn];
2180 in.leafDatum = leafDatums[spgKeyColumn];
2181 in.level = level;
2182 in.allTheSame = innerTuple->allTheSame;
2183 in.hasPrefix = (innerTuple->prefixSize > 0);
2184 in.prefixDatum = SGITDATUM(innerTuple, state);
2185 in.nNodes = innerTuple->nNodes;
2186 in.nodeLabels = spgExtractNodeLabels(state, innerTuple);
2187
2188 memset(&out, 0, sizeof(out));
2189
2190 if (!isnull)
2191 {
2192 /* use user-defined choose method */
2193 FunctionCall2Coll(procinfo,
2194 index->rd_indcollation[0],
2195 PointerGetDatum(&in),
2196 PointerGetDatum(&out));
2197 }
2198 else
2199 {
2200 /* force "match" action (to insert to random subnode) */
2202 }
2203
2204 if (innerTuple->allTheSame)
2205 {
2206 /*
2207 * It's not allowed to do an AddNode at an allTheSame tuple.
2208 * Opclass must say "match", in which case we choose a random
2209 * one of the nodes to descend into, or "split".
2210 */
2211 if (out.resultType == spgAddNode)
2212 elog(ERROR, "cannot add a node to an allTheSame inner tuple");
2213 else if (out.resultType == spgMatchNode)
2214 out.result.matchNode.nodeN =
2216 0, innerTuple->nNodes - 1);
2217 }
2218
2219 switch (out.resultType)
2220 {
2221 case spgMatchNode:
2222 /* Descend to N'th child node */
2223 spgMatchNodeAction(index, state, innerTuple,
2224 &current, &parent,
2225 out.result.matchNode.nodeN);
2226 /* Adjust level as per opclass request */
2227 level += out.result.matchNode.levelAdd;
2228 /* Replace leafDatum and recompute leafSize */
2229 if (!isnull)
2230 {
2231 leafDatums[spgKeyColumn] = out.result.matchNode.restDatum;
2232 leafSize = SpGistGetLeafTupleSize(leafDescriptor,
2233 leafDatums, isnulls);
2234 leafSize += sizeof(ItemIdData);
2235 }
2236
2237 /*
2238 * Check new tuple size; fail if it can't fit, unless the
2239 * opclass says it can handle the situation by suffixing.
2240 *
2241 * However, the opclass can only shorten the leaf datum,
2242 * which may not be enough to ever make the tuple fit,
2243 * since INCLUDE columns might alone use more than a page.
2244 * Depending on the opclass' behavior, that could lead to
2245 * an infinite loop --- spgtextproc.c, for example, will
2246 * just repeatedly generate an empty-string leaf datum
2247 * once it runs out of data. Actual bugs in opclasses
2248 * might cause infinite looping, too. To detect such a
2249 * loop, check to see if we are making progress by
2250 * reducing the leafSize in each pass. This is a bit
2251 * tricky though. Because of alignment considerations,
2252 * the total tuple size might not decrease on every pass.
2253 * Also, there are edge cases where the choose method
2254 * might seem to not make progress for a cycle or two.
2255 * Somewhat arbitrarily, we allow up to 10 no-progress
2256 * iterations before failing. (This limit should be more
2257 * than MAXALIGN, to accommodate opclasses that trim one
2258 * byte from the leaf datum per pass.)
2259 */
2260 if (leafSize > SPGIST_PAGE_CAPACITY)
2261 {
2262 bool ok = false;
2263
2264 if (state->config.longValuesOK && !isnull)
2265 {
2266 if (leafSize < bestLeafSize)
2267 {
2268 ok = true;
2269 bestLeafSize = leafSize;
2270 numNoProgressCycles = 0;
2271 }
2272 else if (++numNoProgressCycles < 10)
2273 ok = true;
2274 }
2275 if (!ok)
2276 ereport(ERROR,
2277 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
2278 errmsg("index row size %zu exceeds maximum %zu for index \"%s\"",
2279 leafSize - sizeof(ItemIdData),
2282 errhint("Values larger than a buffer page cannot be indexed.")));
2283 }
2284
2285 /*
2286 * Loop around and attempt to insert the new leafDatum at
2287 * "current" (which might reference an existing child
2288 * tuple, or might be invalid to force us to find a new
2289 * page for the tuple).
2290 */
2291 break;
2292 case spgAddNode:
2293 /* AddNode is not sensible if nodes don't have labels */
2294 if (in.nodeLabels == NULL)
2295 elog(ERROR, "cannot add a node to an inner tuple without node labels");
2296 /* Add node to inner tuple, per request */
2297 spgAddNodeAction(index, state, innerTuple,
2298 &current, &parent,
2299 out.result.addNode.nodeN,
2301
2302 /*
2303 * Retry insertion into the enlarged node. We assume that
2304 * we'll get a MatchNode result this time.
2305 */
2306 goto process_inner_tuple;
2307 break;
2308 case spgSplitTuple:
2309 /* Split inner tuple, per request */
2310 spgSplitNodeAction(index, state, innerTuple,
2311 &current, &out);
2312
2313 /* Retry insertion into the split node */
2314 goto process_inner_tuple;
2315 break;
2316 default:
2317 elog(ERROR, "unrecognized SPGiST choose result: %d",
2318 (int) out.resultType);
2319 break;
2320 }
2321 }
2322 } /* end loop */
2323
2324 /*
2325 * Release any buffers we're still holding. Beware of possibility that
2326 * current and parent reference same buffer.
2327 */
2328 if (current.buffer != InvalidBuffer)
2329 {
2331 UnlockReleaseBuffer(current.buffer);
2332 }
2333 if (parent.buffer != InvalidBuffer &&
2334 parent.buffer != current.buffer)
2335 {
2338 }
2339
2340 /*
2341 * We do not support being called while some outer function is holding a
2342 * buffer lock (or any other reason to postpone query cancels). If that
2343 * were the case, telling the caller to retry would create an infinite
2344 * loop.
2345 */
2347
2348 /*
2349 * Finally, check for interrupts again. If there was a query cancel,
2350 * ProcessInterrupts() will be able to throw the error here. If it was
2351 * some other kind of interrupt that can just be cleared, return false to
2352 * tell our caller to retry.
2353 */
2355
2356 return result;
2357}
#define InvalidBlockNumber
Definition: block.h:33
#define InvalidBuffer
Definition: buf.h:25
BlockNumber BufferGetBlockNumber(Buffer buffer)
Definition: bufmgr.c:4198
bool ConditionalLockBuffer(Buffer buffer)
Definition: bufmgr.c:5598
void ReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:5338
void UnlockReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:5355
void LockBuffer(Buffer buffer, int mode)
Definition: bufmgr.c:5572
Buffer ReadBuffer(Relation reln, BlockNumber blockNum)
Definition: bufmgr.c:758
static Page BufferGetPage(Buffer buffer)
Definition: bufmgr.h:417
#define BUFFER_LOCK_EXCLUSIVE
Definition: bufmgr.h:198
static Item PageGetItem(const PageData *page, const ItemIdData *itemId)
Definition: bufpage.h:354
static ItemId PageGetItemId(Page page, OffsetNumber offsetNumber)
Definition: bufpage.h:244
#define Min(x, y)
Definition: c.h:1003
#define OidIsValid(objectId)
Definition: c.h:774
int errhint(const char *fmt,...)
Definition: elog.c:1321
int errcode(int sqlerrcode)
Definition: elog.c:854
int errmsg(const char *fmt,...)
Definition: elog.c:1071
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:226
#define ereport(elevel,...)
Definition: elog.h:150
Datum FunctionCall2Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2)
Definition: fmgr.c:1150
Datum FunctionCall1Coll(FmgrInfo *flinfo, Oid collation, Datum arg1)
Definition: fmgr.c:1130
#define PG_DETOAST_DATUM(datum)
Definition: fmgr.h:240
FmgrInfo * index_getprocinfo(Relation irel, AttrNumber attnum, uint16 procnum)
Definition: indexam.c:917
RegProcedure index_getprocid(Relation irel, AttrNumber attnum, uint16 procnum)
Definition: indexam.c:883
void pfree(void *pointer)
Definition: mcxt.c:1594
#define INTERRUPTS_CAN_BE_PROCESSED()
Definition: miscadmin.h:129
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:122
#define INTERRUPTS_PENDING_CONDITION()
Definition: miscadmin.h:113
#define InvalidOffsetNumber
Definition: off.h:26
#define FirstOffsetNumber
Definition: off.h:27
#define INDEX_MAX_KEYS
uint64 pg_prng_uint64_range(pg_prng_state *state, uint64 rmin, uint64 rmax)
Definition: pg_prng.c:144
pg_prng_state pg_global_prng_state
Definition: pg_prng.c:34
#define RelationGetRelationName(relation)
Definition: rel.h:548
static void spgAddNodeAction(Relation index, SpGistState *state, SpGistInnerTuple innerTuple, SPPageDesc *current, SPPageDesc *parent, int nodeN, Datum nodeLabel)
Definition: spgdoinsert.c:1513
static void spgSplitNodeAction(Relation index, SpGistState *state, SpGistInnerTuple innerTuple, SPPageDesc *current, spgChooseOut *out)
Definition: spgdoinsert.c:1715
static void spgMatchNodeAction(Relation index, SpGistState *state, SpGistInnerTuple innerTuple, SPPageDesc *current, SPPageDesc *parent, int nodeN)
Definition: spgdoinsert.c:1459
static bool doPickSplit(Relation index, SpGistState *state, SPPageDesc *current, SPPageDesc *parent, SpGistLeafTuple newLeafTuple, int level, bool isNulls, bool isNew)
Definition: spgdoinsert.c:677
static void moveLeafs(Relation index, SpGistState *state, SPPageDesc *current, SPPageDesc *parent, SpGistLeafTuple newLeafTuple, bool isNulls)
Definition: spgdoinsert.c:387
static int checkSplitConditions(Relation index, SpGistState *state, SPPageDesc *current, int *nToSplit)
Definition: spgdoinsert.c:333
static void addLeafTuple(Relation index, SpGistState *state, SpGistLeafTuple leafTuple, SPPageDesc *current, SPPageDesc *parent, bool isNulls, bool isNew)
Definition: spgdoinsert.c:203
#define SPGIST_COMPRESS_PROC
Definition: spgist.h:28
#define SPGIST_CHOOSE_PROC
Definition: spgist.h:24
@ spgMatchNode
Definition: spgist.h:69
@ spgAddNode
Definition: spgist.h:70
@ spgSplitTuple
Definition: spgist.h:71
#define SPGIST_NULL_BLKNO
Definition: spgist_private.h:49
#define GBUF_NULLS
SpGistInnerTupleData * SpGistInnerTuple
#define SpGistPageStoresNulls(page)
Definition: spgist_private.h:81
#define SGITDATUM(x, s)
#define GBUF_LEAF
#define SpGistPageIsLeaf(page)
Definition: spgist_private.h:80
#define SPGIST_PAGE_CAPACITY
#define SPGIST_ROOT_BLKNO
Definition: spgist_private.h:48
#define SpGistPageGetFreeSpace(p, n)
Datum * spgExtractNodeLabels(SpGistState *state, SpGistInnerTuple innerTuple)
Definition: spgutils.c:1160
SpGistLeafTuple spgFormLeafTuple(SpGistState *state, ItemPointer heapPtr, const Datum *datums, const bool *isnulls)
Definition: spgutils.c:871
Buffer SpGistGetBuffer(Relation index, int flags, int needSpace, bool *isNew)
Definition: spgutils.c:569
void SpGistSetLastUsedPage(Relation index, Buffer buffer)
Definition: spgutils.c:673
Size SpGistGetLeafTupleSize(TupleDesc tupleDescriptor, const Datum *datums, const bool *isnulls)
Definition: spgutils.c:818
int16 attlen
Definition: tupdesc.h:71
Definition: fmgr.h:57
Definition: itemid.h:26
Page page
Definition: spgdoinsert.c:40
int node
Definition: spgdoinsert.c:42
Buffer buffer
Definition: spgdoinsert.c:39
OffsetNumber offnum
Definition: spgdoinsert.c:41
BlockNumber blkno
Definition: spgdoinsert.c:38
unsigned int prefixSize
unsigned int nNodes
unsigned int allTheSame
unsigned int size
Datum * nodeLabels
Definition: spgist.h:64
bool hasPrefix
Definition: spgist.h:61
Datum prefixDatum
Definition: spgist.h:62
int nNodes
Definition: spgist.h:63
Datum datum
Definition: spgist.h:55
int level
Definition: spgist.h:57
Datum leafDatum
Definition: spgist.h:56
bool allTheSame
Definition: spgist.h:60
spgChooseResultType resultType
Definition: spgist.h:76
int levelAdd
Definition: spgist.h:82
struct spgChooseOut::@53::@54 matchNode
union spgChooseOut::@53 result
Datum nodeLabel
Definition: spgist.h:87
Datum restDatum
Definition: spgist.h:83
int nodeN
Definition: spgist.h:81
struct spgChooseOut::@53::@55 addNode

References addLeafTuple(), spgChooseOut::addNode, spgChooseIn::allTheSame, SpGistInnerTupleData::allTheSame, Assert(), CompactAttribute::attlen, SPPageDesc::blkno, SPPageDesc::buffer, BUFFER_LOCK_EXCLUSIVE, BufferGetBlockNumber(), BufferGetPage(), CHECK_FOR_INTERRUPTS, checkSplitConditions(), ConditionalLockBuffer(), spgChooseIn::datum, doPickSplit(), elog, ereport, errcode(), errhint(), errmsg(), ERROR, FirstOffsetNumber, FunctionCall1Coll(), FunctionCall2Coll(), GBUF_LEAF, GBUF_NULLS, spgChooseIn::hasPrefix, i, index_getprocid(), index_getprocinfo(), INDEX_MAX_KEYS, INTERRUPTS_CAN_BE_PROCESSED, INTERRUPTS_PENDING_CONDITION, InvalidBlockNumber, InvalidBuffer, InvalidOffsetNumber, spgChooseIn::leafDatum, spgChooseIn::level, spgChooseOut::levelAdd, LockBuffer(), spgChooseOut::matchNode, Min, moveLeafs(), TupleDescData::natts, spgChooseIn::nNodes, SpGistInnerTupleData::nNodes, SPPageDesc::node, spgChooseOut::nodeLabel, spgChooseIn::nodeLabels, spgChooseOut::nodeN, SPPageDesc::offnum, OidIsValid, SPPageDesc::page, PageGetItem(), PageGetItemId(), pfree(), PG_DETOAST_DATUM, pg_global_prng_state, pg_prng_uint64_range(), PointerGetDatum(), spgChooseIn::prefixDatum, SpGistInnerTupleData::prefixSize, ReadBuffer(), RelationGetRelationName, ReleaseBuffer(), spgChooseOut::restDatum, spgChooseOut::result, spgChooseOut::resultType, SGITDATUM, SpGistLeafTupleData::size, spgAddNode, spgAddNodeAction(), spgExtractNodeLabels(), spgFirstIncludeColumn, spgFormLeafTuple(), SPGIST_CHOOSE_PROC, SPGIST_COMPRESS_PROC, SPGIST_NULL_BLKNO, SPGIST_PAGE_CAPACITY, SPGIST_ROOT_BLKNO, SpGistGetBuffer(), SpGistGetLeafTupleSize(), SpGistPageGetFreeSpace, SpGistPageIsLeaf, SpGistPageStoresNulls, SpGistSetLastUsedPage(), spgKeyColumn, spgMatchNode, spgMatchNodeAction(), spgSplitNodeAction(), spgSplitTuple, TupleDescCompactAttr(), and UnlockReleaseBuffer().

Referenced by spginsert(), and spgistBuildCallback().

◆ spgExtractNodeLabels()

Datum * spgExtractNodeLabels ( SpGistState *  state,
SpGistInnerTuple  innerTuple 
)

Definition at line 1160 of file spgutils.c.

1161{
1162 Datum *nodeLabels;
1163 int i;
1164 SpGistNodeTuple node;
1165
1166 /* Either all the labels must be NULL, or none. */
1167 node = SGITNODEPTR(innerTuple);
1168 if (IndexTupleHasNulls(node))
1169 {
1170 SGITITERATE(innerTuple, i, node)
1171 {
1172 if (!IndexTupleHasNulls(node))
1173 elog(ERROR, "some but not all node labels are null in SPGiST inner tuple");
1174 }
1175 /* They're all null, so just return NULL */
1176 return NULL;
1177 }
1178 else
1179 {
1180 nodeLabels = (Datum *) palloc(sizeof(Datum) * innerTuple->nNodes);
1181 SGITITERATE(innerTuple, i, node)
1182 {
1183 if (IndexTupleHasNulls(node))
1184 elog(ERROR, "some but not all node labels are null in SPGiST inner tuple");
1185 nodeLabels[i] = SGNTDATUM(node, state);
1186 }
1187 return nodeLabels;
1188 }
1189}
static bool IndexTupleHasNulls(const IndexTupleData *itup)
Definition: itup.h:77
#define SGITITERATE(x, i, nt)
#define SGNTDATUM(x, s)

References elog, ERROR, i, IndexTupleHasNulls(), SpGistInnerTupleData::nNodes, palloc(), SGITITERATE, SGITNODEPTR, and SGNTDATUM.

Referenced by spgdoinsert(), and spgInitInnerConsistentIn().

◆ spgFormDeadTuple()

SpGistDeadTuple spgFormDeadTuple ( SpGistState *  state,
int  tupstate,
BlockNumber  blkno,
OffsetNumber  offnum 
)

Definition at line 1085 of file spgutils.c.

1087{
1088 SpGistDeadTuple tuple = (SpGistDeadTuple) state->deadTupleStorage;
1089
1090 tuple->tupstate = tupstate;
1091 tuple->size = SGDTSIZE;
1093
1094 if (tupstate == SPGIST_REDIRECT)
1095 {
1096 ItemPointerSet(&tuple->pointer, blkno, offnum);
1097 tuple->xid = state->redirectXid;
1098 }
1099 else
1100 {
1102 tuple->xid = InvalidTransactionId;
1103 }
1104
1105 return tuple;
1106}
static void ItemPointerSet(ItemPointerData *pointer, BlockNumber blockNumber, OffsetNumber offNum)
Definition: itemptr.h:135
static void ItemPointerSetInvalid(ItemPointerData *pointer)
Definition: itemptr.h:184
SpGistDeadTupleData * SpGistDeadTuple
#define SPGIST_REDIRECT
#define SGLT_SET_NEXTOFFSET(spgLeafTuple, offsetNumber)
unsigned int tupstate
unsigned int size
TransactionId xid
ItemPointerData pointer
#define InvalidTransactionId
Definition: transam.h:31

References InvalidOffsetNumber, InvalidTransactionId, ItemPointerSet(), ItemPointerSetInvalid(), SpGistDeadTupleData::pointer, SGDTSIZE, SGLT_SET_NEXTOFFSET, SpGistDeadTupleData::size, SPGIST_REDIRECT, SpGistDeadTupleData::tupstate, and SpGistDeadTupleData::xid.

Referenced by spgAddNodeAction(), spgPageIndexMultiDelete(), and spgRedoAddNode().

◆ spgFormInnerTuple()

SpGistInnerTuple spgFormInnerTuple ( SpGistState *  state,
bool  hasPrefix,
Datum  prefix,
int  nNodes,
SpGistNodeTuple *  nodes 
)

Definition at line 1002 of file spgutils.c.

1004{
1005 SpGistInnerTuple tup;
1006 unsigned int size;
1007 unsigned int prefixSize;
1008 int i;
1009 char *ptr;
1010
1011 /* Compute size needed */
1012 if (hasPrefix)
1013 prefixSize = SpGistGetInnerTypeSize(&state->attPrefixType, prefix);
1014 else
1015 prefixSize = 0;
1016
1017 size = SGITHDRSZ + prefixSize;
1018
1019 /* Note: we rely on node tuple sizes to be maxaligned already */
1020 for (i = 0; i < nNodes; i++)
1021 size += IndexTupleSize(nodes[i]);
1022
1023 /*
1024 * Ensure that we can replace the tuple with a dead tuple later. This
1025 * test is unnecessary given current tuple layouts, but let's be safe.
1026 */
1027 if (size < SGDTSIZE)
1028 size = SGDTSIZE;
1029
1030 /*
1031 * Inner tuple should be small enough to fit on a page
1032 */
1033 if (size > SPGIST_PAGE_CAPACITY - sizeof(ItemIdData))
1034 ereport(ERROR,
1035 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1036 errmsg("SP-GiST inner tuple size %zu exceeds maximum %zu",
1037 (Size) size,
1039 errhint("Values larger than a buffer page cannot be indexed.")));
1040
1041 /*
1042 * Check for overflow of header fields --- probably can't fail if the
1043 * above succeeded, but let's be paranoid
1044 */
1045 if (size > SGITMAXSIZE ||
1046 prefixSize > SGITMAXPREFIXSIZE ||
1047 nNodes > SGITMAXNNODES)
1048 elog(ERROR, "SPGiST inner tuple header field is too small");
1049
1050 /* OK, form the tuple */
1051 tup = (SpGistInnerTuple) palloc0(size);
1052
1053 tup->nNodes = nNodes;
1054 tup->prefixSize = prefixSize;
1055 tup->size = size;
1056
1057 if (hasPrefix)
1058 memcpyInnerDatum(SGITDATAPTR(tup), &state->attPrefixType, prefix);
1059
1060 ptr = (char *) SGITNODEPTR(tup);
1061
1062 for (i = 0; i < nNodes; i++)
1063 {
1064 SpGistNodeTuple node = nodes[i];
1065
1066 memcpy(ptr, node, IndexTupleSize(node));
1067 ptr += IndexTupleSize(node);
1068 }
1069
1070 return tup;
1071}
size_t Size
Definition: c.h:610
#define SGITDATAPTR(x)
#define SGITMAXSIZE
#define SGITMAXPREFIXSIZE
#define SGITHDRSZ
#define SGITMAXNNODES
static void memcpyInnerDatum(void *target, SpGistTypeDesc *att, Datum datum)
Definition: spgutils.c:797
unsigned int SpGistGetInnerTypeSize(SpGistTypeDesc *att, Datum datum)
Definition: spgutils.c:779

References elog, ereport, errcode(), errhint(), errmsg(), ERROR, i, IndexTupleSize(), memcpyInnerDatum(), SpGistInnerTupleData::nNodes, palloc0(), SpGistInnerTupleData::prefixSize, SGDTSIZE, SGITDATAPTR, SGITHDRSZ, SGITMAXNNODES, SGITMAXPREFIXSIZE, SGITMAXSIZE, SGITNODEPTR, SpGistInnerTupleData::size, SPGIST_PAGE_CAPACITY, and SpGistGetInnerTypeSize().

Referenced by addNode(), doPickSplit(), and spgSplitNodeAction().

◆ spgFormLeafTuple()

SpGistLeafTuple spgFormLeafTuple ( SpGistState *  state,
ItemPointer  heapPtr,
const Datum *  datums,
const bool *  isnulls 
)

Definition at line 871 of file spgutils.c.

873{
874 SpGistLeafTuple tup;
875 TupleDesc tupleDescriptor = state->leafTupDesc;
876 Size size;
877 Size hoff;
878 Size data_size;
879 bool needs_null_mask = false;
880 int natts = tupleDescriptor->natts;
881 char *tp; /* ptr to tuple data */
882 uint16 tupmask = 0; /* unused heap_fill_tuple output */
883
884 /*
885 * Decide whether we need a nulls bitmask.
886 *
887 * If there is only a key attribute (natts == 1), never use a bitmask, for
888 * compatibility with the pre-v14 layout of leaf tuples. Otherwise, we
889 * need one if any attribute is null.
890 */
891 if (natts > 1)
892 {
893 for (int i = 0; i < natts; i++)
894 {
895 if (isnulls[i])
896 {
897 needs_null_mask = true;
898 break;
899 }
900 }
901 }
902
903 /*
904 * Calculate size of the data part; same as for heap tuples.
905 */
906 data_size = heap_compute_data_size(tupleDescriptor, datums, isnulls);
907
908 /*
909 * Compute total size.
910 */
911 hoff = SGLTHDRSZ(needs_null_mask);
912 size = hoff + data_size;
913 size = MAXALIGN(size);
914
915 /*
916 * Ensure that we can replace the tuple with a dead tuple later. This test
917 * is unnecessary when there are any non-null attributes, but be safe.
918 */
919 if (size < SGDTSIZE)
920 size = SGDTSIZE;
921
922 /* OK, form the tuple */
923 tup = (SpGistLeafTuple) palloc0(size);
924
925 tup->size = size;
927 tup->heapPtr = *heapPtr;
928
929 tp = (char *) tup + hoff;
930
931 if (needs_null_mask)
932 {
933 bits8 *bp; /* ptr to null bitmap in tuple */
934
935 /* Set nullmask presence bit in SpGistLeafTuple header */
936 SGLT_SET_HASNULLMASK(tup, true);
937 /* Fill the data area and null mask */
938 bp = (bits8 *) ((char *) tup + sizeof(SpGistLeafTupleData));
939 heap_fill_tuple(tupleDescriptor, datums, isnulls, tp, data_size,
940 &tupmask, bp);
941 }
942 else if (natts > 1 || !isnulls[spgKeyColumn])
943 {
944 /* Fill data area only */
945 heap_fill_tuple(tupleDescriptor, datums, isnulls, tp, data_size,
946 &tupmask, (bits8 *) NULL);
947 }
948 /* otherwise we have no data, nor a bitmap, to fill */
949
950 return tup;
951}
uint16_t uint16
Definition: c.h:537
Size heap_compute_data_size(TupleDesc tupleDesc, const Datum *values, const bool *isnull)
Definition: heaptuple.c:219
void heap_fill_tuple(TupleDesc tupleDesc, const Datum *values, const bool *isnull, char *data, Size data_size, uint16 *infomask, bits8 *bit)
Definition: heaptuple.c:401
#define SGLT_SET_HASNULLMASK(spgLeafTuple, hasnulls)
struct SpGistLeafTupleData * SpGistLeafTuple
ItemPointerData heapPtr

References heap_compute_data_size(), heap_fill_tuple(), SpGistLeafTupleData::heapPtr, i, InvalidOffsetNumber, MAXALIGN, TupleDescData::natts, palloc0(), SGDTSIZE, SGLT_SET_HASNULLMASK, SGLT_SET_NEXTOFFSET, SGLTHDRSZ, SpGistLeafTupleData::size, and spgKeyColumn.

Referenced by doPickSplit(), and spgdoinsert().

◆ spgFormNodeTuple()

SpGistNodeTuple spgFormNodeTuple ( SpGistState *  state,
Datum  label,
bool  isnull 
)

Definition at line 960 of file spgutils.c.

961{
962 SpGistNodeTuple tup;
963 unsigned int size;
964 unsigned short infomask = 0;
965
966 /* compute space needed (note result is already maxaligned) */
967 size = SGNTHDRSZ;
968 if (!isnull)
969 size += SpGistGetInnerTypeSize(&state->attLabelType, label);
970
971 /*
972 * Here we make sure that the size will fit in the field reserved for it
973 * in t_info.
974 */
975 if ((size & INDEX_SIZE_MASK) != size)
977 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
978 errmsg("index row requires %zu bytes, maximum size is %zu",
979 (Size) size, (Size) INDEX_SIZE_MASK)));
980
981 tup = (SpGistNodeTuple) palloc0(size);
982
983 if (isnull)
984 infomask |= INDEX_NULL_MASK;
985 /* we don't bother setting the INDEX_VAR_MASK bit */
986 infomask |= size;
987 tup->t_info = infomask;
988
989 /* The TID field will be filled in later */
991
992 if (!isnull)
993 memcpyInnerDatum(SGNTDATAPTR(tup), &state->attLabelType, label);
994
995 return tup;
996}
#define INDEX_NULL_MASK
Definition: itup.h:68
#define INDEX_SIZE_MASK
Definition: itup.h:65
static char * label
Definition: pg_basebackup.c:135
#define SGNTHDRSZ
ItemPointerData t_tid
Definition: itup.h:37
unsigned short t_info
Definition: itup.h:49

References ereport, errcode(), errmsg(), ERROR, INDEX_NULL_MASK, INDEX_SIZE_MASK, ItemPointerSetInvalid(), label, memcpyInnerDatum(), palloc0(), SGNTDATAPTR, SGNTHDRSZ, SpGistGetInnerTypeSize(), IndexTupleData::t_info, and IndexTupleData::t_tid.

Referenced by addNode(), doPickSplit(), and spgSplitNodeAction().

◆ spgGetCache()

SpGistCache * spgGetCache ( Relation  index )

Definition at line 188 of file spgutils.c.

189{
190 SpGistCache *cache;
191
192 if (index->rd_amcache == NULL)
193 {
194 Oid atttype;
195 spgConfigIn in;
196 FmgrInfo *procinfo;
197
198 cache = MemoryContextAllocZero(index->rd_indexcxt,
199 sizeof(SpGistCache));
200
201 /* SPGiST must have one key column and can also have INCLUDE columns */
204
205 /*
206 * Get the actual (well, nominal) data type of the key column. We
207 * pass this to the opclass config function so that polymorphic
208 * opclasses are possible.
209 */
210 atttype = GetIndexInputType(index, spgKeyColumn + 1);
211
212 /* Call the config function to get config info for the opclass */
213 in.attType = atttype;
214
216 FunctionCall2Coll(procinfo,
217 index->rd_indcollation[spgKeyColumn],
218 PointerGetDatum(&in),
219 PointerGetDatum(&cache->config));
220
221 /*
222 * If leafType isn't specified, use the declared index column type,
223 * which index.c will have derived from the opclass's opcintype.
224 * (Although we now make spgvalidate.c warn if these aren't the same,
225 * old user-defined opclasses may not set the STORAGE parameter
226 * correctly, so believe leafType if it's given.)
227 */
228 if (!OidIsValid(cache->config.leafType))
229 {
230 cache->config.leafType =
232
233 /*
234 * If index column type is binary-coercible to atttype (for
235 * example, it's a domain over atttype), treat it as plain atttype
236 * to avoid thinking we need to compress.
237 */
238 if (cache->config.leafType != atttype &&
239 IsBinaryCoercible(cache->config.leafType, atttype))
240 cache->config.leafType = atttype;
241 }
242
243 /* Get the information we need about each relevant datatype */
244 fillTypeDesc(&cache->attType, atttype);
245
246 if (cache->config.leafType != atttype)
247 {
250 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
251 errmsg("compress method must be defined when leaf type is different from input type")));
252
253 fillTypeDesc(&cache->attLeafType, cache->config.leafType);
254 }
255 else
256 {
257 /* Save lookups in this common case */
258 cache->attLeafType = cache->attType;
259 }
260
262 fillTypeDesc(&cache->attLabelType, cache->config.labelType);
263
264 /*
265 * Finally, if it's a real index (not a partitioned one), get the
266 * lastUsedPages data from the metapage
267 */
268 if (index->rd_rel->relkind != RELKIND_PARTITIONED_INDEX)
269 {
270 Buffer metabuffer;
271 SpGistMetaPageData *metadata;
272
274 LockBuffer(metabuffer, BUFFER_LOCK_SHARE);
275
276 metadata = SpGistPageGetMeta(BufferGetPage(metabuffer));
277
278 if (metadata->magicNumber != SPGIST_MAGIC_NUMBER)
279 elog(ERROR, "index \"%s\" is not an SP-GiST index",
281
282 cache->lastUsedPages = metadata->lastUsedPages;
283
284 UnlockReleaseBuffer(metabuffer);
285 }
286
287 index->rd_amcache = cache;
288 }
289 else
290 {
291 /* assume it's up to date */
292 cache = (SpGistCache *) index->rd_amcache;
293 }
294
295 return cache;
296}
int Buffer
Definition: buf.h:23
#define BUFFER_LOCK_SHARE
Definition: bufmgr.h:197
void * MemoryContextAllocZero(MemoryContext context, Size size)
Definition: mcxt.c:1263
bool IsBinaryCoercible(Oid srctype, Oid targettype)
Definition: parse_coerce.c:3031
unsigned int Oid
Definition: postgres_ext.h:32
#define IndexRelationGetNumberOfAttributes(relation)
Definition: rel.h:526
#define IndexRelationGetNumberOfKeyAttributes(relation)
Definition: rel.h:533
#define SPGIST_CONFIG_PROC
Definition: spgist.h:23
#define SpGistPageGetMeta(p)
#define SPGIST_METAPAGE_BLKNO
Definition: spgist_private.h:47
#define SPGIST_MAGIC_NUMBER
static Oid GetIndexInputType(Relation index, AttrNumber indexcol)
Definition: spgutils.c:121
static void fillTypeDesc(SpGistTypeDesc *desc, Oid type)
Definition: spgutils.c:166
SpGistLUPCache lastUsedPages
SpGistLUPCache lastUsedPages
Oid attType
Definition: spgist.h:38
Oid leafType
Definition: spgist.h:45
Oid labelType
Definition: spgist.h:44
Oid prefixType
Definition: spgist.h:43

References Assert(), SpGistCache::attLabelType, SpGistCache::attLeafType, SpGistCache::attPrefixType, spgConfigIn::attType, SpGistCache::attType, BUFFER_LOCK_SHARE, BufferGetPage(), SpGistCache::config, elog, ereport, errcode(), errmsg(), ERROR, fillTypeDesc(), FunctionCall2Coll(), GetIndexInputType(), index_getprocid(), index_getprocinfo(), INDEX_MAX_KEYS, IndexRelationGetNumberOfAttributes, IndexRelationGetNumberOfKeyAttributes, IsBinaryCoercible(), spgConfigOut::labelType, SpGistMetaPageData::lastUsedPages, SpGistCache::lastUsedPages, spgConfigOut::leafType, LockBuffer(), SpGistMetaPageData::magicNumber, MemoryContextAllocZero(), OidIsValid, PointerGetDatum(), spgConfigOut::prefixType, ReadBuffer(), RelationGetDescr, RelationGetRelationName, SPGIST_COMPRESS_PROC, SPGIST_CONFIG_PROC, SPGIST_MAGIC_NUMBER, SPGIST_METAPAGE_BLKNO, SpGistPageGetMeta, spgKeyColumn, TupleDescAttr(), and UnlockReleaseBuffer().

Referenced by allocNewBuffer(), initSpGistState(), spgcanreturn(), SpGistGetBuffer(), and SpGistSetLastUsedPage().

◆ SpGistGetBuffer()

Buffer SpGistGetBuffer ( Relation  index,
int  flags,
int  needSpace,
bool *  isNew 
)

Definition at line 569 of file spgutils.c.

570{
571 SpGistCache *cache = spgGetCache(index);
573
574 /* Bail out if even an empty page wouldn't meet the demand */
575 if (needSpace > SPGIST_PAGE_CAPACITY)
576 elog(ERROR, "desired SPGiST tuple size is too big");
577
578 /*
579 * If possible, increase the space request to include relation's
580 * fillfactor. This ensures that when we add unrelated tuples to a page,
581 * we try to keep 100-fillfactor% available for adding tuples that are
582 * related to the ones already on it. But fillfactor mustn't cause an
583 * error for requests that would otherwise be legal.
584 */
586 needSpace = Min(needSpace, SPGIST_PAGE_CAPACITY);
587
588 /* Get the cache entry for this flags setting */
589 lup = GET_LUP(cache, flags);
590
591 /* If we have nothing cached, just turn it over to allocNewBuffer */
592 if (lup->blkno == InvalidBlockNumber)
593 {
594 *isNew = true;
595 return allocNewBuffer(index, flags);
596 }
597
598 /* fixed pages should never be in cache */
600
601 /* If cached freeSpace isn't enough, don't bother looking at the page */
602 if (lup->freeSpace >= needSpace)
603 {
604 Buffer buffer;
605 Page page;
606
607 buffer = ReadBuffer(index, lup->blkno);
608
609 if (!ConditionalLockBuffer(buffer))
610 {
611 /*
612 * buffer is locked by another process, so return a new buffer
613 */
614 ReleaseBuffer(buffer);
615 *isNew = true;
616 return allocNewBuffer(index, flags);
617 }
618
619 page = BufferGetPage(buffer);
620
621 if (PageIsNew(page) || SpGistPageIsDeleted(page) || PageIsEmpty(page))
622 {
623 /* OK to initialize the page */
624 uint16 pageflags = 0;
625
626 if (GBUF_REQ_LEAF(flags))
627 pageflags |= SPGIST_LEAF;
628 if (GBUF_REQ_NULLS(flags))
629 pageflags |= SPGIST_NULLS;
630 SpGistInitBuffer(buffer, pageflags);
631 lup->freeSpace = PageGetExactFreeSpace(page) - needSpace;
632 *isNew = true;
633 return buffer;
634 }
635
636 /*
637 * Check that page is of right type and has enough space. We must
638 * recheck this since our cache isn't necessarily up to date.
639 */
640 if ((GBUF_REQ_LEAF(flags) ? SpGistPageIsLeaf(page) : !SpGistPageIsLeaf(page)) &&
642 {
643 int freeSpace = PageGetExactFreeSpace(page);
644
645 if (freeSpace >= needSpace)
646 {
647 /* Success, update freespace info and return the buffer */
648 lup->freeSpace = freeSpace - needSpace;
649 *isNew = false;
650 return buffer;
651 }
652 }
653
654 /*
655 * fallback to allocation of new buffer
656 */
657 UnlockReleaseBuffer(buffer);
658 }
659
660 /* No success with cache, so return a new buffer */
661 *isNew = true;
662 return allocNewBuffer(index, flags);
663}
static bool PageIsEmpty(const PageData *page)
Definition: bufpage.h:224
static bool PageIsNew(const PageData *page)
Definition: bufpage.h:234
PageData * Page
Definition: bufpage.h:82
#define SpGistGetTargetPageFreeSpace(relation)
Definition: spgist_private.h:38
#define SpGistPageIsDeleted(page)
Definition: spgist_private.h:79
#define SPGIST_NULLS
Definition: spgist_private.h:75
#define GBUF_REQ_NULLS(flags)
#define SpGistBlockIsFixed(blkno)
Definition: spgist_private.h:54
#define GBUF_REQ_LEAF(flags)
#define SPGIST_LEAF
Definition: spgist_private.h:74
void SpGistInitBuffer(Buffer b, uint16 f)
Definition: spgutils.c:722
static Buffer allocNewBuffer(Relation index, int flags)
Definition: spgutils.c:513
#define GET_LUP(c, f)
Definition: spgutils.c:490
BlockNumber blkno

References allocNewBuffer(), Assert(), SpGistLastUsedPage::blkno, BufferGetPage(), ConditionalLockBuffer(), elog, ERROR, SpGistLastUsedPage::freeSpace, GBUF_REQ_LEAF, GBUF_REQ_NULLS, GET_LUP, InvalidBlockNumber, Min, PageGetExactFreeSpace(), PageIsEmpty(), PageIsNew(), ReadBuffer(), ReleaseBuffer(), spgGetCache(), SPGIST_LEAF, SPGIST_NULLS, SPGIST_PAGE_CAPACITY, SpGistBlockIsFixed, SpGistGetTargetPageFreeSpace, SpGistInitBuffer(), SpGistPageIsDeleted, SpGistPageIsLeaf, SpGistPageStoresNulls, and UnlockReleaseBuffer().

Referenced by doPickSplit(), moveLeafs(), spgAddNodeAction(), spgdoinsert(), and spgSplitNodeAction().

◆ SpGistGetInnerTypeSize()

unsigned int SpGistGetInnerTypeSize ( SpGistTypeDesc *  att,
Datum  datum 
)

Definition at line 779 of file spgutils.c.

780{
781 unsigned int size;
782
783 if (att->attbyval)
784 size = sizeof(Datum);
785 else if (att->attlen > 0)
786 size = att->attlen;
787 else
788 size = VARSIZE_ANY(DatumGetPointer(datum));
789
790 return MAXALIGN(size);
791}
static Pointer DatumGetPointer(Datum X)
Definition: postgres.h:322
static Size VARSIZE_ANY(const void *PTR)
Definition: varatt.h:460

References SpGistTypeDesc::attbyval, SpGistTypeDesc::attlen, DatumGetPointer(), MAXALIGN, and VARSIZE_ANY().

Referenced by spgFormInnerTuple(), and spgFormNodeTuple().

◆ SpGistGetLeafTupleSize()

Size SpGistGetLeafTupleSize ( TupleDesc  tupleDescriptor,
const Datum *  datums,
const bool *  isnulls 
)

Definition at line 818 of file spgutils.c.

820{
821 Size size;
822 Size data_size;
823 bool needs_null_mask = false;
824 int natts = tupleDescriptor->natts;
825
826 /*
827 * Decide whether we need a nulls bitmask.
828 *
829 * If there is only a key attribute (natts == 1), never use a bitmask, for
830 * compatibility with the pre-v14 layout of leaf tuples. Otherwise, we
831 * need one if any attribute is null.
832 */
833 if (natts > 1)
834 {
835 for (int i = 0; i < natts; i++)
836 {
837 if (isnulls[i])
838 {
839 needs_null_mask = true;
840 break;
841 }
842 }
843 }
844
845 /*
846 * Calculate size of the data part; same as for heap tuples.
847 */
848 data_size = heap_compute_data_size(tupleDescriptor, datums, isnulls);
849
850 /*
851 * Compute total size.
852 */
853 size = SGLTHDRSZ(needs_null_mask);
854 size += data_size;
855 size = MAXALIGN(size);
856
857 /*
858 * Ensure that we can replace the tuple with a dead tuple later. This test
859 * is unnecessary when there are any non-null attributes, but be safe.
860 */
861 if (size < SGDTSIZE)
862 size = SGDTSIZE;
863
864 return size;
865}

References heap_compute_data_size(), i, MAXALIGN, TupleDescData::natts, SGDTSIZE, and SGLTHDRSZ.

Referenced by spgdoinsert().

◆ SpGistInitBuffer()

void SpGistInitBuffer ( Buffer  b,
uint16  f 
)

Definition at line 722 of file spgutils.c.

723{
724 Assert(BufferGetPageSize(b) == BLCKSZ);
726}
static Size BufferGetPageSize(Buffer buffer)
Definition: bufmgr.h:406
b
int b
Definition: isn.c:74
void SpGistInitPage(Page page, uint16 f)
Definition: spgutils.c:708

References Assert(), b, BufferGetPage(), BufferGetPageSize(), and SpGistInitPage().

Referenced by allocNewBuffer(), doPickSplit(), spgbuild(), SpGistGetBuffer(), spgRedoAddLeaf(), spgRedoAddNode(), spgRedoMoveLeafs(), spgRedoPickSplit(), and spgRedoSplitTuple().

◆ SpGistInitMetapage()

void SpGistInitMetapage ( Page  page )

Definition at line 732 of file spgutils.c.

733{
734 SpGistMetaPageData *metadata;
735 int i;
736
738 metadata = SpGistPageGetMeta(page);
739 memset(metadata, 0, sizeof(SpGistMetaPageData));
741
742 /* initialize last-used-page cache to empty */
743 for (i = 0; i < SPGIST_CACHED_PAGES; i++)
745
746 /*
747 * Set pd_lower just past the end of the metadata. This is essential,
748 * because without doing so, metadata will be lost if xlog.c compresses
749 * the page.
750 */
751 ((PageHeader) page)->pd_lower =
752 ((char *) metadata + sizeof(SpGistMetaPageData)) - (char *) page;
753}
#define SPGIST_META
Definition: spgist_private.h:72
#define SPGIST_CACHED_PAGES
SpGistLastUsedPage cachedPage[SPGIST_CACHED_PAGES]

References SpGistLastUsedPage::blkno, SpGistLUPCache::cachedPage, i, InvalidBlockNumber, SpGistMetaPageData::lastUsedPages, SpGistMetaPageData::magicNumber, SPGIST_CACHED_PAGES, SPGIST_MAGIC_NUMBER, SPGIST_META, SpGistInitPage(), and SpGistPageGetMeta.

Referenced by spgbuild(), and spgbuildempty().

◆ SpGistInitPage()

void SpGistInitPage ( Page  page,
uint16  f 
)

Definition at line 708 of file spgutils.c.

709{
710 SpGistPageOpaque opaque;
711
712 PageInit(page, BLCKSZ, sizeof(SpGistPageOpaqueData));
713 opaque = SpGistPageGetOpaque(page);
714 opaque->flags = f;
716}
void PageInit(Page page, Size pageSize, Size specialSize)
Definition: bufpage.c:42
#define SPGIST_PAGE_ID
Definition: spgist_private.h:91

References SpGistPageOpaqueData::flags, PageInit(), SpGistPageOpaqueData::spgist_page_id, SPGIST_PAGE_ID, and SpGistPageGetOpaque.

Referenced by spgbuildempty(), SpGistInitBuffer(), and SpGistInitMetapage().

◆ SpGistNewBuffer()

Buffer SpGistNewBuffer ( Relation  index )

Definition at line 394 of file spgutils.c.

395{
396 Buffer buffer;
397
398 /* First, try to get a page from FSM */
399 for (;;)
400 {
402
403 if (blkno == InvalidBlockNumber)
404 break; /* nothing known to FSM */
405
406 /*
407 * The fixed pages shouldn't ever be listed in FSM, but just in case
408 * one is, ignore it.
409 */
410 if (SpGistBlockIsFixed(blkno))
411 continue;
412
413 buffer = ReadBuffer(index, blkno);
414
415 /*
416 * We have to guard against the possibility that someone else already
417 * recycled this page; the buffer may be locked if so.
418 */
419 if (ConditionalLockBuffer(buffer))
420 {
421 Page page = BufferGetPage(buffer);
422
423 if (PageIsNew(page))
424 return buffer; /* OK to use, if never initialized */
425
426 if (SpGistPageIsDeleted(page) || PageIsEmpty(page))
427 return buffer; /* OK to use */
428
430 }
431
432 /* Can't use it, so release buffer and try again */
433 ReleaseBuffer(buffer);
434 }
435
438
439 return buffer;
440}
uint32 BlockNumber
Definition: block.h:31
Buffer ExtendBufferedRel(BufferManagerRelation bmr, ForkNumber forkNum, BufferAccessStrategy strategy, uint32 flags)
Definition: bufmgr.c:858
#define BUFFER_LOCK_UNLOCK
Definition: bufmgr.h:196
@ EB_LOCK_FIRST
Definition: bufmgr.h:87
#define BMR_REL(p_rel)
Definition: bufmgr.h:111
BlockNumber GetFreeIndexPage(Relation rel)
Definition: indexfsm.c:38
@ MAIN_FORKNUM
Definition: relpath.h:58

References BMR_REL, BUFFER_LOCK_UNLOCK, BufferGetPage(), ConditionalLockBuffer(), EB_LOCK_FIRST, ExtendBufferedRel(), GetFreeIndexPage(), InvalidBlockNumber, LockBuffer(), MAIN_FORKNUM, PageIsEmpty(), PageIsNew(), ReadBuffer(), ReleaseBuffer(), SpGistBlockIsFixed, and SpGistPageIsDeleted.

Referenced by allocNewBuffer(), and spgbuild().

◆ SpGistPageAddNewItem()

OffsetNumber SpGistPageAddNewItem ( SpGistState *  state,
Page  page,
Item  item,
Size  size,
OffsetNumber *  startOffset,
bool  errorOK 
)

Definition at line 1203 of file spgutils.c.

1205{
1208 maxoff,
1209 offnum;
1210
1211 if (opaque->nPlaceholder > 0 &&
1212 PageGetExactFreeSpace(page) + SGDTSIZE >= MAXALIGN(size))
1213 {
1214 /* Try to replace a placeholder */
1215 maxoff = PageGetMaxOffsetNumber(page);
1216 offnum = InvalidOffsetNumber;
1217
1218 for (;;)
1219 {
1220 if (startOffset && *startOffset != InvalidOffsetNumber)
1221 i = *startOffset;
1222 else
1224 for (; i <= maxoff; i++)
1225 {
1227 PageGetItemId(page, i));
1228
1229 if (it->tupstate == SPGIST_PLACEHOLDER)
1230 {
1231 offnum = i;
1232 break;
1233 }
1234 }
1235
1236 /* Done if we found a placeholder */
1237 if (offnum != InvalidOffsetNumber)
1238 break;
1239
1240 if (startOffset && *startOffset != InvalidOffsetNumber)
1241 {
1242 /* Hint was no good, re-search from beginning */
1243 *startOffset = InvalidOffsetNumber;
1244 continue;
1245 }
1246
1247 /* Hmm, no placeholder found? */
1248 opaque->nPlaceholder = 0;
1249 break;
1250 }
1251
1252 if (offnum != InvalidOffsetNumber)
1253 {
1254 /* Replace the placeholder tuple */
1255 PageIndexTupleDelete(page, offnum);
1256
1257 offnum = PageAddItem(page, item, size, offnum, false, false);
1258
1259 /*
1260 * We should not have failed given the size check at the top of
1261 * the function, but test anyway. If we did fail, we must PANIC
1262 * because we've already deleted the placeholder tuple, and
1263 * there's no other way to keep the damage from getting to disk.
1264 */
1265 if (offnum != InvalidOffsetNumber)
1266 {
1267 Assert(opaque->nPlaceholder > 0);
1268 opaque->nPlaceholder--;
1269 if (startOffset)
1270 *startOffset = offnum + 1;
1271 }
1272 else
1273 elog(PANIC, "failed to add item of size %zu to SPGiST index page",
1274 size);
1275
1276 return offnum;
1277 }
1278 }
1279
1280 /* No luck in replacing a placeholder, so just add it to the page */
1281 offnum = PageAddItem(page, item, size,
1282 InvalidOffsetNumber, false, false);
1283
1284 if (offnum == InvalidOffsetNumber && !errorOK)
1285 elog(ERROR, "failed to add item of size %zu to SPGiST index page",
1286 size);
1287
1288 return offnum;
1289}
void PageIndexTupleDelete(Page page, OffsetNumber offnum)
Definition: bufpage.c:1051
#define PageAddItem(page, item, size, offsetNumber, overwrite, is_heap)
Definition: bufpage.h:472
static OffsetNumber PageGetMaxOffsetNumber(const PageData *page)
Definition: bufpage.h:372
#define PANIC
Definition: elog.h:42
uint16 OffsetNumber
Definition: off.h:24
#define SPGIST_PLACEHOLDER

References Assert(), elog, ERROR, FirstOffsetNumber, i, InvalidOffsetNumber, MAXALIGN, SpGistPageOpaqueData::nPlaceholder, PageAddItem, PageGetExactFreeSpace(), PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), PageIndexTupleDelete(), PANIC, SGDTSIZE, SPGIST_PLACEHOLDER, SpGistPageGetOpaque, and SpGistDeadTupleData::tupstate.

Referenced by addLeafTuple(), doPickSplit(), moveLeafs(), spgAddNodeAction(), and spgSplitNodeAction().

◆ SpGistSetLastUsedPage()

void SpGistSetLastUsedPage ( Relation  index,
Buffer  buffer 
)

Definition at line 673 of file spgutils.c.

674{
675 SpGistCache *cache = spgGetCache(index);
677 int freeSpace;
678 Page page = BufferGetPage(buffer);
679 BlockNumber blkno = BufferGetBlockNumber(buffer);
680 int flags;
681
682 /* Never enter fixed pages (root pages) in cache, though */
683 if (SpGistBlockIsFixed(blkno))
684 return;
685
686 if (SpGistPageIsLeaf(page))
687 flags = GBUF_LEAF;
688 else
689 flags = GBUF_INNER_PARITY(blkno);
690 if (SpGistPageStoresNulls(page))
691 flags |= GBUF_NULLS;
692
693 lup = GET_LUP(cache, flags);
694
695 freeSpace = PageGetExactFreeSpace(page);
696 if (lup->blkno == InvalidBlockNumber || lup->blkno == blkno ||
697 lup->freeSpace < freeSpace)
698 {
699 lup->blkno = blkno;
700 lup->freeSpace = freeSpace;
701 }
702}
#define GBUF_INNER_PARITY(x)

References SpGistLastUsedPage::blkno, BufferGetBlockNumber(), BufferGetPage(), SpGistLastUsedPage::freeSpace, GBUF_INNER_PARITY, GBUF_LEAF, GBUF_NULLS, GET_LUP, InvalidBlockNumber, PageGetExactFreeSpace(), spgGetCache(), SpGistBlockIsFixed, SpGistPageIsLeaf, and SpGistPageStoresNulls.

Referenced by doPickSplit(), moveLeafs(), spgAddNodeAction(), spgdoinsert(), spgMatchNodeAction(), spgprocesspending(), spgSplitNodeAction(), and spgvacuumpage().

◆ SpGistUpdateMetaPage()

void SpGistUpdateMetaPage ( Relation  index )

Definition at line 450 of file spgutils.c.

451{
452 SpGistCache *cache = (SpGistCache *) index->rd_amcache;
453
454 if (cache != NULL)
455 {
456 Buffer metabuffer;
457
459
460 if (ConditionalLockBuffer(metabuffer))
461 {
462 Page metapage = BufferGetPage(metabuffer);
463 SpGistMetaPageData *metadata = SpGistPageGetMeta(metapage);
464
465 metadata->lastUsedPages = cache->lastUsedPages;
466
467 /*
468 * Set pd_lower just past the end of the metadata. This is
469 * essential, because without doing so, metadata will be lost if
470 * xlog.c compresses the page. (We must do this here because
471 * pre-v11 versions of PG did not set the metapage's pd_lower
472 * correctly, so a pg_upgraded index might contain the wrong
473 * value.)
474 */
475 ((PageHeader) metapage)->pd_lower =
476 ((char *) metadata + sizeof(SpGistMetaPageData)) - (char *) metapage;
477
478 MarkBufferDirty(metabuffer);
479 UnlockReleaseBuffer(metabuffer);
480 }
481 else
482 {
483 ReleaseBuffer(metabuffer);
484 }
485 }
486}
void MarkBufferDirty(Buffer buffer)
Definition: bufmgr.c:2921
PageHeaderData * PageHeader
Definition: bufpage.h:174
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:81

References BufferGetPage(), ConditionalLockBuffer(), if(), SpGistMetaPageData::lastUsedPages, SpGistCache::lastUsedPages, MarkBufferDirty(), ReadBuffer(), ReleaseBuffer(), SPGIST_METAPAGE_BLKNO, SpGistPageGetMeta, and UnlockReleaseBuffer().

Referenced by spgbuild(), spginsert(), and spgvacuumscan().

◆ spgPageIndexMultiDelete()

void spgPageIndexMultiDelete ( SpGistState *  state,
Page  page,
OffsetNumber *  itemnos,
int  nitems,
int  firststate,
int  reststate,
BlockNumber  blkno,
OffsetNumber  offnum 
)

Definition at line 131 of file spgdoinsert.c.

135{
136 OffsetNumber firstItem;
138 SpGistDeadTuple tuple = NULL;
139 int i;
140
141 if (nitems == 0)
142 return; /* nothing to do */
143
144 /*
145 * For efficiency we want to use PageIndexMultiDelete, which requires the
146 * targets to be listed in sorted order, so we have to sort the itemnos
147 * array. (This also greatly simplifies the math for reinserting the
148 * replacement tuples.) However, we must not scribble on the caller's
149 * array, so we have to make a copy.
150 */
151 memcpy(sortednos, itemnos, sizeof(OffsetNumber) * nitems);
152 if (nitems > 1)
153 qsort(sortednos, nitems, sizeof(OffsetNumber), cmpOffsetNumbers);
154
155 PageIndexMultiDelete(page, sortednos, nitems);
156
157 firstItem = itemnos[0];
158
159 for (i = 0; i < nitems; i++)
160 {
161 OffsetNumber itemno = sortednos[i];
162 int tupstate;
163
164 tupstate = (itemno == firstItem) ? firststate : reststate;
165 if (tuple == NULL || tuple->tupstate != tupstate)
166 tuple = spgFormDeadTuple(state, tupstate, blkno, offnum);
167
168 if (PageAddItem(page, (Item) tuple, tuple->size,
169 itemno, false, false) != itemno)
170 elog(ERROR, "failed to add item of size %u to SPGiST index page",
171 tuple->size);
172
173 if (tupstate == SPGIST_REDIRECT)
174 SpGistPageGetOpaque(page)->nRedirection++;
175 else if (tupstate == SPGIST_PLACEHOLDER)
176 SpGistPageGetOpaque(page)->nPlaceholder++;
177 }
178}
void PageIndexMultiDelete(Page page, OffsetNumber *itemnos, int nitems)
Definition: bufpage.c:1160
#define nitems(x)
Definition: indent.h:31
Pointer Item
Definition: item.h:17
#define MaxIndexTuplesPerPage
Definition: itup.h:181
#define qsort(a, b, c, d)
Definition: port.h:479
static int cmpOffsetNumbers(const void *a, const void *b)
Definition: spgdoinsert.c:112
SpGistDeadTuple spgFormDeadTuple(SpGistState *state, int tupstate, BlockNumber blkno, OffsetNumber offnum)
Definition: spgutils.c:1085

References cmpOffsetNumbers(), elog, ERROR, i, MaxIndexTuplesPerPage, nitems, PageAddItem, PageIndexMultiDelete(), qsort, SpGistDeadTupleData::size, spgFormDeadTuple(), SPGIST_PLACEHOLDER, SPGIST_REDIRECT, SpGistPageGetOpaque, and SpGistDeadTupleData::tupstate.

Referenced by doPickSplit(), moveLeafs(), spgRedoMoveLeafs(), spgRedoPickSplit(), spgRedoVacuumLeaf(), and vacuumLeafPage().

◆ spgproperty()

bool spgproperty ( Oid  index_oid,
int  attno,
IndexAMProperty  prop,
const char *  propname,
bool *  res,
bool *  isnull 
)

Definition at line 1298 of file spgutils.c.

1301{
1302 Oid opclass,
1303 opfamily,
1304 opcintype;
1305 CatCList *catlist;
1306 int i;
1307
1308 /* Only answer column-level inquiries */
1309 if (attno == 0)
1310 return false;
1311
1312 switch (prop)
1313 {
1315 break;
1316 default:
1317 return false;
1318 }
1319
1320 /*
1321 * Currently, SP-GiST distance-ordered scans require that there be a
1322 * distance operator in the opclass with the default types. So we assume
1323 * that if such an operator exists, then there's a reason for it.
1324 */
1325
1326 /* First we need to know the column's opclass. */
1327 opclass = get_index_column_opclass(index_oid, attno);
1328 if (!OidIsValid(opclass))
1329 {
1330 *isnull = true;
1331 return true;
1332 }
1333
1334 /* Now look up the opclass family and input datatype. */
1335 if (!get_opclass_opfamily_and_input_type(opclass, &opfamily, &opcintype))
1336 {
1337 *isnull = true;
1338 return true;
1339 }
1340
1341 /* And now we can check whether the operator is provided. */
1342 catlist = SearchSysCacheList1(AMOPSTRATEGY,
1343 ObjectIdGetDatum(opfamily));
1344
1345 *res = false;
1346
1347 for (i = 0; i < catlist->n_members; i++)
1348 {
1349 HeapTuple amoptup = &catlist->members[i]->tuple;
1350 Form_pg_amop amopform = (Form_pg_amop) GETSTRUCT(amoptup);
1351
1352 if (amopform->amoppurpose == AMOP_ORDER &&
1353 (amopform->amoplefttype == opcintype ||
1354 amopform->amoprighttype == opcintype) &&
1355 opfamily_can_sort_type(amopform->amopsortfamily,
1356 get_op_rettype(amopform->amopopr)))
1357 {
1358 *res = true;
1359 break;
1360 }
1361 }
1362
1363 ReleaseSysCacheList(catlist);
1364
1365 *isnull = false;
1366
1367 return true;
1368}
@ AMPROP_DISTANCE_ORDERABLE
Definition: amapi.h:46
bool opfamily_can_sort_type(Oid opfamilyoid, Oid datatypeoid)
Definition: amvalidate.c:271
static void * GETSTRUCT(const HeapTupleData *tuple)
Definition: htup_details.h:728
bool get_opclass_opfamily_and_input_type(Oid opclass, Oid *opfamily, Oid *opcintype)
Definition: lsyscache.c:1354
Oid get_op_rettype(Oid opno)
Definition: lsyscache.c:1500
Oid get_index_column_opclass(Oid index_oid, int attno)
Definition: lsyscache.c:3679
FormData_pg_amop * Form_pg_amop
Definition: pg_amop.h:88
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:262
CatCTup * members[FLEXIBLE_ARRAY_MEMBER]
Definition: catcache.h:185
int n_members
Definition: catcache.h:183
HeapTupleData tuple
Definition: catcache.h:124
#define ReleaseSysCacheList(x)
Definition: syscache.h:134
#define SearchSysCacheList1(cacheId, key1)
Definition: syscache.h:127

References AMPROP_DISTANCE_ORDERABLE, get_index_column_opclass(), get_op_rettype(), get_opclass_opfamily_and_input_type(), GETSTRUCT(), i, catclist::members, catclist::n_members, ObjectIdGetDatum(), OidIsValid, opfamily_can_sort_type(), ReleaseSysCacheList, SearchSysCacheList1, and catctup::tuple.

Referenced by spghandler().

◆ spgUpdateNodeLink()

void spgUpdateNodeLink ( SpGistInnerTuple  tup,
int  nodeN,
BlockNumber  blkno,
OffsetNumber  offset 
)

Definition at line 52 of file spgdoinsert.c.

54{
55 int i;
56 SpGistNodeTuple node;
57
58 SGITITERATE(tup, i, node)
59 {
60 if (i == nodeN)
61 {
62 ItemPointerSet(&node->t_tid, blkno, offset);
63 return;
64 }
65 }
66
67 elog(ERROR, "failed to find requested node %d in SPGiST inner tuple",
68 nodeN);
69}

References elog, ERROR, i, ItemPointerSet(), SGITITERATE, and IndexTupleData::t_tid.

Referenced by saveNodeLink(), spgRedoAddLeaf(), spgRedoAddNode(), spgRedoMoveLeafs(), spgRedoPickSplit(), and spgSplitNodeAction().

AltStyle によって変換されたページ (->オリジナル) /