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 311 of file spgist_private.h.

GBUF_INNER_PARITY

#define GBUF_INNER_PARITY

(

x

)

((x) % 3)

Definition at line 483 of file spgist_private.h.

GBUF_LEAF

#define GBUF_LEAF   0x03

Definition at line 482 of file spgist_private.h.

GBUF_NULLS

#define GBUF_NULLS   0x04

Definition at line 484 of file spgist_private.h.

GBUF_PARITY_MASK

#define GBUF_PARITY_MASK   0x03

Definition at line 486 of file spgist_private.h.

GBUF_REQ_LEAF

#define GBUF_REQ_LEAF

(

flags

)

(((flags) & GBUF_PARITY_MASK) == GBUF_LEAF)

Definition at line 487 of file spgist_private.h.

GBUF_REQ_NULLS

#define GBUF_REQ_NULLS

(

flags

)

((flags) & GBUF_NULLS)

Definition at line 488 of file spgist_private.h.

SGDTSIZE

#define SGDTSIZE   MAXALIGN(sizeof(SpGistDeadTupleData))

Definition at line 437 of file spgist_private.h.

SGITDATAPTR

#define SGITDATAPTR

(

x

)

((x)->prefixSize ? _SGITDATA(x) : NULL)

Definition at line 312 of file spgist_private.h.

SGITDATUM

#define SGITDATUM	(		x,
			s
	)

Value:

                             ((x)->prefixSize ? \
                             ((s)->attPrefixType.attbyval ? \
                              *(Datum *) _SGITDATA(x) : \
                              PointerGetDatum(_SGITDATA(x))) \
                             : (Datum) 0)

Definition at line 313 of file spgist_private.h.

SGITHDRSZ

#define SGITHDRSZ   MAXALIGN(sizeof(SpGistInnerTupleData))

Definition at line 310 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)))

Definition at line 321 of file spgist_private.h.

SGITMAXNNODES

#define SGITMAXNNODES   0x1FFF

Definition at line 306 of file spgist_private.h.

SGITMAXPREFIXSIZE

#define SGITMAXPREFIXSIZE   0xFFFF

Definition at line 307 of file spgist_private.h.

SGITMAXSIZE

#define SGITMAXSIZE   0xFFFF

Definition at line 308 of file spgist_private.h.

SGITNODEPTR

#define SGITNODEPTR

(

x

)

((SpGistNodeTuple) (_SGITDATA(x) + (x)->prefixSize))

Definition at line 318 of file spgist_private.h.

SGLT_GET_HASNULLMASK

#define SGLT_GET_HASNULLMASK

(

spgLeafTuple

)

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

Definition at line 396 of file spgist_private.h.

SGLT_GET_NEXTOFFSET

#define SGLT_GET_NEXTOFFSET

(

spgLeafTuple

)

((spgLeafTuple)->t_info & 0x3FFF)

Definition at line 394 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 401 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 398 of file spgist_private.h.

SGLTDATAPTR

#define SGLTDATAPTR

(

x

)

(((char *) (x)) + SGLTHDRSZ(SGLT_GET_HASNULLMASK(x)))

Definition at line 409 of file spgist_private.h.

SGLTDATUM

#define SGLTDATUM	(		x,
			s
	)

Value:

                                      fetch_att(SGLTDATAPTR(x), \
                                      (s)->attLeafType.attbyval, \
                                      (s)->attLeafType.attlen)

Definition at line 410 of file spgist_private.h.

SGLTHDRSZ

#define SGLTHDRSZ

(

hasnulls

)

Value:

    ((hasnulls) ? MAXALIGN(sizeof(SpGistLeafTupleData) + \
                           sizeof(IndexAttributeBitMapData)) : \
     MAXALIGN(sizeof(SpGistLeafTupleData)))

Definition at line 405 of file spgist_private.h.

SGNTDATAPTR

#define SGNTDATAPTR

(

x

)

(((char *) (x)) + SGNTHDRSZ)

Definition at line 340 of file spgist_private.h.

SGNTDATUM

#define SGNTDATUM	(		x,
			s
	)

Value:

                             ((s)->attLabelType.attbyval ? \
                             *(Datum *) SGNTDATAPTR(x) : \
                             PointerGetDatum(SGNTDATAPTR(x)))

Definition at line 341 of file spgist_private.h.

SGNTHDRSZ

#define SGNTHDRSZ   MAXALIGN(sizeof(SpGistNodeTupleData))

Definition at line 339 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 494 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 493 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 - \
                  SizeOfPageHeaderData - \
                  MAXALIGN(sizeof(SpGistPageOpaqueData)))

Definition at line 447 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)

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:

    (PageGetExactFreeSpace(p) + \
     Min(SpGistPageGetOpaque(p)->nPlaceholder, n) * \
     (SGDTSIZE + sizeof(ItemIdData)))

Definition at line 456 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 465 of file spgist_private.h.

Typedef Documentation

SpGistCache

typedef struct SpGistCache SpGistCache

SpGistDeadTuple

typedef SpGistDeadTupleData* SpGistDeadTuple

Definition at line 435 of file spgist_private.h.

SpGistDeadTupleData

typedef struct SpGistDeadTupleData SpGistDeadTupleData

SpGistInnerTuple

typedef SpGistInnerTupleData* SpGistInnerTuple

Definition at line 303 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 337 of file spgist_private.h.

SpGistNodeTupleData

typedef IndexTupleData SpGistNodeTupleData

Definition at line 335 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.

{
    BOX        *result = palloc(sizeof(BOX));
 
    *result = *orig;
    return result;
}

References palloc().

Referenced by spg_kd_inner_consistent(), and spg_quad_inner_consistent().

getSpGistTupleDesc()

TupleDesc getSpGistTupleDesc	(	Relation	index,
		SpGistTypeDesc *	keyType
	)

Definition at line 310 of file spgutils.c.

{
    TupleDesc   outTupDesc;
    Form_pg_attribute att;
 
    if (keyType->type ==
        TupleDescAttr(RelationGetDescr(index), spgKeyColumn)->atttypid)
        outTupDesc = RelationGetDescr(index);
    else
    {
        outTupDesc = CreateTupleDescCopy(RelationGetDescr(index));
        att = TupleDescAttr(outTupDesc, spgKeyColumn);
        /* It's sufficient to update the type-dependent fields of the column */
        att->atttypid = keyType->type;
        att->atttypmod = -1;
        att->attlen = keyType->attlen;
        att->attbyval = keyType->attbyval;
        att->attalign = keyType->attalign;
        att->attstorage = keyType->attstorage;
        /* We shouldn't need to bother with making these valid: */
        att->attcompression = InvalidCompressionMethod;
        att->attcollation = InvalidOid;
        /* In case we changed typlen, we'd better reset following offsets */
        for (int i = spgFirstIncludeColumn; i < outTupDesc->natts; i++)
            TupleDescCompactAttr(outTupDesc, i)->attcacheoff = -1;
 
        populate_compact_attribute(outTupDesc, spgKeyColumn);
    }
    return outTupDesc;
}

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 343 of file spgutils.c.

