PostgreSQL Source Code  git master
execProcnode.c File Reference
#include "postgres.h"
#include "executor/executor.h"
#include "executor/nodeAgg.h"
#include "executor/nodeAppend.h"
#include "executor/nodeBitmapAnd.h"
#include "executor/nodeBitmapHeapscan.h"
#include "executor/nodeBitmapIndexscan.h"
#include "executor/nodeBitmapOr.h"
#include "executor/nodeCtescan.h"
#include "executor/nodeCustom.h"
#include "executor/nodeForeignscan.h"
#include "executor/nodeFunctionscan.h"
#include "executor/nodeGather.h"
#include "executor/nodeGatherMerge.h"
#include "executor/nodeGroup.h"
#include "executor/nodeHash.h"
#include "executor/nodeHashjoin.h"
#include "executor/nodeIndexonlyscan.h"
#include "executor/nodeIndexscan.h"
#include "executor/nodeLimit.h"
#include "executor/nodeLockRows.h"
#include "executor/nodeMaterial.h"
#include "executor/nodeMergeAppend.h"
#include "executor/nodeMergejoin.h"
#include "executor/nodeModifyTable.h"
#include "executor/nodeNamedtuplestorescan.h"
#include "executor/nodeNestloop.h"
#include "executor/nodeProjectSet.h"
#include "executor/nodeRecursiveunion.h"
#include "executor/nodeResult.h"
#include "executor/nodeSamplescan.h"
#include "executor/nodeSeqscan.h"
#include "executor/nodeSetOp.h"
#include "executor/nodeSort.h"
#include "executor/nodeSubplan.h"
#include "executor/nodeSubqueryscan.h"
#include "executor/nodeTableFuncscan.h"
#include "executor/nodeTidscan.h"
#include "executor/nodeUnique.h"
#include "executor/nodeValuesscan.h"
#include "executor/nodeWindowAgg.h"
#include "executor/nodeWorktablescan.h"
#include "nodes/nodeFuncs.h"
#include "miscadmin.h"
Include dependency graph for execProcnode.c:

Go to the source code of this file.

Functions

static TupleTableSlotExecProcNodeFirst (PlanState *node)
 
static TupleTableSlotExecProcNodeInstr (PlanState *node)
 
PlanStateExecInitNode (Plan *node, EState *estate, int eflags)
 
void ExecSetExecProcNode (PlanState *node, ExecProcNodeMtd function)
 
NodeMultiExecProcNode (PlanState *node)
 
void ExecEndNode (PlanState *node)
 
bool ExecShutdownNode (PlanState *node)
 
void ExecSetTupleBound (int64 tuples_needed, PlanState *child_node)
 

Function Documentation

◆ ExecEndNode()

void ExecEndNode ( PlanState node)

Definition at line 538 of file execProcnode.c.

References bms_free(), check_stack_depth(), PlanState::chgParam, elog, ERROR, ExecEndAgg(), ExecEndAppend(), ExecEndBitmapAnd(), ExecEndBitmapHeapScan(), ExecEndBitmapIndexScan(), ExecEndBitmapOr(), ExecEndCteScan(), ExecEndCustomScan(), ExecEndForeignScan(), ExecEndFunctionScan(), ExecEndGather(), ExecEndGatherMerge(), ExecEndGroup(), ExecEndHash(), ExecEndHashJoin(), ExecEndIndexOnlyScan(), ExecEndIndexScan(), ExecEndLimit(), ExecEndLockRows(), ExecEndMaterial(), ExecEndMergeAppend(), ExecEndMergeJoin(), ExecEndModifyTable(), ExecEndNamedTuplestoreScan(), ExecEndNestLoop(), ExecEndProjectSet(), ExecEndRecursiveUnion(), ExecEndResult(), ExecEndSampleScan(), ExecEndSeqScan(), ExecEndSetOp(), ExecEndSort(), ExecEndSubqueryScan(), ExecEndTableFuncScan(), ExecEndTidScan(), ExecEndUnique(), ExecEndValuesScan(), ExecEndWindowAgg(), ExecEndWorkTableScan(), nodeTag, T_AggState, T_AppendState, T_BitmapAndState, T_BitmapHeapScanState, T_BitmapIndexScanState, T_BitmapOrState, T_CteScanState, T_CustomScanState, T_ForeignScanState, T_FunctionScanState, T_GatherMergeState, T_GatherState, T_GroupState, T_HashJoinState, T_HashState, T_IndexOnlyScanState, T_IndexScanState, T_LimitState, T_LockRowsState, T_MaterialState, T_MergeAppendState, T_MergeJoinState, T_ModifyTableState, T_NamedTuplestoreScanState, T_NestLoopState, T_ProjectSetState, T_RecursiveUnionState, T_ResultState, T_SampleScanState, T_SeqScanState, T_SetOpState, T_SortState, T_SubqueryScanState, T_TableFuncScanState, T_TidScanState, T_UniqueState, T_ValuesScanState, T_WindowAggState, and T_WorkTableScanState.

Referenced by EvalPlanQualEnd(), ExecEndAgg(), ExecEndAppend(), ExecEndBitmapAnd(), ExecEndBitmapHeapScan(), ExecEndBitmapOr(), ExecEndForeignScan(), ExecEndGather(), ExecEndGatherMerge(), ExecEndGroup(), ExecEndHash(), ExecEndHashJoin(), ExecEndLimit(), ExecEndLockRows(), ExecEndMaterial(), ExecEndMergeAppend(), ExecEndMergeJoin(), ExecEndModifyTable(), ExecEndNestLoop(), ExecEndPlan(), ExecEndProjectSet(), ExecEndRecursiveUnion(), ExecEndResult(), ExecEndSetOp(), ExecEndSort(), ExecEndSubqueryScan(), ExecEndUnique(), and ExecEndWindowAgg().

