gistscan.h File Reference

#include "access/amapi.h"

Include dependency graph for gistscan.h:

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

Go to the source code of this file.

Functions
IndexScanDesc	gistbeginscan (Relation r, int nkeys, int norderbys)
void	gistrescan (IndexScanDesc scan, ScanKey key, int nkeys, ScanKey orderbys, int norderbys)
void	gistendscan (IndexScanDesc scan)

Function Documentation

gistbeginscan()

IndexScanDesc gistbeginscan ( Relation  r, int  nkeys, int  norderbys  )

extern

Definition at line 74 of file gistscan.c.

{
    IndexScanDesc scan;
    GISTSTATE  *giststate;
    GISTScanOpaque so;
    MemoryContext oldCxt;
 
    scan = RelationGetIndexScan(r, nkeys, norderbys);
 
    /* First, set up a GISTSTATE with a scan-lifespan memory context */
    giststate = initGISTstate(scan->indexRelation);
 
    /*
     * Everything made below is in the scanCxt, or is a child of the scanCxt,
     * so it'll all go away automatically in gistendscan.
     */
    oldCxt = MemoryContextSwitchTo(giststate->scanCxt);
 
    /* initialize opaque data */
    so = palloc0_object(GISTScanOpaqueData);
    so->giststate = giststate;
    giststate->tempCxt = createTempGistContext();
    so->queue = NULL;
    so->queueCxt = giststate->scanCxt;  /* see gistrescan */
 
    /* workspaces with size dependent on numberOfOrderBys: */
    so->distances = palloc(sizeof(so->distances[0]) * scan->numberOfOrderBys);
    so->qual_ok = true;         /* in case there are zero keys */
    if (scan->numberOfOrderBys > 0)
    {
        scan->xs_orderbyvals = palloc0_array(Datum, scan->numberOfOrderBys);
        scan->xs_orderbynulls = palloc_array(bool, scan->numberOfOrderBys);
        memset(scan->xs_orderbynulls, true, sizeof(bool) * scan->numberOfOrderBys);
    }
 
    so->killedItems = NULL;     /* until needed */
    so->numKilled = 0;
    so->curBlkno = InvalidBlockNumber;
    so->curPageLSN = InvalidXLogRecPtr;
 
    scan->opaque = so;
 
    /*
     * All fields required for index-only scans are initialized in gistrescan,
     * as we don't know yet if we're doing an index-only scan or not.
     */
 
    MemoryContextSwitchTo(oldCxt);
 
    return scan;
}

References createTempGistContext(), fb(), IndexScanDescData::indexRelation, initGISTstate(), InvalidBlockNumber, InvalidXLogRecPtr, MemoryContextSwitchTo(), IndexScanDescData::numberOfOrderBys, IndexScanDescData::opaque, palloc(), palloc0_array, palloc0_object, palloc_array, RelationGetIndexScan(), GISTSTATE::scanCxt, GISTSTATE::tempCxt, IndexScanDescData::xs_orderbynulls, and IndexScanDescData::xs_orderbyvals.

Referenced by gisthandler().

gistendscan()

void gistendscan ( IndexScanDesc  scan )

extern

Definition at line 348 of file gistscan.c.

{
    GISTScanOpaque so = (GISTScanOpaque) scan->opaque;
 
    /*
     * freeGISTstate is enough to clean up everything made by gistbeginscan,
     * as well as the queueCxt if there is a separate context for it.
     */
    freeGISTstate(so->giststate);
}

References fb(), freeGISTstate(), and IndexScanDescData::opaque.

Referenced by gisthandler().

gistrescan()

void gistrescan ( IndexScanDesc  scan, ScanKey  key, int  nkeys, ScanKey  orderbys, int  norderbys  )

extern

Definition at line 127 of file gistscan.c.