{
    SpGistCache *cache;
 
    state->index = index;
 
    /* Get cached static information about index */
    cache = spgGetCache(index);
 
    state->config = cache->config;
    state->attType = cache->attType;
    state->attLeafType = cache->attLeafType;
    state->attPrefixType = cache->attPrefixType;
    state->attLabelType = cache->attLabelType;
 
    /* Ensure we have a valid descriptor for leaf tuples */
    state->leafTupDesc = getSpGistTupleDesc(state->index, &state->attLeafType);
 
    /* Make workspace for constructing dead tuples */
    state->deadTupleStorage = palloc0(SGDTSIZE);
 
    /*
     * Set horizon XID to use in redirection tuples.  Use our own XID if we
     * have one, else use InvalidTransactionId.  The latter case can happen in
     * VACUUM or REINDEX CONCURRENTLY, and in neither case would it be okay to
     * force an XID to be assigned.  VACUUM won't create any redirection
     * tuples anyway, but REINDEX CONCURRENTLY can.  Fortunately, REINDEX
     * CONCURRENTLY doesn't mark the index valid until the end, so there could
     * never be any concurrent scans "in flight" to a redirection tuple it has
     * inserted.  And it locks out VACUUM until the end, too.  So it's okay
     * for VACUUM to immediately expire a redirection tuple that contains an
     * invalid xid.
     */
    state->redirectXid = GetTopTransactionIdIfAny();
 
    /* Assume we're not in an index build (spgbuild will override) */
    state->isBuild = false;
}

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.

{
    int         sk_num;
    double     *distances = (double *) palloc(norderbys * sizeof(double)),
               *distance = distances;
 
    for (sk_num = 0; sk_num < norderbys; ++sk_num, ++orderbys, ++distance)
    {
        Point      *point = DatumGetPointP(orderbys->sk_argument);
 
        *distance = isLeaf ? point_point_distance(point, DatumGetPointP(key))
            : point_box_distance(point, DatumGetBoxP(key));
    }
 
    return distances;
}

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 1110 of file spgutils.c.

{
    bool        hasNullsMask = SGLT_GET_HASNULLMASK(tup);
    char       *tp;             /* ptr to tuple data */
    bits8      *bp;             /* ptr to null bitmap in tuple */
 
    if (keyColumnIsNull && tupleDescriptor->natts == 1)
    {
        /*
         * Trivial case: there is only the key attribute and we're in a nulls
         * tree.  The hasNullsMask bit in the tuple header should not be set
         * (and thus we can't use index_deform_tuple_internal), but
         * nonetheless the result is NULL.
         *
         * Note: currently this is dead code, because noplace calls this when
         * there is only the key attribute.  But we should cover the case.
         */
        Assert(!hasNullsMask);
 
        datums[spgKeyColumn] = (Datum) 0;
        isnulls[spgKeyColumn] = true;
        return;
    }
 
    tp = (char *) tup + SGLTHDRSZ(hasNullsMask);
    bp = (bits8 *) ((char *) tup + sizeof(SpGistLeafTupleData));
 
    index_deform_tuple_internal(tupleDescriptor,
                                datums, isnulls,
                                tp, bp, hasNullsMask);
 
    /*
     * Key column isnull value from the tuple should be consistent with
     * keyColumnIsNull flag from the caller.
     */
    Assert(keyColumnIsNull == isnulls[spgKeyColumn]);
}

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.