539 {
540  /*
541  * do nothing when we get to the end of a leaf on tree.
542  */
543  if (node == NULL)
544  return;
545 
546  /*
547  * Make sure there's enough stack available. Need to check here, in
548  * addition to ExecProcNode() (via ExecProcNodeFirst()), because it's not
549  * guaranteed that ExecProcNode() is reached for all nodes.
550  */
552 
553  if (node->chgParam != NULL)
554  {
555  bms_free(node->chgParam);
556  node->chgParam = NULL;
557  }
558 
559  switch (nodeTag(node))
560  {
561  /*
562  * control nodes
563  */
564  case T_ResultState:
565  ExecEndResult((ResultState *) node);
566  break;
567 
568  case T_ProjectSetState:
570  break;
571 
572  case T_ModifyTableState:
574  break;
575 
576  case T_AppendState:
577  ExecEndAppend((AppendState *) node);
578  break;
579 
580  case T_MergeAppendState:
582  break;
583 
586  break;
587 
588  case T_BitmapAndState:
590  break;
591 
592  case T_BitmapOrState:
593  ExecEndBitmapOr((BitmapOrState *) node);
594  break;
595 
596  /*
597  * scan nodes
598  */
599  case T_SeqScanState:
600  ExecEndSeqScan((SeqScanState *) node);
601  break;
602 
603  case T_SampleScanState:
605  break;
606 
607  case T_GatherState:
608  ExecEndGather((GatherState *) node);
609  break;
610 
611  case T_GatherMergeState:
613  break;
614 
615  case T_IndexScanState:
617  break;
618 
621  break;
622 
625  break;
626 
629  break;
630 
631  case T_TidScanState:
632  ExecEndTidScan((TidScanState *) node);
633  break;
634 
635  case T_SubqueryScanState:
637  break;
638 
639  case T_FunctionScanState:
641  break;
642 
645  break;
646 
647  case T_ValuesScanState:
649  break;
650 
651  case T_CteScanState:
652  ExecEndCteScan((CteScanState *) node);
653  break;
654 
657  break;
658 
661  break;
662 
663  case T_ForeignScanState:
665  break;
666 
667  case T_CustomScanState:
669  break;
670 
671  /*
672  * join nodes
673  */
674  case T_NestLoopState:
675  ExecEndNestLoop((NestLoopState *) node);
676  break;
677 
678  case T_MergeJoinState:
680  break;
681 
682  case T_HashJoinState:
683  ExecEndHashJoin((HashJoinState *) node);
684  break;
685 
686  /*
687  * materialization nodes
688  */
689  case T_MaterialState:
690  ExecEndMaterial((MaterialState *) node);
691  break;
692 
693  case T_SortState:
694  ExecEndSort((SortState *) node);
695  break;
696 
697  case T_GroupState:
698  ExecEndGroup((GroupState *) node);
699  break;
700 
701  case T_AggState:
702  ExecEndAgg((AggState *) node);
703  break;
704 
705  case T_WindowAggState:
707  break;
708 
709  case T_UniqueState:
710  ExecEndUnique((UniqueState *) node);
711  break;
712 
713  case T_HashState:
714  ExecEndHash((HashState *) node);
715  break;
716 
717  case T_SetOpState:
718  ExecEndSetOp((SetOpState *) node);
719  break;
720 
721  case T_LockRowsState:
722  ExecEndLockRows((LockRowsState *) node);
723  break;
724 
725  case T_LimitState:
726  ExecEndLimit((LimitState *) node);
727  break;
728 
729  default:
730  elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
731  break;
732  }
733 }
void ExecEndGroup(GroupState *node)
Definition: nodeGroup.c:227
void ExecEndSetOp(SetOpState *node)
Definition: nodeSetOp.c:583
void ExecEndFunctionScan(FunctionScanState *node)
void ExecEndNestLoop(NestLoopState *node)
Definition: nodeNestloop.c:362
void ExecEndIndexScan(IndexScanState *node)
void ExecEndLimit(LimitState *node)
Definition: nodeLimit.c:404
void ExecEndUnique(UniqueState *node)
Definition: nodeUnique.c:169
void ExecEndGatherMerge(GatherMergeState *node)
void ExecEndWorkTableScan(WorkTableScanState *node)
void ExecEndLockRows(LockRowsState *node)
Definition: nodeLockRows.c:386
void ExecEndNamedTuplestoreScan(NamedTuplestoreScanState *node)
void ExecEndBitmapAnd(BitmapAndState *node)
void ExecEndRecursiveUnion(RecursiveUnionState *node)
void ExecEndSubqueryScan(SubqueryScanState *node)
void ExecEndHashJoin(HashJoinState *node)
Definition: nodeHashjoin.c:746
void ExecEndTableFuncScan(TableFuncScanState *node)
void ExecEndResult(ResultState *node)
Definition: nodeResult.c:241
#define ERROR
Definition: elog.h:43
void ExecEndAppend(AppendState *node)
Definition: nodeAppend.c:314
void ExecEndForeignScan(ForeignScanState *node)
void ExecEndSort(SortState *node)
Definition: nodeSort.c:234
void ExecEndBitmapIndexScan(BitmapIndexScanState *node)
void check_stack_depth(void)
Definition: postgres.c:3262
void ExecEndValuesScan(ValuesScanState *node)
void ExecEndMergeJoin(MergeJoinState *node)
void ExecEndSeqScan(SeqScanState *node)
Definition: nodeSeqscan.c:184
void ExecEndIndexOnlyScan(IndexOnlyScanState *node)
void ExecEndTidScan(TidScanState *node)
Definition: nodeTidscan.c:476
Bitmapset * chgParam
Definition: execnodes.h:977
void ExecEndCteScan(CteScanState *node)
Definition: nodeCtescan.c:288
void ExecEndCustomScan(CustomScanState *node)
Definition: nodeCustom.c:120
void ExecEndBitmapOr(BitmapOrState *node)
Definition: nodeBitmapOr.c:196
void ExecEndSampleScan(SampleScanState *node)
void bms_free(Bitmapset *a)
Definition: bitmapset.c:208
void ExecEndWindowAgg(WindowAggState *node)
void ExecEndMergeAppend(MergeAppendState *node)
#define nodeTag(nodeptr)
Definition: nodes.h:529
#define elog(elevel,...)
Definition: elog.h:226
void ExecEndHash(HashState *node)
Definition: nodeHash.c:406
void ExecEndProjectSet(ProjectSetState *node)
void ExecEndMaterial(MaterialState *node)
Definition: nodeMaterial.c:240
void ExecEndBitmapHeapScan(BitmapHeapScanState *node)
void ExecEndAgg(AggState *node)
Definition: nodeAgg.c:3388
void ExecEndModifyTable(ModifyTableState *node)
void ExecEndGather(GatherState *node)
Definition: nodeGather.c:249

