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/nodeIncrementalSort.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/nodeResultCache.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/nodeTidrangescan.h"
#include "executor/nodeTidscan.h"
#include "executor/nodeUnique.h"
#include "executor/nodeValuesscan.h"
#include "executor/nodeWindowAgg.h"
#include "executor/nodeWorktablescan.h"
#include "miscadmin.h"
#include "nodes/nodeFuncs.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 555 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(), ExecEndIncrementalSort(), ExecEndIndexOnlyScan(), ExecEndIndexScan(), ExecEndLimit(), ExecEndLockRows(), ExecEndMaterial(), ExecEndMergeAppend(), ExecEndMergeJoin(), ExecEndModifyTable(), ExecEndNamedTuplestoreScan(), ExecEndNestLoop(), ExecEndProjectSet(), ExecEndRecursiveUnion(), ExecEndResult(), ExecEndResultCache(), ExecEndSampleScan(), ExecEndSeqScan(), ExecEndSetOp(), ExecEndSort(), ExecEndSubqueryScan(), ExecEndTableFuncScan(), ExecEndTidRangeScan(), 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_IncrementalSortState, 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_ResultCacheState, T_ResultState, T_SampleScanState, T_SeqScanState, T_SetOpState, T_SortState, T_SubqueryScanState, T_TableFuncScanState, T_TidRangeScanState, 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(), ExecEndIncrementalSort(), ExecEndLimit(), ExecEndLockRows(), ExecEndMaterial(), ExecEndMergeAppend(), ExecEndMergeJoin(), ExecEndModifyTable(), ExecEndNestLoop(), ExecEndPlan(), ExecEndProjectSet(), ExecEndRecursiveUnion(), ExecEndResult(), ExecEndResultCache(), ExecEndSetOp(), ExecEndSort(), ExecEndSubqueryScan(), ExecEndUnique(), and ExecEndWindowAgg().