{
    bool        result = true;
    TupleDesc   leafDescriptor = state->leafTupDesc;
    bool        isnull = isnulls[spgKeyColumn];
    int         level = 0;
    Datum       leafDatums[INDEX_MAX_KEYS];
    int         leafSize;
    int         bestLeafSize;
    int         numNoProgressCycles = 0;
    SPPageDesc  current,
                parent;
    FmgrInfo   *procinfo = NULL;
 
    /*
     * Look up FmgrInfo of the user-defined choose function once, to save
     * cycles in the loop below.
     */
    if (!isnull)
        procinfo = index_getprocinfo(index, 1, SPGIST_CHOOSE_PROC);
 
    /*
     * Prepare the leaf datum to insert.
     *
     * If an optional "compress" method is provided, then call it to form the
     * leaf key datum from the input datum.  Otherwise, store the input datum
     * as is.  Since we don't use index_form_tuple in this AM, we have to make
     * sure value to be inserted is not toasted; FormIndexDatum doesn't
     * guarantee that.  But we assume the "compress" method to return an
     * untoasted value.
     */
    if (!isnull)
    {
        if (OidIsValid(index_getprocid(index, 1, SPGIST_COMPRESS_PROC)))
        {
            FmgrInfo   *compressProcinfo = NULL;
 
            compressProcinfo = index_getprocinfo(index, 1, SPGIST_COMPRESS_PROC);
            leafDatums[spgKeyColumn] =
                FunctionCall1Coll(compressProcinfo,
                                  index->rd_indcollation[spgKeyColumn],
                                  datums[spgKeyColumn]);
        }
        else
        {
            Assert(state->attLeafType.type == state->attType.type);
 
            if (state->attType.attlen == -1)
                leafDatums[spgKeyColumn] =
                    PointerGetDatum(PG_DETOAST_DATUM(datums[spgKeyColumn]));
            else
                leafDatums[spgKeyColumn] = datums[spgKeyColumn];
        }
    }
    else
        leafDatums[spgKeyColumn] = (Datum) 0;
 
    /* Likewise, ensure that any INCLUDE values are not toasted */
    for (int i = spgFirstIncludeColumn; i < leafDescriptor->natts; i++)
    {
        if (!isnulls[i])
        {
            if (TupleDescCompactAttr(leafDescriptor, i)->attlen == -1)
                leafDatums[i] = PointerGetDatum(PG_DETOAST_DATUM(datums[i]));
            else
                leafDatums[i] = datums[i];
        }
        else
            leafDatums[i] = (Datum) 0;
    }
 
    /*
     * Compute space needed for a leaf tuple containing the given data.
     */
    leafSize = SpGistGetLeafTupleSize(leafDescriptor, leafDatums, isnulls);
    /* Account for an item pointer, too */
    leafSize += sizeof(ItemIdData);
 
    /*
     * If it isn't gonna fit, and the opclass can't reduce the datum size by
     * suffixing, bail out now rather than doing a lot of useless work.
     */
    if (leafSize > SPGIST_PAGE_CAPACITY &&
        (isnull || !state->config.longValuesOK))
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("index row size %zu exceeds maximum %zu for index \"%s\"",
                        leafSize - sizeof(ItemIdData),
                        SPGIST_PAGE_CAPACITY - sizeof(ItemIdData),
                        RelationGetRelationName(index)),
                 errhint("Values larger than a buffer page cannot be indexed.")));
    bestLeafSize = leafSize;
 
    /* Initialize "current" to the appropriate root page */
    current.blkno = isnull ? SPGIST_NULL_BLKNO : SPGIST_ROOT_BLKNO;
    current.buffer = InvalidBuffer;
    current.page = NULL;
    current.offnum = FirstOffsetNumber;
    current.node = -1;
 
    /* "parent" is invalid for the moment */
    parent.blkno = InvalidBlockNumber;
    parent.buffer = InvalidBuffer;
    parent.page = NULL;
    parent.offnum = InvalidOffsetNumber;
    parent.node = -1;
 
    /*
     * Before entering the loop, try to clear any pending interrupt condition.
     * If a query cancel is pending, we might as well accept it now not later;
     * while if a non-canceling condition is pending, servicing it here avoids
     * having to restart the insertion and redo all the work so far.
     */
    CHECK_FOR_INTERRUPTS();
 
    for (;;)
    {
        bool        isNew = false;
 
        /*
         * Bail out if query cancel is pending.  We must have this somewhere
         * in the loop since a broken opclass could produce an infinite
         * picksplit loop.  However, because we'll be holding buffer lock(s)
         * after the first iteration, ProcessInterrupts() wouldn't be able to
         * throw a cancel error here.  Hence, if we see that an interrupt is
         * pending, break out of the loop and deal with the situation below.
         * Set result = false because we must restart the insertion if the
         * interrupt isn't a query-cancel-or-die case.
         */
        if (INTERRUPTS_PENDING_CONDITION())
        {
            result = false;
            break;
        }
 
        if (current.blkno == InvalidBlockNumber)
        {
            /*
             * Create a leaf page.  If leafSize is too large to fit on a page,
             * we won't actually use the page yet, but it simplifies the API
             * for doPickSplit to always have a leaf page at hand; so just
             * quietly limit our request to a page size.
             */
            current.buffer =
                SpGistGetBuffer(index,
                                GBUF_LEAF | (isnull ? GBUF_NULLS : 0),
                                Min(leafSize, SPGIST_PAGE_CAPACITY),
                                &isNew);
            current.blkno = BufferGetBlockNumber(current.buffer);
        }
        else if (parent.buffer == InvalidBuffer)
        {
            /* we hold no parent-page lock, so no deadlock is possible */
            current.buffer = ReadBuffer(index, current.blkno);
            LockBuffer(current.buffer, BUFFER_LOCK_EXCLUSIVE);
        }
        else if (current.blkno != parent.blkno)
        {
            /* descend to a new child page */
            current.buffer = ReadBuffer(index, current.blkno);
 
            /*
             * Attempt to acquire lock on child page.  We must beware of
             * deadlock against another insertion process descending from that
             * page to our parent page (see README).  If we fail to get lock,
             * abandon the insertion and tell our caller to start over.
             *
             * XXX this could be improved, because failing to get lock on a
             * buffer is not proof of a deadlock situation; the lock might be
             * held by a reader, or even just background writer/checkpointer
             * process.  Perhaps it'd be worth retrying after sleeping a bit?
             */
            if (!ConditionalLockBuffer(current.buffer))
            {
                ReleaseBuffer(current.buffer);
                UnlockReleaseBuffer(parent.buffer);
                return false;
            }
        }
        else
        {
            /* inner tuple can be stored on the same page as parent one */
            current.buffer = parent.buffer;
        }
        current.page = BufferGetPage(current.buffer);
 
        /* should not arrive at a page of the wrong type */
        if (isnull ? !SpGistPageStoresNulls(current.page) :
            SpGistPageStoresNulls(current.page))
            elog(ERROR, "SPGiST index page %u has wrong nulls flag",
                 current.blkno);
 
        if (SpGistPageIsLeaf(current.page))
        {
            SpGistLeafTuple leafTuple;
            int         nToSplit,
                        sizeToSplit;
 
            leafTuple = spgFormLeafTuple(state, heapPtr, leafDatums, isnulls);
            if (leafTuple->size + sizeof(ItemIdData) <=
                SpGistPageGetFreeSpace(current.page, 1))
            {
                /* it fits on page, so insert it and we're done */
                addLeafTuple(index, state, leafTuple,
                             &current, &parent, isnull, isNew);
                break;
            }
            else if ((sizeToSplit =
                      checkSplitConditions(index, state, &current,
                                           &nToSplit)) < SPGIST_PAGE_CAPACITY / 2 &&
                     nToSplit < 64 &&
                     leafTuple->size + sizeof(ItemIdData) + sizeToSplit <= SPGIST_PAGE_CAPACITY)
            {
                /*
                 * the amount of data is pretty small, so just move the whole
                 * chain to another leaf page rather than splitting it.
                 */
                Assert(!isNew);
                moveLeafs(index, state, &current, &parent, leafTuple, isnull);
                break;          /* we're done */
            }
            else
            {
                /* picksplit */
                if (doPickSplit(index, state, &current, &parent,
                                leafTuple, level, isnull, isNew))
                    break;      /* doPickSplit installed new tuples */
 
                /* leaf tuple will not be inserted yet */
                pfree(leafTuple);
 
                /*
                 * current now describes new inner tuple, go insert into it
                 */
                Assert(!SpGistPageIsLeaf(current.page));
                goto process_inner_tuple;
            }
        }
        else                    /* non-leaf page */
        {
            /*
             * Apply the opclass choose function to figure out how to insert
             * the given datum into the current inner tuple.
             */
            SpGistInnerTuple innerTuple;
            spgChooseIn in;
            spgChooseOut out;
 
            /*
             * spgAddNode and spgSplitTuple cases will loop back to here to
             * complete the insertion operation.  Just in case the choose
             * function is broken and produces add or split requests
             * repeatedly, check for query cancel (see comments above).
             */
    process_inner_tuple:
            if (INTERRUPTS_PENDING_CONDITION())
            {
                result = false;
                break;
            }
 
            innerTuple = (SpGistInnerTuple) PageGetItem(current.page,
                                                        PageGetItemId(current.page, current.offnum));
 
            in.datum = datums[spgKeyColumn];
            in.leafDatum = leafDatums[spgKeyColumn];
            in.level = level;
            in.allTheSame = innerTuple->allTheSame;
            in.hasPrefix = (innerTuple->prefixSize > 0);
            in.prefixDatum = SGITDATUM(innerTuple, state);
            in.nNodes = innerTuple->nNodes;
            in.nodeLabels = spgExtractNodeLabels(state, innerTuple);
 
            memset(&out, 0, sizeof(out));
 
            if (!isnull)
            {
                /* use user-defined choose method */
                FunctionCall2Coll(procinfo,
                                  index->rd_indcollation[0],
                                  PointerGetDatum(&in),
                                  PointerGetDatum(&out));
            }
            else
            {
                /* force "match" action (to insert to random subnode) */
                out.resultType = spgMatchNode;
            }
 
            if (innerTuple->allTheSame)
            {
                /*
                 * It's not allowed to do an AddNode at an allTheSame tuple.
                 * Opclass must say "match", in which case we choose a random
                 * one of the nodes to descend into, or "split".
                 */
                if (out.resultType == spgAddNode)
                    elog(ERROR, "cannot add a node to an allTheSame inner tuple");
                else if (out.resultType == spgMatchNode)
                    out.result.matchNode.nodeN =
                        pg_prng_uint64_range(&pg_global_prng_state,
                                             0, innerTuple->nNodes - 1);
            }
 
            switch (out.resultType)
            {
                case spgMatchNode:
                    /* Descend to N'th child node */
                    spgMatchNodeAction(index, state, innerTuple,
                                       &current, &parent,
                                       out.result.matchNode.nodeN);
                    /* Adjust level as per opclass request */
                    level += out.result.matchNode.levelAdd;
                    /* Replace leafDatum and recompute leafSize */
                    if (!isnull)
                    {
                        leafDatums[spgKeyColumn] = out.result.matchNode.restDatum;
                        leafSize = SpGistGetLeafTupleSize(leafDescriptor,
                                                          leafDatums, isnulls);
                        leafSize += sizeof(ItemIdData);
                    }
 
                    /*
                     * Check new tuple size; fail if it can't fit, unless the
                     * opclass says it can handle the situation by suffixing.
                     *
                     * However, the opclass can only shorten the leaf datum,
                     * which may not be enough to ever make the tuple fit,
                     * since INCLUDE columns might alone use more than a page.
                     * Depending on the opclass' behavior, that could lead to
                     * an infinite loop --- spgtextproc.c, for example, will
                     * just repeatedly generate an empty-string leaf datum
                     * once it runs out of data.  Actual bugs in opclasses
                     * might cause infinite looping, too.  To detect such a
                     * loop, check to see if we are making progress by
                     * reducing the leafSize in each pass.  This is a bit
                     * tricky though.  Because of alignment considerations,
                     * the total tuple size might not decrease on every pass.
                     * Also, there are edge cases where the choose method
                     * might seem to not make progress for a cycle or two.
                     * Somewhat arbitrarily, we allow up to 10 no-progress
                     * iterations before failing.  (This limit should be more
                     * than MAXALIGN, to accommodate opclasses that trim one
                     * byte from the leaf datum per pass.)
                     */
                    if (leafSize > SPGIST_PAGE_CAPACITY)
                    {
                        bool        ok = false;
 
                        if (state->config.longValuesOK && !isnull)
                        {
                            if (leafSize < bestLeafSize)
                            {
                                ok = true;
                                bestLeafSize = leafSize;
                                numNoProgressCycles = 0;
                            }
                            else if (++numNoProgressCycles < 10)
                                ok = true;
                        }
                        if (!ok)
                            ereport(ERROR,
                                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                                     errmsg("index row size %zu exceeds maximum %zu for index \"%s\"",
                                            leafSize - sizeof(ItemIdData),
                                            SPGIST_PAGE_CAPACITY - sizeof(ItemIdData),
                                            RelationGetRelationName(index)),
                                     errhint("Values larger than a buffer page cannot be indexed.")));
                    }
 
                    /*
                     * Loop around and attempt to insert the new leafDatum at
                     * "current" (which might reference an existing child
                     * tuple, or might be invalid to force us to find a new
                     * page for the tuple).
                     */
                    break;
                case spgAddNode:
                    /* AddNode is not sensible if nodes don't have labels */
                    if (in.nodeLabels == NULL)
                        elog(ERROR, "cannot add a node to an inner tuple without node labels");
                    /* Add node to inner tuple, per request */
                    spgAddNodeAction(index, state, innerTuple,
                                     &current, &parent,
                                     out.result.addNode.nodeN,
                                     out.result.addNode.nodeLabel);
 
                    /*
                     * Retry insertion into the enlarged node.  We assume that
                     * we'll get a MatchNode result this time.
                     */
                    goto process_inner_tuple;
                    break;
                case spgSplitTuple:
                    /* Split inner tuple, per request */
                    spgSplitNodeAction(index, state, innerTuple,
                                       &current, &out);
 
                    /* Retry insertion into the split node */
                    goto process_inner_tuple;
                    break;
                default:
                    elog(ERROR, "unrecognized SPGiST choose result: %d",
                         (int) out.resultType);
                    break;
            }
        }
    }                           /* end loop */
 
    /*
     * Release any buffers we're still holding.  Beware of possibility that
     * current and parent reference same buffer.
     */
    if (current.buffer != InvalidBuffer)
    {
        SpGistSetLastUsedPage(index, current.buffer);
        UnlockReleaseBuffer(current.buffer);
    }
    if (parent.buffer != InvalidBuffer &&
        parent.buffer != current.buffer)
    {
        SpGistSetLastUsedPage(index, parent.buffer);
        UnlockReleaseBuffer(parent.buffer);
    }
 
    /*
     * We do not support being called while some outer function is holding a
     * buffer lock (or any other reason to postpone query cancels).  If that
     * were the case, telling the caller to retry would create an infinite
     * loop.
     */
    Assert(INTERRUPTS_CAN_BE_PROCESSED());
 
    /*
     * Finally, check for interrupts again.  If there was a query cancel,
     * ProcessInterrupts() will be able to throw the error here.  If it was
     * some other kind of interrupt that can just be cleared, return false to
     * tell our caller to retry.
     */
    CHECK_FOR_INTERRUPTS();
 
    return result;
}

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 1155 of file spgutils.c.

