nodeBitmapHeapscan.c File Reference

#include "postgres.h"
#include "access/relscan.h"
#include "access/tableam.h"
#include "access/visibilitymap.h"
#include "executor/executor.h"
#include "executor/instrument.h"
#include "executor/nodeBitmapHeapscan.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "storage/bufmgr.h"
#include "storage/condition_variable.h"
#include "utils/dsa.h"
#include "utils/rel.h"
#include "utils/spccache.h"
#include "utils/wait_event.h"

Include dependency graph for nodeBitmapHeapscan.c:

Go to the source code of this file.

Data Structures
struct	ParallelBitmapHeapState

Typedefs
typedef struct ParallelBitmapHeapState	ParallelBitmapHeapState

Enumerations
enum	SharedBitmapState { BM_INITIAL , BM_INPROGRESS , BM_FINISHED }

Functions
static void	BitmapTableScanSetup (BitmapHeapScanState *node)
static TupleTableSlot *	BitmapHeapNext (BitmapHeapScanState *node)
static void	BitmapDoneInitializingSharedState (ParallelBitmapHeapState *pstate)
static bool	BitmapShouldInitializeSharedState (ParallelBitmapHeapState *pstate)
static bool	BitmapHeapRecheck (BitmapHeapScanState *node, TupleTableSlot *slot)
static TupleTableSlot *	ExecBitmapHeapScan (PlanState *pstate)
void	ExecReScanBitmapHeapScan (BitmapHeapScanState *node)
void	ExecEndBitmapHeapScan (BitmapHeapScanState *node)
BitmapHeapScanState *	ExecInitBitmapHeapScan (BitmapHeapScan *node, EState *estate, int eflags)
void	ExecBitmapHeapEstimate (BitmapHeapScanState *node, ParallelContext *pcxt)
void	ExecBitmapHeapInitializeDSM (BitmapHeapScanState *node, ParallelContext *pcxt)
void	ExecBitmapHeapReInitializeDSM (BitmapHeapScanState *node, ParallelContext *pcxt)
void	ExecBitmapHeapInitializeWorker (BitmapHeapScanState *node, ParallelWorkerContext *pwcxt)
void	ExecBitmapHeapInstrumentEstimate (BitmapHeapScanState *node, ParallelContext *pcxt)
void	ExecBitmapHeapInstrumentInitDSM (BitmapHeapScanState *node, ParallelContext *pcxt)
void	ExecBitmapHeapInstrumentInitWorker (BitmapHeapScanState *node, ParallelWorkerContext *pwcxt)
void	ExecBitmapHeapRetrieveInstrumentation (BitmapHeapScanState *node)

Typedef Documentation

ParallelBitmapHeapState

typedef struct ParallelBitmapHeapState ParallelBitmapHeapState

Enumeration Type Documentation

SharedBitmapState

enum SharedBitmapState

Enumerator
BM_INITIAL
BM_INPROGRESS
BM_FINISHED

Definition at line 72 of file nodeBitmapHeapscan.c.

{
    BM_INITIAL,
    BM_INPROGRESS,
    BM_FINISHED,
} SharedBitmapState;

Function Documentation

BitmapDoneInitializingSharedState()

static void BitmapDoneInitializingSharedState ( ParallelBitmapHeapState *  pstate )

inlinestatic

Definition at line 229 of file nodeBitmapHeapscan.c.

{
    SpinLockAcquire(&pstate->mutex);
    pstate->state = BM_FINISHED;
    SpinLockRelease(&pstate->mutex);
    ConditionVariableBroadcast(&pstate->cv);
}

References BM_FINISHED, ConditionVariableBroadcast(), ParallelBitmapHeapState::cv, ParallelBitmapHeapState::mutex, SpinLockAcquire(), SpinLockRelease(), and ParallelBitmapHeapState::state.

Referenced by BitmapTableScanSetup().

BitmapHeapNext()

static TupleTableSlot * BitmapHeapNext ( BitmapHeapScanState *  node )

static