556 {
557  /*
558  * do nothing when we get to the end of a leaf on tree.
559  */
560  if (node == NULL)
561  return;
562 
563  /*
564  * Make sure there's enough stack available. Need to check here, in
565  * addition to ExecProcNode() (via ExecProcNodeFirst()), because it's not
566  * guaranteed that ExecProcNode() is reached for all nodes.
567  */
569 
570  if (node->chgParam != NULL)
571  {
572  bms_free(node->chgParam);
573  node->chgParam = NULL;
574  }
575 
576  switch (nodeTag(node))
577  {
578  /*
579  * control nodes
580  */
581  case T_ResultState:
582  ExecEndResult((ResultState *) node);
583  break;
584 
585  case T_ProjectSetState:
587  break;
588 
589  case T_ModifyTableState:
591  break;
592 
593  case T_AppendState:
594  ExecEndAppend((AppendState *) node);
595  break;
596 
597  case T_MergeAppendState:
599  break;
600 
603  break;
604 
605  case T_BitmapAndState:
607  break;
608 
609  case T_BitmapOrState:
610  ExecEndBitmapOr((BitmapOrState *) node);
611  break;
612 
613  /*
614  * scan nodes
615  */
616  case T_SeqScanState:
617  ExecEndSeqScan((SeqScanState *) node);
618  break;
619 
620  case T_SampleScanState:
622  break;
623 
624  case T_GatherState:
625  ExecEndGather((GatherState *) node);
626  break;
627 
628  case T_GatherMergeState:
630  break;
631 
632  case T_IndexScanState:
634  break;
635 
638  break;
639 
642  break;
643 
646  break;
647 
648  case T_TidScanState:
649  ExecEndTidScan((TidScanState *) node);
650  break;
651 
652  case T_TidRangeScanState:
654  break;
655 
656  case T_SubqueryScanState:
658  break;
659 
660  case T_FunctionScanState:
662  break;
663 
666  break;
667 
668  case T_ValuesScanState:
670  break;
671 
672  case T_CteScanState:
673  ExecEndCteScan((CteScanState *) node);
674  break;
675 
678  break;
679 
682  break;
683 
684  case T_ForeignScanState:
686  break;
687 
688  case T_CustomScanState:
690  break;
691 
692  /*
693  * join nodes
694  */
695  case T_NestLoopState:
696  ExecEndNestLoop((NestLoopState *) node);
697  break;
698 
699  case T_MergeJoinState:
701  break;
702 
703  case T_HashJoinState:
704  ExecEndHashJoin((HashJoinState *) node);
705  break;
706 
707  /*
708  * materialization nodes
709  */
710  case T_MaterialState:
711  ExecEndMaterial((MaterialState *) node);
712  break;
713 
714  case T_SortState:
715  ExecEndSort((SortState *) node);
716  break;
717 
720  break;
721 
722  case T_ResultCacheState:
724  break;
725 
726  case T_GroupState:
727  ExecEndGroup((GroupState *) node);
728  break;
729 
730  case T_AggState:
731  ExecEndAgg((AggState *) node);
732  break;
733 
734  case T_WindowAggState:
736  break;
737 
738  case T_UniqueState:
739  ExecEndUnique((UniqueState *) node);
740  break;
741 
742  case T_HashState:
743  ExecEndHash((HashState *) node);
744  break;
745 
746  case T_SetOpState:
747  ExecEndSetOp((SetOpState *) node);
748  break;
749 
750  case T_LockRowsState:
751  ExecEndLockRows((LockRowsState *) node);
752  break;
753 
754  case T_LimitState:
755  ExecEndLimit((LimitState *) node);
756  break;
757 
758  default:
759  elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
760  break;
761  }
762 }
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:535
void ExecEndUnique(UniqueState *node)
Definition: nodeUnique.c:169
void ExecEndGatherMerge(GatherMergeState *node)
void ExecEndIncrementalSort(IncrementalSortState *node)
void ExecEndWorkTableScan(WorkTableScanState *node)
void ExecEndLockRows(LockRowsState *node)
Definition: nodeLockRows.c:382
void ExecEndNamedTuplestoreScan(NamedTuplestoreScanState *node)
void ExecEndBitmapAnd(BitmapAndState *node)
void ExecEndRecursiveUnion(RecursiveUnionState *node)
void ExecEndSubqueryScan(SubqueryScanState *node)
void ExecEndHashJoin(HashJoinState *node)
Definition: nodeHashjoin.c:765
void ExecEndTableFuncScan(TableFuncScanState *node)
void ExecEndResult(ResultState *node)
Definition: nodeResult.c:241
#define ERROR
Definition: elog.h:46
void ExecEndAppend(AppendState *node)
Definition: nodeAppend.c:387
void ExecEndForeignScan(ForeignScanState *node)
void ExecEndSort(SortState *node)
Definition: nodeSort.c:235
void ExecEndBitmapIndexScan(BitmapIndexScanState *node)
void check_stack_depth(void)
Definition: postgres.c:3441
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:468
Bitmapset * chgParam
Definition: execnodes.h:996
void ExecEndCteScan(CteScanState *node)
Definition: nodeCtescan.c:288
void ExecEndCustomScan(CustomScanState *node)
Definition: nodeCustom.c:119
void ExecEndBitmapOr(BitmapOrState *node)
Definition: nodeBitmapOr.c:196
void ExecEndResultCache(ResultCacheState *node)
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:544
#define elog(elevel,...)
Definition: elog.h:232
void ExecEndHash(HashState *node)
Definition: nodeHash.c:407
void ExecEndProjectSet(ProjectSetState *node)
void ExecEndMaterial(MaterialState *node)
Definition: nodeMaterial.c:240
void ExecEndBitmapHeapScan(BitmapHeapScanState *node)
void ExecEndTidRangeScan(TidRangeScanState *node)
void ExecEndAgg(AggState *node)
Definition: nodeAgg.c:4370
void ExecEndModifyTable(ModifyTableState *node)
void ExecEndGather(GatherState *node)
Definition: nodeGather.c:249

◆ ExecInitNode()

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

Definition at line 141 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(), ExecInitIncrementalSort(), ExecInitIndexOnlyScan(), ExecInitIndexScan(), ExecInitLimit(), ExecInitLockRows(), ExecInitMaterial(), ExecInitMergeAppend(), ExecInitMergeJoin(), ExecInitModifyTable(), ExecInitNamedTuplestoreScan(), ExecInitNestLoop(), ExecInitProjectSet(), ExecInitRecursiveUnion(), ExecInitResult(), ExecInitResultCache(), ExecInitSampleScan(), ExecInitSeqScan(), ExecInitSetOp(), ExecInitSort(), ExecInitSubPlan(), ExecInitSubqueryScan(), ExecInitTableFuncScan(), ExecInitTidRangeScan(), 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_IncrementalSort, 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_ResultCache, T_SampleScan, T_SeqScan, T_SetOp, T_Sort, T_SubqueryScan, T_TableFuncScan, T_TidRangeScan, 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(), ExecInitIncrementalSort(), ExecInitLimit(), ExecInitLockRows(), ExecInitMaterial(), ExecInitMergeAppend(), ExecInitMergeJoin(), ExecInitModifyTable(), ExecInitNestLoop(), ExecInitProjectSet(), ExecInitRecursiveUnion(), ExecInitResult(), ExecInitResultCache(), ExecInitSetOp(), ExecInitSort(), ExecInitSubqueryScan(), ExecInitUnique(), ExecInitWindowAgg(), and InitPlan().

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

