nodeIndexscan.h File Reference

#include "access/genam.h"
#include "access/parallel.h"
#include "nodes/execnodes.h"

Include dependency graph for nodeIndexscan.h:

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

Go to the source code of this file.

Functions
IndexScanState *	ExecInitIndexScan (IndexScan *node, EState *estate, int eflags)
void	ExecEndIndexScan (IndexScanState *node)
void	ExecIndexMarkPos (IndexScanState *node)
void	ExecIndexRestrPos (IndexScanState *node)
void	ExecReScanIndexScan (IndexScanState *node)
void	ExecIndexScanEstimate (IndexScanState *node, ParallelContext *pcxt)
void	ExecIndexScanInitializeDSM (IndexScanState *node, ParallelContext *pcxt)
void	ExecIndexScanReInitializeDSM (IndexScanState *node, ParallelContext *pcxt)
void	ExecIndexScanInitializeWorker (IndexScanState *node, ParallelWorkerContext *pwcxt)
void	ExecIndexScanRetrieveInstrumentation (IndexScanState *node)
void	ExecIndexBuildScanKeys (PlanState *planstate, Relation index, List *quals, bool isorderby, ScanKey *scanKeys, int *numScanKeys, IndexRuntimeKeyInfo **runtimeKeys, int *numRuntimeKeys, IndexArrayKeyInfo **arrayKeys, int *numArrayKeys)
void	ExecIndexEvalRuntimeKeys (ExprContext *econtext, IndexRuntimeKeyInfo *runtimeKeys, int numRuntimeKeys)
bool	ExecIndexEvalArrayKeys (ExprContext *econtext, IndexArrayKeyInfo *arrayKeys, int numArrayKeys)
bool	ExecIndexAdvanceArrayKeys (IndexArrayKeyInfo *arrayKeys, int numArrayKeys)

Function Documentation

ExecEndIndexScan()

void ExecEndIndexScan

(

IndexScanState *

node

)

Definition at line 787 of file nodeIndexscan.c.

{
    Relation    indexRelationDesc;
    IndexScanDesc indexScanDesc;
 
    /*
     * extract information from the node
     */
    indexRelationDesc = node->iss_RelationDesc;
    indexScanDesc = node->iss_ScanDesc;
 
    /*
     * When ending a parallel worker, copy the statistics gathered by the
     * worker back into shared memory so that it can be picked up by the main
     * process to report in EXPLAIN ANALYZE
     */
    if (node->iss_SharedInfo != NULL && IsParallelWorker())
    {
        IndexScanInstrumentation *winstrument;
 
        Assert(ParallelWorkerNumber <= node->iss_SharedInfo->num_workers);
        winstrument = &node->iss_SharedInfo->winstrument[ParallelWorkerNumber];
 
        /*
         * We have to accumulate the stats rather than performing a memcpy.
         * When a Gather/GatherMerge node finishes it will perform planner
         * shutdown on the workers.  On rescan it will spin up new workers
         * which will have a new IndexOnlyScanState and zeroed stats.
         */
        winstrument->nsearches += node->iss_Instrument.nsearches;
    }
 
    /*
     * close the index relation (no-op if we didn't open it)
     */
    if (indexScanDesc)
        index_endscan(indexScanDesc);
    if (indexRelationDesc)
        index_close(indexRelationDesc, NoLock);
}

References Assert(), index_close(), index_endscan(), IsParallelWorker, IndexScanState::iss_Instrument, IndexScanState::iss_RelationDesc, IndexScanState::iss_ScanDesc, IndexScanState::iss_SharedInfo, NoLock, IndexScanInstrumentation::nsearches, ParallelWorkerNumber, and SharedIndexScanInstrumentation::winstrument.

Referenced by ExecEndNode().

ExecIndexAdvanceArrayKeys()

bool ExecIndexAdvanceArrayKeys	(	IndexArrayKeyInfo *	arrayKeys,
		int	numArrayKeys
	)

Definition at line 742 of file nodeIndexscan.c.

{
    bool        found = false;
    int         j;
 
    /*
     * Note we advance the rightmost array key most quickly, since it will
     * correspond to the lowest-order index column among the available
     * qualifications.  This is hypothesized to result in better locality of
     * access in the index.
     */
    for (j = numArrayKeys - 1; j >= 0; j--)
    {
        ScanKey     scan_key = arrayKeys[j].scan_key;
        int         next_elem = arrayKeys[j].next_elem;
        int         num_elems = arrayKeys[j].num_elems;
        Datum      *elem_values = arrayKeys[j].elem_values;
        bool       *elem_nulls = arrayKeys[j].elem_nulls;
 
        if (next_elem >= num_elems)
        {
            next_elem = 0;
            found = false;      /* need to advance next array key */
        }
        else
            found = true;
        scan_key->sk_argument = elem_values[next_elem];
        if (elem_nulls[next_elem])
            scan_key->sk_flags |= SK_ISNULL;
        else
            scan_key->sk_flags &= ~SK_ISNULL;
        arrayKeys[j].next_elem = next_elem + 1;
        if (found)
            break;
    }
 
    return found;
}

References IndexArrayKeyInfo::elem_nulls, IndexArrayKeyInfo::elem_values, j, IndexArrayKeyInfo::next_elem, IndexArrayKeyInfo::num_elems, IndexArrayKeyInfo::scan_key, ScanKeyData::sk_argument, ScanKeyData::sk_flags, and SK_ISNULL.

Referenced by MultiExecBitmapIndexScan().

ExecIndexBuildScanKeys()

void ExecIndexBuildScanKeys	(	PlanState *	planstate,
		Relation	index,
		List *	quals,
		bool	isorderby,
		ScanKey *	scanKeys,
		int *	numScanKeys,
		IndexRuntimeKeyInfo **	runtimeKeys,
		int *	numRuntimeKeys,
		IndexArrayKeyInfo **	arrayKeys,
		int *	numArrayKeys
	)

Definition at line 1158 of file nodeIndexscan.c.

