spgutils.c File Reference

#include "postgres.h"
#include "access/amvalidate.h"
#include "access/htup_details.h"
#include "access/reloptions.h"
#include "access/spgist_private.h"
#include "access/toast_compression.h"
#include "access/transam.h"
#include "access/xact.h"
#include "catalog/pg_amop.h"
#include "commands/vacuum.h"
#include "nodes/nodeFuncs.h"
#include "parser/parse_coerce.h"
#include "storage/bufmgr.h"
#include "storage/indexfsm.h"
#include "utils/catcache.h"
#include "utils/fmgrprotos.h"
#include "utils/index_selfuncs.h"
#include "utils/lsyscache.h"
#include "utils/rel.h"
#include "utils/syscache.h"

Include dependency graph for spgutils.c:

Go to the source code of this file.

Macros
#define	GET_LUP(c, f)   (&(c)->lastUsedPages.cachedPage[((unsigned int) (f)) % SPGIST_CACHED_PAGES])

Functions
Datum	spghandler (PG_FUNCTION_ARGS)
static Oid	GetIndexInputType (Relation index, AttrNumber indexcol)
static void	fillTypeDesc (SpGistTypeDesc *desc, Oid type)
SpGistCache *	spgGetCache (Relation index)
TupleDesc	getSpGistTupleDesc (Relation index, SpGistTypeDesc *keyType)
void	initSpGistState (SpGistState *state, Relation index)
Buffer	SpGistNewBuffer (Relation index)
void	SpGistUpdateMetaPage (Relation index)
static Buffer	allocNewBuffer (Relation index, int flags)
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)
bytea *	spgoptions (Datum reloptions, bool validate)
unsigned int	SpGistGetInnerTypeSize (SpGistTypeDesc *att, Datum datum)
static void	memcpyInnerDatum (void *target, 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)

Macro Definition Documentation

GET_LUP

#define GET_LUP	(		c,
			f
	)		(&(c)->lastUsedPages.cachedPage[((unsigned int) (f)) % SPGIST_CACHED_PAGES])

Definition at line 471 of file spgutils.c.

Function Documentation

allocNewBuffer()

static Buffer allocNewBuffer ( Relation  index, int  flags  )

static

Definition at line 494 of file spgutils.c.

{
    SpGistCache *cache = spgGetCache(index);
    uint16      pageflags = 0;
 
    if (GBUF_REQ_LEAF(flags))
        pageflags |= SPGIST_LEAF;
    if (GBUF_REQ_NULLS(flags))
        pageflags |= SPGIST_NULLS;
 
    for (;;)
    {
        Buffer      buffer;
 
        buffer = SpGistNewBuffer(index);
        SpGistInitBuffer(buffer, pageflags);
 
        if (pageflags & SPGIST_LEAF)
        {
            /* Leaf pages have no parity concerns, so just use it */
            return buffer;
        }
        else
        {
            BlockNumber blkno = BufferGetBlockNumber(buffer);
            int         blkFlags = GBUF_INNER_PARITY(blkno);
 
            if ((flags & GBUF_PARITY_MASK) == blkFlags)
            {
                /* Page has right parity, use it */
                return buffer;
            }
            else
            {
                /* Page has wrong parity, record it in cache and try again */
                if (pageflags & SPGIST_NULLS)
                    blkFlags |= GBUF_NULLS;
                cache->lastUsedPages.cachedPage[blkFlags].blkno = blkno;
                cache->lastUsedPages.cachedPage[blkFlags].freeSpace =
                    PageGetExactFreeSpace(BufferGetPage(buffer));
                UnlockReleaseBuffer(buffer);
            }
        }
    }
}

References SpGistLastUsedPage::blkno, BufferGetBlockNumber(), BufferGetPage(), SpGistLUPCache::cachedPage, SpGistLastUsedPage::freeSpace, GBUF_INNER_PARITY, GBUF_NULLS, GBUF_PARITY_MASK, GBUF_REQ_LEAF, GBUF_REQ_NULLS, SpGistCache::lastUsedPages, PageGetExactFreeSpace(), spgGetCache(), SPGIST_LEAF, SPGIST_NULLS, SpGistInitBuffer(), SpGistNewBuffer(), and UnlockReleaseBuffer().

Referenced by SpGistGetBuffer().

fillTypeDesc()

static void fillTypeDesc ( SpGistTypeDesc *  desc, Oid  type  )

static

Definition at line 160 of file spgutils.c.

{
    HeapTuple   tp;
    Form_pg_type typtup;
 
    desc->type = type;
    tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for type %u", type);
    typtup = (Form_pg_type) GETSTRUCT(tp);
    desc->attlen = typtup->typlen;
    desc->attbyval = typtup->typbyval;
    desc->attalign = typtup->typalign;
    desc->attstorage = typtup->typstorage;
    ReleaseSysCache(tp);
}

References SpGistTypeDesc::attalign, SpGistTypeDesc::attbyval, SpGistTypeDesc::attlen, SpGistTypeDesc::attstorage, elog, ERROR, GETSTRUCT, HeapTupleIsValid, ObjectIdGetDatum(), ReleaseSysCache(), SearchSysCache1(), type, and SpGistTypeDesc::type.