Definition at line 174 of file nodeBitmapHeapscan.c.

{
    ExprContext *econtext = node->ss.ps.ps_ExprContext;
    TupleTableSlot *slot = node->ss.ss_ScanTupleSlot;
 
    /*
     * If we haven't yet performed the underlying index scan, do it, and begin
     * the iteration over the bitmap.
     */
    if (!node->initialized)
        BitmapTableScanSetup(node);
 
    while (table_scan_bitmap_next_tuple(node->ss.ss_currentScanDesc,
                                        slot, &node->recheck,
                                        &node->stats.lossy_pages,
                                        &node->stats.exact_pages))
    {
        /*
         * Continuing in previously obtained page.
         */
        CHECK_FOR_INTERRUPTS();
 
        /*
         * If we are using lossy info, we have to recheck the qual conditions
         * at every tuple.
         */
        if (node->recheck)
        {
            econtext->ecxt_scantuple = slot;
            if (!ExecQualAndReset(node->bitmapqualorig, econtext))
            {
                /* Fails recheck, so drop it and loop back for another */
                InstrCountFiltered2(node, 1);
                ExecClearTuple(slot);
                continue;
            }
        }
 
        /* OK to return this tuple */
        return slot;
    }
 
    /*
     * if we get here it means we are at the end of the scan..
     */
    return ExecClearTuple(slot);
}

References BitmapHeapScanState::bitmapqualorig, BitmapTableScanSetup(), CHECK_FOR_INTERRUPTS, ExprContext::ecxt_scantuple, BitmapHeapScanInstrumentation::exact_pages, ExecClearTuple(), ExecQualAndReset(), BitmapHeapScanState::initialized, InstrCountFiltered2, BitmapHeapScanInstrumentation::lossy_pages, ScanState::ps, PlanState::ps_ExprContext, BitmapHeapScanState::recheck, BitmapHeapScanState::ss, ScanState::ss_currentScanDesc, ScanState::ss_ScanTupleSlot, BitmapHeapScanState::stats, and table_scan_bitmap_next_tuple().

Referenced by ExecBitmapHeapScan().

BitmapHeapRecheck()

static bool BitmapHeapRecheck ( BitmapHeapScanState *  node, TupleTableSlot *  slot  )

static

Definition at line 241 of file nodeBitmapHeapscan.c.

{
    ExprContext *econtext;
 
    /*
     * extract necessary information from index scan node
     */
    econtext = node->ss.ps.ps_ExprContext;
 
    /* Does the tuple meet the original qual conditions? */
    econtext->ecxt_scantuple = slot;
    return ExecQualAndReset(node->bitmapqualorig, econtext);
}

References BitmapHeapScanState::bitmapqualorig, ExprContext::ecxt_scantuple, ExecQualAndReset(), ScanState::ps, PlanState::ps_ExprContext, and BitmapHeapScanState::ss.

Referenced by ExecBitmapHeapScan().

BitmapShouldInitializeSharedState()

static bool BitmapShouldInitializeSharedState ( ParallelBitmapHeapState *  pstate )

static

Definition at line 477 of file nodeBitmapHeapscan.c.

{
    SharedBitmapState state;
 
    while (1)
    {
        SpinLockAcquire(&pstate->mutex);
        state = pstate->state;
        if (pstate->state == BM_INITIAL)
            pstate->state = BM_INPROGRESS;
        SpinLockRelease(&pstate->mutex);
 
        /* Exit if bitmap is done, or if we're the leader. */
        if (state != BM_INPROGRESS)
            break;
 
        /* Wait for the leader to wake us up. */
        ConditionVariableSleep(&pstate->cv, WAIT_EVENT_PARALLEL_BITMAP_SCAN);
    }
 
    ConditionVariableCancelSleep();
 
    return (state == BM_INITIAL);
}

References BM_INITIAL, BM_INPROGRESS, ConditionVariableCancelSleep(), ConditionVariableSleep(), ParallelBitmapHeapState::cv, fb(), ParallelBitmapHeapState::mutex, SpinLockAcquire(), SpinLockRelease(), and ParallelBitmapHeapState::state.