{
    ListCell   *qual_cell;
    ScanKey     scan_keys;
    IndexRuntimeKeyInfo *runtime_keys;
    IndexArrayKeyInfo *array_keys;
    int         n_scan_keys;
    int         n_runtime_keys;
    int         max_runtime_keys;
    int         n_array_keys;
    int         j;
 
    /* Allocate array for ScanKey structs: one per qual */
    n_scan_keys = list_length(quals);
    scan_keys = (ScanKey) palloc(n_scan_keys * sizeof(ScanKeyData));
 
    /*
     * runtime_keys array is dynamically resized as needed.  We handle it this
     * way so that the same runtime keys array can be shared between
     * indexquals and indexorderbys, which will be processed in separate calls
     * of this function.  Caller must be sure to pass in NULL/0 for first
     * call.
     */
    runtime_keys = *runtimeKeys;
    n_runtime_keys = max_runtime_keys = *numRuntimeKeys;
 
    /* Allocate array_keys as large as it could possibly need to be */
    array_keys = (IndexArrayKeyInfo *)
        palloc0(n_scan_keys * sizeof(IndexArrayKeyInfo));
    n_array_keys = 0;
 
    /*
     * for each opclause in the given qual, convert the opclause into a single
     * scan key
     */
    j = 0;
    foreach(qual_cell, quals)
    {
        Expr       *clause = (Expr *) lfirst(qual_cell);
        ScanKey     this_scan_key = &scan_keys[j++];
        Oid         opno;       /* operator's OID */
        RegProcedure opfuncid;  /* operator proc id used in scan */
        Oid         opfamily;   /* opfamily of index column */
        int         op_strategy;    /* operator's strategy number */
        Oid         op_lefttype;    /* operator's declared input types */
        Oid         op_righttype;
        Expr       *leftop;     /* expr on lhs of operator */
        Expr       *rightop;    /* expr on rhs ... */
        AttrNumber  varattno;   /* att number used in scan */
        int         indnkeyatts;
 
        indnkeyatts = IndexRelationGetNumberOfKeyAttributes(index);
        if (IsA(clause, OpExpr))
        {
            /* indexkey op const or indexkey op expression */
            int         flags = 0;
            Datum       scanvalue;
 
            opno = ((OpExpr *) clause)->opno;
            opfuncid = ((OpExpr *) clause)->opfuncid;
 
            /*
             * leftop should be the index key Var, possibly relabeled
             */
            leftop = (Expr *) get_leftop(clause);
 
            if (leftop && IsA(leftop, RelabelType))
                leftop = ((RelabelType *) leftop)->arg;
 
            Assert(leftop != NULL);
 
            if (!(IsA(leftop, Var) &&
                  ((Var *) leftop)->varno == INDEX_VAR))
                elog(ERROR, "indexqual doesn't have key on left side");
 
            varattno = ((Var *) leftop)->varattno;
            if (varattno < 1 || varattno > indnkeyatts)
                elog(ERROR, "bogus index qualification");
 
            /*
             * We have to look up the operator's strategy number.  This
             * provides a cross-check that the operator does match the index.
             */
            opfamily = index->rd_opfamily[varattno - 1];
 
            get_op_opfamily_properties(opno, opfamily, isorderby,
                                       &op_strategy,
                                       &op_lefttype,
                                       &op_righttype);
 
            if (isorderby)
                flags |= SK_ORDER_BY;
 
            /*
             * rightop is the constant or variable comparison value
             */
            rightop = (Expr *) get_rightop(clause);
 
            if (rightop && IsA(rightop, RelabelType))
                rightop = ((RelabelType *) rightop)->arg;
 
            Assert(rightop != NULL);
 
            if (IsA(rightop, Const))
            {
                /* OK, simple constant comparison value */
                scanvalue = ((Const *) rightop)->constvalue;
                if (((Const *) rightop)->constisnull)
                    flags |= SK_ISNULL;
            }
            else
            {
                /* Need to treat this one as a runtime key */
                if (n_runtime_keys >= max_runtime_keys)
                {
                    if (max_runtime_keys == 0)
                    {
                        max_runtime_keys = 8;
                        runtime_keys = (IndexRuntimeKeyInfo *)
                            palloc(max_runtime_keys * sizeof(IndexRuntimeKeyInfo));
                    }
                    else
                    {
                        max_runtime_keys *= 2;
                        runtime_keys = (IndexRuntimeKeyInfo *)
                            repalloc(runtime_keys, max_runtime_keys * sizeof(IndexRuntimeKeyInfo));
                    }
                }
                runtime_keys[n_runtime_keys].scan_key = this_scan_key;
                runtime_keys[n_runtime_keys].key_expr =
                    ExecInitExpr(rightop, planstate);
                runtime_keys[n_runtime_keys].key_toastable =
                    TypeIsToastable(op_righttype);
                n_runtime_keys++;
                scanvalue = (Datum) 0;
            }
 
            /*
             * initialize the scan key's fields appropriately
             */
            ScanKeyEntryInitialize(this_scan_key,
                                   flags,
                                   varattno,    /* attribute number to scan */
                                   op_strategy, /* op's strategy */
                                   op_righttype,    /* strategy subtype */
                                   ((OpExpr *) clause)->inputcollid,    /* collation */
                                   opfuncid,    /* reg proc to use */
                                   scanvalue);  /* constant */
        }
        else if (IsA(clause, RowCompareExpr))
        {
            /* (indexkey, indexkey, ...) op (expression, expression, ...) */
            RowCompareExpr *rc = (RowCompareExpr *) clause;
            ScanKey     first_sub_key;
            int         n_sub_key;
            ListCell   *largs_cell;
            ListCell   *rargs_cell;
            ListCell   *opnos_cell;
            ListCell   *collids_cell;
 
            Assert(!isorderby);
 
            first_sub_key = (ScanKey)
                palloc(list_length(rc->opnos) * sizeof(ScanKeyData));
            n_sub_key = 0;
 
            /* Scan RowCompare columns and generate subsidiary ScanKey items */
            forfour(largs_cell, rc->largs, rargs_cell, rc->rargs,
                    opnos_cell, rc->opnos, collids_cell, rc->inputcollids)
            {
                ScanKey     this_sub_key = &first_sub_key[n_sub_key];
                int         flags = SK_ROW_MEMBER;
                Datum       scanvalue;
                Oid         inputcollation;
 
                leftop = (Expr *) lfirst(largs_cell);
                rightop = (Expr *) lfirst(rargs_cell);
                opno = lfirst_oid(opnos_cell);
                inputcollation = lfirst_oid(collids_cell);
 
                /*
                 * leftop should be the index key Var, possibly relabeled
                 */
                if (leftop && IsA(leftop, RelabelType))
                    leftop = ((RelabelType *) leftop)->arg;
 
                Assert(leftop != NULL);
 
                if (!(IsA(leftop, Var) &&
                      ((Var *) leftop)->varno == INDEX_VAR))
                    elog(ERROR, "indexqual doesn't have key on left side");
 
                varattno = ((Var *) leftop)->varattno;
 
                /*
                 * We have to look up the operator's associated support
                 * function
                 */
                if (!index->rd_indam->amcanorder ||
                    varattno < 1 || varattno > indnkeyatts)
                    elog(ERROR, "bogus RowCompare index qualification");
                opfamily = index->rd_opfamily[varattno - 1];
 
                get_op_opfamily_properties(opno, opfamily, isorderby,
                                           &op_strategy,
                                           &op_lefttype,
                                           &op_righttype);
 
                if (op_strategy != rc->cmptype)
                    elog(ERROR, "RowCompare index qualification contains wrong operator");
 
                opfuncid = get_opfamily_proc(opfamily,
                                             op_lefttype,
                                             op_righttype,
                                             BTORDER_PROC);
                if (!RegProcedureIsValid(opfuncid))
                    elog(ERROR, "missing support function %d(%u,%u) in opfamily %u",
                         BTORDER_PROC, op_lefttype, op_righttype, opfamily);
 
                /*
                 * rightop is the constant or variable comparison value
                 */
                if (rightop && IsA(rightop, RelabelType))
                    rightop = ((RelabelType *) rightop)->arg;
 
                Assert(rightop != NULL);
 
                if (IsA(rightop, Const))
                {
                    /* OK, simple constant comparison value */
                    scanvalue = ((Const *) rightop)->constvalue;
                    if (((Const *) rightop)->constisnull)
                        flags |= SK_ISNULL;
                }
                else
                {
                    /* Need to treat this one as a runtime key */
                    if (n_runtime_keys >= max_runtime_keys)
                    {
                        if (max_runtime_keys == 0)
                        {
                            max_runtime_keys = 8;
                            runtime_keys = (IndexRuntimeKeyInfo *)
                                palloc(max_runtime_keys * sizeof(IndexRuntimeKeyInfo));
                        }
                        else
                        {
                            max_runtime_keys *= 2;
                            runtime_keys = (IndexRuntimeKeyInfo *)
                                repalloc(runtime_keys, max_runtime_keys * sizeof(IndexRuntimeKeyInfo));
                        }
                    }
                    runtime_keys[n_runtime_keys].scan_key = this_sub_key;
                    runtime_keys[n_runtime_keys].key_expr =
                        ExecInitExpr(rightop, planstate);
                    runtime_keys[n_runtime_keys].key_toastable =
                        TypeIsToastable(op_righttype);
                    n_runtime_keys++;
                    scanvalue = (Datum) 0;
                }
 
                /*
                 * initialize the subsidiary scan key's fields appropriately
                 */
                ScanKeyEntryInitialize(this_sub_key,
                                       flags,
                                       varattno,    /* attribute number */
                                       op_strategy, /* op's strategy */
                                       op_righttype,    /* strategy subtype */
                                       inputcollation,  /* collation */
                                       opfuncid,    /* reg proc to use */
                                       scanvalue);  /* constant */
                n_sub_key++;
            }
 
            /* Mark the last subsidiary scankey correctly */
            first_sub_key[n_sub_key - 1].sk_flags |= SK_ROW_END;
 
            /*
             * We don't use ScanKeyEntryInitialize for the header because it
             * isn't going to contain a valid sk_func pointer.
             */
            MemSet(this_scan_key, 0, sizeof(ScanKeyData));
            this_scan_key->sk_flags = SK_ROW_HEADER;
            this_scan_key->sk_attno = first_sub_key->sk_attno;
            this_scan_key->sk_strategy = rc->cmptype;
            /* sk_subtype, sk_collation, sk_func not used in a header */
            this_scan_key->sk_argument = PointerGetDatum(first_sub_key);
        }
        else if (IsA(clause, ScalarArrayOpExpr))
        {
            /* indexkey op ANY (array-expression) */
            ScalarArrayOpExpr *saop = (ScalarArrayOpExpr *) clause;
            int         flags = 0;
            Datum       scanvalue;
 
            Assert(!isorderby);
 
            Assert(saop->useOr);
            opno = saop->opno;
            opfuncid = saop->opfuncid;
 
            /*
             * leftop should be the index key Var, possibly relabeled
             */
            leftop = (Expr *) linitial(saop->args);
 
            if (leftop && IsA(leftop, RelabelType))
                leftop = ((RelabelType *) leftop)->arg;
 
            Assert(leftop != NULL);
 
            if (!(IsA(leftop, Var) &&
                  ((Var *) leftop)->varno == INDEX_VAR))
                elog(ERROR, "indexqual doesn't have key on left side");
 
            varattno = ((Var *) leftop)->varattno;
            if (varattno < 1 || varattno > indnkeyatts)
                elog(ERROR, "bogus index qualification");
 
            /*
             * We have to look up the operator's strategy number.  This
             * provides a cross-check that the operator does match the index.
             */
            opfamily = index->rd_opfamily[varattno - 1];
 
            get_op_opfamily_properties(opno, opfamily, isorderby,
                                       &op_strategy,
                                       &op_lefttype,
                                       &op_righttype);
 
            /*
             * rightop is the constant or variable array value
             */
            rightop = (Expr *) lsecond(saop->args);
 
            if (rightop && IsA(rightop, RelabelType))
                rightop = ((RelabelType *) rightop)->arg;
 
            Assert(rightop != NULL);
 
            if (index->rd_indam->amsearcharray)
            {
                /* Index AM will handle this like a simple operator */
                flags |= SK_SEARCHARRAY;
                if (IsA(rightop, Const))
                {
                    /* OK, simple constant comparison value */
                    scanvalue = ((Const *) rightop)->constvalue;
                    if (((Const *) rightop)->constisnull)
                        flags |= SK_ISNULL;
                }
                else
                {
                    /* Need to treat this one as a runtime key */
                    if (n_runtime_keys >= max_runtime_keys)
                    {
                        if (max_runtime_keys == 0)
                        {
                            max_runtime_keys = 8;
                            runtime_keys = (IndexRuntimeKeyInfo *)
                                palloc(max_runtime_keys * sizeof(IndexRuntimeKeyInfo));
                        }
                        else
                        {
                            max_runtime_keys *= 2;
                            runtime_keys = (IndexRuntimeKeyInfo *)
                                repalloc(runtime_keys, max_runtime_keys * sizeof(IndexRuntimeKeyInfo));
                        }
                    }
                    runtime_keys[n_runtime_keys].scan_key = this_scan_key;
                    runtime_keys[n_runtime_keys].key_expr =
                        ExecInitExpr(rightop, planstate);
 
                    /*
                     * Careful here: the runtime expression is not of
                     * op_righttype, but rather is an array of same; so
                     * TypeIsToastable() isn't helpful.  However, we can
                     * assume that all array types are toastable.
                     */
                    runtime_keys[n_runtime_keys].key_toastable = true;
                    n_runtime_keys++;
                    scanvalue = (Datum) 0;
                }
            }
            else
            {
                /* Executor has to expand the array value */
                array_keys[n_array_keys].scan_key = this_scan_key;
                array_keys[n_array_keys].array_expr =
                    ExecInitExpr(rightop, planstate);
                /* the remaining fields were zeroed by palloc0 */
                n_array_keys++;
                scanvalue = (Datum) 0;
            }
 
            /*
             * initialize the scan key's fields appropriately
             */
            ScanKeyEntryInitialize(this_scan_key,
                                   flags,
                                   varattno,    /* attribute number to scan */
                                   op_strategy, /* op's strategy */
                                   op_righttype,    /* strategy subtype */
                                   saop->inputcollid,   /* collation */
                                   opfuncid,    /* reg proc to use */
                                   scanvalue);  /* constant */
        }
        else if (IsA(clause, NullTest))
        {
            /* indexkey IS NULL or indexkey IS NOT NULL */
            NullTest   *ntest = (NullTest *) clause;
            int         flags;
 
            Assert(!isorderby);
 
            /*
             * argument should be the index key Var, possibly relabeled
             */
            leftop = ntest->arg;
 
            if (leftop && IsA(leftop, RelabelType))
                leftop = ((RelabelType *) leftop)->arg;
 
            Assert(leftop != NULL);
 
            if (!(IsA(leftop, Var) &&
                  ((Var *) leftop)->varno == INDEX_VAR))
                elog(ERROR, "NullTest indexqual has wrong key");
 
            varattno = ((Var *) leftop)->varattno;
 
            /*
             * initialize the scan key's fields appropriately
             */
            switch (ntest->nulltesttype)
            {
                case IS_NULL:
                    flags = SK_ISNULL | SK_SEARCHNULL;
                    break;
                case IS_NOT_NULL:
                    flags = SK_ISNULL | SK_SEARCHNOTNULL;
                    break;
                default:
                    elog(ERROR, "unrecognized nulltesttype: %d",
                         (int) ntest->nulltesttype);
                    flags = 0;  /* keep compiler quiet */
                    break;
            }
 
            ScanKeyEntryInitialize(this_scan_key,
                                   flags,
                                   varattno,    /* attribute number to scan */
                                   InvalidStrategy, /* no strategy */
                                   InvalidOid,  /* no strategy subtype */
                                   InvalidOid,  /* no collation */
                                   InvalidOid,  /* no reg proc for this */
                                   (Datum) 0);  /* constant */
        }
        else
            elog(ERROR, "unsupported indexqual type: %d",
                 (int) nodeTag(clause));
    }
 
    Assert(n_runtime_keys <= max_runtime_keys);
 
    /* Get rid of any unused arrays */
    if (n_array_keys == 0)
    {
        pfree(array_keys);
        array_keys = NULL;
    }
 
    /*
     * Return info to our caller.
     */
    *scanKeys = scan_keys;
    *numScanKeys = n_scan_keys;
    *runtimeKeys = runtime_keys;
    *numRuntimeKeys = n_runtime_keys;
    if (arrayKeys)
    {
        *arrayKeys = array_keys;
        *numArrayKeys = n_array_keys;
    }
    else if (n_array_keys != 0)
        elog(ERROR, "ScalarArrayOpExpr index qual found where not allowed");
}

