PostgreSQL Source Code  git master
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

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

Definition at line 249 of file nodeGather.c.

250 {
251  ExecEndNode(outerPlanState(node)); /* let children clean up first */
252  ExecShutdownGather(node);
253 }
void ExecEndNode(PlanState *node)
Definition: execProcnode.c:557
#define outerPlanState(node)
Definition: execnodes.h:1132
void ExecShutdownGather(GatherState *node)
Definition: nodeGather.c:416

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

Referenced by ExecEndNode().

◆ ExecInitGather()

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

Definition at line 58 of file nodeGather.c.

59 {
60  GatherState *gatherstate;
61  Plan *outerNode;
62  TupleDesc tupDesc;
63 
64  /* Gather node doesn't have innerPlan node. */
65  Assert(innerPlan(node) == NULL);
66 
67  /*
68  * create state structure
69  */
70  gatherstate = makeNode(GatherState);
71  gatherstate->ps.plan = (Plan *) node;
72  gatherstate->ps.state = estate;
73  gatherstate->ps.ExecProcNode = ExecGather;
74 
75  gatherstate->initialized = false;
76  gatherstate->need_to_scan_locally =
78  gatherstate->tuples_needed = -1;
79 
80  /*
81  * Miscellaneous initialization
82  *
83  * create expression context for node
84  */
85  ExecAssignExprContext(estate, &gatherstate->ps);
86 
87  /*
88  * now initialize outer plan
89  */
90  outerNode = outerPlan(node);
91  outerPlanState(gatherstate) = ExecInitNode(outerNode, estate, eflags);
92  tupDesc = ExecGetResultType(outerPlanState(gatherstate));
93 
94  /*
95  * Leader may access ExecProcNode result directly (if
96  * need_to_scan_locally), or from workers via tuple queue. So we can't
97  * trivially rely on the slot type being fixed for expressions evaluated
98  * within this node.
99  */
100  gatherstate->ps.outeropsset = true;
101  gatherstate->ps.outeropsfixed = false;
102 
103  /*
104  * Initialize result type and projection.
105  */
106  ExecInitResultTypeTL(&gatherstate->ps);
107  ExecConditionalAssignProjectionInfo(&gatherstate->ps, tupDesc, OUTER_VAR);
108 
109  /*
110  * Without projections result slot type is not trivially known, see
111  * comment above.
112  */
113  if (gatherstate->ps.ps_ProjInfo == NULL)
114  {
115  gatherstate->ps.resultopsset = true;
116  gatherstate->ps.resultopsfixed = false;
117  }
118 
119  /*
120  * Initialize funnel slot to same tuple descriptor as outer plan.
121  */
122  gatherstate->funnel_slot = ExecInitExtraTupleSlot(estate, tupDesc,
124 
125  /*
126  * Gather doesn't support checking a qual (it's always more efficient to
127  * do it in the child node).
128  */
129  Assert(!node->plan.qual);
130 
131  return gatherstate;
132 }
PlanState * ExecInitNode(Plan *node, EState *estate, int eflags)
Definition: execProcnode.c:142
void ExecInitResultTypeTL(PlanState *planstate)
Definition: execTuples.c:1756
TupleTableSlot * ExecInitExtraTupleSlot(EState *estate, TupleDesc tupledesc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1832
const TupleTableSlotOps TTSOpsMinimalTuple
Definition: execTuples.c:85
TupleDesc ExecGetResultType(PlanState *planstate)
Definition: execUtils.c:498
void ExecAssignExprContext(EState *estate, PlanState *planstate)
Definition: execUtils.c:488
void ExecConditionalAssignProjectionInfo(PlanState *planstate, TupleDesc inputDesc, int varno)
Definition: execUtils.c:563
Assert(fmt[strlen(fmt) - 1] !='\n')
static TupleTableSlot * ExecGather(PlanState *pstate)
Definition: nodeGather.c:142
#define makeNode(_type_)
Definition: nodes.h:176
bool parallel_leader_participation
Definition: planner.c:74
#define innerPlan(node)
Definition: plannodes.h:181
#define outerPlan(node)
Definition: plannodes.h:182
#define OUTER_VAR
Definition: primnodes.h:223
bool initialized
Definition: execnodes.h:2586
TupleTableSlot * funnel_slot
Definition: execnodes.h:2590
PlanState ps
Definition: execnodes.h:2585
int64 tuples_needed
Definition: execnodes.h:2588
bool need_to_scan_locally
Definition: execnodes.h:2587
bool single_copy
Definition: plannodes.h:1143
Plan plan
Definition: plannodes.h:1140
bool outeropsset
Definition: execnodes.h:1119
bool resultopsset
Definition: execnodes.h:1121
Plan * plan
Definition: execnodes.h:1036
bool outeropsfixed
Definition: execnodes.h:1115
EState * state
Definition: execnodes.h:1038
ProjectionInfo * ps_ProjInfo
Definition: execnodes.h:1076
bool resultopsfixed
Definition: execnodes.h:1117
ExecProcNodeMtd ExecProcNode
Definition: execnodes.h:1042
List * qual
Definition: plannodes.h:153

References Assert(), ExecAssignExprContext(), ExecConditionalAssignProjectionInfo(), ExecGather(), ExecGetResultType(), ExecInitExtraTupleSlot(), ExecInitNode(), ExecInitResultTypeTL(), PlanState::ExecProcNode, GatherState::funnel_slot, GatherState::initialized, innerPlan, makeNode, GatherState::need_to_scan_locally, OUTER_VAR, PlanState::outeropsfixed, PlanState::outeropsset, outerPlan, outerPlanState, parallel_leader_participation, PlanState::plan, Gather::plan, GatherState::ps, PlanState::ps_ProjInfo, Plan::qual, PlanState::resultopsfixed, PlanState::resultopsset, Gather::single_copy, PlanState::state, TTSOpsMinimalTuple, and GatherState::tuples_needed.

Referenced by ExecInitNode().

◆ ExecReScanGather()

void ExecReScanGather ( GatherState node)

Definition at line 440 of file nodeGather.c.

441 {
442  Gather *gather = (Gather *) node->ps.plan;
444 
445  /* Make sure any existing workers are gracefully shut down */
447 
448  /* Mark node so that shared state will be rebuilt at next call */
449  node->initialized = false;
450 
451  /*
452  * Set child node's chgParam to tell it that the next scan might deliver a
453  * different set of rows within the leader process. (The overall rowset
454  * shouldn't change, but the leader process's subset might; hence nodes
455  * between here and the parallel table scan node mustn't optimize on the
456  * assumption of an unchanging rowset.)
457  */
458  if (gather->rescan_param >= 0)
459  outerPlan->chgParam = bms_add_member(outerPlan->chgParam,
460  gather->rescan_param);
461 
462  /*
463  * If chgParam of subnode is not null then plan will be re-scanned by
464  * first ExecProcNode. Note: because this does nothing if we have a
465  * rescan_param, it's currently guaranteed that parallel-aware child nodes
466  * will not see a ReScan call until after they get a ReInitializeDSM call.
467  * That ordering might not be something to rely on, though. A good rule
468  * of thumb is that ReInitializeDSM should reset only shared state, ReScan
469  * should reset only local state, and anything that depends on both of
470  * those steps being finished must wait until the first ExecProcNode call.
471  */
472  if (outerPlan->chgParam == NULL)
474 }
Bitmapset * bms_add_member(Bitmapset *a, int x)
Definition: bitmapset.c:753
void ExecReScan(PlanState *node)
Definition: execAmi.c:78
static void ExecShutdownGatherWorkers(GatherState *node)
Definition: nodeGather.c:398
int rescan_param
Definition: plannodes.h:1142

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

Referenced by ExecReScan().

◆ ExecShutdownGather()

void ExecShutdownGather ( GatherState node)

Definition at line 416 of file nodeGather.c.

417 {
419 
420  /* Now destroy the parallel context. */
421  if (node->pei != NULL)
422  {
423  ExecParallelCleanup(node->pei);
424  node->pei = NULL;
425  }
426 }
void ExecParallelCleanup(ParallelExecutorInfo *pei)
struct ParallelExecutorInfo * pei
Definition: execnodes.h:2591

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

Referenced by ExecEndGather(), and ExecShutdownNode_walker().