Referenced by BitmapTableScanSetup().

BitmapTableScanSetup()

static void BitmapTableScanSetup ( BitmapHeapScanState *  node )

static

Definition at line 102 of file nodeBitmapHeapscan.c.

{
    TBMIterator tbmiterator = {0};
    ParallelBitmapHeapState *pstate = node->pstate;
    dsa_area   *dsa = node->ss.ps.state->es_query_dsa;
 
    if (!pstate)
    {
        node->tbm = (TIDBitmap *) MultiExecProcNode(outerPlanState(node));
 
        if (!node->tbm || !IsA(node->tbm, TIDBitmap))
            elog(ERROR, "unrecognized result from subplan");
    }
    else if (BitmapShouldInitializeSharedState(pstate))
    {
        /*
         * The leader will immediately come out of the function, but others
         * will be blocked until leader populates the TBM and wakes them up.
         */
        node->tbm = (TIDBitmap *) MultiExecProcNode(outerPlanState(node));
        if (!node->tbm || !IsA(node->tbm, TIDBitmap))
            elog(ERROR, "unrecognized result from subplan");
 
        /*
         * Prepare to iterate over the TBM. This will return the dsa_pointer
         * of the iterator state which will be used by multiple processes to
         * iterate jointly.
         */
        pstate->tbmiterator = tbm_prepare_shared_iterate(node->tbm);
 
        /* We have initialized the shared state so wake up others. */
        BitmapDoneInitializingSharedState(pstate);
    }
 
    tbmiterator = tbm_begin_iterate(node->tbm, dsa,
                                    pstate ?
                                    pstate->tbmiterator :
                                    InvalidDsaPointer);
 
    /*
     * If this is the first scan of the underlying table, create the table
     * scan descriptor and begin the scan.
     */
    if (!node->ss.ss_currentScanDesc)
    {
        uint32      flags = SO_NONE;
 
        if (ScanRelIsReadOnly(&node->ss))
            flags |= SO_HINT_REL_READ_ONLY;
 
        if (node->ss.ps.state->es_instrument & INSTRUMENT_IO)
            flags |= SO_SCAN_INSTRUMENT;
 
        node->ss.ss_currentScanDesc =
            table_beginscan_bm(node->ss.ss_currentRelation,
                               node->ss.ps.state->es_snapshot,
                               0,
                               NULL,
                               flags);
    }
 
    node->ss.ss_currentScanDesc->st.rs_tbmiterator = tbmiterator;
    node->initialized = true;
}

References BitmapDoneInitializingSharedState(), BitmapShouldInitializeSharedState(), elog, ERROR, EState::es_instrument, EState::es_query_dsa, EState::es_snapshot, fb(), BitmapHeapScanState::initialized, INSTRUMENT_IO, InvalidDsaPointer, IsA, MultiExecProcNode(), outerPlanState, ScanState::ps, BitmapHeapScanState::pstate, TableScanDescData::rs_tbmiterator, ScanRelIsReadOnly(), SO_HINT_REL_READ_ONLY, SO_NONE, SO_SCAN_INSTRUMENT, BitmapHeapScanState::ss, ScanState::ss_currentRelation, ScanState::ss_currentScanDesc, TableScanDescData::st, PlanState::state, table_beginscan_bm(), BitmapHeapScanState::tbm, tbm_begin_iterate(), tbm_prepare_shared_iterate(), and ParallelBitmapHeapState::tbmiterator.

Referenced by BitmapHeapNext().

ExecBitmapHeapEstimate()