References arg, NullTest::arg, ScalarArrayOpExpr::args, IndexArrayKeyInfo::array_expr, Assert(), BTORDER_PROC, RowCompareExpr::cmptype, elog, ERROR, ExecInitExpr(), forfour, get_leftop(), get_op_opfamily_properties(), get_opfamily_proc(), get_rightop(), INDEX_VAR, IndexRelationGetNumberOfKeyAttributes, InvalidOid, InvalidStrategy, IS_NOT_NULL, IS_NULL, IsA, j, IndexRuntimeKeyInfo::key_expr, IndexRuntimeKeyInfo::key_toastable, RowCompareExpr::largs, lfirst, lfirst_oid, linitial, list_length(), lsecond, MemSet, nodeTag, NullTest::nulltesttype, ScalarArrayOpExpr::opno, palloc(), palloc0(), pfree(), PointerGetDatum(), RowCompareExpr::rargs, RegProcedureIsValid, repalloc(), IndexRuntimeKeyInfo::scan_key, IndexArrayKeyInfo::scan_key, ScanKeyEntryInitialize(), ScanKeyData::sk_argument, ScanKeyData::sk_attno, ScanKeyData::sk_flags, SK_ISNULL, SK_ORDER_BY, SK_ROW_END, SK_ROW_HEADER, SK_ROW_MEMBER, SK_SEARCHARRAY, SK_SEARCHNOTNULL, SK_SEARCHNULL, ScanKeyData::sk_strategy, TypeIsToastable, and ScalarArrayOpExpr::useOr.