◆ ExecInitNode()

PlanState* ExecInitNode ( Plan node,
EState estate,
int  eflags 
)

Definition at line 139 of file execProcnode.c.

References Assert, check_stack_depth(), elog, ERROR, EState::es_instrument, ExecInitAgg(), ExecInitAppend(), ExecInitBitmapAnd(), ExecInitBitmapHeapScan(), ExecInitBitmapIndexScan(), ExecInitBitmapOr(), ExecInitCteScan(), ExecInitCustomScan(), ExecInitForeignScan(), ExecInitFunctionScan(), ExecInitGather(), ExecInitGatherMerge(), ExecInitGroup(), ExecInitHash(), ExecInitHashJoin(), ExecInitIndexOnlyScan(), ExecInitIndexScan(), ExecInitLimit(), ExecInitLockRows(), ExecInitMaterial(), ExecInitMergeAppend(), ExecInitMergeJoin(), ExecInitModifyTable(), ExecInitNamedTuplestoreScan(), ExecInitNestLoop(), ExecInitProjectSet(), ExecInitRecursiveUnion(), ExecInitResult(), ExecInitSampleScan(), ExecInitSeqScan(), ExecInitSetOp(), ExecInitSort(), ExecInitSubPlan(), ExecInitSubqueryScan(), ExecInitTableFuncScan(), ExecInitTidScan(), ExecInitUnique(), ExecInitValuesScan(), ExecInitWindowAgg(), ExecInitWorkTableScan(), PlanState::ExecProcNode, ExecSetExecProcNode(), Plan::initPlan, PlanState::initPlan, InstrAlloc(), PlanState::instrument, IsA, lappend(), lfirst, NIL, nodeTag, T_Agg, T_Append, T_BitmapAnd, T_BitmapHeapScan, T_BitmapIndexScan, T_BitmapOr, T_CteScan, T_CustomScan, T_ForeignScan, T_FunctionScan, T_Gather, T_GatherMerge, T_Group, T_Hash, T_HashJoin, T_IndexOnlyScan, T_IndexScan, T_Limit, T_LockRows, T_Material, T_MergeAppend, T_MergeJoin, T_ModifyTable, T_NamedTuplestoreScan, T_NestLoop, T_ProjectSet, T_RecursiveUnion, T_Result, T_SampleScan, T_SeqScan, T_SetOp, T_Sort, T_SubqueryScan, T_TableFuncScan, T_TidScan, T_Unique, T_ValuesScan, T_WindowAgg, and T_WorkTableScan.

Referenced by EvalPlanQualStart(), ExecInitAgg(), ExecInitAppend(), ExecInitBitmapAnd(), ExecInitBitmapHeapScan(), ExecInitBitmapOr(), ExecInitForeignScan(), ExecInitGather(), ExecInitGatherMerge(), ExecInitGroup(), ExecInitHash(), ExecInitHashJoin(), ExecInitLimit(), ExecInitLockRows(), ExecInitMaterial(), ExecInitMergeAppend(), ExecInitMergeJoin(), ExecInitModifyTable(), ExecInitNestLoop(), ExecInitProjectSet(), ExecInitRecursiveUnion(), ExecInitResult(), ExecInitSetOp(), ExecInitSort(), ExecInitSubqueryScan(), ExecInitUnique(), ExecInitWindowAgg(), and InitPlan().

