nodeSeqscan.c File Reference

#include "postgres.h"
#include "access/relscan.h"
#include "access/tableam.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)

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 fb(), 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, ExecAssignExprContext(), ExecAssignScanProjectionInfo(), ExecInitQual(), ExecInitResultTypeTL(), ExecInitScanTupleSlot(), ExecOpenScanRelation(), ExecSeqScan(), ExecSeqScanEPQ(), ExecSeqScanWithProject(), ExecSeqScanWithQual(), ExecSeqScanWithQualProject(), fb(), innerPlan, makeNode, outerPlan, RelationGetDescr, SeqScan::scan, Scan::scanrelid, 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(), fb(), SeqScanState::ss, ScanState::ss_currentScanDesc, and table_rescan().

Referenced by ExecReScan().

ExecSeqScan()

static TupleTableSlot * ExecSeqScan ( PlanState *  pstate )

static

Definition at line 110 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 197 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 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, fb(), 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 fb(), PlanState::plan, Plan::plan_node_id, ScanState::ps, shm_toc_lookup(), SeqScanState::ss, ScanState::ss_currentRelation, ScanState::ss_currentScanDesc, and table_beginscan_parallel().

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 fb(), TableScanDescData::rs_parallel, SeqScanState::ss, ScanState::ss_currentRelation, ScanState::ss_currentScanDesc, and table_parallelscan_reinitialize().

Referenced by ExecParallelReInitializeDSM().

ExecSeqScanWithProject()

static TupleTableSlot * ExecSeqScanWithProject ( PlanState *  pstate )

static

Definition at line 154 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 130 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 175 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 51 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)
    {
        /*
         * 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);
        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_snapshot, fb(), ScanState::ps, 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 90 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().