◆ ExecProcNodeFirst()

static TupleTableSlot * ExecProcNodeFirst ( PlanState node)
static

Definition at line 441 of file execProcnode.c.

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

Referenced by ExecSetExecProcNode().

442 {
443  /*
444  * Perform stack depth check during the first execution of the node. We
445  * only do so the first time round because it turns out to not be cheap on
446  * some common architectures (eg. x86). This relies on the assumption
447  * that ExecProcNode calls for a given plan node will always be made at
448  * roughly the same stack depth.
449  */
451 
452  /*
453  * If instrumentation is required, change the wrapper to one that just
454  * does instrumentation. Otherwise we can dispense with all wrappers and
455  * have ExecProcNode() directly call the relevant function from now on.
456  */
457  if (node->instrument)
459  else
460  node->ExecProcNode = node->ExecProcNodeReal;
461 
462  return node->ExecProcNode(node);
463 }
Instrumentation * instrument
Definition: execnodes.h:974
void check_stack_depth(void)
Definition: postgres.c:3441
ExecProcNodeMtd ExecProcNode
Definition: execnodes.h:970
ExecProcNodeMtd ExecProcNodeReal
Definition: execnodes.h:971
static TupleTableSlot * ExecProcNodeInstr(PlanState *node)
Definition: execProcnode.c:472

◆ ExecProcNodeInstr()

static TupleTableSlot * ExecProcNodeInstr ( PlanState node)
static

Definition at line 472 of file execProcnode.c.

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

Referenced by ExecProcNodeFirst().

473 {
474  TupleTableSlot *result;
475 
476  InstrStartNode(node->instrument);
477 
478  result = node->ExecProcNodeReal(node);
479 
480  InstrStopNode(node->instrument, TupIsNull(result) ? 0.0 : 1.0);
481 
482  return result;
483 }
void InstrStopNode(Instrumentation *instr, double nTuples)
Definition: instrument.c:83
Instrumentation * instrument
Definition: execnodes.h:974
void InstrStartNode(Instrumentation *instr)
Definition: instrument.c:67
#define TupIsNull(slot)
Definition: tuptable.h:292
ExecProcNodeMtd ExecProcNodeReal
Definition: execnodes.h:971

◆ ExecSetExecProcNode()

void ExecSetExecProcNode ( PlanState node,
ExecProcNodeMtd  function 
)

Definition at line 423 of file execProcnode.c.

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

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

424 {
425  /*
426  * Add a wrapper around the ExecProcNode callback that checks stack depth
427  * during the first execution and maybe adds an instrumentation wrapper.
428  * When the callback is changed after execution has already begun that
429  * means we'll superfluously execute ExecProcNodeFirst, but that seems ok.
430  */
431  node->ExecProcNodeReal = function;
433 }
ExecProcNodeMtd ExecProcNode
Definition: execnodes.h:970
ExecProcNodeMtd ExecProcNodeReal
Definition: execnodes.h:971
static TupleTableSlot * ExecProcNodeFirst(PlanState *node)
Definition: execProcnode.c:441

◆ ExecSetTupleBound()

void ExecSetTupleBound ( int64  tuples_needed,
PlanState child_node 
)

Definition at line 841 of file execProcnode.c.

References AppendState::appendplans, AppendState::as_nplans, SortState::bound, IncrementalSortState::bound, SortState::bounded, IncrementalSortState::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().