Referenced by ExecInitBitmapIndexScan(), ExecInitIndexOnlyScan(), and ExecInitIndexScan().

ExecIndexEvalArrayKeys()

bool ExecIndexEvalArrayKeys	(	ExprContext *	econtext,
		IndexArrayKeyInfo *	arrayKeys,
		int	numArrayKeys
	)

Definition at line 663 of file nodeIndexscan.c.

{
    bool        result = true;
    int         j;
    MemoryContext oldContext;
 
    /* We want to keep the arrays in per-tuple memory */
    oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
 
    for (j = 0; j < numArrayKeys; j++)
    {
        ScanKey     scan_key = arrayKeys[j].scan_key;
        ExprState  *array_expr = arrayKeys[j].array_expr;
        Datum       arraydatum;
        bool        isNull;
        ArrayType  *arrayval;
        int16       elmlen;
        bool        elmbyval;
        char        elmalign;
        int         num_elems;
        Datum      *elem_values;
        bool       *elem_nulls;
 
        /*
         * Compute and deconstruct the array expression. (Notes in
         * ExecIndexEvalRuntimeKeys() apply here too.)
         */
        arraydatum = ExecEvalExpr(array_expr,
                                  econtext,
                                  &isNull);
        if (isNull)
        {
            result = false;
            break;              /* no point in evaluating more */
        }
        arrayval = DatumGetArrayTypeP(arraydatum);
        /* We could cache this data, but not clear it's worth it */
        get_typlenbyvalalign(ARR_ELEMTYPE(arrayval),
                             &elmlen, &elmbyval, &elmalign);
        deconstruct_array(arrayval,
                          ARR_ELEMTYPE(arrayval),
                          elmlen, elmbyval, elmalign,
                          &elem_values, &elem_nulls, &num_elems);
        if (num_elems <= 0)
        {
            result = false;
            break;              /* no point in evaluating more */
        }
 
        /*
         * Note: we expect the previous array data, if any, to be
         * automatically freed by resetting the per-tuple context; hence no
         * pfree's here.
         */
        arrayKeys[j].elem_values = elem_values;
        arrayKeys[j].elem_nulls = elem_nulls;
        arrayKeys[j].num_elems = num_elems;
        scan_key->sk_argument = elem_values[0];
        if (elem_nulls[0])
            scan_key->sk_flags |= SK_ISNULL;
        else
            scan_key->sk_flags &= ~SK_ISNULL;
        arrayKeys[j].next_elem = 1;
    }
 
    MemoryContextSwitchTo(oldContext);
 
    return result;
}