140 {
141  PlanState *result;
142  List *subps;
143  ListCell *l;
144 
145  /*
146  * do nothing when we get to the end of a leaf on tree.
147  */
148  if (node == NULL)
149  return NULL;
150 
151  /*
152  * Make sure there's enough stack available. Need to check here, in
153  * addition to ExecProcNode() (via ExecProcNodeFirst()), to ensure the
154  * stack isn't overrun while initializing the node tree.
155  */
157 
158  switch (nodeTag(node))
159  {
160  /*
161  * control nodes
162  */
163  case T_Result:
164  result = (PlanState *) ExecInitResult((Result *) node,
165  estate, eflags);
166  break;
167 
168  case T_ProjectSet:
169  result = (PlanState *) ExecInitProjectSet((ProjectSet *) node,
170  estate, eflags);
171  break;
172 
173  case T_ModifyTable:
174  result = (PlanState *) ExecInitModifyTable((ModifyTable *) node,
175  estate, eflags);
176  break;
177 
178  case T_Append:
179  result = (PlanState *) ExecInitAppend((Append *) node,
180  estate, eflags);
181  break;
182 
183  case T_MergeAppend:
184  result = (PlanState *) ExecInitMergeAppend((MergeAppend *) node,
185  estate, eflags);
186  break;
187 
188  case T_RecursiveUnion:
189  result = (PlanState *) ExecInitRecursiveUnion((RecursiveUnion *) node,
190  estate, eflags);
191  break;
192 
193  case T_BitmapAnd:
194  result = (PlanState *) ExecInitBitmapAnd((BitmapAnd *) node,
195  estate, eflags);
196  break;
197 
198  case T_BitmapOr:
199  result = (PlanState *) ExecInitBitmapOr((BitmapOr *) node,
200  estate, eflags);
201  break;
202 
203  /*
204  * scan nodes
205  */
206  case T_SeqScan:
207  result = (PlanState *) ExecInitSeqScan((SeqScan *) node,
208  estate, eflags);
209  break;
210 
211  case T_SampleScan:
212  result = (PlanState *) ExecInitSampleScan((SampleScan *) node,
213  estate, eflags);
214  break;
215 
216  case T_IndexScan:
217  result = (PlanState *) ExecInitIndexScan((IndexScan *) node,
218  estate, eflags);
219  break;
220 
221  case T_IndexOnlyScan:
222  result = (PlanState *) ExecInitIndexOnlyScan((IndexOnlyScan *) node,
223  estate, eflags);
224  break;
225 
226  case T_BitmapIndexScan:
227  result = (PlanState *) ExecInitBitmapIndexScan((BitmapIndexScan *) node,
228  estate, eflags);
229  break;
230 
231  case T_BitmapHeapScan:
232  result = (PlanState *) ExecInitBitmapHeapScan((BitmapHeapScan *) node,
233  estate, eflags);
234  break;
235 
236  case T_TidScan:
237  result = (PlanState *) ExecInitTidScan((TidScan *) node,
238  estate, eflags);
239  break;
240 
241  case T_SubqueryScan:
242  result = (PlanState *) ExecInitSubqueryScan((SubqueryScan *) node,
243  estate, eflags);
244  break;
245 
246  case T_FunctionScan:
247  result = (PlanState *) ExecInitFunctionScan((FunctionScan *) node,
248  estate, eflags);
249  break;
250 
251  case T_TableFuncScan:
252  result = (PlanState *) ExecInitTableFuncScan((TableFuncScan *) node,
253  estate, eflags);
254  break;
255 
256  case T_ValuesScan:
257  result = (PlanState *) ExecInitValuesScan((ValuesScan *) node,
258  estate, eflags);
259  break;
260 
261  case T_CteScan:
262  result = (PlanState *) ExecInitCteScan((CteScan *) node,
263  estate, eflags);
264  break;
265 
268  estate, eflags);
269  break;
270 
271  case T_WorkTableScan:
272  result = (PlanState *) ExecInitWorkTableScan((WorkTableScan *) node,
273  estate, eflags);
274  break;
275 
276  case T_ForeignScan:
277  result = (PlanState *) ExecInitForeignScan((ForeignScan *) node,
278  estate, eflags);
279  break;
280 
281  case T_CustomScan:
282  result = (PlanState *) ExecInitCustomScan((CustomScan *) node,
283  estate, eflags);
284  break;
285 
286  /*
287  * join nodes
288  */
289  case T_NestLoop:
290  result = (PlanState *) ExecInitNestLoop((NestLoop *) node,
291  estate, eflags);
292  break;
293 
294  case T_MergeJoin:
295  result = (PlanState *) ExecInitMergeJoin((MergeJoin *) node,
296  estate, eflags);
297  break;
298 
299  case T_HashJoin:
300  result = (PlanState *) ExecInitHashJoin((HashJoin *) node,
301  estate, eflags);
302  break;
303 
304  /*
305  * materialization nodes
306  */
307  case T_Material:
308  result = (PlanState *) ExecInitMaterial((Material *) node,
309  estate, eflags);
310  break;
311 
312  case T_Sort:
313  result = (PlanState *) ExecInitSort((Sort *) node,
314  estate, eflags);
315  break;
316 
317  case T_Group:
318  result = (PlanState *) ExecInitGroup((Group *) node,
319  estate, eflags);
320  break;
321 
322  case T_Agg:
323  result = (PlanState *) ExecInitAgg((Agg *) node,
324  estate, eflags);
325  break;
326 
327  case T_WindowAgg:
328  result = (PlanState *) ExecInitWindowAgg((WindowAgg *) node,
329  estate, eflags);
330  break;
331 
332  case T_Unique:
333  result = (PlanState *) ExecInitUnique((Unique *) node,
334  estate, eflags);
335  break;
336 
337  case T_Gather:
338  result = (PlanState *) ExecInitGather((Gather *) node,
339  estate, eflags);
340  break;
341 
342  case T_GatherMerge:
343  result = (PlanState *) ExecInitGatherMerge((GatherMerge *) node,
344  estate, eflags);
345  break;
346 
347  case T_Hash:
348  result = (PlanState *) ExecInitHash((Hash *) node,
349  estate, eflags);
350  break;
351 
352  case T_SetOp:
353  result = (PlanState *) ExecInitSetOp((SetOp *) node,
354  estate, eflags);
355  break;
356 
357  case T_LockRows:
358  result = (PlanState *) ExecInitLockRows((LockRows *) node,
359  estate, eflags);
360  break;
361 
362  case T_Limit:
363  result = (PlanState *) ExecInitLimit((Limit *) node,
364  estate, eflags);
365  break;
366 
367  default:
368  elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
369  result = NULL; /* keep compiler quiet */
370  break;
371  }
372 
373  ExecSetExecProcNode(result, result->ExecProcNode);
374 
375  /*
376  * Initialize any initPlans present in this node. The planner put them in
377  * a separate list for us.
378  */
379  subps = NIL;
380  foreach(l, node->initPlan)
381  {
382  SubPlan *subplan = (SubPlan *) lfirst(l);
383  SubPlanState *sstate;
384 
385  Assert(IsA(subplan, SubPlan));
386  sstate = ExecInitSubPlan(subplan, result);
387  subps = lappend(subps, sstate);
388  }
389  result->initPlan = subps;
390 
391  /* Set up instrumentation for this node if requested */
392  if (estate->es_instrument)
393  result->instrument = InstrAlloc(1, estate->es_instrument);
394 
395  return result;
396 }
MergeJoinState * ExecInitMergeJoin(MergeJoin *node, EState *estate, int eflags)
#define NIL
Definition: pg_list.h:65
NamedTuplestoreScanState * ExecInitNamedTuplestoreScan(NamedTuplestoreScan *node, EState *estate, int eflags)
Definition: nodes.h:78
SortState * ExecInitSort(Sort *node, EState *estate, int eflags)
Definition: nodeSort.c:166
#define IsA(nodeptr, _type_)
Definition: nodes.h:575
BitmapHeapScanState * ExecInitBitmapHeapScan(BitmapHeapScan *node, EState *estate, int eflags)
Definition: nodes.h:80
Instrumentation * instrument
Definition: execnodes.h:955
GroupState * ExecInitGroup(Group *node, EState *estate, int eflags)
Definition: nodeGroup.c:162
MergeAppendState * ExecInitMergeAppend(MergeAppend *node, EState *estate, int eflags)
GatherMergeState * ExecInitGatherMerge(GatherMerge *node, EState *estate, int eflags)
List * initPlan
Definition: execnodes.h:970
RecursiveUnionState * ExecInitRecursiveUnion(RecursiveUnion *node, EState *estate, int eflags)
NestLoopState * ExecInitNestLoop(NestLoop *node, EState *estate, int eflags)
Definition: nodeNestloop.c:263
LockRowsState * ExecInitLockRows(LockRows *node, EState *estate, int eflags)
Definition: nodeLockRows.c:292
HashState * ExecInitHash(Hash *node, EState *estate, int eflags)
Definition: nodeHash.c:353
CteScanState * ExecInitCteScan(CteScan *node, EState *estate, int eflags)
Definition: nodeCtescan.c:175
Definition: nodes.h:49
Instrumentation * InstrAlloc(int n, int instrument_options)
Definition: instrument.c:30
AppendState * ExecInitAppend(Append *node, EState *estate, int eflags)
Definition: nodeAppend.c:101
Definition: nodes.h:76
GatherState * ExecInitGather(Gather *node, EState *estate, int eflags)
Definition: nodeGather.c:58
SubPlanState * ExecInitSubPlan(SubPlan *subplan, PlanState *parent)
Definition: nodeSubplan.c:790
AggState * ExecInitAgg(Agg *node, EState *estate, int eflags)
Definition: nodeAgg.c:2097
TidScanState * ExecInitTidScan(TidScan *node, EState *estate, int eflags)
Definition: nodeTidscan.c:506
Definition: nodes.h:46
#define ERROR
Definition: elog.h:43
IndexScanState * ExecInitIndexScan(IndexScan *node, EState *estate, int eflags)
CustomScanState * ExecInitCustomScan(CustomScan *cscan, EState *estate, int eflags)
Definition: nodeCustom.c:30
BitmapIndexScanState * ExecInitBitmapIndexScan(BitmapIndexScan *node, EState *estate, int eflags)
Definition: nodes.h:77
SampleScanState * ExecInitSampleScan(SampleScan *node, EState *estate, int eflags)
void check_stack_depth(void)
Definition: postgres.c:3262
ModifyTableState * ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
SubqueryScanState * ExecInitSubqueryScan(SubqueryScan *node, EState *estate, int eflags)
SetOpState * ExecInitSetOp(SetOp *node, EState *estate, int eflags)
Definition: nodeSetOp.c:481
FunctionScanState * ExecInitFunctionScan(FunctionScan *node, EState *estate, int eflags)
List * lappend(List *list, void *datum)
Definition: list.c:321
ValuesScanState * ExecInitValuesScan(ValuesScan *node, EState *estate, int eflags)
BitmapAndState * ExecInitBitmapAnd(BitmapAnd *node, EState *estate, int eflags)
Definition: nodeBitmapAnd.c:55
HashJoinState * ExecInitHashJoin(HashJoin *node, EState *estate, int eflags)
Definition: nodeHashjoin.c:598
ExecProcNodeMtd ExecProcNode
Definition: execnodes.h:951
UniqueState * ExecInitUnique(Unique *node, EState *estate, int eflags)
Definition: nodeUnique.c:115
void ExecSetExecProcNode(PlanState *node, ExecProcNodeMtd function)
Definition: execProcnode.c:406
Definition: nodes.h:83
BitmapOrState * ExecInitBitmapOr(BitmapOr *node, EState *estate, int eflags)
Definition: nodeBitmapOr.c:56
IndexOnlyScanState * ExecInitIndexOnlyScan(IndexOnlyScan *node, EState *estate, int eflags)
#define Assert(condition)
Definition: c.h:732
#define lfirst(lc)
Definition: pg_list.h:190
ResultState * ExecInitResult(Result *node, EState *estate, int eflags)
Definition: nodeResult.c:181
WindowAggState * ExecInitWindowAgg(WindowAgg *node, EState *estate, int eflags)
ProjectSetState * ExecInitProjectSet(ProjectSet *node, EState *estate, int eflags)
#define nodeTag(nodeptr)
Definition: nodes.h:529
Definition: nodes.h:84
TableFuncScanState * ExecInitTableFuncScan(TableFuncScan *node, EState *estate, int eflags)
ForeignScanState * ExecInitForeignScan(ForeignScan *node, EState *estate, int eflags)
SeqScanState * ExecInitSeqScan(SeqScan *node, EState *estate, int eflags)
Definition: nodeSeqscan.c:123
List * initPlan
Definition: plannodes.h:144
Definition: nodes.h:81
#define elog(elevel,...)
Definition: elog.h:226
LimitState * ExecInitLimit(Limit *node, EState *estate, int eflags)
Definition: nodeLimit.c:338
WorkTableScanState * ExecInitWorkTableScan(WorkTableScan *node, EState *estate, int eflags)
Definition: plannodes.h:802
Definition: pg_list.h:50
MaterialState * ExecInitMaterial(Material *node, EState *estate, int eflags)
Definition: nodeMaterial.c:164
Definition: nodes.h:86