{
    Datum      *nodeLabels;
    int         i;
    SpGistNodeTuple node;
 
    /* Either all the labels must be NULL, or none. */
    node = SGITNODEPTR(innerTuple);
    if (IndexTupleHasNulls(node))
    {
        SGITITERATE(innerTuple, i, node)
        {
            if (!IndexTupleHasNulls(node))
                elog(ERROR, "some but not all node labels are null in SPGiST inner tuple");
        }
        /* They're all null, so just return NULL */
        return NULL;
    }
    else
    {
        nodeLabels = (Datum *) palloc(sizeof(Datum) * innerTuple->nNodes);
        SGITITERATE(innerTuple, i, node)
        {
            if (IndexTupleHasNulls(node))
                elog(ERROR, "some but not all node labels are null in SPGiST inner tuple");
            nodeLabels[i] = SGNTDATUM(node, state);
        }
        return nodeLabels;
    }
}

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 1080 of file spgutils.c.

{
    SpGistDeadTuple tuple = (SpGistDeadTuple) state->deadTupleStorage;
 
    tuple->tupstate = tupstate;
    tuple->size = SGDTSIZE;
    SGLT_SET_NEXTOFFSET(tuple, InvalidOffsetNumber);
 
    if (tupstate == SPGIST_REDIRECT)
    {
        ItemPointerSet(&tuple->pointer, blkno, offnum);
        tuple->xid = state->redirectXid;
    }
    else
    {
        ItemPointerSetInvalid(&tuple->pointer);
        tuple->xid = InvalidTransactionId;
    }
 
    return tuple;
}

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 997 of file spgutils.c.