842 {
843  /*
844  * Since this function recurses, in principle we should check stack depth
845  * here. In practice, it's probably pointless since the earlier node
846  * initialization tree traversal would surely have consumed more stack.
847  */
848 
849  if (IsA(child_node, SortState))
850  {
851  /*
852  * If it is a Sort node, notify it that it can use bounded sort.
853  *
854  * Note: it is the responsibility of nodeSort.c to react properly to
855  * changes of these parameters. If we ever redesign this, it'd be a
856  * good idea to integrate this signaling with the parameter-change
857  * mechanism.
858  */
859  SortState *sortState = (SortState *) child_node;
860 
861  if (tuples_needed < 0)
862  {
863  /* make sure flag gets reset if needed upon rescan */
864  sortState->bounded = false;
865  }
866  else
867  {
868  sortState->bounded = true;
869  sortState->bound = tuples_needed;
870  }
871  }
872  else if (IsA(child_node, IncrementalSortState))
873  {
874  /*
875  * If it is an IncrementalSort node, notify it that it can use bounded
876  * sort.
877  *
878  * Note: it is the responsibility of nodeIncrementalSort.c to react
879  * properly to changes of these parameters. If we ever redesign this,
880  * it'd be a good idea to integrate this signaling with the
881  * parameter-change mechanism.
882  */
883  IncrementalSortState *sortState = (IncrementalSortState *) child_node;
884 
885  if (tuples_needed < 0)
886  {
887  /* make sure flag gets reset if needed upon rescan */
888  sortState->bounded = false;
889  }
890  else
891  {
892  sortState->bounded = true;
893  sortState->bound = tuples_needed;
894  }
895  }
896  else if (IsA(child_node, AppendState))
897  {
898  /*
899  * If it is an Append, we can apply the bound to any nodes that are
900  * children of the Append, since the Append surely need read no more
901  * than that many tuples from any one input.
902  */
903  AppendState *aState = (AppendState *) child_node;
904  int i;
905 
906  for (i = 0; i < aState->as_nplans; i++)
907  ExecSetTupleBound(tuples_needed, aState->appendplans[i]);
908  }
909  else if (IsA(child_node, MergeAppendState))
910  {
911  /*
912  * If it is a MergeAppend, we can apply the bound to any nodes that
913  * are children of the MergeAppend, since the MergeAppend surely need
914  * read no more than that many tuples from any one input.
915  */
916  MergeAppendState *maState = (MergeAppendState *) child_node;
917  int i;
918 
919  for (i = 0; i < maState->ms_nplans; i++)
920  ExecSetTupleBound(tuples_needed, maState->mergeplans[i]);
921  }
922  else if (IsA(child_node, ResultState))
923  {
924  /*
925  * Similarly, for a projecting Result, we can apply the bound to its
926  * child node.
927  *
928  * If Result supported qual checking, we'd have to punt on seeing a
929  * qual. Note that having a resconstantqual is not a showstopper: if
930  * that condition succeeds it affects nothing, while if it fails, no
931  * rows will be demanded from the Result child anyway.
932  */
933  if (outerPlanState(child_node))
934  ExecSetTupleBound(tuples_needed, outerPlanState(child_node));
935  }
936  else if (IsA(child_node, SubqueryScanState))
937  {
938  /*
939  * We can also descend through SubqueryScan, but only if it has no
940  * qual (otherwise it might discard rows).
941  */
942  SubqueryScanState *subqueryState = (SubqueryScanState *) child_node;
943 
944  if (subqueryState->ss.ps.qual == NULL)
945  ExecSetTupleBound(tuples_needed, subqueryState->subplan);
946  }
947  else if (IsA(child_node, GatherState))
948  {
949  /*
950  * A Gather node can propagate the bound to its workers. As with
951  * MergeAppend, no one worker could possibly need to return more
952  * tuples than the Gather itself needs to.
953  *
954  * Note: As with Sort, the Gather node is responsible for reacting
955  * properly to changes to this parameter.
956  */
957  GatherState *gstate = (GatherState *) child_node;
958 
959  gstate->tuples_needed = tuples_needed;
960 
961  /* Also pass down the bound to our own copy of the child plan */
962  ExecSetTupleBound(tuples_needed, outerPlanState(child_node));
963  }
964  else if (IsA(child_node, GatherMergeState))
965  {
966  /* Same comments as for Gather */
967  GatherMergeState *gstate = (GatherMergeState *) child_node;
968 
969  gstate->tuples_needed = tuples_needed;
970 
971  ExecSetTupleBound(tuples_needed, outerPlanState(child_node));
972  }
973 
974  /*
975  * In principle we could descend through any plan node type that is
976  * certain not to discard or combine input rows; but on seeing a node that
977  * can do that, we can't propagate the bound any further. For the moment
978  * it's unclear that any other cases are worth checking here.
979  */
980 }
#define IsA(nodeptr, _type_)
Definition: nodes.h:590
bool bounded
Definition: execnodes.h:2143
int64 bound
Definition: execnodes.h:2144
void ExecSetTupleBound(int64 tuples_needed, PlanState *child_node)
Definition: execProcnode.c:841
PlanState ps
Definition: execnodes.h:1373
#define outerPlanState(node)
Definition: execnodes.h:1058
PlanState ** mergeplans
Definition: execnodes.h:1293
PlanState * subplan
Definition: execnodes.h:1698
ExprState * qual
Definition: execnodes.h:985
PlanState ** appendplans
Definition: execnodes.h:1250
int i
int64 tuples_needed
Definition: execnodes.h:2459