◆ ExecProcNodeFirst()

static TupleTableSlot * ExecProcNodeFirst ( PlanState node)
static

Definition at line 424 of file execProcnode.c.

References check_stack_depth(), PlanState::ExecProcNode, ExecProcNodeInstr(), PlanState::ExecProcNodeReal, and PlanState::instrument.

Referenced by ExecSetExecProcNode().

425 {
426  /*
427  * Perform stack depth check during the first execution of the node. We
428  * only do so the first time round because it turns out to not be cheap on
429  * some common architectures (eg. x86). This relies on the assumption
430  * that ExecProcNode calls for a given plan node will always be made at
431  * roughly the same stack depth.
432  */
434 
435  /*
436  * If instrumentation is required, change the wrapper to one that just
437  * does instrumentation. Otherwise we can dispense with all wrappers and
438  * have ExecProcNode() directly call the relevant function from now on.
439  */
440  if (node->instrument)
442  else
443  node->ExecProcNode = node->ExecProcNodeReal;
444 
445  return node->ExecProcNode(node);
446 }
Instrumentation * instrument
Definition: execnodes.h:955
void check_stack_depth(void)
Definition: postgres.c:3262
ExecProcNodeMtd ExecProcNode
Definition: execnodes.h:951
ExecProcNodeMtd ExecProcNodeReal
Definition: execnodes.h:952
static TupleTableSlot * ExecProcNodeInstr(PlanState *node)
Definition: execProcnode.c:455