{
    SpGistInnerTuple tup;
    unsigned int size;
    unsigned int prefixSize;
    int         i;
    char       *ptr;
 
    /* Compute size needed */
    if (hasPrefix)
        prefixSize = SpGistGetInnerTypeSize(&state->attPrefixType, prefix);
    else
        prefixSize = 0;
 
    size = SGITHDRSZ + prefixSize;
 
    /* Note: we rely on node tuple sizes to be maxaligned already */
    for (i = 0; i < nNodes; i++)
        size += IndexTupleSize(nodes[i]);
 
    /*
     * Ensure that we can replace the tuple with a dead tuple later.  This
     * test is unnecessary given current tuple layouts, but let's be safe.
     */
    if (size < SGDTSIZE)
        size = SGDTSIZE;
 
    /*
     * Inner tuple should be small enough to fit on a page
     */
    if (size > SPGIST_PAGE_CAPACITY - sizeof(ItemIdData))
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("SP-GiST inner tuple size %zu exceeds maximum %zu",
                        (Size) size,
                        SPGIST_PAGE_CAPACITY - sizeof(ItemIdData)),
                 errhint("Values larger than a buffer page cannot be indexed.")));
 
    /*
     * Check for overflow of header fields --- probably can't fail if the
     * above succeeded, but let's be paranoid
     */
    if (size > SGITMAXSIZE ||
        prefixSize > SGITMAXPREFIXSIZE ||
        nNodes > SGITMAXNNODES)
        elog(ERROR, "SPGiST inner tuple header field is too small");
 
    /* OK, form the tuple */
    tup = (SpGistInnerTuple) palloc0(size);
 
    tup->nNodes = nNodes;
    tup->prefixSize = prefixSize;
    tup->size = size;
 
    if (hasPrefix)
        memcpyInnerDatum(SGITDATAPTR(tup), &state->attPrefixType, prefix);
 
    ptr = (char *) SGITNODEPTR(tup);
 
    for (i = 0; i < nNodes; i++)
    {
        SpGistNodeTuple node = nodes[i];
 
        memcpy(ptr, node, IndexTupleSize(node));
        ptr += IndexTupleSize(node);
    }
 
    return tup;
}

References elog, ereport, errcode(), errhint(), errmsg(), ERROR, i, IndexTupleSize, memcpyInnerDatum(), SpGistInnerTupleData::nNodes, palloc0(), SpGistInnerTupleData::prefixSize, SGDTSIZE, SGITDATAPTR, SGITHDRSZ, SGITMAXNNODES, SGITMAXPREFIXSIZE, SGITMAXSIZE, SGITNODEPTR, size, 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 866 of file spgutils.c.

{
    SpGistLeafTuple tup;
    TupleDesc   tupleDescriptor = state->leafTupDesc;
    Size        size;
    Size        hoff;
    Size        data_size;
    bool        needs_null_mask = false;
    int         natts = tupleDescriptor->natts;
    char       *tp;             /* ptr to tuple data */
    uint16      tupmask = 0;    /* unused heap_fill_tuple output */
 
    /*
     * Decide whether we need a nulls bitmask.
     *
     * If there is only a key attribute (natts == 1), never use a bitmask, for
     * compatibility with the pre-v14 layout of leaf tuples.  Otherwise, we
     * need one if any attribute is null.
     */
    if (natts > 1)
    {
        for (int i = 0; i < natts; i++)
        {
            if (isnulls[i])
            {
                needs_null_mask = true;
                break;
            }
        }
    }
 
    /*
     * Calculate size of the data part; same as for heap tuples.
     */
    data_size = heap_compute_data_size(tupleDescriptor, datums, isnulls);
 
    /*
     * Compute total size.
     */
    hoff = SGLTHDRSZ(needs_null_mask);
    size = hoff + data_size;
    size = MAXALIGN(size);
 
    /*
     * Ensure that we can replace the tuple with a dead tuple later. This test
     * is unnecessary when there are any non-null attributes, but be safe.
     */
    if (size < SGDTSIZE)
        size = SGDTSIZE;
 
    /* OK, form the tuple */
    tup = (SpGistLeafTuple) palloc0(size);
 
    tup->size = size;
    SGLT_SET_NEXTOFFSET(tup, InvalidOffsetNumber);
    tup->heapPtr = *heapPtr;
 
    tp = (char *) tup + hoff;
 
    if (needs_null_mask)
    {
        bits8      *bp;         /* ptr to null bitmap in tuple */
 
        /* Set nullmask presence bit in SpGistLeafTuple header */
        SGLT_SET_HASNULLMASK(tup, true);
        /* Fill the data area and null mask */
        bp = (bits8 *) ((char *) tup + sizeof(SpGistLeafTupleData));
        heap_fill_tuple(tupleDescriptor, datums, isnulls, tp, data_size,
                        &tupmask, bp);
    }
    else if (natts > 1 || !isnulls[spgKeyColumn])
    {
        /* Fill data area only */
        heap_fill_tuple(tupleDescriptor, datums, isnulls, tp, data_size,
                        &tupmask, (bits8 *) NULL);
    }
    /* otherwise we have no data, nor a bitmap, to fill */
 
    return tup;
}

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

Referenced by doPickSplit(), and spgdoinsert().

spgFormNodeTuple()

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

Definition at line 955 of file spgutils.c.

{
    SpGistNodeTuple tup;
    unsigned int size;
    unsigned short infomask = 0;
 
    /* compute space needed (note result is already maxaligned) */
    size = SGNTHDRSZ;
    if (!isnull)
        size += SpGistGetInnerTypeSize(&state->attLabelType, label);
 
    /*
     * Here we make sure that the size will fit in the field reserved for it
     * in t_info.
     */
    if ((size & INDEX_SIZE_MASK) != size)
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("index row requires %zu bytes, maximum size is %zu",
                        (Size) size, (Size) INDEX_SIZE_MASK)));
 
    tup = (SpGistNodeTuple) palloc0(size);
 
    if (isnull)
        infomask |= INDEX_NULL_MASK;
    /* we don't bother setting the INDEX_VAR_MASK bit */
    infomask |= size;
    tup->t_info = infomask;
 
    /* The TID field will be filled in later */
    ItemPointerSetInvalid(&tup->t_tid);
 
    if (!isnull)
        memcpyInnerDatum(SGNTDATAPTR(tup), &state->attLabelType, label);
 
    return tup;
}

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

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