Referenced by spgGetCache().

GetIndexInputType()

static Oid GetIndexInputType ( Relation  index, AttrNumber  indexcol  )

static

Definition at line 115 of file spgutils.c.

{
    Oid         opcintype;
    AttrNumber  heapcol;
    List       *indexprs;
    ListCell   *indexpr_item;
 
    Assert(index->rd_index != NULL);
    Assert(indexcol > 0 && indexcol <= index->rd_index->indnkeyatts);
    opcintype = index->rd_opcintype[indexcol - 1];
    if (!IsPolymorphicType(opcintype))
        return opcintype;
    heapcol = index->rd_index->indkey.values[indexcol - 1];
    if (heapcol != 0)           /* Simple index column? */
        return getBaseType(get_atttype(index->rd_index->indrelid, heapcol));
 
    /*
     * If the index expressions are already cached, skip calling
     * RelationGetIndexExpressions, as it will make a copy which is overkill.
     * We're not going to modify the trees, and we're not going to do anything
     * that would invalidate the relcache entry before we're done.
     */
    if (index->rd_indexprs)
        indexprs = index->rd_indexprs;
    else
        indexprs = RelationGetIndexExpressions(index);
    indexpr_item = list_head(indexprs);
    for (int i = 1; i <= index->rd_index->indnkeyatts; i++)
    {
        if (index->rd_index->indkey.values[i - 1] == 0)
        {
            /* expression column */
            if (indexpr_item == NULL)
                elog(ERROR, "wrong number of index expressions");
            if (i == indexcol)
                return getBaseType(exprType((Node *) lfirst(indexpr_item)));
            indexpr_item = lnext(indexprs, indexpr_item);
        }
    }
    elog(ERROR, "wrong number of index expressions");
    return InvalidOid;          /* keep compiler quiet */
}

References Assert, elog, ERROR, exprType(), get_atttype(), getBaseType(), i, InvalidOid, lfirst, list_head(), lnext(), and RelationGetIndexExpressions().

Referenced by spgGetCache().

getSpGistTupleDesc()

TupleDesc getSpGistTupleDesc	(	Relation	index,
		SpGistTypeDesc *	keyType
	)

Definition at line 309 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++)
            TupleDescAttr(outTupDesc, i)->attcacheoff = -1;
    }
    return outTupDesc;
}

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

Referenced by initSpGistState(), and spgbeginscan().

initSpGistState()

void initSpGistState	(	SpGistState *	state,
		Relation	index
	)

Definition at line 340 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 XID to use in redirection tuples */
    state->myXid = 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().

memcpyInnerDatum()

static void memcpyInnerDatum ( void *  target, SpGistTypeDesc *  att, Datum  datum  )

static

Definition at line 778 of file spgutils.c.

{
    unsigned int size;
 
    if (att->attbyval)
    {
        memcpy(target, &datum, sizeof(Datum));
    }
    else
    {
        size = (att->attlen > 0) ? att->attlen : VARSIZE_ANY(datum);
        memcpy(target, DatumGetPointer(datum), size);
    }
}

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

Referenced by spgFormInnerTuple(), and spgFormNodeTuple().

spgDeformLeafTuple()

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

Definition at line 1097 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().

spgExtractNodeLabels()

Datum* spgExtractNodeLabels	(	SpGistState *	state,
		SpGistInnerTuple	innerTuple
	)

Definition at line 1142 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 1066 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);
        Assert(TransactionIdIsValid(state->myXid));
        tuple->xid = state->myXid;
    }
    else
    {
        ItemPointerSetInvalid(&tuple->pointer);
        tuple->xid = InvalidTransactionId;
    }
 
    return tuple;
}

References Assert, InvalidOffsetNumber, InvalidTransactionId, ItemPointerSet(), ItemPointerSetInvalid(), SpGistDeadTupleData::pointer, SGDTSIZE, SGLT_SET_NEXTOFFSET, SpGistDeadTupleData::size, SPGIST_REDIRECT, TransactionIdIsValid, 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 983 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 852 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 941 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 182 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 = (void *) 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().

spghandler()

Datum spghandler

(

PG_FUNCTION_ARGS

)

Definition at line 44 of file spgutils.c.

