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

extern

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  )

extern

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 )

extern

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().

ExecSeqScanEstimate()

void ExecSeqScanEstimate ( SeqScanState *  node, ParallelContext *  pcxt  )

extern

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  )

extern

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  )

extern

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  )

extern

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  )

extern

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  )

extern

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  )

extern

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 )

extern

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().