nodeSeqscan.c File Reference

#include "postgres.h"
#include "access/relscan.h"
#include "access/tableam.h"
#include "executor/execParallel.h"
#include "executor/execScan.h"
#include "executor/executor.h"
#include "executor/nodeSeqscan.h"
#include "utils/rel.h"

Include dependency graph for nodeSeqscan.c:

Go to the source code of this file.

Functions
static TupleTableSlot *	SeqNext (SeqScanState *node)
static pg_attribute_always_inline bool	SeqRecheck (SeqScanState *node, TupleTableSlot *slot)
static TupleTableSlot *	ExecSeqScan (PlanState *pstate)
static TupleTableSlot *	ExecSeqScanWithQual (PlanState *pstate)
static TupleTableSlot *	ExecSeqScanWithProject (PlanState *pstate)
static TupleTableSlot *	ExecSeqScanWithQualProject (PlanState *pstate)
static TupleTableSlot *	ExecSeqScanEPQ (PlanState *pstate)
SeqScanState *	ExecInitSeqScan (SeqScan *node, EState *estate, int eflags)
void	ExecEndSeqScan (SeqScanState *node)
void	ExecReScanSeqScan (SeqScanState *node)
void	ExecSeqScanEstimate (SeqScanState *node, ParallelContext *pcxt)
void	ExecSeqScanInitializeDSM (SeqScanState *node, ParallelContext *pcxt)
void	ExecSeqScanReInitializeDSM (SeqScanState *node, ParallelContext *pcxt)
void	ExecSeqScanInitializeWorker (SeqScanState *node, ParallelWorkerContext *pwcxt)
void	ExecSeqScanInstrumentEstimate (SeqScanState *node, ParallelContext *pcxt)
void	ExecSeqScanInstrumentInitDSM (SeqScanState *node, ParallelContext *pcxt)
void	ExecSeqScanInstrumentInitWorker (SeqScanState *node, ParallelWorkerContext *pwcxt)
void	ExecSeqScanRetrieveInstrumentation (SeqScanState *node)

Function Documentation

ExecEndSeqScan()

void ExecEndSeqScan

(

SeqScanState *

node

)

Definition at line 303 of file nodeSeqscan.c.

{
    TableScanDesc scanDesc;
 
    /*
     * get information from node
     */
    scanDesc = node->ss.ss_currentScanDesc;
 
    /*
     * Collect I/O stats for this process into shared instrumentation.
     */
    if (node->sinstrument != NULL && IsParallelWorker())
    {
        SeqScanInstrumentation *si;
 
        Assert(ParallelWorkerNumber < node->sinstrument->num_workers);
        si = &node->sinstrument->sinstrument[ParallelWorkerNumber];
 
        if (scanDesc && scanDesc->rs_instrument)
        {
            AccumulateIOStats(&si->stats.io, &scanDesc->rs_instrument->io);
        }
    }
 
    /*
     * close heap scan
     */
    if (scanDesc != NULL)
        table_endscan(scanDesc);
}

References AccumulateIOStats(), Assert, fb(), IsParallelWorker, ParallelWorkerNumber, SharedSeqScanInstrumentation::sinstrument, SeqScanState::sinstrument, SeqScanState::ss, ScanState::ss_currentScanDesc, and table_endscan().

Referenced by ExecEndNode().

ExecInitSeqScan()

SeqScanState * ExecInitSeqScan	(	SeqScan *	node,
		EState *	estate,
		int	eflags
	)

Definition at line 220 of file nodeSeqscan.c.