◆ ExecProcNodeInstr()

static TupleTableSlot * ExecProcNodeInstr ( PlanState node)
static

Definition at line 455 of file execProcnode.c.

References PlanState::ExecProcNodeReal, InstrStartNode(), InstrStopNode(), PlanState::instrument, and TupIsNull.

Referenced by ExecProcNodeFirst().

456 {
457  TupleTableSlot *result;
458 
459  InstrStartNode(node->instrument);
460 
461  result = node->ExecProcNodeReal(node);
462 
463  InstrStopNode(node->instrument, TupIsNull(result) ? 0.0 : 1.0);
464 
465  return result;
466 }
void InstrStopNode(Instrumentation *instr, double nTuples)
Definition: instrument.c:76
Instrumentation * instrument
Definition: execnodes.h:955
void InstrStartNode(Instrumentation *instr)
Definition: instrument.c:63
#define TupIsNull(slot)
Definition: tuptable.h:293
ExecProcNodeMtd ExecProcNodeReal
Definition: execnodes.h:952

◆ ExecSetExecProcNode()

void ExecSetExecProcNode ( PlanState node,
ExecProcNodeMtd  function 
)

Definition at line 406 of file execProcnode.c.

References PlanState::ExecProcNode, ExecProcNodeFirst(), and PlanState::ExecProcNodeReal.

Referenced by ExecHashJoinInitializeDSM(), ExecHashJoinInitializeWorker(), and ExecInitNode().

407 {
408  /*
409  * Add a wrapper around the ExecProcNode callback that checks stack depth
410  * during the first execution and maybe adds an instrumentation wrapper.
411  * When the callback is changed after execution has already begun that
412  * means we'll superfluously execute ExecProcNodeFirst, but that seems ok.
413  */
414  node->ExecProcNodeReal = function;
416 }
ExecProcNodeMtd ExecProcNode
Definition: execnodes.h:951
ExecProcNodeMtd ExecProcNodeReal
Definition: execnodes.h:952
static TupleTableSlot * ExecProcNodeFirst(PlanState *node)
Definition: execProcnode.c:424

