spgist.h File Reference

#include "access/amapi.h"
#include "access/xlogreader.h"
#include "lib/stringinfo.h"

Include dependency graph for spgist.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	spgConfigIn
struct	spgConfigOut
struct	spgChooseIn
struct	spgChooseOut
struct	spgPickSplitIn
struct	spgPickSplitOut
struct	spgInnerConsistentIn
struct	spgInnerConsistentOut
struct	spgLeafConsistentIn
struct	spgLeafConsistentOut

Macros
#define	SPGIST_CONFIG_PROC   1
#define	SPGIST_CHOOSE_PROC   2
#define	SPGIST_PICKSPLIT_PROC   3
#define	SPGIST_INNER_CONSISTENT_PROC   4
#define	SPGIST_LEAF_CONSISTENT_PROC   5
#define	SPGIST_COMPRESS_PROC   6
#define	SPGIST_OPTIONS_PROC   7
#define	SPGISTNRequiredProc   5
#define	SPGISTNProc   7

Typedefs
typedef struct spgConfigIn	spgConfigIn
typedef struct spgConfigOut	spgConfigOut
typedef struct spgChooseIn	spgChooseIn
typedef enum spgChooseResultType	spgChooseResultType
typedef struct spgChooseOut	spgChooseOut
typedef struct spgPickSplitIn	spgPickSplitIn
typedef struct spgPickSplitOut	spgPickSplitOut
typedef struct spgInnerConsistentIn	spgInnerConsistentIn
typedef struct spgInnerConsistentOut	spgInnerConsistentOut
typedef struct spgLeafConsistentIn	spgLeafConsistentIn
typedef struct spgLeafConsistentOut	spgLeafConsistentOut

Enumerations
enum	spgChooseResultType { spgMatchNode = 1 , spgAddNode , spgSplitTuple }

Functions
bytea *	spgoptions (Datum reloptions, bool validate)
IndexBuildResult *	spgbuild (Relation heap, Relation index, struct IndexInfo *indexInfo)
void	spgbuildempty (Relation index)
bool	spginsert (Relation index, Datum *values, bool *isnull, ItemPointer ht_ctid, Relation heapRel, IndexUniqueCheck checkUnique, bool indexUnchanged, struct IndexInfo *indexInfo)
IndexScanDesc	spgbeginscan (Relation rel, int keysz, int orderbysz)
void	spgendscan (IndexScanDesc scan)
void	spgrescan (IndexScanDesc scan, ScanKey scankey, int nscankeys, ScanKey orderbys, int norderbys)
int64	spggetbitmap (IndexScanDesc scan, TIDBitmap *tbm)
bool	spggettuple (IndexScanDesc scan, ScanDirection dir)
bool	spgcanreturn (Relation index, int attno)
IndexBulkDeleteResult *	spgbulkdelete (IndexVacuumInfo *info, IndexBulkDeleteResult *stats, IndexBulkDeleteCallback callback, void *callback_state)
IndexBulkDeleteResult *	spgvacuumcleanup (IndexVacuumInfo *info, IndexBulkDeleteResult *stats)
bool	spgvalidate (Oid opclassoid)
void	spgadjustmembers (Oid opfamilyoid, Oid opclassoid, List *operators, List *functions)

Macro Definition Documentation

SPGIST_CHOOSE_PROC

#define SPGIST_CHOOSE_PROC   2

Definition at line 24 of file spgist.h.

SPGIST_COMPRESS_PROC

#define SPGIST_COMPRESS_PROC   6

Definition at line 28 of file spgist.h.

SPGIST_CONFIG_PROC

#define SPGIST_CONFIG_PROC   1

Definition at line 23 of file spgist.h.

SPGIST_INNER_CONSISTENT_PROC

#define SPGIST_INNER_CONSISTENT_PROC   4

Definition at line 26 of file spgist.h.

SPGIST_LEAF_CONSISTENT_PROC

#define SPGIST_LEAF_CONSISTENT_PROC   5

Definition at line 27 of file spgist.h.

SPGIST_OPTIONS_PROC

#define SPGIST_OPTIONS_PROC   7

Definition at line 29 of file spgist.h.

SPGIST_PICKSPLIT_PROC

#define SPGIST_PICKSPLIT_PROC   3

Definition at line 25 of file spgist.h.

SPGISTNProc

#define SPGISTNProc   7

Definition at line 31 of file spgist.h.

SPGISTNRequiredProc

#define SPGISTNRequiredProc   5

Definition at line 30 of file spgist.h.

Typedef Documentation

spgChooseIn

typedef struct spgChooseIn spgChooseIn

spgChooseOut

typedef struct spgChooseOut spgChooseOut

spgChooseResultType

typedef enum spgChooseResultType spgChooseResultType

spgConfigIn

typedef struct spgConfigIn spgConfigIn

spgConfigOut

typedef struct spgConfigOut spgConfigOut

spgInnerConsistentIn

typedef struct spgInnerConsistentIn spgInnerConsistentIn

spgInnerConsistentOut

typedef struct spgInnerConsistentOut spgInnerConsistentOut

spgLeafConsistentIn

typedef struct spgLeafConsistentIn spgLeafConsistentIn

spgLeafConsistentOut

typedef struct spgLeafConsistentOut spgLeafConsistentOut

spgPickSplitIn

typedef struct spgPickSplitIn spgPickSplitIn

spgPickSplitOut

typedef struct spgPickSplitOut spgPickSplitOut

Enumeration Type Documentation