◆ ExecShutdownNode()

bool ExecShutdownNode ( PlanState node)

Definition at line 771 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 ExecShutdownNode(), and ExecutePlan().

772 {
773  if (node == NULL)
774  return false;
775 
777 
778  /*
779  * Treat the node as running while we shut it down, but only if it's run
780  * at least once already. We don't expect much CPU consumption during
781  * node shutdown, but in the case of Gather or Gather Merge, we may shut
782  * down workers at this stage. If so, their buffer usage will get
783  * propagated into pgBufferUsage at this point, and we want to make sure
784  * that it gets associated with the Gather node. We skip this if the node
785  * has never been executed, so as to avoid incorrectly making it appear
786  * that it has.
787  */
788  if (node->instrument && node->instrument->running)
789  InstrStartNode(node->instrument);
790 
792 
793  switch (nodeTag(node))
794  {
795  case T_GatherState:
797  break;
798  case T_ForeignScanState:
800  break;
801  case T_CustomScanState:
803  break;
804  case T_GatherMergeState:
806  break;
807  case T_HashState:
808  ExecShutdownHash((HashState *) node);
809  break;
810  case T_HashJoinState:
812  break;
813  default:
814  break;
815  }
816 
817  /* Stop the node if we started it above, reporting 0 tuples. */
818  if (node->instrument && node->instrument->running)
819  InstrStopNode(node->instrument, 0);
820 
821  return false;
822 }
void InstrStopNode(Instrumentation *instr, double nTuples)
Definition: instrument.c:83
Instrumentation * instrument
Definition: execnodes.h:974
bool ExecShutdownNode(PlanState *node)
Definition: execProcnode.c:771
void ExecShutdownCustomScan(CustomScanState *node)
Definition: nodeCustom.c:222
void ExecShutdownHashJoin(HashJoinState *node)
void ExecShutdownHash(HashState *node)
Definition: nodeHash.c:2644
void InstrStartNode(Instrumentation *instr)
Definition: instrument.c:67
void check_stack_depth(void)
Definition: postgres.c:3441
void ExecShutdownGather(GatherState *node)
Definition: nodeGather.c:419
void ExecShutdownGatherMerge(GatherMergeState *node)
#define nodeTag(nodeptr)
Definition: nodes.h:544
void ExecShutdownForeignScan(ForeignScanState *node)
bool planstate_tree_walker(PlanState *planstate, bool(*walker)(), void *context)
Definition: nodeFuncs.c:3993

◆ MultiExecProcNode()

Node* MultiExecProcNode ( PlanState node)

Definition at line 500 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().

501 {
502  Node *result;
503 
505 
507 
508  if (node->chgParam != NULL) /* something changed */
509  ExecReScan(node); /* let ReScan handle this */
510 
511  switch (nodeTag(node))
512  {
513  /*
514  * Only node types that actually support multiexec will be listed
515  */
516 
517  case T_HashState:
518  result = MultiExecHash((HashState *) node);
519  break;
520 
523  break;
524 
525  case T_BitmapAndState:
526  result = MultiExecBitmapAnd((BitmapAndState *) node);
527  break;
528 
529  case T_BitmapOrState:
530  result = MultiExecBitmapOr((BitmapOrState *) node);
531  break;
532 
533  default:
534  elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
535  result = NULL;
536  break;
537  }
538 
539  return result;
540 }
void ExecReScan(PlanState *node)
Definition: execAmi.c:78
Definition: nodes.h:539
Node * MultiExecHash(HashState *node)
Definition: nodeHash.c:106
#define ERROR
Definition: elog.h:46
void check_stack_depth(void)
Definition: postgres.c:3441
Node * MultiExecBitmapIndexScan(BitmapIndexScanState *node)
Bitmapset * chgParam
Definition: execnodes.h:996
Node * MultiExecBitmapAnd(BitmapAndState *node)
Node * MultiExecBitmapOr(BitmapOrState *node)
Definition: nodeBitmapOr.c:111
#define nodeTag(nodeptr)
Definition: nodes.h:544
#define elog(elevel,...)
Definition: elog.h:232
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:102