{
    IndexAmRoutine *amroutine = makeNode(IndexAmRoutine);
 
    amroutine->amstrategies = 0;
    amroutine->amsupport = SPGISTNProc;
    amroutine->amoptsprocnum = SPGIST_OPTIONS_PROC;
    amroutine->amcanorder = false;
    amroutine->amcanorderbyop = true;
    amroutine->amcanbackward = false;
    amroutine->amcanunique = false;
    amroutine->amcanmulticol = false;
    amroutine->amoptionalkey = true;
    amroutine->amsearcharray = false;
    amroutine->amsearchnulls = true;
    amroutine->amstorage = true;
    amroutine->amclusterable = false;
    amroutine->ampredlocks = false;
    amroutine->amcanparallel = false;
    amroutine->amcanbuildparallel = false;
    amroutine->amcaninclude = true;
    amroutine->amusemaintenanceworkmem = false;
    amroutine->amsummarizing = false;
    amroutine->amparallelvacuumoptions =
        VACUUM_OPTION_PARALLEL_BULKDEL | VACUUM_OPTION_PARALLEL_COND_CLEANUP;
    amroutine->amkeytype = InvalidOid;
 
    amroutine->ambuild = spgbuild;
    amroutine->ambuildempty = spgbuildempty;
    amroutine->aminsert = spginsert;
    amroutine->aminsertcleanup = NULL;
    amroutine->ambulkdelete = spgbulkdelete;
    amroutine->amvacuumcleanup = spgvacuumcleanup;
    amroutine->amcanreturn = spgcanreturn;
    amroutine->amcostestimate = spgcostestimate;
    amroutine->amoptions = spgoptions;
    amroutine->amproperty = spgproperty;
    amroutine->ambuildphasename = NULL;
    amroutine->amvalidate = spgvalidate;
    amroutine->amadjustmembers = spgadjustmembers;
    amroutine->ambeginscan = spgbeginscan;
    amroutine->amrescan = spgrescan;
    amroutine->amgettuple = spggettuple;
    amroutine->amgetbitmap = spggetbitmap;
    amroutine->amendscan = spgendscan;
    amroutine->ammarkpos = NULL;
    amroutine->amrestrpos = NULL;
    amroutine->amestimateparallelscan = NULL;
    amroutine->aminitparallelscan = NULL;
    amroutine->amparallelrescan = NULL;
 
    PG_RETURN_POINTER(amroutine);
}

References IndexAmRoutine::amadjustmembers, IndexAmRoutine::ambeginscan, IndexAmRoutine::ambuild, IndexAmRoutine::ambuildempty, IndexAmRoutine::ambuildphasename, IndexAmRoutine::ambulkdelete, IndexAmRoutine::amcanbackward, IndexAmRoutine::amcanbuildparallel, IndexAmRoutine::amcaninclude, IndexAmRoutine::amcanmulticol, IndexAmRoutine::amcanorder, IndexAmRoutine::amcanorderbyop, IndexAmRoutine::amcanparallel, IndexAmRoutine::amcanreturn, IndexAmRoutine::amcanunique, IndexAmRoutine::amclusterable, IndexAmRoutine::amcostestimate, IndexAmRoutine::amendscan, IndexAmRoutine::amestimateparallelscan, IndexAmRoutine::amgetbitmap, IndexAmRoutine::amgettuple, IndexAmRoutine::aminitparallelscan, IndexAmRoutine::aminsert, IndexAmRoutine::aminsertcleanup, IndexAmRoutine::amkeytype, IndexAmRoutine::ammarkpos, IndexAmRoutine::amoptionalkey, IndexAmRoutine::amoptions, IndexAmRoutine::amoptsprocnum, IndexAmRoutine::amparallelrescan, IndexAmRoutine::amparallelvacuumoptions, IndexAmRoutine::ampredlocks, IndexAmRoutine::amproperty, IndexAmRoutine::amrescan, IndexAmRoutine::amrestrpos, IndexAmRoutine::amsearcharray, IndexAmRoutine::amsearchnulls, IndexAmRoutine::amstorage, IndexAmRoutine::amstrategies, IndexAmRoutine::amsummarizing, IndexAmRoutine::amsupport, IndexAmRoutine::amusemaintenanceworkmem, IndexAmRoutine::amvacuumcleanup, IndexAmRoutine::amvalidate, InvalidOid, makeNode, PG_RETURN_POINTER, spgadjustmembers(), spgbeginscan(), spgbuild(), spgbuildempty(), spgbulkdelete(), spgcanreturn(), spgcostestimate(), spgendscan(), spggetbitmap(), spggettuple(), spginsert(), SPGIST_OPTIONS_PROC, SPGISTNProc, spgoptions(), spgproperty(), spgrescan(), spgvacuumcleanup(), spgvalidate(), VACUUM_OPTION_PARALLEL_BULKDEL, and VACUUM_OPTION_PARALLEL_COND_CLEANUP.

SpGistGetBuffer()

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

Definition at line 550 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 760 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 799 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 703 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 713 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 689 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 375 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 1185 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 654 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 431 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().

spgoptions()

bytea* spgoptions	(	Datum	reloptions,
		bool	validate
	)

Definition at line 740 of file spgutils.c.

{
    static const relopt_parse_elt tab[] = {
        {"fillfactor", RELOPT_TYPE_INT, offsetof(SpGistOptions, fillfactor)},
    };
 
    return (bytea *) build_reloptions(reloptions, validate,
                                      RELOPT_KIND_SPGIST,
                                      sizeof(SpGistOptions),
                                      tab, lengthof(tab));
}

References build_reloptions(), fillfactor, lengthof, RELOPT_KIND_SPGIST, and RELOPT_TYPE_INT.

Referenced by spghandler().

spgproperty()

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

Definition at line 1280 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().