nodeSeqscan.h File Reference

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

Include dependency graph for nodeSeqscan.h:

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

Go to the source code of this file.

Functions
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)

Function Documentation

ExecEndSeqScan()

void ExecEndSeqScan

(

SeqScanState *

node

)

Definition at line 293 of file nodeSeqscan.c.

{
    TableScanDesc scanDesc;
 
    /*
     * get information from node
     */
    scanDesc = node->ss.ss_currentScanDesc;
 
    /*
     * close heap scan
     */
    if (scanDesc != NULL)
        table_endscan(scanDesc);
}

References SeqScanState::ss, ScanState::ss_currentScanDesc, and table_endscan().

Referenced by ExecEndNode().

ExecInitSeqScan()

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

Definition at line 211 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));
 
    /*
     * 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(), EState::es_epq_active, ExecAssignExprContext(), ExecAssignScanProjectionInfo(), ExecInitQual(), ExecInitResultTypeTL(), ExecInitScanTupleSlot(), ExecOpenScanRelation(), PlanState::ExecProcNode, ExecSeqScan(), ExecSeqScanEPQ(), ExecSeqScanWithProject(), ExecSeqScanWithQual(), ExecSeqScanWithQualProject(), innerPlan, makeNode, outerPlan, PlanState::plan, ScanState::ps, PlanState::ps_ProjInfo, PlanState::qual, RelationGetDescr, SeqScan::scan, Scan::scanrelid, SeqScanState::ss, ScanState::ss_currentRelation, PlanState::state, and table_slot_callbacks().

Referenced by ExecInitNode().

ExecReScanSeqScan()

void ExecReScanSeqScan

(

SeqScanState *

node

)

Definition at line 321 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(), SeqScanState::ss, ScanState::ss_currentScanDesc, and table_rescan().

Referenced by ExecReScan().

ExecSeqScanEstimate()

void ExecSeqScanEstimate	(	SeqScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 347 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 365 of file nodeSeqscan.c.

{
    EState     *estate = node->ss.ps.state;
    ParallelTableScanDesc pscan;
 
    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);
}

References EState::es_snapshot, PlanState::plan, Plan::plan_node_id, ScanState::ps, SeqScanState::pscan_len, shm_toc_allocate(), shm_toc_insert(), 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 403 of file nodeSeqscan.c.

{
    ParallelTableScanDesc pscan;
 
    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);
}

References PlanState::plan, Plan::plan_node_id, ScanState::ps, shm_toc_lookup(), SeqScanState::ss, ScanState::ss_currentRelation, ScanState::ss_currentScanDesc, table_beginscan_parallel(), and ParallelWorkerContext::toc.

Referenced by ExecParallelInitializeWorker().

ExecSeqScanReInitializeDSM()

void ExecSeqScanReInitializeDSM	(	SeqScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 387 of file nodeSeqscan.c.

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

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

Referenced by ExecParallelReInitializeDSM().