nodeTidrangescan.h File Reference

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

Include dependency graph for nodeTidrangescan.h:

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

Go to the source code of this file.

Functions
TidRangeScanState *	ExecInitTidRangeScan (TidRangeScan *node, EState *estate, int eflags)
void	ExecEndTidRangeScan (TidRangeScanState *node)
void	ExecReScanTidRangeScan (TidRangeScanState *node)
void	ExecTidRangeScanEstimate (TidRangeScanState *node, ParallelContext *pcxt)
void	ExecTidRangeScanInitializeDSM (TidRangeScanState *node, ParallelContext *pcxt)
void	ExecTidRangeScanReInitializeDSM (TidRangeScanState *node, ParallelContext *pcxt)
void	ExecTidRangeScanInitializeWorker (TidRangeScanState *node, ParallelWorkerContext *pwcxt)
void	ExecTidRangeScanInstrumentEstimate (TidRangeScanState *node, ParallelContext *pcxt)
void	ExecTidRangeScanInstrumentInitDSM (TidRangeScanState *node, ParallelContext *pcxt)
void	ExecTidRangeScanInstrumentInitWorker (TidRangeScanState *node, ParallelWorkerContext *pwcxt)
void	ExecTidRangeScanRetrieveInstrumentation (TidRangeScanState *node)

Function Documentation

ExecEndTidRangeScan()

void ExecEndTidRangeScan ( TidRangeScanState *  node )

extern

Definition at line 350 of file nodeTidrangescan.c.

{
    TableScanDesc scan = node->ss.ss_currentScanDesc;
 
    /* Collect IO stats for this process into shared instrumentation */
    if (node->trss_sinstrument != NULL && IsParallelWorker())
    {
        TidRangeScanInstrumentation *si;
 
        Assert(ParallelWorkerNumber < node->trss_sinstrument->num_workers);
        si = &node->trss_sinstrument->sinstrument[ParallelWorkerNumber];
 
        if (scan && scan->rs_instrument)
        {
            AccumulateIOStats(&si->stats.io, &scan->rs_instrument->io);
        }
    }
 
    if (scan != NULL)
        table_endscan(scan);
}

References AccumulateIOStats(), Assert, fb(), TableScanInstrumentation::io, IsParallelWorker, ParallelWorkerNumber, TableScanDescData::rs_instrument, SharedTidRangeScanInstrumentation::sinstrument, TidRangeScanState::ss, ScanState::ss_currentScanDesc, table_endscan(), and TidRangeScanState::trss_sinstrument.

Referenced by ExecEndNode().

ExecInitTidRangeScan()

TidRangeScanState * ExecInitTidRangeScan ( TidRangeScan *  node, EState *  estate, int  eflags  )

extern

Definition at line 384 of file nodeTidrangescan.c.

{
    TidRangeScanState *tidrangestate;
    Relation    currentRelation;
 
    /*
     * create state structure
     */
    tidrangestate = makeNode(TidRangeScanState);
    tidrangestate->ss.ps.plan = (Plan *) node;
    tidrangestate->ss.ps.state = estate;
    tidrangestate->ss.ps.ExecProcNode = ExecTidRangeScan;
 
    /*
     * Miscellaneous initialization
     *
     * create expression context for node
     */
    ExecAssignExprContext(estate, &tidrangestate->ss.ps);
 
    /*
     * mark scan as not in progress, and TID range as not computed yet
     */
    tidrangestate->trss_inScan = false;
 
    /*
     * open the scan relation
     */
    currentRelation = ExecOpenScanRelation(estate, node->scan.scanrelid, eflags);
 
    tidrangestate->ss.ss_currentRelation = currentRelation;
    tidrangestate->ss.ss_currentScanDesc = NULL;    /* no table scan here */
 
    /*
     * get the scan type from the relation descriptor.
     */
    ExecInitScanTupleSlot(estate, &tidrangestate->ss,
                          RelationGetDescr(currentRelation),
                          table_slot_callbacks(currentRelation),
                          TTS_FLAG_OBEYS_NOT_NULL_CONSTRAINTS);
 
    /*
     * Initialize result type and projection.
     */
    ExecInitResultTypeTL(&tidrangestate->ss.ps);
    ExecAssignScanProjectionInfo(&tidrangestate->ss);
 
    /*
     * initialize child expressions
     */
    tidrangestate->ss.ps.qual =
        ExecInitQual(node->scan.plan.qual, (PlanState *) tidrangestate);
 
    TidExprListCreate(tidrangestate);
 
    /*
     * all done.
     */
    return tidrangestate;
}

References ExecAssignExprContext(), ExecAssignScanProjectionInfo(), ExecInitQual(), ExecInitResultTypeTL(), ExecInitScanTupleSlot(), ExecOpenScanRelation(), ExecTidRangeScan(), fb(), makeNode, RelationGetDescr, TidRangeScan::scan, Scan::scanrelid, table_slot_callbacks(), TidExprListCreate(), and TTS_FLAG_OBEYS_NOT_NULL_CONSTRAINTS.