References ARR_ELEMTYPE, IndexArrayKeyInfo::array_expr, DatumGetArrayTypeP, deconstruct_array(), ExprContext::ecxt_per_tuple_memory, IndexArrayKeyInfo::elem_nulls, IndexArrayKeyInfo::elem_values, ExecEvalExpr(), get_typlenbyvalalign(), j, MemoryContextSwitchTo(), IndexArrayKeyInfo::next_elem, IndexArrayKeyInfo::num_elems, IndexArrayKeyInfo::scan_key, ScanKeyData::sk_argument, ScanKeyData::sk_flags, and SK_ISNULL.

Referenced by ExecReScanBitmapIndexScan().

ExecIndexEvalRuntimeKeys()

void ExecIndexEvalRuntimeKeys	(	ExprContext *	econtext,
		IndexRuntimeKeyInfo *	runtimeKeys,
		int	numRuntimeKeys
	)

Definition at line 601 of file nodeIndexscan.c.

{
    int         j;
    MemoryContext oldContext;
 
    /* We want to keep the key values in per-tuple memory */
    oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
 
    for (j = 0; j < numRuntimeKeys; j++)
    {
        ScanKey     scan_key = runtimeKeys[j].scan_key;
        ExprState  *key_expr = runtimeKeys[j].key_expr;
        Datum       scanvalue;
        bool        isNull;
 
        /*
         * For each run-time key, extract the run-time expression and evaluate
         * it with respect to the current context.  We then stick the result
         * into the proper scan key.
         *
         * Note: the result of the eval could be a pass-by-ref value that's
         * stored in some outer scan's tuple, not in
         * econtext->ecxt_per_tuple_memory.  We assume that the outer tuple
         * will stay put throughout our scan.  If this is wrong, we could copy
         * the result into our context explicitly, but I think that's not
         * necessary.
         *
         * It's also entirely possible that the result of the eval is a
         * toasted value.  In this case we should forcibly detoast it, to
         * avoid repeat detoastings each time the value is examined by an
         * index support function.
         */
        scanvalue = ExecEvalExpr(key_expr,
                                 econtext,
                                 &isNull);
        if (isNull)
        {
            scan_key->sk_argument = scanvalue;
            scan_key->sk_flags |= SK_ISNULL;
        }
        else
        {
            if (runtimeKeys[j].key_toastable)
                scanvalue = PointerGetDatum(PG_DETOAST_DATUM(scanvalue));
            scan_key->sk_argument = scanvalue;
            scan_key->sk_flags &= ~SK_ISNULL;
        }
    }
 
    MemoryContextSwitchTo(oldContext);
}

References ExprContext::ecxt_per_tuple_memory, ExecEvalExpr(), j, IndexRuntimeKeyInfo::key_expr, MemoryContextSwitchTo(), PG_DETOAST_DATUM, PointerGetDatum(), IndexRuntimeKeyInfo::scan_key, ScanKeyData::sk_argument, ScanKeyData::sk_flags, and SK_ISNULL.

Referenced by ExecReScanBitmapIndexScan(), ExecReScanIndexOnlyScan(), and ExecReScanIndexScan().

ExecIndexMarkPos()

void ExecIndexMarkPos

(

IndexScanState *

node

)

Definition at line 836 of file nodeIndexscan.c.

{
    EState     *estate = node->ss.ps.state;
    EPQState   *epqstate = estate->es_epq_active;
 
    if (epqstate != NULL)
    {
        /*
         * We are inside an EvalPlanQual recheck.  If a test tuple exists for
         * this relation, then we shouldn't access the index at all.  We would
         * instead need to save, and later restore, the state of the
         * relsubs_done flag, so that re-fetching the test tuple is possible.
         * However, given the assumption that no caller sets a mark at the
         * start of the scan, we can only get here with relsubs_done[i]
         * already set, and so no state need be saved.
         */
        Index       scanrelid = ((Scan *) node->ss.ps.plan)->scanrelid;
 
        Assert(scanrelid > 0);
        if (epqstate->relsubs_slot[scanrelid - 1] != NULL ||
            epqstate->relsubs_rowmark[scanrelid - 1] != NULL)
        {
            /* Verify the claim above */
            if (!epqstate->relsubs_done[scanrelid - 1])
                elog(ERROR, "unexpected ExecIndexMarkPos call in EPQ recheck");
            return;
        }
    }
 
    index_markpos(node->iss_ScanDesc);
}

References Assert(), elog, ERROR, EState::es_epq_active, index_markpos(), IndexScanState::iss_ScanDesc, PlanState::plan, ScanState::ps, EPQState::relsubs_done, EPQState::relsubs_rowmark, EPQState::relsubs_slot, IndexScanState::ss, and PlanState::state.

Referenced by ExecMarkPos().

ExecIndexRestrPos()

void ExecIndexRestrPos

(

IndexScanState *

node

)

Definition at line 873 of file nodeIndexscan.c.

{
    EState     *estate = node->ss.ps.state;
    EPQState   *epqstate = estate->es_epq_active;
 
    if (estate->es_epq_active != NULL)
    {
        /* See comments in ExecIndexMarkPos */
        Index       scanrelid = ((Scan *) node->ss.ps.plan)->scanrelid;
 
        Assert(scanrelid > 0);
        if (epqstate->relsubs_slot[scanrelid - 1] != NULL ||
            epqstate->relsubs_rowmark[scanrelid - 1] != NULL)
        {
            /* Verify the claim above */
            if (!epqstate->relsubs_done[scanrelid - 1])
                elog(ERROR, "unexpected ExecIndexRestrPos call in EPQ recheck");
            return;
        }
    }
 
    index_restrpos(node->iss_ScanDesc);
}

References Assert(), elog, ERROR, EState::es_epq_active, index_restrpos(), IndexScanState::iss_ScanDesc, PlanState::plan, ScanState::ps, EPQState::relsubs_done, EPQState::relsubs_rowmark, EPQState::relsubs_slot, IndexScanState::ss, and PlanState::state.