spgChooseResultType

enum spgChooseResultType

Enumerator
spgMatchNode
spgAddNode
spgSplitTuple

Definition at line 67 of file spgist.h.

{
    spgMatchNode = 1,           /* descend into existing node */
    spgAddNode,                 /* add a node to the inner tuple */
    spgSplitTuple               /* split inner tuple (change its prefix) */
} spgChooseResultType;

Function Documentation

spgadjustmembers()

void spgadjustmembers	(	Oid	opfamilyoid,
		Oid	opclassoid,
		List *	operators,
		List *	functions
	)

Definition at line 332 of file spgvalidate.c.

{
    ListCell   *lc;
 
    /*
     * Operator members of an SP-GiST opfamily should never have hard
     * dependencies, since their connection to the opfamily depends only on
     * what the support functions think, and that can be altered.  For
     * consistency, we make all soft dependencies point to the opfamily,
     * though a soft dependency on the opclass would work as well in the
     * CREATE OPERATOR CLASS case.
     */
    foreach(lc, operators)
    {
        OpFamilyMember *op = (OpFamilyMember *) lfirst(lc);
 
        op->ref_is_hard = false;
        op->ref_is_family = true;
        op->refobjid = opfamilyoid;
    }
 
    /*
     * Required support functions should have hard dependencies.  Preferably
     * those are just dependencies on the opclass, but if we're in ALTER
     * OPERATOR FAMILY, we leave the dependency pointing at the whole
     * opfamily.  (Given that SP-GiST opclasses generally don't share
     * opfamilies, it seems unlikely to be worth working harder.)
     */
    foreach(lc, functions)
    {
        OpFamilyMember *op = (OpFamilyMember *) lfirst(lc);
 
        switch (op->number)
        {
            case SPGIST_CONFIG_PROC:
            case SPGIST_CHOOSE_PROC:
            case SPGIST_PICKSPLIT_PROC:
            case SPGIST_INNER_CONSISTENT_PROC:
            case SPGIST_LEAF_CONSISTENT_PROC:
                /* Required support function */
                op->ref_is_hard = true;
                break;
            case SPGIST_COMPRESS_PROC:
            case SPGIST_OPTIONS_PROC:
                /* Optional, so force it to be a soft family dependency */
                op->ref_is_hard = false;
                op->ref_is_family = true;
                op->refobjid = opfamilyoid;
                break;
            default:
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("support function number %d is invalid for access method %s",
                                op->number, "spgist")));
                break;
        }
    }
}

References ereport, errcode(), errmsg(), ERROR, functions, lfirst, OpFamilyMember::number, OpFamilyMember::ref_is_family, OpFamilyMember::ref_is_hard, OpFamilyMember::refobjid, SPGIST_CHOOSE_PROC, SPGIST_COMPRESS_PROC, SPGIST_CONFIG_PROC, SPGIST_INNER_CONSISTENT_PROC, SPGIST_LEAF_CONSISTENT_PROC, SPGIST_OPTIONS_PROC, and SPGIST_PICKSPLIT_PROC.

Referenced by spghandler().

spgbeginscan()

IndexScanDesc spgbeginscan	(	Relation	rel,
		int	keysz,
		int	orderbysz
	)

Definition at line 304 of file spgscan.c.