{
    /* nkeys and norderbys arguments are ignored */
    GISTScanOpaque so = (GISTScanOpaque) scan->opaque;
    bool        first_time;
    int         i;
    MemoryContext oldCxt;
 
    /* rescan an existing indexscan --- reset state */
 
    /*
     * The first time through, we create the search queue in the scanCxt.
     * Subsequent times through, we create the queue in a separate queueCxt,
     * which is created on the second call and reset on later calls.  Thus, in
     * the common case where a scan is only rescan'd once, we just put the
     * queue in scanCxt and don't pay the overhead of making a second memory
     * context.  If we do rescan more than once, the first queue is just left
     * for dead until end of scan; this small wastage seems worth the savings
     * in the common case.
     */
    if (so->queue == NULL)
    {
        /* first time through */
        Assert(so->queueCxt == so->giststate->scanCxt);
        first_time = true;
    }
    else if (so->queueCxt == so->giststate->scanCxt)
    {
        /* second time through */
        so->queueCxt = AllocSetContextCreate(so->giststate->scanCxt,
                                             "GiST queue context",
                                             ALLOCSET_DEFAULT_SIZES);
        first_time = false;
    }
    else
    {
        /* third or later time through */
        MemoryContextReset(so->queueCxt);
        first_time = false;
    }
 
    /*
     * If we're doing an index-only scan, on the first call, also initialize a
     * tuple descriptor to represent the returned index tuples and create a
     * memory context to hold them during the scan.
     */
    if (scan->xs_want_itup && !scan->xs_hitupdesc)
    {
        int         natts;
        int         nkeyatts;
        int         attno;
 
        /*
         * The storage type of the index can be different from the original
         * datatype being indexed, so we cannot just grab the index's tuple
         * descriptor. Instead, construct a descriptor with the original data
         * types.
         */
        natts = RelationGetNumberOfAttributes(scan->indexRelation);
        nkeyatts = IndexRelationGetNumberOfKeyAttributes(scan->indexRelation);
        so->giststate->fetchTupdesc = CreateTemplateTupleDesc(natts);
        for (attno = 1; attno <= nkeyatts; attno++)
        {
            TupleDescInitEntry(so->giststate->fetchTupdesc, attno, NULL,
                               scan->indexRelation->rd_opcintype[attno - 1],
                               -1, 0);
        }
 
        for (; attno <= natts; attno++)
        {
            /* taking opcintype from giststate->tupdesc */
            TupleDescInitEntry(so->giststate->fetchTupdesc, attno, NULL,
                               TupleDescAttr(so->giststate->leafTupdesc,
                                             attno - 1)->atttypid,
                               -1, 0);
        }
        TupleDescFinalize(so->giststate->fetchTupdesc);
        scan->xs_hitupdesc = so->giststate->fetchTupdesc;
 
        /* Also create a memory context that will hold the returned tuples */
        so->pageDataCxt = AllocSetContextCreate(so->giststate->scanCxt,
                                                "GiST page data context",
                                                ALLOCSET_DEFAULT_SIZES);
    }
 
    /* create new, empty pairing heap for search queue */
    oldCxt = MemoryContextSwitchTo(so->queueCxt);
    so->queue = pairingheap_allocate(pairingheap_GISTSearchItem_cmp, scan);
    MemoryContextSwitchTo(oldCxt);
 
    so->firstCall = true;
 
    /* Update scan key, if a new one is given */
    if (key && scan->numberOfKeys > 0)
    {
        void      **fn_extras = NULL;
 
        /*
         * If this isn't the first time through, preserve the fn_extra
         * pointers, so that if the consistentFns are using them to cache
         * data, that data is not leaked across a rescan.
         */
        if (!first_time)
        {
            fn_extras = (void **) palloc(scan->numberOfKeys * sizeof(void *));
            for (i = 0; i < scan->numberOfKeys; i++)
                fn_extras[i] = scan->keyData[i].sk_func.fn_extra;
        }
 
        memcpy(scan->keyData, key, scan->numberOfKeys * sizeof(ScanKeyData));
 
        /*
         * Modify the scan key so that the Consistent method is called for all
         * comparisons. The original operator is passed to the Consistent
         * function in the form of its strategy number, which is available
         * from the sk_strategy field, and its subtype from the sk_subtype
         * field.
         *
         * Next, if any of keys is a NULL and that key is not marked with
         * SK_SEARCHNULL/SK_SEARCHNOTNULL then nothing can be found (ie, we
         * assume all indexable operators are strict).
         */
        so->qual_ok = true;
 
        for (i = 0; i < scan->numberOfKeys; i++)
        {
            ScanKey     skey = scan->keyData + i;
 
            /*
             * Copy consistent support function to ScanKey structure instead
             * of function implementing filtering operator.
             */
            fmgr_info_copy(&(skey->sk_func),
                           &(so->giststate->consistentFn[skey->sk_attno - 1]),
                           so->giststate->scanCxt);
 
            /* Restore prior fn_extra pointers, if not first time */
            if (!first_time)
                skey->sk_func.fn_extra = fn_extras[i];
 
            if (skey->sk_flags & SK_ISNULL)
            {
                if (!(skey->sk_flags & (SK_SEARCHNULL | SK_SEARCHNOTNULL)))
                    so->qual_ok = false;
            }
        }
 
        if (!first_time)
            pfree(fn_extras);
    }
 
    /* Update order-by key, if a new one is given */
    if (orderbys && scan->numberOfOrderBys > 0)
    {
        void      **fn_extras = NULL;
 
        /* As above, preserve fn_extra if not first time through */
        if (!first_time)
        {
            fn_extras = (void **) palloc(scan->numberOfOrderBys * sizeof(void *));
            for (i = 0; i < scan->numberOfOrderBys; i++)
                fn_extras[i] = scan->orderByData[i].sk_func.fn_extra;
        }
 
        memcpy(scan->orderByData, orderbys, scan->numberOfOrderBys * sizeof(ScanKeyData));
 
        so->orderByTypes = (Oid *) palloc(scan->numberOfOrderBys * sizeof(Oid));
 
        /*
         * Modify the order-by key so that the Distance method is called for
         * all comparisons. The original operator is passed to the Distance
         * function in the form of its strategy number, which is available
         * from the sk_strategy field, and its subtype from the sk_subtype
         * field.
         */
        for (i = 0; i < scan->numberOfOrderBys; i++)
        {
            ScanKey     skey = scan->orderByData + i;
            FmgrInfo   *finfo = &(so->giststate->distanceFn[skey->sk_attno - 1]);
 
            /* Check we actually have a distance function ... */
            if (!OidIsValid(finfo->fn_oid))
                elog(ERROR, "missing support function %d for attribute %d of index \"%s\"",
                     GIST_DISTANCE_PROC, skey->sk_attno,
                     RelationGetRelationName(scan->indexRelation));
 
            /*
             * Look up the datatype returned by the original ordering
             * operator. 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);
 
            /*
             * Copy distance support function to ScanKey structure instead of
             * function implementing ordering operator.
             */
            fmgr_info_copy(&(skey->sk_func), finfo, so->giststate->scanCxt);
 
            /* Restore prior fn_extra pointers, if not first time */
            if (!first_time)
                skey->sk_func.fn_extra = fn_extras[i];
        }
 
        if (!first_time)
            pfree(fn_extras);
    }
 
    /* any previous xs_hitup will have been pfree'd in context resets above */
    scan->xs_hitup = NULL;
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert, CreateTemplateTupleDesc(), elog, ERROR, fb(), fmgr_info_copy(), FmgrInfo::fn_extra, FmgrInfo::fn_oid, get_func_rettype(), GIST_DISTANCE_PROC, i, IndexScanDescData::indexRelation, IndexRelationGetNumberOfKeyAttributes, IndexScanDescData::keyData, MemoryContextReset(), MemoryContextSwitchTo(), IndexScanDescData::numberOfKeys, IndexScanDescData::numberOfOrderBys, OidIsValid, IndexScanDescData::opaque, IndexScanDescData::orderByData, pairingheap_allocate(), pairingheap_GISTSearchItem_cmp(), palloc(), pfree(), RelationData::rd_opcintype, RelationGetNumberOfAttributes, RelationGetRelationName, ScanKeyData::sk_func, SK_ISNULL, SK_SEARCHNOTNULL, SK_SEARCHNULL, TupleDescAttr(), TupleDescFinalize(), TupleDescInitEntry(), IndexScanDescData::xs_hitup, IndexScanDescData::xs_hitupdesc, and IndexScanDescData::xs_want_itup.

Referenced by gisthandler().