Referenced by ExecRestrPos().

ExecIndexScanEstimate()

void ExecIndexScanEstimate	(	IndexScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 1664 of file nodeIndexscan.c.

{
    EState     *estate = node->ss.ps.state;
    bool        instrument = node->ss.ps.instrument != NULL;
    bool        parallel_aware = node->ss.ps.plan->parallel_aware;
 
    if (!instrument && !parallel_aware)
    {
        /* No DSM required by the scan */
        return;
    }
 
    node->iss_PscanLen = index_parallelscan_estimate(node->iss_RelationDesc,
                                                     node->iss_NumScanKeys,
                                                     node->iss_NumOrderByKeys,
                                                     estate->es_snapshot,
                                                     instrument, parallel_aware,
                                                     pcxt->nworkers);
    shm_toc_estimate_chunk(&pcxt->estimator, node->iss_PscanLen);
    shm_toc_estimate_keys(&pcxt->estimator, 1);
}

References EState::es_snapshot, ParallelContext::estimator, index_parallelscan_estimate(), PlanState::instrument, IndexScanState::iss_NumOrderByKeys, IndexScanState::iss_NumScanKeys, IndexScanState::iss_PscanLen, IndexScanState::iss_RelationDesc, ParallelContext::nworkers, Plan::parallel_aware, PlanState::plan, ScanState::ps, shm_toc_estimate_chunk, shm_toc_estimate_keys, IndexScanState::ss, and PlanState::state.

Referenced by ExecParallelEstimate().

ExecIndexScanInitializeDSM()

void ExecIndexScanInitializeDSM	(	IndexScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 1694 of file nodeIndexscan.c.

{
    EState     *estate = node->ss.ps.state;
    ParallelIndexScanDesc piscan;
    bool        instrument = node->ss.ps.instrument != NULL;
    bool        parallel_aware = node->ss.ps.plan->parallel_aware;
 
    if (!instrument && !parallel_aware)
    {
        /* No DSM required by the scan */
        return;
    }
 
    piscan = shm_toc_allocate(pcxt->toc, node->iss_PscanLen);
    index_parallelscan_initialize(node->ss.ss_currentRelation,
                                  node->iss_RelationDesc,
                                  estate->es_snapshot,
                                  instrument, parallel_aware, pcxt->nworkers,
                                  &node->iss_SharedInfo, piscan);
    shm_toc_insert(pcxt->toc, node->ss.ps.plan->plan_node_id, piscan);
 
    if (!parallel_aware)
    {
        /* Only here to initialize SharedInfo in DSM */
        return;
    }
 
    node->iss_ScanDesc =
        index_beginscan_parallel(node->ss.ss_currentRelation,
                                 node->iss_RelationDesc,
                                 &node->iss_Instrument,
                                 node->iss_NumScanKeys,
                                 node->iss_NumOrderByKeys,
                                 piscan);
 
    /*
     * If no run-time keys to calculate or they are ready, go ahead and pass
     * the scankeys to the index AM.
     */
    if (node->iss_NumRuntimeKeys == 0 || node->iss_RuntimeKeysReady)
        index_rescan(node->iss_ScanDesc,
                     node->iss_ScanKeys, node->iss_NumScanKeys,
                     node->iss_OrderByKeys, node->iss_NumOrderByKeys);
}

References EState::es_snapshot, index_beginscan_parallel(), index_parallelscan_initialize(), index_rescan(), PlanState::instrument, IndexScanState::iss_Instrument, IndexScanState::iss_NumOrderByKeys, IndexScanState::iss_NumRuntimeKeys, IndexScanState::iss_NumScanKeys, IndexScanState::iss_OrderByKeys, IndexScanState::iss_PscanLen, IndexScanState::iss_RelationDesc, IndexScanState::iss_RuntimeKeysReady, IndexScanState::iss_ScanDesc, IndexScanState::iss_ScanKeys, IndexScanState::iss_SharedInfo, ParallelContext::nworkers, Plan::parallel_aware, PlanState::plan, Plan::plan_node_id, ScanState::ps, shm_toc_allocate(), shm_toc_insert(), IndexScanState::ss, ScanState::ss_currentRelation, PlanState::state, and ParallelContext::toc.

Referenced by ExecParallelInitializeDSM().

ExecIndexScanInitializeWorker()

void ExecIndexScanInitializeWorker	(	IndexScanState *	node,
		ParallelWorkerContext *	pwcxt
	)

Definition at line 1761 of file nodeIndexscan.c.

{
    ParallelIndexScanDesc piscan;
    bool        instrument = node->ss.ps.instrument != NULL;
    bool        parallel_aware = node->ss.ps.plan->parallel_aware;
 
    if (!instrument && !parallel_aware)
    {
        /* No DSM required by the scan */
        return;
    }
 
    piscan = shm_toc_lookup(pwcxt->toc, node->ss.ps.plan->plan_node_id, false);
 
    if (instrument)
        node->iss_SharedInfo = (SharedIndexScanInstrumentation *)
            OffsetToPointer(piscan, piscan->ps_offset_ins);
 
    if (!parallel_aware)
    {
        /* Only here to set up worker node's SharedInfo */
        return;
    }
 
    node->iss_ScanDesc =
        index_beginscan_parallel(node->ss.ss_currentRelation,
                                 node->iss_RelationDesc,
                                 &node->iss_Instrument,
                                 node->iss_NumScanKeys,
                                 node->iss_NumOrderByKeys,
                                 piscan);
 
    /*
     * If no run-time keys to calculate or they are ready, go ahead and pass
     * the scankeys to the index AM.
     */
    if (node->iss_NumRuntimeKeys == 0 || node->iss_RuntimeKeysReady)
        index_rescan(node->iss_ScanDesc,
                     node->iss_ScanKeys, node->iss_NumScanKeys,
                     node->iss_OrderByKeys, node->iss_NumOrderByKeys);
}

References index_beginscan_parallel(), index_rescan(), PlanState::instrument, IndexScanState::iss_Instrument, IndexScanState::iss_NumOrderByKeys, IndexScanState::iss_NumRuntimeKeys, IndexScanState::iss_NumScanKeys, IndexScanState::iss_OrderByKeys, IndexScanState::iss_RelationDesc, IndexScanState::iss_RuntimeKeysReady, IndexScanState::iss_ScanDesc, IndexScanState::iss_ScanKeys, IndexScanState::iss_SharedInfo, OffsetToPointer, Plan::parallel_aware, PlanState::plan, Plan::plan_node_id, ScanState::ps, ParallelIndexScanDescData::ps_offset_ins, shm_toc_lookup(), IndexScanState::ss, ScanState::ss_currentRelation, and ParallelWorkerContext::toc.

Referenced by ExecParallelInitializeWorker().

ExecIndexScanReInitializeDSM()

void ExecIndexScanReInitializeDSM	(	IndexScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 1747 of file nodeIndexscan.c.

{
    Assert(node->ss.ps.plan->parallel_aware);
    index_parallelrescan(node->iss_ScanDesc);
}

References Assert(), index_parallelrescan(), IndexScanState::iss_ScanDesc, Plan::parallel_aware, PlanState::plan, ScanState::ps, and IndexScanState::ss.

Referenced by ExecParallelReInitializeDSM().

ExecIndexScanRetrieveInstrumentation()

void ExecIndexScanRetrieveInstrumentation

(

IndexScanState *

node

)

Definition at line 1811 of file nodeIndexscan.c.

{
    SharedIndexScanInstrumentation *SharedInfo = node->iss_SharedInfo;
    size_t      size;
 
    if (SharedInfo == NULL)
        return;
 
    /* Create a copy of SharedInfo in backend-local memory */
    size = offsetof(SharedIndexScanInstrumentation, winstrument) +
        SharedInfo->num_workers * sizeof(IndexScanInstrumentation);
    node->iss_SharedInfo = palloc(size);
    memcpy(node->iss_SharedInfo, SharedInfo, size);
}

References IndexScanState::iss_SharedInfo, SharedIndexScanInstrumentation::num_workers, and palloc().

Referenced by ExecParallelRetrieveInstrumentation().

ExecInitIndexScan()

IndexScanState * ExecInitIndexScan	(	IndexScan *	node,
		EState *	estate,
		int	eflags
	)

Definition at line 909 of file nodeIndexscan.c.

{
    IndexScanState *indexstate;
    Relation    currentRelation;
    LOCKMODE    lockmode;
 
    /*
     * create state structure
     */
    indexstate = makeNode(IndexScanState);
    indexstate->ss.ps.plan = (Plan *) node;
    indexstate->ss.ps.state = estate;
    indexstate->ss.ps.ExecProcNode = ExecIndexScan;
 
    /*
     * Miscellaneous initialization
     *
     * create expression context for node
     */
    ExecAssignExprContext(estate, &indexstate->ss.ps);
 
    /*
     * open the scan relation
     */
    currentRelation = ExecOpenScanRelation(estate, node->scan.scanrelid, eflags);
 
    indexstate->ss.ss_currentRelation = currentRelation;
    indexstate->ss.ss_currentScanDesc = NULL;   /* no heap scan here */
 
    /*
     * get the scan type from the relation descriptor.
     */
    ExecInitScanTupleSlot(estate, &indexstate->ss,
                          RelationGetDescr(currentRelation),
                          table_slot_callbacks(currentRelation));
 
    /*
     * Initialize result type and projection.
     */
    ExecInitResultTypeTL(&indexstate->ss.ps);
    ExecAssignScanProjectionInfo(&indexstate->ss);
 
    /*
     * initialize child expressions
     *
     * Note: we don't initialize all of the indexqual expression, only the
     * sub-parts corresponding to runtime keys (see below).  Likewise for
     * indexorderby, if any.  But the indexqualorig expression is always
     * initialized even though it will only be used in some uncommon cases ---
     * would be nice to improve that.  (Problem is that any SubPlans present
     * in the expression must be found now...)
     */
    indexstate->ss.ps.qual =
        ExecInitQual(node->scan.plan.qual, (PlanState *) indexstate);
    indexstate->indexqualorig =
        ExecInitQual(node->indexqualorig, (PlanState *) indexstate);
    indexstate->indexorderbyorig =
        ExecInitExprList(node->indexorderbyorig, (PlanState *) indexstate);
 
    /*
     * If we are just doing EXPLAIN (ie, aren't going to run the plan), stop
     * here.  This allows an index-advisor plugin to EXPLAIN a plan containing
     * references to nonexistent indexes.
     */
    if (eflags & EXEC_FLAG_EXPLAIN_ONLY)
        return indexstate;
 
    /* Open the index relation. */
    lockmode = exec_rt_fetch(node->scan.scanrelid, estate)->rellockmode;
    indexstate->iss_RelationDesc = index_open(node->indexid, lockmode);
 
    /*
     * Initialize index-specific scan state
     */
    indexstate->iss_RuntimeKeysReady = false;
    indexstate->iss_RuntimeKeys = NULL;
    indexstate->iss_NumRuntimeKeys = 0;
 
    /*
     * build the index scan keys from the index qualification
     */
    ExecIndexBuildScanKeys((PlanState *) indexstate,
                           indexstate->iss_RelationDesc,
                           node->indexqual,
                           false,
                           &indexstate->iss_ScanKeys,
                           &indexstate->iss_NumScanKeys,
                           &indexstate->iss_RuntimeKeys,
                           &indexstate->iss_NumRuntimeKeys,
                           NULL,    /* no ArrayKeys */
                           NULL);
 
    /*
     * any ORDER BY exprs have to be turned into scankeys in the same way
     */
    ExecIndexBuildScanKeys((PlanState *) indexstate,
                           indexstate->iss_RelationDesc,
                           node->indexorderby,
                           true,
                           &indexstate->iss_OrderByKeys,
                           &indexstate->iss_NumOrderByKeys,
                           &indexstate->iss_RuntimeKeys,
                           &indexstate->iss_NumRuntimeKeys,
                           NULL,    /* no ArrayKeys */
                           NULL);
 
    /* Initialize sort support, if we need to re-check ORDER BY exprs */
    if (indexstate->iss_NumOrderByKeys > 0)
    {
        int         numOrderByKeys = indexstate->iss_NumOrderByKeys;
        int         i;
        ListCell   *lco;
        ListCell   *lcx;
 
        /*
         * Prepare sort support, and look up the data type for each ORDER BY
         * expression.
         */
        Assert(numOrderByKeys == list_length(node->indexorderbyops));
        Assert(numOrderByKeys == list_length(node->indexorderbyorig));
        indexstate->iss_SortSupport = (SortSupportData *)
            palloc0(numOrderByKeys * sizeof(SortSupportData));
        indexstate->iss_OrderByTypByVals = (bool *)
            palloc(numOrderByKeys * sizeof(bool));
        indexstate->iss_OrderByTypLens = (int16 *)
            palloc(numOrderByKeys * sizeof(int16));
        i = 0;
        forboth(lco, node->indexorderbyops, lcx, node->indexorderbyorig)
        {
            Oid         orderbyop = lfirst_oid(lco);
            Node       *orderbyexpr = (Node *) lfirst(lcx);
            Oid         orderbyType = exprType(orderbyexpr);
            Oid         orderbyColl = exprCollation(orderbyexpr);
            SortSupport orderbysort = &indexstate->iss_SortSupport[i];
 
            /* Initialize sort support */
            orderbysort->ssup_cxt = CurrentMemoryContext;
            orderbysort->ssup_collation = orderbyColl;
            /* See cmp_orderbyvals() comments on NULLS LAST */
            orderbysort->ssup_nulls_first = false;
            /* ssup_attno is unused here and elsewhere */
            orderbysort->ssup_attno = 0;
            /* No abbreviation */
            orderbysort->abbreviate = false;
            PrepareSortSupportFromOrderingOp(orderbyop, orderbysort);
 
            get_typlenbyval(orderbyType,
                            &indexstate->iss_OrderByTypLens[i],
                            &indexstate->iss_OrderByTypByVals[i]);
            i++;
        }
 
        /* allocate arrays to hold the re-calculated distances */
        indexstate->iss_OrderByValues = (Datum *)
            palloc(numOrderByKeys * sizeof(Datum));
        indexstate->iss_OrderByNulls = (bool *)
            palloc(numOrderByKeys * sizeof(bool));
 
        /* and initialize the reorder queue */
        indexstate->iss_ReorderQueue = pairingheap_allocate(reorderqueue_cmp,
                                                            indexstate);
    }
 
    /*
     * If we have runtime keys, we need an ExprContext to evaluate them. The
     * node's standard context won't do because we want to reset that context
     * for every tuple.  So, build another context just like the other one...
     * -tgl 7/11/00
     */
    if (indexstate->iss_NumRuntimeKeys != 0)
    {
        ExprContext *stdecontext = indexstate->ss.ps.ps_ExprContext;
 
        ExecAssignExprContext(estate, &indexstate->ss.ps);
        indexstate->iss_RuntimeContext = indexstate->ss.ps.ps_ExprContext;
        indexstate->ss.ps.ps_ExprContext = stdecontext;
    }
    else
    {
        indexstate->iss_RuntimeContext = NULL;
    }
 
    /*
     * all done.
     */
    return indexstate;
}

References SortSupportData::abbreviate, Assert(), CurrentMemoryContext, EXEC_FLAG_EXPLAIN_ONLY, exec_rt_fetch(), ExecAssignExprContext(), ExecAssignScanProjectionInfo(), ExecIndexBuildScanKeys(), ExecIndexScan(), ExecInitExprList(), ExecInitQual(), ExecInitResultTypeTL(), ExecInitScanTupleSlot(), ExecOpenScanRelation(), PlanState::ExecProcNode, exprCollation(), exprType(), forboth, get_typlenbyval(), i, index_open(), IndexScan::indexid, IndexScan::indexorderby, IndexScan::indexorderbyops, IndexScanState::indexorderbyorig, IndexScan::indexorderbyorig, IndexScan::indexqual, IndexScanState::indexqualorig, IndexScan::indexqualorig, IndexScanState::iss_NumOrderByKeys, IndexScanState::iss_NumRuntimeKeys, IndexScanState::iss_NumScanKeys, IndexScanState::iss_OrderByKeys, IndexScanState::iss_OrderByNulls, IndexScanState::iss_OrderByTypByVals, IndexScanState::iss_OrderByTypLens, IndexScanState::iss_OrderByValues, IndexScanState::iss_RelationDesc, IndexScanState::iss_ReorderQueue, IndexScanState::iss_RuntimeContext, IndexScanState::iss_RuntimeKeys, IndexScanState::iss_RuntimeKeysReady, IndexScanState::iss_ScanKeys, IndexScanState::iss_SortSupport, lfirst, lfirst_oid, list_length(), makeNode, pairingheap_allocate(), palloc(), palloc0(), PlanState::plan, PrepareSortSupportFromOrderingOp(), ScanState::ps, PlanState::ps_ExprContext, PlanState::qual, RelationGetDescr, reorderqueue_cmp(), IndexScan::scan, Scan::scanrelid, IndexScanState::ss, ScanState::ss_currentRelation, ScanState::ss_currentScanDesc, SortSupportData::ssup_attno, SortSupportData::ssup_collation, SortSupportData::ssup_cxt, SortSupportData::ssup_nulls_first, PlanState::state, and table_slot_callbacks().

Referenced by ExecInitNode().

ExecReScanIndexScan()

void ExecReScanIndexScan

(

IndexScanState *

node

)

Definition at line 553 of file nodeIndexscan.c.

{
    /*
     * If we are doing runtime key calculations (ie, any of the index key
     * values weren't simple Consts), compute the new key values.  But first,
     * reset the context so we don't leak memory as each outer tuple is
     * scanned.  Note this assumes that we will recalculate *all* runtime keys
     * on each call.
     */
    if (node->iss_NumRuntimeKeys != 0)
    {
        ExprContext *econtext = node->iss_RuntimeContext;
 
        ResetExprContext(econtext);
        ExecIndexEvalRuntimeKeys(econtext,
                                 node->iss_RuntimeKeys,
                                 node->iss_NumRuntimeKeys);
    }
    node->iss_RuntimeKeysReady = true;
 
    /* flush the reorder queue */
    if (node->iss_ReorderQueue)
    {
        HeapTuple   tuple;
 
        while (!pairingheap_is_empty(node->iss_ReorderQueue))
        {
            tuple = reorderqueue_pop(node);
            heap_freetuple(tuple);
        }
    }
 
    /* reset index scan */
    if (node->iss_ScanDesc)
        index_rescan(node->iss_ScanDesc,
                     node->iss_ScanKeys, node->iss_NumScanKeys,
                     node->iss_OrderByKeys, node->iss_NumOrderByKeys);
    node->iss_ReachedEnd = false;
 
    ExecScanReScan(&node->ss);
}

References ExecIndexEvalRuntimeKeys(), ExecScanReScan(), heap_freetuple(), index_rescan(), IndexScanState::iss_NumOrderByKeys, IndexScanState::iss_NumRuntimeKeys, IndexScanState::iss_NumScanKeys, IndexScanState::iss_OrderByKeys, IndexScanState::iss_ReachedEnd, IndexScanState::iss_ReorderQueue, IndexScanState::iss_RuntimeContext, IndexScanState::iss_RuntimeKeys, IndexScanState::iss_RuntimeKeysReady, IndexScanState::iss_ScanDesc, IndexScanState::iss_ScanKeys, pairingheap_is_empty, reorderqueue_pop(), ResetExprContext, and IndexScanState::ss.

Referenced by ExecReScan().