{
    IndexScanDesc scan;
    SpGistScanOpaque so;
    int         i;
 
    scan = RelationGetIndexScan(rel, keysz, orderbysz);
 
    so = (SpGistScanOpaque) palloc0(sizeof(SpGistScanOpaqueData));
    if (keysz > 0)
        so->keyData = (ScanKey) palloc(sizeof(ScanKeyData) * keysz);
    else
        so->keyData = NULL;
    initSpGistState(&so->state, scan->indexRelation);
 
    so->tempCxt = AllocSetContextCreate(CurrentMemoryContext,
                                        "SP-GiST search temporary context",
                                        ALLOCSET_DEFAULT_SIZES);
    so->traversalCxt = AllocSetContextCreate(CurrentMemoryContext,
                                             "SP-GiST traversal-value context",
                                             ALLOCSET_DEFAULT_SIZES);
 
    /*
     * Set up reconTupDesc and xs_hitupdesc in case it's an index-only scan,
     * making sure that the key column is shown as being of type attType.
     * (It's rather annoying to do this work when it might be wasted, but for
     * most opclasses we can re-use the index reldesc instead of making one.)
     */
    so->reconTupDesc = scan->xs_hitupdesc =
        getSpGistTupleDesc(rel, &so->state.attType);
 
    /* Allocate various arrays needed for order-by scans */
    if (scan->numberOfOrderBys > 0)
    {
        /* This will be filled in spgrescan, but allocate the space here */
        so->orderByTypes = (Oid *)
            palloc(sizeof(Oid) * scan->numberOfOrderBys);
        so->nonNullOrderByOffsets = (int *)
            palloc(sizeof(int) * scan->numberOfOrderBys);
 
        /* These arrays have constant contents, so we can fill them now */
        so->zeroDistances = (double *)
            palloc(sizeof(double) * scan->numberOfOrderBys);
        so->infDistances = (double *)
            palloc(sizeof(double) * scan->numberOfOrderBys);
 
        for (i = 0; i < scan->numberOfOrderBys; i++)
        {
            so->zeroDistances[i] = 0.0;
            so->infDistances[i] = get_float8_infinity();
        }
 
        scan->xs_orderbyvals = (Datum *)
            palloc0(sizeof(Datum) * scan->numberOfOrderBys);
        scan->xs_orderbynulls = (bool *)
            palloc(sizeof(bool) * scan->numberOfOrderBys);
        memset(scan->xs_orderbynulls, true,
               sizeof(bool) * scan->numberOfOrderBys);
    }
 
    fmgr_info_copy(&so->innerConsistentFn,
                   index_getprocinfo(rel, 1, SPGIST_INNER_CONSISTENT_PROC),
                   CurrentMemoryContext);
 
    fmgr_info_copy(&so->leafConsistentFn,
                   index_getprocinfo(rel, 1, SPGIST_LEAF_CONSISTENT_PROC),
                   CurrentMemoryContext);
 
    so->indexCollation = rel->rd_indcollation[0];
 
    scan->opaque = so;
 
    return scan;
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, SpGistState::attType, CurrentMemoryContext, fmgr_info_copy(), get_float8_infinity(), getSpGistTupleDesc(), i, index_getprocinfo(), SpGistScanOpaqueData::indexCollation, IndexScanDescData::indexRelation, SpGistScanOpaqueData::infDistances, initSpGistState(), SpGistScanOpaqueData::innerConsistentFn, SpGistScanOpaqueData::keyData, SpGistScanOpaqueData::leafConsistentFn, SpGistScanOpaqueData::nonNullOrderByOffsets, IndexScanDescData::numberOfOrderBys, IndexScanDescData::opaque, SpGistScanOpaqueData::orderByTypes, palloc(), palloc0(), RelationData::rd_indcollation, SpGistScanOpaqueData::reconTupDesc, RelationGetIndexScan(), SPGIST_INNER_CONSISTENT_PROC, SPGIST_LEAF_CONSISTENT_PROC, SpGistScanOpaqueData::state, SpGistScanOpaqueData::tempCxt, SpGistScanOpaqueData::traversalCxt, IndexScanDescData::xs_hitupdesc, IndexScanDescData::xs_orderbynulls, IndexScanDescData::xs_orderbyvals, and SpGistScanOpaqueData::zeroDistances.

Referenced by spghandler().

spgbuild()

IndexBuildResult* spgbuild	(	Relation	heap,
		Relation	index,
		struct IndexInfo *	indexInfo
	)

Definition at line 75 of file spginsert.c.

{
    IndexBuildResult *result;
    double      reltuples;
    SpGistBuildState buildstate;
    Buffer      metabuffer,
                rootbuffer,
                nullbuffer;
 
    if (RelationGetNumberOfBlocks(index) != 0)
        elog(ERROR, "index \"%s\" already contains data",
             RelationGetRelationName(index));
 
    /*
     * Initialize the meta page and root pages
     */
    metabuffer = SpGistNewBuffer(index);
    rootbuffer = SpGistNewBuffer(index);
    nullbuffer = SpGistNewBuffer(index);
 
    Assert(BufferGetBlockNumber(metabuffer) == SPGIST_METAPAGE_BLKNO);
    Assert(BufferGetBlockNumber(rootbuffer) == SPGIST_ROOT_BLKNO);
    Assert(BufferGetBlockNumber(nullbuffer) == SPGIST_NULL_BLKNO);
 
    START_CRIT_SECTION();
 
    SpGistInitMetapage(BufferGetPage(metabuffer));
    MarkBufferDirty(metabuffer);
    SpGistInitBuffer(rootbuffer, SPGIST_LEAF);
    MarkBufferDirty(rootbuffer);
    SpGistInitBuffer(nullbuffer, SPGIST_LEAF | SPGIST_NULLS);
    MarkBufferDirty(nullbuffer);
 
 
    END_CRIT_SECTION();
 
    UnlockReleaseBuffer(metabuffer);
    UnlockReleaseBuffer(rootbuffer);
    UnlockReleaseBuffer(nullbuffer);
 
    /*
     * Now insert all the heap data into the index
     */
    initSpGistState(&buildstate.spgstate, index);
    buildstate.spgstate.isBuild = true;
    buildstate.indtuples = 0;
 
    buildstate.tmpCtx = AllocSetContextCreate(CurrentMemoryContext,
                                              "SP-GiST build temporary context",
                                              ALLOCSET_DEFAULT_SIZES);
 
    reltuples = table_index_build_scan(heap, index, indexInfo, true, true,
                                       spgistBuildCallback, (void *) &buildstate,
                                       NULL);
 
    MemoryContextDelete(buildstate.tmpCtx);
 
    SpGistUpdateMetaPage(index);
 
    /*
     * We didn't write WAL records as we built the index, so if WAL-logging is
     * required, write all pages to the WAL now.
     */
    if (RelationNeedsWAL(index))
    {
        log_newpage_range(index, MAIN_FORKNUM,
                          0, RelationGetNumberOfBlocks(index),
                          true);
    }
 
    result = (IndexBuildResult *) palloc0(sizeof(IndexBuildResult));
    result->heap_tuples = reltuples;
    result->index_tuples = buildstate.indtuples;
 
    return result;
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert(), BufferGetBlockNumber(), BufferGetPage(), CurrentMemoryContext, elog(), END_CRIT_SECTION, ERROR, IndexBuildResult::heap_tuples, IndexBuildResult::index_tuples, SpGistBuildState::indtuples, initSpGistState(), SpGistState::isBuild, log_newpage_range(), MAIN_FORKNUM, MarkBufferDirty(), MemoryContextDelete(), palloc0(), RelationGetNumberOfBlocks, RelationGetRelationName, RelationNeedsWAL, SPGIST_LEAF, SPGIST_METAPAGE_BLKNO, SPGIST_NULL_BLKNO, SPGIST_NULLS, SPGIST_ROOT_BLKNO, spgistBuildCallback(), SpGistInitBuffer(), SpGistInitMetapage(), SpGistNewBuffer(), SpGistUpdateMetaPage(), SpGistBuildState::spgstate, START_CRIT_SECTION, table_index_build_scan(), SpGistBuildState::tmpCtx, and UnlockReleaseBuffer().

Referenced by spghandler().

spgbuildempty()

void spgbuildempty

(

Relation

index

)

Definition at line 156 of file spginsert.c.

{
    Page        page;
 
    /* Construct metapage. */
    page = (Page) palloc_aligned(BLCKSZ, PG_IO_ALIGN_SIZE, 0);
    SpGistInitMetapage(page);
 
    /*
     * Write the page and log it unconditionally.  This is important
     * particularly for indexes created on tablespaces and databases whose
     * creation happened after the last redo pointer as recovery removes any
     * of their existing content when the corresponding create records are
     * replayed.
     */
    PageSetChecksumInplace(page, SPGIST_METAPAGE_BLKNO);
    smgrwrite(RelationGetSmgr(index), INIT_FORKNUM, SPGIST_METAPAGE_BLKNO,
              page, true);
    log_newpage(&(RelationGetSmgr(index))->smgr_rlocator.locator, INIT_FORKNUM,
                SPGIST_METAPAGE_BLKNO, page, true);
 
    /* Likewise for the root page. */
    SpGistInitPage(page, SPGIST_LEAF);
 
    PageSetChecksumInplace(page, SPGIST_ROOT_BLKNO);
    smgrwrite(RelationGetSmgr(index), INIT_FORKNUM, SPGIST_ROOT_BLKNO,
              page, true);
    log_newpage(&(RelationGetSmgr(index))->smgr_rlocator.locator, INIT_FORKNUM,
                SPGIST_ROOT_BLKNO, page, true);
 
    /* Likewise for the null-tuples root page. */
    SpGistInitPage(page, SPGIST_LEAF | SPGIST_NULLS);
 
    PageSetChecksumInplace(page, SPGIST_NULL_BLKNO);
    smgrwrite(RelationGetSmgr(index), INIT_FORKNUM, SPGIST_NULL_BLKNO,
              page, true);
    log_newpage(&(RelationGetSmgr(index))->smgr_rlocator.locator, INIT_FORKNUM,
                SPGIST_NULL_BLKNO, page, true);
 
    /*
     * An immediate sync is required even if we xlog'd the pages, because the
     * writes did not go through shared buffers and therefore a concurrent
     * checkpoint may have moved the redo pointer past our xlog record.
     */
    smgrimmedsync(RelationGetSmgr(index), INIT_FORKNUM);
}

References INIT_FORKNUM, log_newpage(), PageSetChecksumInplace(), palloc_aligned(), PG_IO_ALIGN_SIZE, RelationGetSmgr(), smgrimmedsync(), smgrwrite(), SPGIST_LEAF, SPGIST_METAPAGE_BLKNO, SPGIST_NULL_BLKNO, SPGIST_NULLS, SPGIST_ROOT_BLKNO, SpGistInitMetapage(), and SpGistInitPage().

Referenced by spghandler().

spgbulkdelete()

IndexBulkDeleteResult* spgbulkdelete	(	IndexVacuumInfo *	info,
		IndexBulkDeleteResult *	stats,
		IndexBulkDeleteCallback	callback,
		void *	callback_state
	)

Definition at line 906 of file spgvacuum.c.

{
    spgBulkDeleteState bds;
 
    /* allocate stats if first time through, else re-use existing struct */
    if (stats == NULL)
        stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
    bds.info = info;
    bds.stats = stats;
    bds.callback = callback;
    bds.callback_state = callback_state;
 
    spgvacuumscan(&bds);
 
    return stats;
}

References spgBulkDeleteState::callback, callback(), spgBulkDeleteState::callback_state, spgBulkDeleteState::info, palloc0(), spgvacuumscan(), and spgBulkDeleteState::stats.

Referenced by spghandler().

spgcanreturn()

bool spgcanreturn	(	Relation	index,
		int	attno
	)

Definition at line 1085 of file spgscan.c.

{
    SpGistCache *cache;
 
    /* INCLUDE attributes can always be fetched for index-only scans */
    if (attno > 1)
        return true;
 
    /* We can do it if the opclass config function says so */
    cache = spgGetCache(index);
 
    return cache->config.canReturnData;
}

References spgConfigOut::canReturnData, SpGistCache::config, and spgGetCache().

Referenced by spghandler().

spgendscan()

void spgendscan

(

IndexScanDesc

scan

)

Definition at line 429 of file spgscan.c.

{
    SpGistScanOpaque so = (SpGistScanOpaque) scan->opaque;
 
    MemoryContextDelete(so->tempCxt);
    MemoryContextDelete(so->traversalCxt);
 
    if (so->keyData)
        pfree(so->keyData);
 
    if (so->state.leafTupDesc &&
        so->state.leafTupDesc != RelationGetDescr(so->state.index))
        FreeTupleDesc(so->state.leafTupDesc);
 
    if (so->state.deadTupleStorage)
        pfree(so->state.deadTupleStorage);
 
    if (scan->numberOfOrderBys > 0)
    {
        pfree(so->orderByTypes);
        pfree(so->nonNullOrderByOffsets);
        pfree(so->zeroDistances);
        pfree(so->infDistances);
        pfree(scan->xs_orderbyvals);
        pfree(scan->xs_orderbynulls);
    }
 
    pfree(so);
}

References SpGistState::deadTupleStorage, FreeTupleDesc(), SpGistState::index, SpGistScanOpaqueData::infDistances, SpGistScanOpaqueData::keyData, SpGistState::leafTupDesc, MemoryContextDelete(), SpGistScanOpaqueData::nonNullOrderByOffsets, IndexScanDescData::numberOfOrderBys, IndexScanDescData::opaque, SpGistScanOpaqueData::orderByTypes, pfree(), RelationGetDescr, SpGistScanOpaqueData::state, SpGistScanOpaqueData::tempCxt, SpGistScanOpaqueData::traversalCxt, IndexScanDescData::xs_orderbynulls, IndexScanDescData::xs_orderbyvals, and SpGistScanOpaqueData::zeroDistances.

Referenced by spghandler().

spggetbitmap()

int64 spggetbitmap	(	IndexScanDesc	scan,
		TIDBitmap *	tbm
	)

Definition at line 943 of file spgscan.c.

{
    SpGistScanOpaque so = (SpGistScanOpaque) scan->opaque;
 
    /* Copy want_itup to *so so we don't need to pass it around separately */
    so->want_itup = false;
 
    so->tbm = tbm;
    so->ntids = 0;
 
    spgWalk(scan->indexRelation, so, true, storeBitmap, scan->xs_snapshot);
 
    return so->ntids;
}

References IndexScanDescData::indexRelation, SpGistScanOpaqueData::ntids, IndexScanDescData::opaque, spgWalk(), storeBitmap(), SpGistScanOpaqueData::tbm, SpGistScanOpaqueData::want_itup, and IndexScanDescData::xs_snapshot.

Referenced by spghandler().

spggettuple()

bool spggettuple	(	IndexScanDesc	scan,
		ScanDirection	dir
	)

Definition at line 1027 of file spgscan.c.

{
    SpGistScanOpaque so = (SpGistScanOpaque) scan->opaque;
 
    if (dir != ForwardScanDirection)
        elog(ERROR, "SP-GiST only supports forward scan direction");
 
    /* Copy want_itup to *so so we don't need to pass it around separately */
    so->want_itup = scan->xs_want_itup;
 
    for (;;)
    {
        if (so->iPtr < so->nPtrs)
        {
            /* continuing to return reported tuples */
            scan->xs_heaptid = so->heapPtrs[so->iPtr];
            scan->xs_recheck = so->recheck[so->iPtr];
            scan->xs_hitup = so->reconTups[so->iPtr];
 
            if (so->numberOfOrderBys > 0)
                index_store_float8_orderby_distances(scan, so->orderByTypes,
                                                     so->distances[so->iPtr],
                                                     so->recheckDistances[so->iPtr]);
            so->iPtr++;
            return true;
        }
 
        if (so->numberOfOrderBys > 0)
        {
            /* Must pfree distances to avoid memory leak */
            int         i;
 
            for (i = 0; i < so->nPtrs; i++)
                if (so->distances[i])
                    pfree(so->distances[i]);
        }
 
        if (so->want_itup)
        {
            /* Must pfree reconstructed tuples to avoid memory leak */
            int         i;
 
            for (i = 0; i < so->nPtrs; i++)
                pfree(so->reconTups[i]);
        }
        so->iPtr = so->nPtrs = 0;
 
        spgWalk(scan->indexRelation, so, false, storeGettuple,
                scan->xs_snapshot);
 
        if (so->nPtrs == 0)
            break;              /* must have completed scan */
    }
 
    return false;
}

References SpGistScanOpaqueData::distances, elog(), ERROR, ForwardScanDirection, SpGistScanOpaqueData::heapPtrs, i, if(), index_store_float8_orderby_distances(), IndexScanDescData::indexRelation, SpGistScanOpaqueData::iPtr, SpGistScanOpaqueData::nPtrs, SpGistScanOpaqueData::numberOfOrderBys, IndexScanDescData::opaque, SpGistScanOpaqueData::orderByTypes, pfree(), SpGistScanOpaqueData::recheck, SpGistScanOpaqueData::recheckDistances, SpGistScanOpaqueData::reconTups, spgWalk(), storeGettuple(), SpGistScanOpaqueData::want_itup, IndexScanDescData::xs_heaptid, IndexScanDescData::xs_hitup, IndexScanDescData::xs_recheck, IndexScanDescData::xs_snapshot, and IndexScanDescData::xs_want_itup.

Referenced by spghandler().

spginsert()

bool spginsert	(	Relation	index,
		Datum *	values,
		bool *	isnull,
		ItemPointer	ht_ctid,
		Relation	heapRel,
		IndexUniqueCheck	checkUnique,
		bool	indexUnchanged,
		struct IndexInfo *	indexInfo
	)

Definition at line 207 of file spginsert.c.

{
    SpGistState spgstate;
    MemoryContext oldCtx;
    MemoryContext insertCtx;
 
    insertCtx = AllocSetContextCreate(CurrentMemoryContext,
                                      "SP-GiST insert temporary context",
                                      ALLOCSET_DEFAULT_SIZES);
    oldCtx = MemoryContextSwitchTo(insertCtx);
 
    initSpGistState(&spgstate, index);
 
    /*
     * We might have to repeat spgdoinsert() multiple times, if conflicts
     * occur with concurrent insertions.  If so, reset the insertCtx each time
     * to avoid cumulative memory consumption.  That means we also have to
     * redo initSpGistState(), but it's cheap enough not to matter.
     */
    while (!spgdoinsert(index, &spgstate, ht_ctid, values, isnull))
    {
        MemoryContextReset(insertCtx);
        initSpGistState(&spgstate, index);
    }
 
    SpGistUpdateMetaPage(index);
 
    MemoryContextSwitchTo(oldCtx);
    MemoryContextDelete(insertCtx);
 
    /* return false since we've not done any unique check */
    return false;
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, CurrentMemoryContext, initSpGistState(), MemoryContextDelete(), MemoryContextReset(), MemoryContextSwitchTo(), spgdoinsert(), SpGistUpdateMetaPage(), and values.

Referenced by spghandler().

spgoptions()

bytea* spgoptions	(	Datum	reloptions,
		bool	validate
	)

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

spgrescan()

void spgrescan	(	IndexScanDesc	scan,
		ScanKey	scankey,
		int	nscankeys,
		ScanKey	orderbys,
		int	norderbys
	)

Definition at line 380 of file spgscan.c.

{
    SpGistScanOpaque so = (SpGistScanOpaque) scan->opaque;
 
    /* copy scankeys into local storage */
    if (scankey && scan->numberOfKeys > 0)
        memmove(scan->keyData, scankey,
                scan->numberOfKeys * sizeof(ScanKeyData));
 
    /* initialize order-by data if needed */
    if (orderbys && scan->numberOfOrderBys > 0)
    {
        int         i;
 
        memmove(scan->orderByData, orderbys,
                scan->numberOfOrderBys * sizeof(ScanKeyData));
 
        for (i = 0; i < scan->numberOfOrderBys; i++)
        {
            ScanKey     skey = &scan->orderByData[i];
 
            /*
             * Look up the datatype returned by the original ordering
             * operator. SP-GiST always uses a float8 for the distance
             * function, but the ordering operator could be anything else.
             *
             * XXX: The distance function is only allowed to be lossy if the
             * ordering operator's result type is float4 or float8.  Otherwise
             * we don't know how to return the distance to the executor.  But
             * we cannot check that here, as we won't know if the distance
             * function is lossy until it returns *recheck = true for the
             * first time.
             */
            so->orderByTypes[i] = get_func_rettype(skey->sk_func.fn_oid);
        }
    }
 
    /* preprocess scankeys, set up the representation in *so */
    spgPrepareScanKeys(scan);
 
    /* set up starting queue entries */
    resetSpGistScanOpaque(so);
 
    /* count an indexscan for stats */
    pgstat_count_index_scan(scan->indexRelation);
}

References FmgrInfo::fn_oid, get_func_rettype(), i, if(), IndexScanDescData::indexRelation, IndexScanDescData::keyData, IndexScanDescData::numberOfKeys, IndexScanDescData::numberOfOrderBys, IndexScanDescData::opaque, IndexScanDescData::orderByData, SpGistScanOpaqueData::orderByTypes, pgstat_count_index_scan, resetSpGistScanOpaque(), ScanKeyData::sk_func, and spgPrepareScanKeys().

Referenced by spghandler().

spgvacuumcleanup()

IndexBulkDeleteResult* spgvacuumcleanup	(	IndexVacuumInfo *	info,
		IndexBulkDeleteResult *	stats
	)

Definition at line 937 of file spgvacuum.c.

{
    spgBulkDeleteState bds;
 
    /* No-op in ANALYZE ONLY mode */
    if (info->analyze_only)
        return stats;
 
    /*
     * We don't need to scan the index if there was a preceding bulkdelete
     * pass.  Otherwise, make a pass that won't delete any live tuples, but
     * might still accomplish useful stuff with redirect/placeholder cleanup
     * and/or FSM housekeeping, and in any case will provide stats.
     */
    if (stats == NULL)
    {
        stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
        bds.info = info;
        bds.stats = stats;
        bds.callback = dummy_callback;
        bds.callback_state = NULL;
 
        spgvacuumscan(&bds);
    }
 
    /*
     * It's quite possible for us to be fooled by concurrent tuple moves into
     * double-counting some index tuples, so disbelieve any total that exceeds
     * the underlying heap's count ... if we know that accurately.  Otherwise
     * this might just make matters worse.
     */
    if (!info->estimated_count)
    {
        if (stats->num_index_tuples > info->num_heap_tuples)
            stats->num_index_tuples = info->num_heap_tuples;
    }
 
    return stats;
}

References IndexVacuumInfo::analyze_only, spgBulkDeleteState::callback, spgBulkDeleteState::callback_state, dummy_callback(), IndexVacuumInfo::estimated_count, spgBulkDeleteState::info, IndexVacuumInfo::num_heap_tuples, IndexBulkDeleteResult::num_index_tuples, palloc0(), spgvacuumscan(), and spgBulkDeleteState::stats.

Referenced by spghandler().

spgvalidate()

bool spgvalidate

(

Oid

opclassoid

)

Definition at line 39 of file spgvalidate.c.

{
    bool        result = true;
    HeapTuple   classtup;
    Form_pg_opclass classform;
    Oid         opfamilyoid;
    Oid         opcintype;
    Oid         opckeytype;
    char       *opclassname;
    HeapTuple   familytup;
    Form_pg_opfamily familyform;
    char       *opfamilyname;
    CatCList   *proclist,
               *oprlist;
    List       *grouplist;
    OpFamilyOpFuncGroup *opclassgroup;
    int         i;
    ListCell   *lc;
    spgConfigIn configIn;
    spgConfigOut configOut;
    Oid         configOutLefttype = InvalidOid;
    Oid         configOutRighttype = InvalidOid;
    Oid         configOutLeafType = InvalidOid;
 
    /* Fetch opclass information */
    classtup = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclassoid));
    if (!HeapTupleIsValid(classtup))
        elog(ERROR, "cache lookup failed for operator class %u", opclassoid);
    classform = (Form_pg_opclass) GETSTRUCT(classtup);
 
    opfamilyoid = classform->opcfamily;
    opcintype = classform->opcintype;
    opckeytype = classform->opckeytype;
    opclassname = NameStr(classform->opcname);
 
    /* Fetch opfamily information */
    familytup = SearchSysCache1(OPFAMILYOID, ObjectIdGetDatum(opfamilyoid));
    if (!HeapTupleIsValid(familytup))
        elog(ERROR, "cache lookup failed for operator family %u", opfamilyoid);
    familyform = (Form_pg_opfamily) GETSTRUCT(familytup);
 
    opfamilyname = NameStr(familyform->opfname);
 
    /* Fetch all operators and support functions of the opfamily */
    oprlist = SearchSysCacheList1(AMOPSTRATEGY, ObjectIdGetDatum(opfamilyoid));
    proclist = SearchSysCacheList1(AMPROCNUM, ObjectIdGetDatum(opfamilyoid));
    grouplist = identify_opfamily_groups(oprlist, proclist);
 
    /* Check individual support functions */
    for (i = 0; i < proclist->n_members; i++)
    {
        HeapTuple   proctup = &proclist->members[i]->tuple;
        Form_pg_amproc procform = (Form_pg_amproc) GETSTRUCT(proctup);
        bool        ok;
 
        /*
         * All SP-GiST support functions should be registered with matching
         * left/right types
         */
        if (procform->amproclefttype != procform->amprocrighttype)
        {
            ereport(INFO,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("operator family \"%s\" of access method %s contains support function %s with different left and right input types",
                            opfamilyname, "spgist",
                            format_procedure(procform->amproc))));
            result = false;
        }
 
        /* Check procedure numbers and function signatures */
        switch (procform->amprocnum)
        {
            case SPGIST_CONFIG_PROC:
                ok = check_amproc_signature(procform->amproc, VOIDOID, true,
                                            2, 2, INTERNALOID, INTERNALOID);
                configIn.attType = procform->amproclefttype;
                memset(&configOut, 0, sizeof(configOut));
 
                OidFunctionCall2(procform->amproc,
                                 PointerGetDatum(&configIn),
                                 PointerGetDatum(&configOut));
 
                configOutLefttype = procform->amproclefttype;
                configOutRighttype = procform->amprocrighttype;
 
                /* Default leaf type is opckeytype or input type */
                if (OidIsValid(opckeytype))
                    configOutLeafType = opckeytype;
                else
                    configOutLeafType = procform->amproclefttype;
 
                /* If some other leaf datum type is specified, warn */
                if (OidIsValid(configOut.leafType) &&
                    configOutLeafType != configOut.leafType)
                {
                    ereport(INFO,
                            (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                             errmsg("SP-GiST leaf data type %s does not match declared type %s",
                                    format_type_be(configOut.leafType),
                                    format_type_be(configOutLeafType))));
                    result = false;
                    configOutLeafType = configOut.leafType;
                }
 
                /*
                 * When leaf and attribute types are the same, compress
                 * function is not required and we set corresponding bit in
                 * functionset for later group consistency check.
                 */
                if (configOutLeafType == configIn.attType)
                {
                    foreach(lc, grouplist)
                    {
                        OpFamilyOpFuncGroup *group = lfirst(lc);
 
                        if (group->lefttype == procform->amproclefttype &&
                            group->righttype == procform->amprocrighttype)
                        {
                            group->functionset |=
                                ((uint64) 1) << SPGIST_COMPRESS_PROC;
                            break;
                        }
                    }
                }
                break;
            case SPGIST_CHOOSE_PROC:
            case SPGIST_PICKSPLIT_PROC:
            case SPGIST_INNER_CONSISTENT_PROC:
                ok = check_amproc_signature(procform->amproc, VOIDOID, true,
                                            2, 2, INTERNALOID, INTERNALOID);
                break;
            case SPGIST_LEAF_CONSISTENT_PROC:
                ok = check_amproc_signature(procform->amproc, BOOLOID, true,
                                            2, 2, INTERNALOID, INTERNALOID);
                break;
            case SPGIST_COMPRESS_PROC:
                if (configOutLefttype != procform->amproclefttype ||
                    configOutRighttype != procform->amprocrighttype)
                    ok = false;
                else
                    ok = check_amproc_signature(procform->amproc,
                                                configOutLeafType, true,
                                                1, 1, procform->amproclefttype);
                break;
            case SPGIST_OPTIONS_PROC:
                ok = check_amoptsproc_signature(procform->amproc);
                break;
            default:
                ereport(INFO,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("operator family \"%s\" of access method %s contains function %s with invalid support number %d",
                                opfamilyname, "spgist",
                                format_procedure(procform->amproc),
                                procform->amprocnum)));
                result = false;
                continue;       /* don't want additional message */
        }
 
        if (!ok)
        {
            ereport(INFO,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("operator family \"%s\" of access method %s contains function %s with wrong signature for support number %d",
                            opfamilyname, "spgist",
                            format_procedure(procform->amproc),
                            procform->amprocnum)));
            result = false;
        }
    }
 
    /* Check individual operators */
    for (i = 0; i < oprlist->n_members; i++)
    {
        HeapTuple   oprtup = &oprlist->members[i]->tuple;
        Form_pg_amop oprform = (Form_pg_amop) GETSTRUCT(oprtup);
        Oid         op_rettype;
 
        /* TODO: Check that only allowed strategy numbers exist */
        if (oprform->amopstrategy < 1 || oprform->amopstrategy > 63)
        {
            ereport(INFO,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("operator family \"%s\" of access method %s contains operator %s with invalid strategy number %d",
                            opfamilyname, "spgist",
                            format_operator(oprform->amopopr),
                            oprform->amopstrategy)));
            result = false;
        }
 
        /* spgist supports ORDER BY operators */
        if (oprform->amoppurpose != AMOP_SEARCH)
        {
            /* ... and operator result must match the claimed btree opfamily */
            op_rettype = get_op_rettype(oprform->amopopr);
            if (!opfamily_can_sort_type(oprform->amopsortfamily, op_rettype))
            {
                ereport(INFO,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("operator family \"%s\" of access method %s contains invalid ORDER BY specification for operator %s",
                                opfamilyname, "spgist",
                                format_operator(oprform->amopopr))));
                result = false;
            }
        }
        else
            op_rettype = BOOLOID;
 
        /* Check operator signature --- same for all spgist strategies */
        if (!check_amop_signature(oprform->amopopr, op_rettype,
                                  oprform->amoplefttype,
                                  oprform->amoprighttype))
        {
            ereport(INFO,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("operator family \"%s\" of access method %s contains operator %s with wrong signature",
                            opfamilyname, "spgist",
                            format_operator(oprform->amopopr))));
            result = false;
        }
    }
 
    /* Now check for inconsistent groups of operators/functions */
    opclassgroup = NULL;
    foreach(lc, grouplist)
    {
        OpFamilyOpFuncGroup *thisgroup = (OpFamilyOpFuncGroup *) lfirst(lc);
 
        /* Remember the group exactly matching the test opclass */
        if (thisgroup->lefttype == opcintype &&
            thisgroup->righttype == opcintype)
            opclassgroup = thisgroup;
 
        /*
         * Complain if there are any datatype pairs with functions but no
         * operators.  This is about the best we can do for now to detect
         * missing operators.
         */
        if (thisgroup->operatorset == 0)
        {
            ereport(INFO,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("operator family \"%s\" of access method %s is missing operator(s) for types %s and %s",
                            opfamilyname, "spgist",
                            format_type_be(thisgroup->lefttype),
                            format_type_be(thisgroup->righttype))));
            result = false;
        }
 
        /*
         * Complain if we're missing functions for any datatype, remembering
         * that SP-GiST doesn't use cross-type support functions.
         */
        if (thisgroup->lefttype != thisgroup->righttype)
            continue;
 
        for (i = 1; i <= SPGISTNProc; i++)
        {
            if ((thisgroup->functionset & (((uint64) 1) << i)) != 0)
                continue;       /* got it */
            if (i == SPGIST_OPTIONS_PROC)
                continue;       /* optional method */
            ereport(INFO,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("operator family \"%s\" of access method %s is missing support function %d for type %s",
                            opfamilyname, "spgist", i,
                            format_type_be(thisgroup->lefttype))));
            result = false;
        }
    }
 
    /* Check that the originally-named opclass is supported */
    /* (if group is there, we already checked it adequately above) */
    if (!opclassgroup)
    {
        ereport(INFO,
                (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                 errmsg("operator class \"%s\" of access method %s is missing operator(s)",
                        opclassname, "spgist")));
        result = false;
    }
 
    ReleaseCatCacheList(proclist);
    ReleaseCatCacheList(oprlist);
    ReleaseSysCache(familytup);
    ReleaseSysCache(classtup);
 
    return result;
}

