nodeGather.h File Reference

#include "nodes/execnodes.h"

Include dependency graph for nodeGather.h:

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

Go to the source code of this file.

Functions
GatherState *	ExecInitGather (Gather *node, EState *estate, int eflags)
void	ExecEndGather (GatherState *node)
void	ExecShutdownGather (GatherState *node)
void	ExecReScanGather (GatherState *node)

Function Documentation

ExecEndGather()

void ExecEndGather ( GatherState *  node )

extern

Definition at line 252 of file nodeGather.c.

{
    ExecEndNode(outerPlanState(node));  /* let children clean up first */
    ExecShutdownGather(node);
}

References ExecEndNode(), ExecShutdownGather(), and outerPlanState.

Referenced by ExecEndNode().

ExecInitGather()

GatherState * ExecInitGather ( Gather *  node, EState *  estate, int  eflags  )

extern

Definition at line 54 of file nodeGather.c.

{
    GatherState *gatherstate;
    Plan       *outerNode;
    TupleDesc   tupDesc;
 
    /* Gather node doesn't have innerPlan node. */
    Assert(innerPlan(node) == NULL);
 
    /*
     * create state structure
     */
    gatherstate = makeNode(GatherState);
    gatherstate->ps.plan = (Plan *) node;
    gatherstate->ps.state = estate;
    gatherstate->ps.ExecProcNode = ExecGather;
 
    gatherstate->initialized = false;
    gatherstate->need_to_scan_locally =
        !node->single_copy && parallel_leader_participation;
    gatherstate->tuples_needed = -1;
 
    /*
     * Miscellaneous initialization
     *
     * create expression context for node
     */
    ExecAssignExprContext(estate, &gatherstate->ps);
 
    /*
     * now initialize outer plan
     */
    outerNode = outerPlan(node);
    outerPlanState(gatherstate) = ExecInitNode(outerNode, estate, eflags);
    tupDesc = ExecGetResultType(outerPlanState(gatherstate));
 
    /*
     * Leader may access ExecProcNode result directly (if
     * need_to_scan_locally), or from workers via tuple queue.  So we can't
     * trivially rely on the slot type being fixed for expressions evaluated
     * within this node.
     */
    gatherstate->ps.outeropsset = true;
    gatherstate->ps.outeropsfixed = false;
 
    /*
     * Initialize result type and projection.
     */
    ExecInitResultTypeTL(&gatherstate->ps);
    ExecConditionalAssignProjectionInfo(&gatherstate->ps, tupDesc, OUTER_VAR);
 
    /*
     * Without projections result slot type is not trivially known, see
     * comment above.
     */
    if (gatherstate->ps.ps_ProjInfo == NULL)
    {
        gatherstate->ps.resultopsset = true;
        gatherstate->ps.resultopsfixed = false;
    }
 
    /*
     * Initialize funnel slot to same tuple descriptor as outer plan.
     */
    gatherstate->funnel_slot = ExecInitExtraTupleSlot(estate, tupDesc,
                                                      &TTSOpsMinimalTuple);
 
    /*
     * Gather doesn't support checking a qual (it's always more efficient to
     * do it in the child node).
     */
    Assert(!node->plan.qual);
 
    return gatherstate;
}

References Assert, ExecAssignExprContext(), ExecConditionalAssignProjectionInfo(), ExecGather(), ExecGetResultType(), ExecInitExtraTupleSlot(), ExecInitNode(), ExecInitResultTypeTL(), fb(), innerPlan, makeNode, OUTER_VAR, outerPlan, outerPlanState, parallel_leader_participation, Gather::plan, Plan::qual, Gather::single_copy, and TTSOpsMinimalTuple.

Referenced by ExecInitNode().

ExecReScanGather()

void ExecReScanGather ( GatherState *  node )

extern

Definition at line 443 of file nodeGather.c.

{
    Gather     *gather = (Gather *) node->ps.plan;
    PlanState  *outerPlan = outerPlanState(node);
 
    /* Make sure any existing workers are gracefully shut down */
    ExecShutdownGatherWorkers(node);
 
    /* Mark node so that shared state will be rebuilt at next call */
    node->initialized = false;
 
    /*
     * Set child node's chgParam to tell it that the next scan might deliver a
     * different set of rows within the leader process.  (The overall rowset
     * shouldn't change, but the leader process's subset might; hence nodes
     * between here and the parallel table scan node mustn't optimize on the
     * assumption of an unchanging rowset.)
     */
    if (gather->rescan_param >= 0)
        outerPlan->chgParam = bms_add_member(outerPlan->chgParam,
                                             gather->rescan_param);
 
    /*
     * If chgParam of subnode is not null then plan will be re-scanned by
     * first ExecProcNode.  Note: because this does nothing if we have a
     * rescan_param, it's currently guaranteed that parallel-aware child nodes
     * will not see a ReScan call until after they get a ReInitializeDSM call.
     * That ordering might not be something to rely on, though.  A good rule
     * of thumb is that ReInitializeDSM should reset only shared state, ReScan
     * should reset only local state, and anything that depends on both of
     * those steps being finished must wait until the first ExecProcNode call.
     */
    if (outerPlan->chgParam == NULL)
        ExecReScan(outerPlan);
}

References bms_add_member(), ExecReScan(), ExecShutdownGatherWorkers(), fb(), GatherState::initialized, outerPlan, outerPlanState, PlanState::plan, and GatherState::ps.

Referenced by ExecReScan().

ExecShutdownGather()

void ExecShutdownGather ( GatherState *  node )

extern

Definition at line 419 of file nodeGather.c.

{
    ExecShutdownGatherWorkers(node);
 
    /* Now destroy the parallel context. */
    if (node->pei != NULL)
    {
        ExecParallelCleanup(node->pei);
        node->pei = NULL;
    }
}

References ExecParallelCleanup(), ExecShutdownGatherWorkers(), fb(), and GatherState::pei.

Referenced by ExecEndGather(), and ExecShutdownNode_walker().