void ExecBitmapHeapEstimate	(	BitmapHeapScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 510 of file nodeBitmapHeapscan.c.

{
    shm_toc_estimate_chunk(&pcxt->estimator,
                           MAXALIGN(sizeof(ParallelBitmapHeapState)));
    shm_toc_estimate_keys(&pcxt->estimator, 1);
}

References ParallelContext::estimator, MAXALIGN, shm_toc_estimate_chunk, and shm_toc_estimate_keys.

Referenced by ExecParallelEstimate().

ExecBitmapHeapInitializeDSM()

void ExecBitmapHeapInitializeDSM	(	BitmapHeapScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 525 of file nodeBitmapHeapscan.c.

{
    ParallelBitmapHeapState *pstate;
    dsa_area   *dsa = node->ss.ps.state->es_query_dsa;
 
    /* If there's no DSA, there are no workers; initialize nothing. */
    if (dsa == NULL)
        return;
 
    pstate = (ParallelBitmapHeapState *)
        shm_toc_allocate(pcxt->toc,
                         MAXALIGN(sizeof(ParallelBitmapHeapState)));
 
    pstate->tbmiterator = 0;
 
    /* Initialize the mutex */
    SpinLockInit(&pstate->mutex);
    pstate->state = BM_INITIAL;
 
    ConditionVariableInit(&pstate->cv);
 
    shm_toc_insert(pcxt->toc, node->ss.ps.plan->plan_node_id, pstate);
    node->pstate = pstate;
}

References BM_INITIAL, ConditionVariableInit(), ParallelBitmapHeapState::cv, EState::es_query_dsa, fb(), MAXALIGN, ParallelBitmapHeapState::mutex, PlanState::plan, Plan::plan_node_id, ScanState::ps, BitmapHeapScanState::pstate, shm_toc_allocate(), shm_toc_insert(), SpinLockInit(), BitmapHeapScanState::ss, ParallelBitmapHeapState::state, PlanState::state, ParallelBitmapHeapState::tbmiterator, and ParallelContext::toc.

Referenced by ExecParallelInitializeDSM().

ExecBitmapHeapInitializeWorker()

void ExecBitmapHeapInitializeWorker	(	BitmapHeapScanState *	node,
		ParallelWorkerContext *	pwcxt
	)

Definition at line 583 of file nodeBitmapHeapscan.c.

{
    Assert(node->ss.ps.state->es_query_dsa != NULL);
 
    node->pstate = (ParallelBitmapHeapState *)
        shm_toc_lookup(pwcxt->toc, node->ss.ps.plan->plan_node_id, false);
}

References Assert, EState::es_query_dsa, fb(), PlanState::plan, Plan::plan_node_id, ScanState::ps, BitmapHeapScanState::pstate, shm_toc_lookup(), BitmapHeapScanState::ss, and PlanState::state.

Referenced by ExecParallelInitializeWorker().

ExecBitmapHeapInstrumentEstimate()

void ExecBitmapHeapInstrumentEstimate	(	BitmapHeapScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 597 of file nodeBitmapHeapscan.c.

{
    Size        size;
 
    if (!node->ss.ps.instrument || pcxt->nworkers == 0)
        return;
 
    size = add_size(offsetof(SharedBitmapHeapInstrumentation, sinstrument),
                    mul_size(pcxt->nworkers, sizeof(BitmapHeapScanInstrumentation)));
    shm_toc_estimate_chunk(&pcxt->estimator, size);
    shm_toc_estimate_keys(&pcxt->estimator, 1);
}

References add_size(), ParallelContext::estimator, fb(), PlanState::instrument, mul_size(), ParallelContext::nworkers, ScanState::ps, shm_toc_estimate_chunk, shm_toc_estimate_keys, and BitmapHeapScanState::ss.

Referenced by ExecParallelEstimate().

ExecBitmapHeapInstrumentInitDSM()

void ExecBitmapHeapInstrumentInitDSM	(	BitmapHeapScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 615 of file nodeBitmapHeapscan.c.

{
    Size        size;
 
    if (!node->ss.ps.instrument || pcxt->nworkers == 0)
        return;
 
    size = add_size(offsetof(SharedBitmapHeapInstrumentation, sinstrument),
                    mul_size(pcxt->nworkers, sizeof(BitmapHeapScanInstrumentation)));
    node->sinstrument =
        (SharedBitmapHeapInstrumentation *) shm_toc_allocate(pcxt->toc, size);
 
    /* Each per-worker area must start out as zeroes */
    memset(node->sinstrument, 0, size);
    node->sinstrument->num_workers = pcxt->nworkers;
    shm_toc_insert(pcxt->toc,
                   node->ss.ps.plan->plan_node_id +
                   PARALLEL_KEY_SCAN_INSTRUMENT_OFFSET,
                   node->sinstrument);
}

References add_size(), fb(), PlanState::instrument, mul_size(), SharedBitmapHeapInstrumentation::num_workers, ParallelContext::nworkers, PARALLEL_KEY_SCAN_INSTRUMENT_OFFSET, PlanState::plan, Plan::plan_node_id, ScanState::ps, shm_toc_allocate(), shm_toc_insert(), BitmapHeapScanState::sinstrument, BitmapHeapScanState::ss, and ParallelContext::toc.

Referenced by ExecParallelInitializeDSM().

ExecBitmapHeapInstrumentInitWorker()

void ExecBitmapHeapInstrumentInitWorker	(	BitmapHeapScanState *	node,
		ParallelWorkerContext *	pwcxt
	)

Definition at line 641 of file nodeBitmapHeapscan.c.

{
    if (!node->ss.ps.instrument)
        return;
 
    node->sinstrument = (SharedBitmapHeapInstrumentation *)
        shm_toc_lookup(pwcxt->toc,
                       node->ss.ps.plan->plan_node_id +
                       PARALLEL_KEY_SCAN_INSTRUMENT_OFFSET,
                       false);
}

References fb(), PlanState::instrument, PARALLEL_KEY_SCAN_INSTRUMENT_OFFSET, PlanState::plan, Plan::plan_node_id, ScanState::ps, shm_toc_lookup(), BitmapHeapScanState::sinstrument, and BitmapHeapScanState::ss.

Referenced by ExecParallelInitializeWorker().

ExecBitmapHeapReInitializeDSM()

void ExecBitmapHeapReInitializeDSM	(	BitmapHeapScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 558 of file nodeBitmapHeapscan.c.

{
    ParallelBitmapHeapState *pstate = node->pstate;
    dsa_area   *dsa = node->ss.ps.state->es_query_dsa;
 
    /* If there's no DSA, there are no workers; do nothing. */
    if (dsa == NULL)
        return;
 
    pstate->state = BM_INITIAL;
 
    if (DsaPointerIsValid(pstate->tbmiterator))
        tbm_free_shared_area(dsa, pstate->tbmiterator);
 
    pstate->tbmiterator = InvalidDsaPointer;
}

References BM_INITIAL, DsaPointerIsValid, EState::es_query_dsa, fb(), InvalidDsaPointer, ScanState::ps, BitmapHeapScanState::pstate, BitmapHeapScanState::ss, ParallelBitmapHeapState::state, PlanState::state, tbm_free_shared_area(), and ParallelBitmapHeapState::tbmiterator.

Referenced by ExecParallelReInitializeDSM().

ExecBitmapHeapRetrieveInstrumentation()

void ExecBitmapHeapRetrieveInstrumentation

(

BitmapHeapScanState *

node

)

Definition at line 661 of file nodeBitmapHeapscan.c.

{
    SharedBitmapHeapInstrumentation *sinstrument = node->sinstrument;
    Size        size;
 
    if (sinstrument == NULL)
        return;
 
    size = offsetof(SharedBitmapHeapInstrumentation, sinstrument)
        + sinstrument->num_workers * sizeof(BitmapHeapScanInstrumentation);
 
    node->sinstrument = palloc(size);
    memcpy(node->sinstrument, sinstrument, size);
}

References fb(), memcpy(), SharedBitmapHeapInstrumentation::num_workers, palloc(), and BitmapHeapScanState::sinstrument.

Referenced by ExecParallelRetrieveInstrumentation().

ExecBitmapHeapScan()

static TupleTableSlot * ExecBitmapHeapScan ( PlanState *  pstate )

static

Definition at line 260 of file nodeBitmapHeapscan.c.

{
    BitmapHeapScanState *node = castNode(BitmapHeapScanState, pstate);
 
    return ExecScan(&node->ss,
                    (ExecScanAccessMtd) BitmapHeapNext,
                    (ExecScanRecheckMtd) BitmapHeapRecheck);
}

References BitmapHeapNext(), BitmapHeapRecheck(), castNode, ExecScan(), and BitmapHeapScanState::ss.

Referenced by ExecInitBitmapHeapScan().

ExecEndBitmapHeapScan()

void ExecEndBitmapHeapScan

(

BitmapHeapScanState *

node

)

Definition at line 315 of file nodeBitmapHeapscan.c.

{
    TableScanDesc 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->sinstrument != NULL && IsParallelWorker())
    {
        BitmapHeapScanInstrumentation *si;
 
        Assert(ParallelWorkerNumber < node->sinstrument->num_workers);
        si = &node->sinstrument->sinstrument[ParallelWorkerNumber];
 
        /*
         * Here we accumulate the stats rather than performing memcpy on
         * node->stats into si.  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 BitmapHeapScanState and
         * zeroed stats.
         */
        si->exact_pages += node->stats.exact_pages;
        si->lossy_pages += node->stats.lossy_pages;
 
        /* collect I/O instrumentation for this process */
        if (node->ss.ss_currentScanDesc &&
            node->ss.ss_currentScanDesc->rs_instrument)
        {
            AccumulateIOStats(&si->stats.io,
                              &node->ss.ss_currentScanDesc->rs_instrument->io);
        }
    }
 
    /*
     * extract information from the node
     */
    scanDesc = node->ss.ss_currentScanDesc;
 
    /*
     * close down subplans
     */
    ExecEndNode(outerPlanState(node));
 
    if (scanDesc)
    {
        /*
         * End iteration on iterators saved in scan descriptor if they have
         * not already been cleaned up.
         */
        if (!tbm_exhausted(&scanDesc->st.rs_tbmiterator))
            tbm_end_iterate(&scanDesc->st.rs_tbmiterator);
 
        /*
         * close table scan
         */
        table_endscan(scanDesc);
    }
 
    /*
     * release bitmaps and buffers if any
     */
    if (node->tbm)
        tbm_free(node->tbm);
}

References AccumulateIOStats(), Assert, BitmapHeapScanInstrumentation::exact_pages, ExecEndNode(), fb(), TableScanInstrumentation::io, IsParallelWorker, BitmapHeapScanInstrumentation::lossy_pages, outerPlanState, ParallelWorkerNumber, TableScanDescData::rs_instrument, SharedBitmapHeapInstrumentation::sinstrument, BitmapHeapScanState::sinstrument, BitmapHeapScanState::ss, ScanState::ss_currentScanDesc, BitmapHeapScanState::stats, table_endscan(), BitmapHeapScanState::tbm, tbm_end_iterate(), tbm_exhausted(), and tbm_free().

Referenced by ExecEndNode().

ExecInitBitmapHeapScan()

BitmapHeapScanState * ExecInitBitmapHeapScan	(	BitmapHeapScan *	node,
		EState *	estate,
		int	eflags
	)

Definition at line 389 of file nodeBitmapHeapscan.c.

{
    BitmapHeapScanState *scanstate;
    Relation    currentRelation;
 
    /* check for unsupported flags */
    Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
 
    /*
     * Assert caller didn't ask for an unsafe snapshot --- see comments at
     * head of file.
     */
    Assert(IsMVCCSnapshot(estate->es_snapshot));
 
    /*
     * create state structure
     */
    scanstate = makeNode(BitmapHeapScanState);
    scanstate->ss.ps.plan = (Plan *) node;
    scanstate->ss.ps.state = estate;
    scanstate->ss.ps.ExecProcNode = ExecBitmapHeapScan;
 
    scanstate->tbm = NULL;
 
    /* Zero the statistics counters */
    memset(&scanstate->stats, 0, sizeof(BitmapHeapScanInstrumentation));
 
    scanstate->initialized = false;
    scanstate->pstate = NULL;
    scanstate->recheck = true;
 
    /*
     * Miscellaneous initialization
     *
     * create expression context for node
     */
    ExecAssignExprContext(estate, &scanstate->ss.ps);
 
    /*
     * open the scan relation
     */
    currentRelation = ExecOpenScanRelation(estate, node->scan.scanrelid, eflags);
 
    /*
     * initialize child nodes
     */
    outerPlanState(scanstate) = ExecInitNode(outerPlan(node), estate, eflags);
 
    /*
     * get the scan type from the relation descriptor.
     */
    ExecInitScanTupleSlot(estate, &scanstate->ss,
                          RelationGetDescr(currentRelation),
                          table_slot_callbacks(currentRelation),
                          TTS_FLAG_OBEYS_NOT_NULL_CONSTRAINTS);
 
    /*
     * Initialize result type and projection.
     */
    ExecInitResultTypeTL(&scanstate->ss.ps);
    ExecAssignScanProjectionInfo(&scanstate->ss);
 
    /*
     * initialize child expressions
     */
    scanstate->ss.ps.qual =
        ExecInitQual(node->scan.plan.qual, (PlanState *) scanstate);
    scanstate->bitmapqualorig =
        ExecInitQual(node->bitmapqualorig, (PlanState *) scanstate);
 
    scanstate->ss.ss_currentRelation = currentRelation;
 
    /*
     * all done.
     */
    return scanstate;
}

References Assert, BitmapHeapScan::bitmapqualorig, EState::es_snapshot, EXEC_FLAG_BACKWARD, EXEC_FLAG_MARK, ExecAssignExprContext(), ExecAssignScanProjectionInfo(), ExecBitmapHeapScan(), ExecInitNode(), ExecInitQual(), ExecInitResultTypeTL(), ExecInitScanTupleSlot(), ExecOpenScanRelation(), fb(), IsMVCCSnapshot, makeNode, outerPlan, outerPlanState, RelationGetDescr, BitmapHeapScan::scan, Scan::scanrelid, table_slot_callbacks(), and TTS_FLAG_OBEYS_NOT_NULL_CONSTRAINTS.

Referenced by ExecInitNode().

ExecReScanBitmapHeapScan()

void ExecReScanBitmapHeapScan

(

BitmapHeapScanState *

node

)

Definition at line 274 of file nodeBitmapHeapscan.c.

{
    PlanState  *outerPlan = outerPlanState(node);
 
    TableScanDesc scan = node->ss.ss_currentScanDesc;
 
    if (scan)
    {
        /*
         * End iteration on iterators saved in scan descriptor if they have
         * not already been cleaned up.
         */
        if (!tbm_exhausted(&scan->st.rs_tbmiterator))
            tbm_end_iterate(&scan->st.rs_tbmiterator);
 
        /* rescan to release any page pin */
        table_rescan(node->ss.ss_currentScanDesc, NULL);
    }
 
    /* release bitmaps and buffers if any */
    if (node->tbm)
        tbm_free(node->tbm);
    node->tbm = NULL;
    node->initialized = false;
    node->recheck = true;
 
    ExecScanReScan(&node->ss);
 
    /*
     * if chgParam of subnode is not null then plan will be re-scanned by
     * first ExecProcNode.
     */
    if (outerPlan->chgParam == NULL)
        ExecReScan(outerPlan);
}

References ExecReScan(), ExecScanReScan(), fb(), BitmapHeapScanState::initialized, outerPlan, outerPlanState, BitmapHeapScanState::recheck, TableScanDescData::rs_tbmiterator, BitmapHeapScanState::ss, ScanState::ss_currentScanDesc, TableScanDescData::st, table_rescan(), BitmapHeapScanState::tbm, tbm_end_iterate(), tbm_exhausted(), and tbm_free().

Referenced by ExecReScan().