spgGetCache()

SpGistCache * spgGetCache

(

Relation

index

)

Definition at line 183 of file spgutils.c.

{
    SpGistCache *cache;
 
    if (index->rd_amcache == NULL)
    {
        Oid         atttype;
        spgConfigIn in;
        FmgrInfo   *procinfo;
 
        cache = MemoryContextAllocZero(index->rd_indexcxt,
                                       sizeof(SpGistCache));
 
        /* SPGiST must have one key column and can also have INCLUDE columns */
        Assert(IndexRelationGetNumberOfKeyAttributes(index) == 1);
        Assert(IndexRelationGetNumberOfAttributes(index) <= INDEX_MAX_KEYS);
 
        /*
         * Get the actual (well, nominal) data type of the key column.  We
         * pass this to the opclass config function so that polymorphic
         * opclasses are possible.
         */
        atttype = GetIndexInputType(index, spgKeyColumn + 1);
 
        /* Call the config function to get config info for the opclass */
        in.attType = atttype;
 
        procinfo = index_getprocinfo(index, 1, SPGIST_CONFIG_PROC);
        FunctionCall2Coll(procinfo,
                          index->rd_indcollation[spgKeyColumn],
                          PointerGetDatum(&in),
                          PointerGetDatum(&cache->config));
 
        /*
         * If leafType isn't specified, use the declared index column type,
         * which index.c will have derived from the opclass's opcintype.
         * (Although we now make spgvalidate.c warn if these aren't the same,
         * old user-defined opclasses may not set the STORAGE parameter
         * correctly, so believe leafType if it's given.)
         */
        if (!OidIsValid(cache->config.leafType))
        {
            cache->config.leafType =
                TupleDescAttr(RelationGetDescr(index), spgKeyColumn)->atttypid;
 
            /*
             * If index column type is binary-coercible to atttype (for
             * example, it's a domain over atttype), treat it as plain atttype
             * to avoid thinking we need to compress.
             */
            if (cache->config.leafType != atttype &&
                IsBinaryCoercible(cache->config.leafType, atttype))
                cache->config.leafType = atttype;
        }
 
        /* Get the information we need about each relevant datatype */
        fillTypeDesc(&cache->attType, atttype);
 
        if (cache->config.leafType != atttype)
        {
            if (!OidIsValid(index_getprocid(index, 1, SPGIST_COMPRESS_PROC)))
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("compress method must be defined when leaf type is different from input type")));
 
            fillTypeDesc(&cache->attLeafType, cache->config.leafType);
        }
        else
        {
            /* Save lookups in this common case */
            cache->attLeafType = cache->attType;
        }
 
        fillTypeDesc(&cache->attPrefixType, cache->config.prefixType);
        fillTypeDesc(&cache->attLabelType, cache->config.labelType);
 
        /*
         * Finally, if it's a real index (not a partitioned one), get the
         * lastUsedPages data from the metapage
         */
        if (index->rd_rel->relkind != RELKIND_PARTITIONED_INDEX)
        {
            Buffer      metabuffer;
            SpGistMetaPageData *metadata;
 
            metabuffer = ReadBuffer(index, SPGIST_METAPAGE_BLKNO);
            LockBuffer(metabuffer, BUFFER_LOCK_SHARE);
 
            metadata = SpGistPageGetMeta(BufferGetPage(metabuffer));
 
            if (metadata->magicNumber != SPGIST_MAGIC_NUMBER)
                elog(ERROR, "index \"%s\" is not an SP-GiST index",
                     RelationGetRelationName(index));
 
            cache->lastUsedPages = metadata->lastUsedPages;
 
            UnlockReleaseBuffer(metabuffer);
        }
 
        index->rd_amcache = cache;
    }
    else
    {
        /* assume it's up to date */
        cache = (SpGistCache *) index->rd_amcache;
    }
 
    return cache;
}

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 564 of file spgutils.c.

{
    SpGistCache *cache = spgGetCache(index);
    SpGistLastUsedPage *lup;
 
    /* Bail out if even an empty page wouldn't meet the demand */
    if (needSpace > SPGIST_PAGE_CAPACITY)
        elog(ERROR, "desired SPGiST tuple size is too big");
 
    /*
     * If possible, increase the space request to include relation's
     * fillfactor.  This ensures that when we add unrelated tuples to a page,
     * we try to keep 100-fillfactor% available for adding tuples that are
     * related to the ones already on it.  But fillfactor mustn't cause an
     * error for requests that would otherwise be legal.
     */
    needSpace += SpGistGetTargetPageFreeSpace(index);
    needSpace = Min(needSpace, SPGIST_PAGE_CAPACITY);
 
    /* Get the cache entry for this flags setting */
    lup = GET_LUP(cache, flags);
 
    /* If we have nothing cached, just turn it over to allocNewBuffer */
    if (lup->blkno == InvalidBlockNumber)
    {
        *isNew = true;
        return allocNewBuffer(index, flags);
    }
 
    /* fixed pages should never be in cache */
    Assert(!SpGistBlockIsFixed(lup->blkno));
 
    /* If cached freeSpace isn't enough, don't bother looking at the page */
    if (lup->freeSpace >= needSpace)
    {
        Buffer      buffer;
        Page        page;
 
        buffer = ReadBuffer(index, lup->blkno);
 
        if (!ConditionalLockBuffer(buffer))
        {
            /*
             * buffer is locked by another process, so return a new buffer
             */
            ReleaseBuffer(buffer);
            *isNew = true;
            return allocNewBuffer(index, flags);
        }
 
        page = BufferGetPage(buffer);
 
        if (PageIsNew(page) || SpGistPageIsDeleted(page) || PageIsEmpty(page))
        {
            /* OK to initialize the page */
            uint16      pageflags = 0;
 
            if (GBUF_REQ_LEAF(flags))
                pageflags |= SPGIST_LEAF;
            if (GBUF_REQ_NULLS(flags))
                pageflags |= SPGIST_NULLS;
            SpGistInitBuffer(buffer, pageflags);
            lup->freeSpace = PageGetExactFreeSpace(page) - needSpace;
            *isNew = true;
            return buffer;
        }
 
        /*
         * Check that page is of right type and has enough space.  We must
         * recheck this since our cache isn't necessarily up to date.
         */
        if ((GBUF_REQ_LEAF(flags) ? SpGistPageIsLeaf(page) : !SpGistPageIsLeaf(page)) &&
            (GBUF_REQ_NULLS(flags) ? SpGistPageStoresNulls(page) : !SpGistPageStoresNulls(page)))
        {
            int         freeSpace = PageGetExactFreeSpace(page);
 
            if (freeSpace >= needSpace)
            {
                /* Success, update freespace info and return the buffer */
                lup->freeSpace = freeSpace - needSpace;
                *isNew = false;
                return buffer;
            }
        }
 
        /*
         * fallback to allocation of new buffer
         */
        UnlockReleaseBuffer(buffer);
    }
 
    /* No success with cache, so return a new buffer */
    *isNew = true;
    return allocNewBuffer(index, flags);
}

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 774 of file spgutils.c.