◆ ExecSetTupleBound()

void ExecSetTupleBound ( int64  tuples_needed,
PlanState child_node 
)

Definition at line 812 of file execProcnode.c.

References AppendState::appendplans, AppendState::as_nplans, SortState::bound, SortState::bounded, ExecSetTupleBound(), i, IsA, MergeAppendState::mergeplans, MergeAppendState::ms_nplans, outerPlanState, ScanState::ps, PlanState::qual, SubqueryScanState::ss, SubqueryScanState::subplan, GatherState::tuples_needed, and GatherMergeState::tuples_needed.

Referenced by ExecSetTupleBound(), ParallelQueryMain(), and recompute_limits().

813 {
814  /*
815  * Since this function recurses, in principle we should check stack depth
816  * here. In practice, it's probably pointless since the earlier node
817  * initialization tree traversal would surely have consumed more stack.
818  */
819 
820  if (IsA(child_node, SortState))
821  {
822  /*
823  * If it is a Sort node, notify it that it can use bounded sort.
824  *
825  * Note: it is the responsibility of nodeSort.c to react properly to
826  * changes of these parameters. If we ever redesign this, it'd be a
827  * good idea to integrate this signaling with the parameter-change
828  * mechanism.
829  */
830  SortState *sortState = (SortState *) child_node;
831 
832  if (tuples_needed < 0)
833  {
834  /* make sure flag gets reset if needed upon rescan */
835  sortState->bounded = false;
836  }
837  else
838  {
839  sortState->bounded = true;
840  sortState->bound = tuples_needed;
841  }
842  }
843  else if (IsA(child_node, AppendState))
844  {
845  /*
846  * If it is an Append, we can apply the bound to any nodes that are
847  * children of the Append, since the Append surely need read no more
848  * than that many tuples from any one input.
849  */
850  AppendState *aState = (AppendState *) child_node;
851  int i;
852 
853  for (i = 0; i < aState->as_nplans; i++)
854  ExecSetTupleBound(tuples_needed, aState->appendplans[i]);
855  }
856  else if (IsA(child_node, MergeAppendState))
857  {
858  /*
859  * If it is a MergeAppend, we can apply the bound to any nodes that
860  * are children of the MergeAppend, since the MergeAppend surely need
861  * read no more than that many tuples from any one input.
862  */
863  MergeAppendState *maState = (MergeAppendState *) child_node;
864  int i;
865 
866  for (i = 0; i < maState->ms_nplans; i++)
867  ExecSetTupleBound(tuples_needed, maState->mergeplans[i]);
868  }
869  else if (IsA(child_node, ResultState))
870  {
871  /*
872  * Similarly, for a projecting Result, we can apply the bound to its
873  * child node.
874  *
875  * If Result supported qual checking, we'd have to punt on seeing a
876  * qual. Note that having a resconstantqual is not a showstopper: if
877  * that condition succeeds it affects nothing, while if it fails, no
878  * rows will be demanded from the Result child anyway.
879  */
880  if (outerPlanState(child_node))
881  ExecSetTupleBound(tuples_needed, outerPlanState(child_node));
882  }
883  else if (IsA(child_node, SubqueryScanState))
884  {
885  /*
886  * We can also descend through SubqueryScan, but only if it has no
887  * qual (otherwise it might discard rows).
888  */
889  SubqueryScanState *subqueryState = (SubqueryScanState *) child_node;
890 
891  if (subqueryState->ss.ps.qual == NULL)
892  ExecSetTupleBound(tuples_needed, subqueryState->subplan);
893  }
894  else if (IsA(child_node, GatherState))
895  {
896  /*
897  * A Gather node can propagate the bound to its workers. As with
898  * MergeAppend, no one worker could possibly need to return more
899  * tuples than the Gather itself needs to.
900  *
901  * Note: As with Sort, the Gather node is responsible for reacting
902  * properly to changes to this parameter.
903  */
904  GatherState *gstate = (GatherState *) child_node;
905 
906  gstate->tuples_needed = tuples_needed;
907 
908  /* Also pass down the bound to our own copy of the child plan */
909  ExecSetTupleBound(tuples_needed, outerPlanState(child_node));
910  }
911  else if (IsA(child_node, GatherMergeState))
912  {
913  /* Same comments as for Gather */
914  GatherMergeState *gstate = (GatherMergeState *) child_node;
915 
916  gstate->tuples_needed = tuples_needed;
917 
918  ExecSetTupleBound(tuples_needed, outerPlanState(child_node));
919  }
920 
921  /*
922  * In principle we could descend through any plan node type that is
923  * certain not to discard or combine input rows; but on seeing a node that
924  * can do that, we can't propagate the bound any further. For the moment
925  * it's unclear that any other cases are worth checking here.
926  */
927 }
#define IsA(nodeptr, _type_)
Definition: nodes.h:575
bool bounded
Definition: execnodes.h:1943
int64 bound
Definition: execnodes.h:1944
void ExecSetTupleBound(int64 tuples_needed, PlanState *child_node)
Definition: execProcnode.c:812
PlanState ps
Definition: execnodes.h:1280
#define outerPlanState(node)
Definition: execnodes.h:1039
PlanState ** mergeplans
Definition: execnodes.h:1199
PlanState * subplan
Definition: execnodes.h:1587
ExprState * qual
Definition: execnodes.h:966
PlanState ** appendplans
Definition: execnodes.h:1167
int i
int64 tuples_needed
Definition: execnodes.h:2148