Referenced by ExecInitNode().

ExecReScanTidRangeScan()

void ExecReScanTidRangeScan ( TidRangeScanState *  node )

extern

Definition at line 331 of file nodeTidrangescan.c.

{
    /* mark scan as not in progress, and tid range list as not computed yet */
    node->trss_inScan = false;
 
    /*
     * We must wait until TidRangeNext before calling table_rescan_tidrange.
     */
    ExecScanReScan(&node->ss);
}

References ExecScanReScan(), TidRangeScanState::ss, and TidRangeScanState::trss_inScan.

Referenced by ExecReScan().

ExecTidRangeScanEstimate()

void ExecTidRangeScanEstimate ( TidRangeScanState *  node, ParallelContext *  pcxt  )

extern

Definition at line 458 of file nodeTidrangescan.c.

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

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

Referenced by ExecParallelEstimate().

ExecTidRangeScanInitializeDSM()

void ExecTidRangeScanInitializeDSM ( TidRangeScanState *  node, ParallelContext *  pcxt  )

extern

Definition at line 476 of file nodeTidrangescan.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->trss_pscanlen);
    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_tidrange(node->ss.ss_currentRelation,
                                          pscan, flags);
}

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

Referenced by ExecParallelInitializeDSM().

ExecTidRangeScanInitializeWorker()

void ExecTidRangeScanInitializeWorker ( TidRangeScanState *  node, ParallelWorkerContext *  pwcxt  )

extern

Definition at line 521 of file nodeTidrangescan.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_tidrange(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, TidRangeScanState::ss, ScanState::ss_currentRelation, ScanState::ss_currentScanDesc, PlanState::state, and table_beginscan_parallel_tidrange().

Referenced by ExecParallelInitializeWorker().

ExecTidRangeScanInstrumentEstimate()

void ExecTidRangeScanInstrumentEstimate ( TidRangeScanState *  node, ParallelContext *  pcxt  )

extern

Definition at line 544 of file nodeTidrangescan.c.

{
    EState     *estate = node->ss.ps.state;
    Size        size;
 
    if ((estate->es_instrument & INSTRUMENT_IO) == 0 || pcxt->nworkers == 0)
        return;
 
    size = add_size(offsetof(SharedTidRangeScanInstrumentation, sinstrument),
                    mul_size(pcxt->nworkers, sizeof(TidRangeScanInstrumentation)));
 
    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, TidRangeScanState::ss, and PlanState::state.

Referenced by ExecParallelEstimate().

ExecTidRangeScanInstrumentInitDSM()

void ExecTidRangeScanInstrumentInitDSM ( TidRangeScanState *  node, ParallelContext *  pcxt  )

extern

Definition at line 564 of file nodeTidrangescan.c.

{
    EState     *estate = node->ss.ps.state;
    SharedTidRangeScanInstrumentation *sinstrument;
    Size        size;
 
    if ((estate->es_instrument & INSTRUMENT_IO) == 0 || pcxt->nworkers == 0)
        return;
 
    size = add_size(offsetof(SharedTidRangeScanInstrumentation, sinstrument),
                    mul_size(pcxt->nworkers, sizeof(TidRangeScanInstrumentation)));
    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->trss_sinstrument = sinstrument;
}

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

Referenced by ExecParallelInitializeDSM().

ExecTidRangeScanInstrumentInitWorker()

void ExecTidRangeScanInstrumentInitWorker ( TidRangeScanState *  node, ParallelWorkerContext *  pwcxt  )

extern

Definition at line 590 of file nodeTidrangescan.c.

{
    EState     *estate = node->ss.ps.state;
 
    if ((estate->es_instrument & INSTRUMENT_IO) == 0)
        return;
 
    node->trss_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(), TidRangeScanState::ss, PlanState::state, and TidRangeScanState::trss_sinstrument.

Referenced by ExecParallelInitializeWorker().

ExecTidRangeScanReInitializeDSM()

void ExecTidRangeScanReInitializeDSM ( TidRangeScanState *  node, ParallelContext *  pcxt  )

extern

Definition at line 505 of file nodeTidrangescan.c.

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

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

Referenced by ExecParallelReInitializeDSM().

ExecTidRangeScanRetrieveInstrumentation()

void ExecTidRangeScanRetrieveInstrumentation ( TidRangeScanState *  node )

extern

Definition at line 608 of file nodeTidrangescan.c.

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

References fb(), memcpy(), SharedTidRangeScanInstrumentation::num_workers, palloc(), and TidRangeScanState::trss_sinstrument.

Referenced by ExecParallelRetrieveInstrumentation().