{
    unsigned int size;
 
    if (att->attbyval)
        size = sizeof(Datum);
    else if (att->attlen > 0)
        size = att->attlen;
    else
        size = VARSIZE_ANY(datum);
 
    return MAXALIGN(size);
}

References SpGistTypeDesc::attbyval, SpGistTypeDesc::attlen, MAXALIGN, size, and VARSIZE_ANY.

Referenced by spgFormInnerTuple(), and spgFormNodeTuple().

SpGistGetLeafTupleSize()

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

Definition at line 813 of file spgutils.c.

{
    Size        size;
    Size        data_size;
    bool        needs_null_mask = false;
    int         natts = tupleDescriptor->natts;
 
    /*
     * Decide whether we need a nulls bitmask.
     *
     * If there is only a key attribute (natts == 1), never use a bitmask, for
     * compatibility with the pre-v14 layout of leaf tuples.  Otherwise, we
     * need one if any attribute is null.
     */
    if (natts > 1)
    {
        for (int i = 0; i < natts; i++)
        {
            if (isnulls[i])
            {
                needs_null_mask = true;
                break;
            }
        }
    }
 
    /*
     * Calculate size of the data part; same as for heap tuples.
     */
    data_size = heap_compute_data_size(tupleDescriptor, datums, isnulls);
 
    /*
     * Compute total size.
     */
    size = SGLTHDRSZ(needs_null_mask);
    size += data_size;
    size = MAXALIGN(size);
 
    /*
     * Ensure that we can replace the tuple with a dead tuple later. This test
     * is unnecessary when there are any non-null attributes, but be safe.
     */
    if (size < SGDTSIZE)
        size = SGDTSIZE;
 
    return size;
}

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

Referenced by spgdoinsert().

SpGistInitBuffer()

void SpGistInitBuffer	(	Buffer	b,
		uint16	f
	)

Definition at line 717 of file spgutils.c.

{
    Assert(BufferGetPageSize(b) == BLCKSZ);
    SpGistInitPage(BufferGetPage(b), f);
}

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 727 of file spgutils.c.

{
    SpGistMetaPageData *metadata;
    int         i;
 
    SpGistInitPage(page, SPGIST_META);
    metadata = SpGistPageGetMeta(page);
    memset(metadata, 0, sizeof(SpGistMetaPageData));
    metadata->magicNumber = SPGIST_MAGIC_NUMBER;
 
    /* initialize last-used-page cache to empty */
    for (i = 0; i < SPGIST_CACHED_PAGES; i++)
        metadata->lastUsedPages.cachedPage[i].blkno = InvalidBlockNumber;
 
    /*
     * Set pd_lower just past the end of the metadata.  This is essential,
     * because without doing so, metadata will be lost if xlog.c compresses
     * the page.
     */
    ((PageHeader) page)->pd_lower =
        ((char *) metadata + sizeof(SpGistMetaPageData)) - (char *) page;
}

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 703 of file spgutils.c.

{
    SpGistPageOpaque opaque;
 
    PageInit(page, BLCKSZ, sizeof(SpGistPageOpaqueData));
    opaque = SpGistPageGetOpaque(page);
    opaque->flags = f;
    opaque->spgist_page_id = SPGIST_PAGE_ID;
}

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 389 of file spgutils.c.

{
    Buffer      buffer;
 
    /* First, try to get a page from FSM */
    for (;;)
    {
        BlockNumber blkno = GetFreeIndexPage(index);
 
        if (blkno == InvalidBlockNumber)
            break;              /* nothing known to FSM */
 
        /*
         * The fixed pages shouldn't ever be listed in FSM, but just in case
         * one is, ignore it.
         */
        if (SpGistBlockIsFixed(blkno))
            continue;
 
        buffer = ReadBuffer(index, blkno);
 
        /*
         * We have to guard against the possibility that someone else already
         * recycled this page; the buffer may be locked if so.
         */
        if (ConditionalLockBuffer(buffer))
        {
            Page        page = BufferGetPage(buffer);
 
            if (PageIsNew(page))
                return buffer;  /* OK to use, if never initialized */
 
            if (SpGistPageIsDeleted(page) || PageIsEmpty(page))
                return buffer;  /* OK to use */
 
            LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
        }
 
        /* Can't use it, so release buffer and try again */
        ReleaseBuffer(buffer);
    }
 
    buffer = ExtendBufferedRel(BMR_REL(index), MAIN_FORKNUM, NULL,
                               EB_LOCK_FIRST);
 
    return buffer;
}

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 1198 of file spgutils.c.

{
    SpGistPageOpaque opaque = SpGistPageGetOpaque(page);
    OffsetNumber i,
                maxoff,
                offnum;
 
    if (opaque->nPlaceholder > 0 &&
        PageGetExactFreeSpace(page) + SGDTSIZE >= MAXALIGN(size))
    {
        /* Try to replace a placeholder */
        maxoff = PageGetMaxOffsetNumber(page);
        offnum = InvalidOffsetNumber;
 
        for (;;)
        {
            if (startOffset && *startOffset != InvalidOffsetNumber)
                i = *startOffset;
            else
                i = FirstOffsetNumber;
            for (; i <= maxoff; i++)
            {
                SpGistDeadTuple it = (SpGistDeadTuple) PageGetItem(page,
                                                                   PageGetItemId(page, i));
 
                if (it->tupstate == SPGIST_PLACEHOLDER)
                {
                    offnum = i;
                    break;
                }
            }
 
            /* Done if we found a placeholder */
            if (offnum != InvalidOffsetNumber)
                break;
 
            if (startOffset && *startOffset != InvalidOffsetNumber)
            {
                /* Hint was no good, re-search from beginning */
                *startOffset = InvalidOffsetNumber;
                continue;
            }
 
            /* Hmm, no placeholder found? */
            opaque->nPlaceholder = 0;
            break;
        }
 
        if (offnum != InvalidOffsetNumber)
        {
            /* Replace the placeholder tuple */
            PageIndexTupleDelete(page, offnum);
 
            offnum = PageAddItem(page, item, size, offnum, false, false);
 
            /*
             * We should not have failed given the size check at the top of
             * the function, but test anyway.  If we did fail, we must PANIC
             * because we've already deleted the placeholder tuple, and
             * there's no other way to keep the damage from getting to disk.
             */
            if (offnum != InvalidOffsetNumber)
            {
                Assert(opaque->nPlaceholder > 0);
                opaque->nPlaceholder--;
                if (startOffset)
                    *startOffset = offnum + 1;
            }
            else
                elog(PANIC, "failed to add item of size %zu to SPGiST index page",
                     size);
 
            return offnum;
        }
    }
 
    /* No luck in replacing a placeholder, so just add it to the page */
    offnum = PageAddItem(page, item, size,
                         InvalidOffsetNumber, false, false);
 
    if (offnum == InvalidOffsetNumber && !errorOK)
        elog(ERROR, "failed to add item of size %zu to SPGiST index page",
             size);
 
    return offnum;
}

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

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

