nodeIndexonlyscan.h File Reference

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

Include dependency graph for nodeIndexonlyscan.h:

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

Go to the source code of this file.

Functions
IndexOnlyScanState *	ExecInitIndexOnlyScan (IndexOnlyScan *node, EState *estate, int eflags)
void	ExecEndIndexOnlyScan (IndexOnlyScanState *node)
void	ExecIndexOnlyMarkPos (IndexOnlyScanState *node)
void	ExecIndexOnlyRestrPos (IndexOnlyScanState *node)
void	ExecReScanIndexOnlyScan (IndexOnlyScanState *node)
void	ExecIndexOnlyScanEstimate (IndexOnlyScanState *node, ParallelContext *pcxt)
void	ExecIndexOnlyScanInitializeDSM (IndexOnlyScanState *node, ParallelContext *pcxt)
void	ExecIndexOnlyScanReInitializeDSM (IndexOnlyScanState *node, ParallelContext *pcxt)
void	ExecIndexOnlyScanInitializeWorker (IndexOnlyScanState *node, ParallelWorkerContext *pwcxt)

Function Documentation

ExecEndIndexOnlyScan()

void ExecEndIndexOnlyScan

(

IndexOnlyScanState *

node

)

Definition at line 365 of file nodeIndexonlyscan.c.

{
    Relation    indexRelationDesc;
    IndexScanDesc indexScanDesc;
 
    /*
     * extract information from the node
     */
    indexRelationDesc = node->ioss_RelationDesc;
    indexScanDesc = node->ioss_ScanDesc;
 
    /* Release VM buffer pin, if any. */
    if (node->ioss_VMBuffer != InvalidBuffer)
    {
        ReleaseBuffer(node->ioss_VMBuffer);
        node->ioss_VMBuffer = InvalidBuffer;
    }
 
    /*
     * close the index relation (no-op if we didn't open it)
     */
    if (indexScanDesc)
        index_endscan(indexScanDesc);
    if (indexRelationDesc)
        index_close(indexRelationDesc, NoLock);
}

References index_close(), index_endscan(), InvalidBuffer, IndexOnlyScanState::ioss_RelationDesc, IndexOnlyScanState::ioss_ScanDesc, IndexOnlyScanState::ioss_VMBuffer, NoLock, and ReleaseBuffer().

Referenced by ExecEndNode().

ExecIndexOnlyMarkPos()

void ExecIndexOnlyMarkPos

(

IndexOnlyScanState *

node

)

Definition at line 400 of file nodeIndexonlyscan.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 ExecIndexOnlyMarkPos call in EPQ recheck");
            return;
        }
    }
 
    index_markpos(node->ioss_ScanDesc);
}

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

Referenced by ExecMarkPos().

ExecIndexOnlyRestrPos()

void ExecIndexOnlyRestrPos

(

IndexOnlyScanState *

node

)

Definition at line 437 of file nodeIndexonlyscan.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 ExecIndexOnlyRestrPos call in EPQ recheck");
            return;
        }
    }
 
    index_restrpos(node->ioss_ScanDesc);
}

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

Referenced by ExecRestrPos().

ExecIndexOnlyScanEstimate()