{
    SeqScanState *scanstate;
 
    /*
     * Once upon a time it was possible to have an outerPlan of a SeqScan, but
     * not any more.
     */
    Assert(outerPlan(node) == NULL);
    Assert(innerPlan(node) == NULL);
 
    /*
     * create state structure
     */
    scanstate = makeNode(SeqScanState);
    scanstate->ss.ps.plan = (Plan *) node;
    scanstate->ss.ps.state = estate;
 
    /*
     * Miscellaneous initialization
     *
     * create expression context for node
     */
    ExecAssignExprContext(estate, &scanstate->ss.ps);
 
    /*
     * open the scan relation
     */
    scanstate->ss.ss_currentRelation =
        ExecOpenScanRelation(estate,
                             node->scan.scanrelid,
                             eflags);
 
    /* and create slot with the appropriate rowtype */
    ExecInitScanTupleSlot(estate, &scanstate->ss,
                          RelationGetDescr(scanstate->ss.ss_currentRelation),
                          table_slot_callbacks(scanstate->ss.ss_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);
 
    /*
     * When EvalPlanQual() is not in use, assign ExecProcNode for this node
     * based on the presence of qual and projection. Each ExecSeqScan*()
     * variant is optimized for the specific combination of these conditions.
     */
    if (scanstate->ss.ps.state->es_epq_active != NULL)
        scanstate->ss.ps.ExecProcNode = ExecSeqScanEPQ;
    else if (scanstate->ss.ps.qual == NULL)
    {
        if (scanstate->ss.ps.ps_ProjInfo == NULL)
            scanstate->ss.ps.ExecProcNode = ExecSeqScan;
        else
            scanstate->ss.ps.ExecProcNode = ExecSeqScanWithProject;
    }
    else
    {
        if (scanstate->ss.ps.ps_ProjInfo == NULL)
            scanstate->ss.ps.ExecProcNode = ExecSeqScanWithQual;
        else
            scanstate->ss.ps.ExecProcNode = ExecSeqScanWithQualProject;
    }
 
    return scanstate;
}

References Assert, ExecAssignExprContext(), ExecAssignScanProjectionInfo(), ExecInitQual(), ExecInitResultTypeTL(), ExecInitScanTupleSlot(), ExecOpenScanRelation(), ExecSeqScan(), ExecSeqScanEPQ(), ExecSeqScanWithProject(), ExecSeqScanWithQual(), ExecSeqScanWithQualProject(), fb(), innerPlan, makeNode, outerPlan, RelationGetDescr, SeqScan::scan, Scan::scanrelid, table_slot_callbacks(), and TTS_FLAG_OBEYS_NOT_NULL_CONSTRAINTS.

Referenced by ExecInitNode().

ExecReScanSeqScan()

void ExecReScanSeqScan

(

SeqScanState *

node

)

Definition at line 347 of file nodeSeqscan.c.

{
    TableScanDesc scan;
 
    scan = node->ss.ss_currentScanDesc;
 
    if (scan != NULL)
        table_rescan(scan,      /* scan desc */
                     NULL);     /* new scan keys */
 
    ExecScanReScan((ScanState *) node);
}

References ExecScanReScan(), fb(), SeqScanState::ss, ScanState::ss_currentScanDesc, and table_rescan().

Referenced by ExecReScan().

ExecSeqScan()

static TupleTableSlot * ExecSeqScan ( PlanState *  pstate )

static

Definition at line 119 of file nodeSeqscan.c.

{
    SeqScanState *node = castNode(SeqScanState, pstate);
 
    Assert(pstate->state->es_epq_active == NULL);
    Assert(pstate->qual == NULL);
    Assert(pstate->ps_ProjInfo == NULL);
 
    return ExecScanExtended(&node->ss,
                            (ExecScanAccessMtd) SeqNext,
                            (ExecScanRecheckMtd) SeqRecheck,
                            NULL,
                            NULL,
                            NULL);
}

References Assert, castNode, EState::es_epq_active, ExecScanExtended(), fb(), PlanState::ps_ProjInfo, PlanState::qual, SeqNext(), SeqRecheck(), SeqScanState::ss, and PlanState::state.

Referenced by ExecInitSeqScan().

ExecSeqScanEPQ()

static TupleTableSlot * ExecSeqScanEPQ ( PlanState *  pstate )

static

Definition at line 206 of file nodeSeqscan.c.

{
    SeqScanState *node = castNode(SeqScanState, pstate);
 
    return ExecScan(&node->ss,
                    (ExecScanAccessMtd) SeqNext,
                    (ExecScanRecheckMtd) SeqRecheck);
}

References castNode, ExecScan(), SeqNext(), SeqRecheck(), and SeqScanState::ss.

Referenced by ExecInitSeqScan().

ExecSeqScanEstimate()

void ExecSeqScanEstimate	(	SeqScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 373 of file nodeSeqscan.c.

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

References EState::es_snapshot, ParallelContext::estimator, ScanState::ps, SeqScanState::pscan_len, shm_toc_estimate_chunk, shm_toc_estimate_keys, SeqScanState::ss, ScanState::ss_currentRelation, PlanState::state, and table_parallelscan_estimate().

Referenced by ExecParallelEstimate().

ExecSeqScanInitializeDSM()

void ExecSeqScanInitializeDSM	(	SeqScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 391 of file nodeSeqscan.c.

{
    EState     *estate = node->ss.ps.state;
    ParallelTableScanDesc pscan;
    uint32      flags = SO_NONE;
 
    if (ScanRelIsReadOnly(&node->ss))
        flags |= SO_HINT_REL_READ_ONLY;
 
    if (estate->es_instrument & INSTRUMENT_IO)
        flags |= SO_SCAN_INSTRUMENT;
 
    pscan = shm_toc_allocate(pcxt->toc, node->pscan_len);
    table_parallelscan_initialize(node->ss.ss_currentRelation,
                                  pscan,
                                  estate->es_snapshot);
    shm_toc_insert(pcxt->toc, node->ss.ps.plan->plan_node_id, pscan);
 
    node->ss.ss_currentScanDesc =
        table_beginscan_parallel(node->ss.ss_currentRelation, pscan, flags);
}

References EState::es_instrument, EState::es_snapshot, fb(), INSTRUMENT_IO, PlanState::plan, Plan::plan_node_id, ScanState::ps, SeqScanState::pscan_len, ScanRelIsReadOnly(), shm_toc_allocate(), shm_toc_insert(), SO_HINT_REL_READ_ONLY, SO_NONE, SO_SCAN_INSTRUMENT, SeqScanState::ss, ScanState::ss_currentRelation, ScanState::ss_currentScanDesc, PlanState::state, table_beginscan_parallel(), table_parallelscan_initialize(), and ParallelContext::toc.

Referenced by ExecParallelInitializeDSM().

ExecSeqScanInitializeWorker()

void ExecSeqScanInitializeWorker	(	SeqScanState *	node,
		ParallelWorkerContext *	pwcxt
	)

Definition at line 437 of file nodeSeqscan.c.

{
    ParallelTableScanDesc pscan;
    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;
 
    pscan = shm_toc_lookup(pwcxt->toc, node->ss.ps.plan->plan_node_id, false);
    node->ss.ss_currentScanDesc =
        table_beginscan_parallel(node->ss.ss_currentRelation, pscan, flags);
}

References EState::es_instrument, fb(), INSTRUMENT_IO, PlanState::plan, Plan::plan_node_id, ScanState::ps, ScanRelIsReadOnly(), shm_toc_lookup(), SO_HINT_REL_READ_ONLY, SO_NONE, SO_SCAN_INSTRUMENT, SeqScanState::ss, ScanState::ss_currentRelation, ScanState::ss_currentScanDesc, PlanState::state, and table_beginscan_parallel().

Referenced by ExecParallelInitializeWorker().

ExecSeqScanInstrumentEstimate()

void ExecSeqScanInstrumentEstimate	(	SeqScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 459 of file nodeSeqscan.c.

{
    EState     *estate = node->ss.ps.state;
    Size        size;
 
    if ((estate->es_instrument & INSTRUMENT_IO) == 0 || pcxt->nworkers == 0)
        return;
 
    size = add_size(offsetof(SharedSeqScanInstrumentation, sinstrument),
                    mul_size(pcxt->nworkers, sizeof(SeqScanInstrumentation)));
 
    shm_toc_estimate_chunk(&pcxt->estimator, size);
    shm_toc_estimate_keys(&pcxt->estimator, 1);
}

References add_size(), EState::es_instrument, ParallelContext::estimator, fb(), INSTRUMENT_IO, mul_size(), ParallelContext::nworkers, ScanState::ps, shm_toc_estimate_chunk, shm_toc_estimate_keys, SeqScanState::ss, and PlanState::state.

Referenced by ExecParallelEstimate().

ExecSeqScanInstrumentInitDSM()

void ExecSeqScanInstrumentInitDSM	(	SeqScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 478 of file nodeSeqscan.c.

{
    EState     *estate = node->ss.ps.state;
    SharedSeqScanInstrumentation *sinstrument;
    Size        size;
 
    if ((estate->es_instrument & INSTRUMENT_IO) == 0 || pcxt->nworkers == 0)
        return;
 
    size = add_size(offsetof(SharedSeqScanInstrumentation, sinstrument),
                    mul_size(pcxt->nworkers, sizeof(SeqScanInstrumentation)));
    sinstrument = shm_toc_allocate(pcxt->toc, size);
    memset(sinstrument, 0, size);
    sinstrument->num_workers = pcxt->nworkers;
    shm_toc_insert(pcxt->toc,
                   node->ss.ps.plan->plan_node_id +
                   PARALLEL_KEY_SCAN_INSTRUMENT_OFFSET,
                   sinstrument);
    node->sinstrument = sinstrument;
}

References add_size(), EState::es_instrument, fb(), INSTRUMENT_IO, mul_size(), SharedSeqScanInstrumentation::num_workers, ParallelContext::nworkers, PARALLEL_KEY_SCAN_INSTRUMENT_OFFSET, PlanState::plan, Plan::plan_node_id, ScanState::ps, shm_toc_allocate(), shm_toc_insert(), SeqScanState::sinstrument, SeqScanState::ss, PlanState::state, and ParallelContext::toc.

Referenced by ExecParallelInitializeDSM().

ExecSeqScanInstrumentInitWorker()

void ExecSeqScanInstrumentInitWorker	(	SeqScanState *	node,
		ParallelWorkerContext *	pwcxt
	)

Definition at line 503 of file nodeSeqscan.c.

{
    EState     *estate = node->ss.ps.state;
 
    if ((estate->es_instrument & INSTRUMENT_IO) == 0)
        return;
 
    node->sinstrument = shm_toc_lookup(pwcxt->toc,
                                       node->ss.ps.plan->plan_node_id +
                                       PARALLEL_KEY_SCAN_INSTRUMENT_OFFSET,
                                       false);
}

References EState::es_instrument, fb(), INSTRUMENT_IO, PARALLEL_KEY_SCAN_INSTRUMENT_OFFSET, PlanState::plan, Plan::plan_node_id, ScanState::ps, shm_toc_lookup(), SeqScanState::sinstrument, SeqScanState::ss, and PlanState::state.

Referenced by ExecParallelInitializeWorker().

ExecSeqScanReInitializeDSM()

void ExecSeqScanReInitializeDSM	(	SeqScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 421 of file nodeSeqscan.c.

{
    ParallelTableScanDesc pscan;
 
    pscan = node->ss.ss_currentScanDesc->rs_parallel;
    table_parallelscan_reinitialize(node->ss.ss_currentRelation, pscan);
}

References fb(), TableScanDescData::rs_parallel, SeqScanState::ss, ScanState::ss_currentRelation, ScanState::ss_currentScanDesc, and table_parallelscan_reinitialize().

Referenced by ExecParallelReInitializeDSM().

ExecSeqScanRetrieveInstrumentation()

void ExecSeqScanRetrieveInstrumentation

(

SeqScanState *

node

)

Definition at line 521 of file nodeSeqscan.c.

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

References fb(), memcpy(), SharedSeqScanInstrumentation::num_workers, palloc(), and SeqScanState::sinstrument.

Referenced by ExecParallelRetrieveInstrumentation().

ExecSeqScanWithProject()

static TupleTableSlot * ExecSeqScanWithProject ( PlanState *  pstate )

static

Definition at line 163 of file nodeSeqscan.c.

{
    SeqScanState *node = castNode(SeqScanState, pstate);
 
    Assert(pstate->state->es_epq_active == NULL);
    Assert(pstate->qual == NULL);
    pg_assume(pstate->ps_ProjInfo != NULL);
 
    return ExecScanExtended(&node->ss,
                            (ExecScanAccessMtd) SeqNext,
                            (ExecScanRecheckMtd) SeqRecheck,
                            NULL,
                            NULL,
                            pstate->ps_ProjInfo);
}

References Assert, castNode, EState::es_epq_active, ExecScanExtended(), fb(), pg_assume, PlanState::ps_ProjInfo, PlanState::qual, SeqNext(), SeqRecheck(), SeqScanState::ss, and PlanState::state.

Referenced by ExecInitSeqScan().

ExecSeqScanWithQual()

static TupleTableSlot * ExecSeqScanWithQual ( PlanState *  pstate )

static

Definition at line 139 of file nodeSeqscan.c.

{
    SeqScanState *node = castNode(SeqScanState, pstate);
 
    /*
     * Use pg_assume() for != NULL tests to make the compiler realize no
     * runtime check for the field is needed in ExecScanExtended().
     */
    Assert(pstate->state->es_epq_active == NULL);
    pg_assume(pstate->qual != NULL);
    Assert(pstate->ps_ProjInfo == NULL);
 
    return ExecScanExtended(&node->ss,
                            (ExecScanAccessMtd) SeqNext,
                            (ExecScanRecheckMtd) SeqRecheck,
                            NULL,
                            pstate->qual,
                            NULL);
}

References Assert, castNode, EState::es_epq_active, ExecScanExtended(), fb(), pg_assume, PlanState::ps_ProjInfo, PlanState::qual, SeqNext(), SeqRecheck(), SeqScanState::ss, and PlanState::state.

Referenced by ExecInitSeqScan().

ExecSeqScanWithQualProject()

static TupleTableSlot * ExecSeqScanWithQualProject ( PlanState *  pstate )

static

Definition at line 184 of file nodeSeqscan.c.

{
    SeqScanState *node = castNode(SeqScanState, pstate);
 
    Assert(pstate->state->es_epq_active == NULL);
    pg_assume(pstate->qual != NULL);
    pg_assume(pstate->ps_ProjInfo != NULL);
 
    return ExecScanExtended(&node->ss,
                            (ExecScanAccessMtd) SeqNext,
                            (ExecScanRecheckMtd) SeqRecheck,
                            NULL,
                            pstate->qual,
                            pstate->ps_ProjInfo);
}

References Assert, castNode, EState::es_epq_active, ExecScanExtended(), fb(), pg_assume, PlanState::ps_ProjInfo, PlanState::qual, SeqNext(), SeqRecheck(), SeqScanState::ss, and PlanState::state.

Referenced by ExecInitSeqScan().

SeqNext()

static pg_attribute_always_inline TupleTableSlot * SeqNext ( SeqScanState *  node )

static

Definition at line 52 of file nodeSeqscan.c.

{
    TableScanDesc scandesc;
    EState     *estate;
    ScanDirection direction;
    TupleTableSlot *slot;
 
    /*
     * get information from the estate and scan state
     */
    scandesc = node->ss.ss_currentScanDesc;
    estate = node->ss.ps.state;
    direction = estate->es_direction;
    slot = node->ss.ss_ScanTupleSlot;
 
    if (scandesc == NULL)
    {
        uint32      flags = SO_NONE;
 
        if (ScanRelIsReadOnly(&node->ss))
            flags |= SO_HINT_REL_READ_ONLY;
 
        if (estate->es_instrument & INSTRUMENT_IO)
            flags |= SO_SCAN_INSTRUMENT;
 
        /*
         * We reach here if the scan is not parallel, or if we're serially
         * executing a scan that was planned to be parallel.
         */
        scandesc = table_beginscan(node->ss.ss_currentRelation,
                                   estate->es_snapshot,
                                   0, NULL, flags);
        node->ss.ss_currentScanDesc = scandesc;
    }
 
    /*
     * get the next tuple from the table
     */
    if (table_scan_getnextslot(scandesc, direction, slot))
        return slot;
    return NULL;
}

References EState::es_direction, EState::es_instrument, EState::es_snapshot, fb(), INSTRUMENT_IO, ScanState::ps, ScanRelIsReadOnly(), SO_HINT_REL_READ_ONLY, SO_NONE, SO_SCAN_INSTRUMENT, SeqScanState::ss, ScanState::ss_currentRelation, ScanState::ss_currentScanDesc, ScanState::ss_ScanTupleSlot, PlanState::state, table_beginscan(), and table_scan_getnextslot().

Referenced by ExecSeqScan(), ExecSeqScanEPQ(), ExecSeqScanWithProject(), ExecSeqScanWithQual(), and ExecSeqScanWithQualProject().

SeqRecheck()

static pg_attribute_always_inline bool SeqRecheck ( SeqScanState *  node, TupleTableSlot *  slot  )

static

Definition at line 99 of file nodeSeqscan.c.

{
    /*
     * Note that unlike IndexScan, SeqScan never use keys in heap_beginscan
     * (and this is very bad) - so, here we do not check are keys ok or not.
     */
    return true;
}

Referenced by ExecSeqScan(), ExecSeqScanEPQ(), ExecSeqScanWithProject(), ExecSeqScanWithQual(), and ExecSeqScanWithQualProject().