SpGistSetLastUsedPage()

void SpGistSetLastUsedPage	(	Relation	index,
		Buffer	buffer
	)

Definition at line 668 of file spgutils.c.

{
    SpGistCache *cache = spgGetCache(index);
    SpGistLastUsedPage *lup;
    int         freeSpace;
    Page        page = BufferGetPage(buffer);
    BlockNumber blkno = BufferGetBlockNumber(buffer);
    int         flags;
 
    /* Never enter fixed pages (root pages) in cache, though */
    if (SpGistBlockIsFixed(blkno))
        return;
 
    if (SpGistPageIsLeaf(page))
        flags = GBUF_LEAF;
    else
        flags = GBUF_INNER_PARITY(blkno);
    if (SpGistPageStoresNulls(page))
        flags |= GBUF_NULLS;
 
    lup = GET_LUP(cache, flags);
 
    freeSpace = PageGetExactFreeSpace(page);
    if (lup->blkno == InvalidBlockNumber || lup->blkno == blkno ||
        lup->freeSpace < freeSpace)
    {
        lup->blkno = blkno;
        lup->freeSpace = freeSpace;
    }
}

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 445 of file spgutils.c.

{
    SpGistCache *cache = (SpGistCache *) index->rd_amcache;
 
    if (cache != NULL)
    {
        Buffer      metabuffer;
 
        metabuffer = ReadBuffer(index, SPGIST_METAPAGE_BLKNO);
 
        if (ConditionalLockBuffer(metabuffer))
        {
            Page        metapage = BufferGetPage(metabuffer);
            SpGistMetaPageData *metadata = SpGistPageGetMeta(metapage);
 
            metadata->lastUsedPages = cache->lastUsedPages;
 
            /*
             * Set pd_lower just past the end of the metadata.  This is
             * essential, because without doing so, metadata will be lost if
             * xlog.c compresses the page.  (We must do this here because
             * pre-v11 versions of PG did not set the metapage's pd_lower
             * correctly, so a pg_upgraded index might contain the wrong
             * value.)
             */
            ((PageHeader) metapage)->pd_lower =
                ((char *) metadata + sizeof(SpGistMetaPageData)) - (char *) metapage;
 
            MarkBufferDirty(metabuffer);
            UnlockReleaseBuffer(metabuffer);
        }
        else
        {
            ReleaseBuffer(metabuffer);
        }
    }
}

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.

{
    OffsetNumber firstItem;
    OffsetNumber sortednos[MaxIndexTuplesPerPage];
    SpGistDeadTuple tuple = NULL;
    int         i;
 
    if (nitems == 0)
        return;                 /* nothing to do */
 
    /*
     * For efficiency we want to use PageIndexMultiDelete, which requires the
     * targets to be listed in sorted order, so we have to sort the itemnos
     * array.  (This also greatly simplifies the math for reinserting the
     * replacement tuples.)  However, we must not scribble on the caller's
     * array, so we have to make a copy.
     */
    memcpy(sortednos, itemnos, sizeof(OffsetNumber) * nitems);
    if (nitems > 1)
        qsort(sortednos, nitems, sizeof(OffsetNumber), cmpOffsetNumbers);
 
    PageIndexMultiDelete(page, sortednos, nitems);
 
    firstItem = itemnos[0];
 
    for (i = 0; i < nitems; i++)
    {
        OffsetNumber itemno = sortednos[i];
        int         tupstate;
 
        tupstate = (itemno == firstItem) ? firststate : reststate;
        if (tuple == NULL || tuple->tupstate != tupstate)
            tuple = spgFormDeadTuple(state, tupstate, blkno, offnum);
 
        if (PageAddItem(page, (Item) tuple, tuple->size,
                        itemno, false, false) != itemno)
            elog(ERROR, "failed to add item of size %u to SPGiST index page",
                 tuple->size);
 
        if (tupstate == SPGIST_REDIRECT)
            SpGistPageGetOpaque(page)->nRedirection++;
        else if (tupstate == SPGIST_PLACEHOLDER)
            SpGistPageGetOpaque(page)->nPlaceholder++;
    }
}

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 1293 of file spgutils.c.

{
    Oid         opclass,
                opfamily,
                opcintype;
    CatCList   *catlist;
    int         i;
 
    /* Only answer column-level inquiries */
    if (attno == 0)
        return false;
 
    switch (prop)
    {
        case AMPROP_DISTANCE_ORDERABLE:
            break;
        default:
            return false;
    }
 
    /*
     * Currently, SP-GiST distance-ordered scans require that there be a
     * distance operator in the opclass with the default types. So we assume
     * that if such an operator exists, then there's a reason for it.
     */
 
    /* First we need to know the column's opclass. */
    opclass = get_index_column_opclass(index_oid, attno);
    if (!OidIsValid(opclass))
    {
        *isnull = true;
        return true;
    }
 
    /* Now look up the opclass family and input datatype. */
    if (!get_opclass_opfamily_and_input_type(opclass, &opfamily, &opcintype))
    {
        *isnull = true;
        return true;
    }
 
    /* And now we can check whether the operator is provided. */
    catlist = SearchSysCacheList1(AMOPSTRATEGY,
                                  ObjectIdGetDatum(opfamily));
 
    *res = false;
 
    for (i = 0; i < catlist->n_members; i++)
    {
        HeapTuple   amoptup = &catlist->members[i]->tuple;
        Form_pg_amop amopform = (Form_pg_amop) GETSTRUCT(amoptup);
 
        if (amopform->amoppurpose == AMOP_ORDER &&
            (amopform->amoplefttype == opcintype ||
             amopform->amoprighttype == opcintype) &&
            opfamily_can_sort_type(amopform->amopsortfamily,
                                   get_op_rettype(amopform->amopopr)))
        {
            *res = true;
            break;
        }
    }
 
    ReleaseSysCacheList(catlist);
 
    *isnull = false;
 
    return true;
}

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, res, 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.

{
    int         i;
    SpGistNodeTuple node;
 
    SGITITERATE(tup, i, node)
    {
        if (i == nodeN)
        {
            ItemPointerSet(&node->t_tid, blkno, offset);
            return;
        }
    }
 
    elog(ERROR, "failed to find requested node %d in SPGiST inner tuple",
         nodeN);
}

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

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