◆ ExecShutdownNode()

bool ExecShutdownNode ( PlanState node)

Definition at line 742 of file execProcnode.c.

References check_stack_depth(), ExecShutdownCustomScan(), ExecShutdownForeignScan(), ExecShutdownGather(), ExecShutdownGatherMerge(), ExecShutdownHash(), ExecShutdownHashJoin(), ExecShutdownNode(), InstrStartNode(), InstrStopNode(), PlanState::instrument, nodeTag, planstate_tree_walker(), Instrumentation::running, T_CustomScanState, T_ForeignScanState, T_GatherMergeState, T_GatherState, T_HashJoinState, and T_HashState.

Referenced by ExecLimit(), ExecShutdownNode(), and ExecutePlan().

743 {
744  if (node == NULL)
745  return false;
746 
748 
750 
751  /*
752  * Treat the node as running while we shut it down, but only if it's run
753  * at least once already. We don't expect much CPU consumption during
754  * node shutdown, but in the case of Gather or Gather Merge, we may shut
755  * down workers at this stage. If so, their buffer usage will get
756  * propagated into pgBufferUsage at this point, and we want to make sure
757  * that it gets associated with the Gather node. We skip this if the node
758  * has never been executed, so as to avoid incorrectly making it appear
759  * that it has.
760  */
761  if (node->instrument && node->instrument->running)
762  InstrStartNode(node->instrument);
763 
764  switch (nodeTag(node))
765  {
766  case T_GatherState:
768  break;
769  case T_ForeignScanState:
771  break;
772  case T_CustomScanState:
774  break;
775  case T_GatherMergeState:
777  break;
778  case T_HashState:
779  ExecShutdownHash((HashState *) node);
780  break;
781  case T_HashJoinState:
783  break;
784  default:
785  break;
786  }
787 
788  /* Stop the node if we started it above, reporting 0 tuples. */
789  if (node->instrument && node->instrument->running)
790  InstrStopNode(node->instrument, 0);
791 
792  return false;
793 }
void InstrStopNode(Instrumentation *instr, double nTuples)
Definition: instrument.c:76
Instrumentation * instrument
Definition: execnodes.h:955
bool ExecShutdownNode(PlanState *node)
Definition: execProcnode.c:742
void ExecShutdownCustomScan(CustomScanState *node)
Definition: nodeCustom.c:223
void ExecShutdownHashJoin(HashJoinState *node)
void ExecShutdownHash(HashState *node)
Definition: nodeHash.c:2631
void InstrStartNode(Instrumentation *instr)
Definition: instrument.c:63
void check_stack_depth(void)
Definition: postgres.c:3262
void ExecShutdownGather(GatherState *node)
Definition: nodeGather.c:419
void ExecShutdownGatherMerge(GatherMergeState *node)
#define nodeTag(nodeptr)
Definition: nodes.h:529
void ExecShutdownForeignScan(ForeignScanState *node)
bool planstate_tree_walker(PlanState *planstate, bool(*walker)(), void *context)
Definition: nodeFuncs.c:3762

◆ MultiExecProcNode()

Node* MultiExecProcNode ( PlanState node)

Definition at line 483 of file execProcnode.c.

References CHECK_FOR_INTERRUPTS, check_stack_depth(), PlanState::chgParam, elog, ERROR, ExecReScan(), MultiExecBitmapAnd(), MultiExecBitmapIndexScan(), MultiExecBitmapOr(), MultiExecHash(), nodeTag, T_BitmapAndState, T_BitmapIndexScanState, T_BitmapOrState, and T_HashState.

Referenced by BitmapHeapNext(), ExecHashJoinImpl(), MultiExecBitmapAnd(), and MultiExecBitmapOr().

484 {
485  Node *result;
486 
488 
490 
491  if (node->chgParam != NULL) /* something changed */
492  ExecReScan(node); /* let ReScan handle this */
493 
494  switch (nodeTag(node))
495  {
496  /*
497  * Only node types that actually support multiexec will be listed
498  */
499 
500  case T_HashState:
501  result = MultiExecHash((HashState *) node);
502  break;
503 
506  break;
507 
508  case T_BitmapAndState:
509  result = MultiExecBitmapAnd((BitmapAndState *) node);
510  break;
511 
512  case T_BitmapOrState:
513  result = MultiExecBitmapOr((BitmapOrState *) node);
514  break;
515 
516  default:
517  elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
518  result = NULL;
519  break;
520  }
521 
522  return result;
523 }
void ExecReScan(PlanState *node)
Definition: execAmi.c:77
Definition: nodes.h:524
Node * MultiExecHash(HashState *node)
Definition: nodeHash.c:105
#define ERROR
Definition: elog.h:43
void check_stack_depth(void)
Definition: postgres.c:3262
Node * MultiExecBitmapIndexScan(BitmapIndexScanState *node)
Bitmapset * chgParam
Definition: execnodes.h:977
Node * MultiExecBitmapAnd(BitmapAndState *node)
Node * MultiExecBitmapOr(BitmapOrState *node)
Definition: nodeBitmapOr.c:111
#define nodeTag(nodeptr)
Definition: nodes.h:529
#define elog(elevel,...)
Definition: elog.h:226
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:99