References AMOPSTRATEGY, AMPROCNUM, spgConfigIn::attType, check_amop_signature(), check_amoptsproc_signature(), check_amproc_signature(), CLAOID, elog(), ereport, errcode(), errmsg(), ERROR, format_operator(), format_procedure(), format_type_be(), OpFamilyOpFuncGroup::functionset, get_op_rettype(), GETSTRUCT, HeapTupleIsValid, i, identify_opfamily_groups(), INFO, InvalidOid, spgConfigOut::leafType, OpFamilyOpFuncGroup::lefttype, lfirst, catclist::members, catclist::n_members, NameStr, ObjectIdGetDatum(), OidFunctionCall2, OidIsValid, OpFamilyOpFuncGroup::operatorset, opfamily_can_sort_type(), OPFAMILYOID, PointerGetDatum(), ReleaseCatCacheList(), ReleaseSysCache(), OpFamilyOpFuncGroup::righttype, SearchSysCache1(), SearchSysCacheList1, SPGIST_CHOOSE_PROC, SPGIST_COMPRESS_PROC, SPGIST_CONFIG_PROC, SPGIST_INNER_CONSISTENT_PROC, SPGIST_LEAF_CONSISTENT_PROC, SPGIST_OPTIONS_PROC, SPGIST_PICKSPLIT_PROC, SPGISTNProc, and catctup::tuple.

Referenced by spghandler().