void ExecIndexOnlyScanEstimate	(	IndexOnlyScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 626 of file nodeIndexonlyscan.c.

{
    EState     *estate = node->ss.ps.state;
 
    node->ioss_PscanLen = index_parallelscan_estimate(node->ioss_RelationDesc,
                                                      estate->es_snapshot);
    shm_toc_estimate_chunk(&pcxt->estimator, node->ioss_PscanLen);
    shm_toc_estimate_keys(&pcxt->estimator, 1);
}

References EState::es_snapshot, ParallelContext::estimator, index_parallelscan_estimate(), IndexOnlyScanState::ioss_PscanLen, IndexOnlyScanState::ioss_RelationDesc, ScanState::ps, shm_toc_estimate_chunk, shm_toc_estimate_keys, IndexOnlyScanState::ss, and PlanState::state.

Referenced by ExecParallelEstimate().

ExecIndexOnlyScanInitializeDSM()

void ExecIndexOnlyScanInitializeDSM	(	IndexOnlyScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 644 of file nodeIndexonlyscan.c.

{
    EState     *estate = node->ss.ps.state;
    ParallelIndexScanDesc piscan;
 
    piscan = shm_toc_allocate(pcxt->toc, node->ioss_PscanLen);
    index_parallelscan_initialize(node->ss.ss_currentRelation,
                                  node->ioss_RelationDesc,
                                  estate->es_snapshot,
                                  piscan);
    shm_toc_insert(pcxt->toc, node->ss.ps.plan->plan_node_id, piscan);
    node->ioss_ScanDesc =
        index_beginscan_parallel(node->ss.ss_currentRelation,
                                 node->ioss_RelationDesc,
                                 node->ioss_NumScanKeys,
                                 node->ioss_NumOrderByKeys,
                                 piscan);
    node->ioss_ScanDesc->xs_want_itup = true;
    node->ioss_VMBuffer = InvalidBuffer;
 
    /*
     * If no run-time keys to calculate or they are ready, go ahead and pass
     * the scankeys to the index AM.
     */
    if (node->ioss_NumRuntimeKeys == 0 || node->ioss_RuntimeKeysReady)
        index_rescan(node->ioss_ScanDesc,
                     node->ioss_ScanKeys, node->ioss_NumScanKeys,
                     node->ioss_OrderByKeys, node->ioss_NumOrderByKeys);
}

References EState::es_snapshot, index_beginscan_parallel(), index_parallelscan_initialize(), index_rescan(), InvalidBuffer, IndexOnlyScanState::ioss_NumOrderByKeys, IndexOnlyScanState::ioss_NumRuntimeKeys, IndexOnlyScanState::ioss_NumScanKeys, IndexOnlyScanState::ioss_OrderByKeys, IndexOnlyScanState::ioss_PscanLen, IndexOnlyScanState::ioss_RelationDesc, IndexOnlyScanState::ioss_RuntimeKeysReady, IndexOnlyScanState::ioss_ScanDesc, IndexOnlyScanState::ioss_ScanKeys, IndexOnlyScanState::ioss_VMBuffer, PlanState::plan, Plan::plan_node_id, ScanState::ps, shm_toc_allocate(), shm_toc_insert(), IndexOnlyScanState::ss, ScanState::ss_currentRelation, PlanState::state, ParallelContext::toc, and IndexScanDescData::xs_want_itup.

Referenced by ExecParallelInitializeDSM().

ExecIndexOnlyScanInitializeWorker()

void ExecIndexOnlyScanInitializeWorker	(	IndexOnlyScanState *	node,
		ParallelWorkerContext *	pwcxt
	)

Definition at line 695 of file nodeIndexonlyscan.c.

{
    ParallelIndexScanDesc piscan;
 
    piscan = shm_toc_lookup(pwcxt->toc, node->ss.ps.plan->plan_node_id, false);
    node->ioss_ScanDesc =
        index_beginscan_parallel(node->ss.ss_currentRelation,
                                 node->ioss_RelationDesc,
                                 node->ioss_NumScanKeys,
                                 node->ioss_NumOrderByKeys,
                                 piscan);
    node->ioss_ScanDesc->xs_want_itup = true;
 
    /*
     * If no run-time keys to calculate or they are ready, go ahead and pass
     * the scankeys to the index AM.
     */
    if (node->ioss_NumRuntimeKeys == 0 || node->ioss_RuntimeKeysReady)
        index_rescan(node->ioss_ScanDesc,
                     node->ioss_ScanKeys, node->ioss_NumScanKeys,
                     node->ioss_OrderByKeys, node->ioss_NumOrderByKeys);
}

References index_beginscan_parallel(), index_rescan(), IndexOnlyScanState::ioss_NumOrderByKeys, IndexOnlyScanState::ioss_NumRuntimeKeys, IndexOnlyScanState::ioss_NumScanKeys, IndexOnlyScanState::ioss_OrderByKeys, IndexOnlyScanState::ioss_RelationDesc, IndexOnlyScanState::ioss_RuntimeKeysReady, IndexOnlyScanState::ioss_ScanDesc, IndexOnlyScanState::ioss_ScanKeys, PlanState::plan, Plan::plan_node_id, ScanState::ps, shm_toc_lookup(), IndexOnlyScanState::ss, ScanState::ss_currentRelation, ParallelWorkerContext::toc, and IndexScanDescData::xs_want_itup.

Referenced by ExecParallelInitializeWorker().

ExecIndexOnlyScanReInitializeDSM()

void ExecIndexOnlyScanReInitializeDSM	(	IndexOnlyScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 682 of file nodeIndexonlyscan.c.

{
    index_parallelrescan(node->ioss_ScanDesc);
}

References index_parallelrescan(), and IndexOnlyScanState::ioss_ScanDesc.

Referenced by ExecParallelReInitializeDSM().

ExecInitIndexOnlyScan()

IndexOnlyScanState* ExecInitIndexOnlyScan	(	IndexOnlyScan *	node,
		EState *	estate,
		int	eflags
	)

Definition at line 473 of file nodeIndexonlyscan.c.

{
    IndexOnlyScanState *indexstate;
    Relation    currentRelation;
    LOCKMODE    lockmode;
    TupleDesc   tupDesc;
 
    /*
     * create state structure
     */
    indexstate = makeNode(IndexOnlyScanState);
    indexstate->ss.ps.plan = (Plan *) node;
    indexstate->ss.ps.state = estate;
    indexstate->ss.ps.ExecProcNode = ExecIndexOnlyScan;
 
    /*
     * 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 */
 
    /*
     * Build the scan tuple type using the indextlist generated by the
     * planner.  We use this, rather than the index's physical tuple
     * descriptor, because the latter contains storage column types not the
     * types of the original datums.  (It's the AM's responsibility to return
     * suitable data anyway.)
     */
    tupDesc = ExecTypeFromTL(node->indextlist);
    ExecInitScanTupleSlot(estate, &indexstate->ss, tupDesc,
                          &TTSOpsVirtual);
 
    /*
     * We need another slot, in a format that's suitable for the table AM, for
     * when we need to fetch a tuple from the table for rechecking visibility.
     */
    indexstate->ioss_TableSlot =
        ExecAllocTableSlot(&estate->es_tupleTable,
                           RelationGetDescr(currentRelation),
                           table_slot_callbacks(currentRelation));
 
    /*
     * Initialize result type and projection info.  The node's targetlist will
     * contain Vars with varno = INDEX_VAR, referencing the scan tuple.
     */
    ExecInitResultTypeTL(&indexstate->ss.ps);
    ExecAssignScanProjectionInfoWithVarno(&indexstate->ss, INDEX_VAR);
 
    /*
     * initialize child expressions
     *
     * Note: we don't initialize all of the indexorderby expression, only the
     * sub-parts corresponding to runtime keys (see below).
     */
    indexstate->ss.ps.qual =
        ExecInitQual(node->scan.plan.qual, (PlanState *) indexstate);
    indexstate->recheckqual =
        ExecInitQual(node->recheckqual, (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->ioss_RelationDesc = index_open(node->indexid, lockmode);
 
    /*
     * Initialize index-specific scan state
     */
    indexstate->ioss_RuntimeKeysReady = false;
    indexstate->ioss_RuntimeKeys = NULL;
    indexstate->ioss_NumRuntimeKeys = 0;
 
    /*
     * build the index scan keys from the index qualification
     */
    ExecIndexBuildScanKeys((PlanState *) indexstate,
                           indexstate->ioss_RelationDesc,
                           node->indexqual,
                           false,
                           &indexstate->ioss_ScanKeys,
                           &indexstate->ioss_NumScanKeys,
                           &indexstate->ioss_RuntimeKeys,
                           &indexstate->ioss_NumRuntimeKeys,
                           NULL,    /* no ArrayKeys */
                           NULL);
 
    /*
     * any ORDER BY exprs have to be turned into scankeys in the same way
     */
    ExecIndexBuildScanKeys((PlanState *) indexstate,
                           indexstate->ioss_RelationDesc,
                           node->indexorderby,
                           true,
                           &indexstate->ioss_OrderByKeys,
                           &indexstate->ioss_NumOrderByKeys,
                           &indexstate->ioss_RuntimeKeys,
                           &indexstate->ioss_NumRuntimeKeys,
                           NULL,    /* no ArrayKeys */
                           NULL);
 
    /*
     * 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->ioss_NumRuntimeKeys != 0)
    {
        ExprContext *stdecontext = indexstate->ss.ps.ps_ExprContext;
 
        ExecAssignExprContext(estate, &indexstate->ss.ps);
        indexstate->ioss_RuntimeContext = indexstate->ss.ps.ps_ExprContext;
        indexstate->ss.ps.ps_ExprContext = stdecontext;
    }
    else
    {
        indexstate->ioss_RuntimeContext = NULL;
    }
 
    /*
     * all done.
     */
    return indexstate;
}

References EState::es_tupleTable, EXEC_FLAG_EXPLAIN_ONLY, exec_rt_fetch(), ExecAllocTableSlot(), ExecAssignExprContext(), ExecAssignScanProjectionInfoWithVarno(), ExecIndexBuildScanKeys(), ExecIndexOnlyScan(), ExecInitQual(), ExecInitResultTypeTL(), ExecInitScanTupleSlot(), ExecOpenScanRelation(), PlanState::ExecProcNode, ExecTypeFromTL(), index_open(), INDEX_VAR, IndexOnlyScan::indexid, IndexOnlyScan::indexorderby, IndexOnlyScan::indexqual, IndexOnlyScan::indextlist, IndexOnlyScanState::ioss_NumOrderByKeys, IndexOnlyScanState::ioss_NumRuntimeKeys, IndexOnlyScanState::ioss_NumScanKeys, IndexOnlyScanState::ioss_OrderByKeys, IndexOnlyScanState::ioss_RelationDesc, IndexOnlyScanState::ioss_RuntimeContext, IndexOnlyScanState::ioss_RuntimeKeys, IndexOnlyScanState::ioss_RuntimeKeysReady, IndexOnlyScanState::ioss_ScanKeys, IndexOnlyScanState::ioss_TableSlot, makeNode, PlanState::plan, ScanState::ps, PlanState::ps_ExprContext, PlanState::qual, IndexOnlyScanState::recheckqual, IndexOnlyScan::recheckqual, RelationGetDescr, RangeTblEntry::rellockmode, IndexOnlyScan::scan, Scan::scanrelid, IndexOnlyScanState::ss, ScanState::ss_currentRelation, ScanState::ss_currentScanDesc, PlanState::state, table_slot_callbacks(), and TTSOpsVirtual.

Referenced by ExecInitNode().

ExecReScanIndexOnlyScan()

void ExecReScanIndexOnlyScan

(

IndexOnlyScanState *

node

)

Definition at line 330 of file nodeIndexonlyscan.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->ioss_NumRuntimeKeys != 0)
    {
        ExprContext *econtext = node->ioss_RuntimeContext;
 
        ResetExprContext(econtext);
        ExecIndexEvalRuntimeKeys(econtext,
                                 node->ioss_RuntimeKeys,
                                 node->ioss_NumRuntimeKeys);
    }
    node->ioss_RuntimeKeysReady = true;
 
    /* reset index scan */
    if (node->ioss_ScanDesc)
        index_rescan(node->ioss_ScanDesc,
                     node->ioss_ScanKeys, node->ioss_NumScanKeys,
                     node->ioss_OrderByKeys, node->ioss_NumOrderByKeys);
 
    ExecScanReScan(&node->ss);
}

References ExecIndexEvalRuntimeKeys(), ExecScanReScan(), index_rescan(), IndexOnlyScanState::ioss_NumOrderByKeys, IndexOnlyScanState::ioss_NumRuntimeKeys, IndexOnlyScanState::ioss_NumScanKeys, IndexOnlyScanState::ioss_OrderByKeys, IndexOnlyScanState::ioss_RuntimeContext, IndexOnlyScanState::ioss_RuntimeKeys, IndexOnlyScanState::ioss_RuntimeKeysReady, IndexOnlyScanState::ioss_ScanDesc, IndexOnlyScanState::ioss_ScanKeys, ResetExprContext, and IndexOnlyScanState::ss.

Referenced by ExecReScan().