PostgreSQL Source Code  git master
execProcnode.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * execProcnode.c
4  * contains dispatch functions which call the appropriate "initialize",
5  * "get a tuple", and "cleanup" routines for the given node type.
6  * If the node has children, then it will presumably call ExecInitNode,
7  * ExecProcNode, or ExecEndNode on its subnodes and do the appropriate
8  * processing.
9  *
10  * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group
11  * Portions Copyright (c) 1994, Regents of the University of California
12  *
13  *
14  * IDENTIFICATION
15  * src/backend/executor/execProcnode.c
16  *
17  *-------------------------------------------------------------------------
18  */
19 /*
20  * NOTES
21  * This used to be three files. It is now all combined into
22  * one file so that it is easier to keep the dispatch routines
23  * in sync when new nodes are added.
24  *
25  * EXAMPLE
26  * Suppose we want the age of the manager of the shoe department and
27  * the number of employees in that department. So we have the query:
28  *
29  * select DEPT.no_emps, EMP.age
30  * from DEPT, EMP
31  * where EMP.name = DEPT.mgr and
32  * DEPT.name = "shoe"
33  *
34  * Suppose the planner gives us the following plan:
35  *
36  * Nest Loop (DEPT.mgr = EMP.name)
37  * / \
38  * / \
39  * Seq Scan Seq Scan
40  * DEPT EMP
41  * (name = "shoe")
42  *
43  * ExecutorStart() is called first.
44  * It calls InitPlan() which calls ExecInitNode() on
45  * the root of the plan -- the nest loop node.
46  *
47  * * ExecInitNode() notices that it is looking at a nest loop and
48  * as the code below demonstrates, it calls ExecInitNestLoop().
49  * Eventually this calls ExecInitNode() on the right and left subplans
50  * and so forth until the entire plan is initialized. The result
51  * of ExecInitNode() is a plan state tree built with the same structure
52  * as the underlying plan tree.
53  *
54  * * Then when ExecutorRun() is called, it calls ExecutePlan() which calls
55  * ExecProcNode() repeatedly on the top node of the plan state tree.
56  * Each time this happens, ExecProcNode() will end up calling
57  * ExecNestLoop(), which calls ExecProcNode() on its subplans.
58  * Each of these subplans is a sequential scan so ExecSeqScan() is
59  * called. The slots returned by ExecSeqScan() may contain
60  * tuples which contain the attributes ExecNestLoop() uses to
61  * form the tuples it returns.
62  *
63  * * Eventually ExecSeqScan() stops returning tuples and the nest
64  * loop join ends. Lastly, ExecutorEnd() calls ExecEndNode() which
65  * calls ExecEndNestLoop() which in turn calls ExecEndNode() on
66  * its subplans which result in ExecEndSeqScan().
67  *
68  * This should show how the executor works by having
69  * ExecInitNode(), ExecProcNode() and ExecEndNode() dispatch
70  * their work to the appropriate node support routines which may
71  * in turn call these routines themselves on their subplans.
72  */
73 #include "postgres.h"
74 
75 #include "executor/executor.h"
76 #include "executor/nodeAgg.h"
77 #include "executor/nodeAppend.h"
78 #include "executor/nodeBitmapAnd.h"
81 #include "executor/nodeBitmapOr.h"
82 #include "executor/nodeCtescan.h"
83 #include "executor/nodeCustom.h"
86 #include "executor/nodeGather.h"
88 #include "executor/nodeGroup.h"
89 #include "executor/nodeHash.h"
90 #include "executor/nodeHashjoin.h"
93 #include "executor/nodeIndexscan.h"
94 #include "executor/nodeLimit.h"
95 #include "executor/nodeLockRows.h"
96 #include "executor/nodeMaterial.h"
97 #include "executor/nodeMemoize.h"
99 #include "executor/nodeMergejoin.h"
102 #include "executor/nodeNestloop.h"
103 #include "executor/nodeProjectSet.h"
105 #include "executor/nodeResult.h"
106 #include "executor/nodeSamplescan.h"
107 #include "executor/nodeSeqscan.h"
108 #include "executor/nodeSetOp.h"
109 #include "executor/nodeSort.h"
110 #include "executor/nodeSubplan.h"
114 #include "executor/nodeTidscan.h"
115 #include "executor/nodeUnique.h"
116 #include "executor/nodeValuesscan.h"
117 #include "executor/nodeWindowAgg.h"
119 #include "miscadmin.h"
120 #include "nodes/nodeFuncs.h"
121 
124 
125 
126 /* ------------------------------------------------------------------------
127  * ExecInitNode
128  *
129  * Recursively initializes all the nodes in the plan tree rooted
130  * at 'node'.
131  *
132  * Inputs:
133  * 'node' is the current node of the plan produced by the query planner
134  * 'estate' is the shared execution state for the plan tree
135  * 'eflags' is a bitwise OR of flag bits described in executor.h
136  *
137  * Returns a PlanState node corresponding to the given Plan node.
138  * ------------------------------------------------------------------------
139  */
140 PlanState *
141 ExecInitNode(Plan *node, EState *estate, int eflags)
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_Memoize:
330  result = (PlanState *) ExecInitMemoize((Memoize *) node, estate,
331  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  result->async_capable);
412 
413  return result;
414 }
415 
416 
417 /*
418  * If a node wants to change its ExecProcNode function after ExecInitNode()
419  * has finished, it should do so with this function. That way any wrapper
420  * functions can be reinstalled, without the node having to know how that
421  * works.
422  */
423 void
425 {
426  /*
427  * Add a wrapper around the ExecProcNode callback that checks stack depth
428  * during the first execution and maybe adds an instrumentation wrapper.
429  * When the callback is changed after execution has already begun that
430  * means we'll superfluously execute ExecProcNodeFirst, but that seems ok.
431  */
432  node->ExecProcNodeReal = function;
434 }
435 
436 
437 /*
438  * ExecProcNode wrapper that performs some one-time checks, before calling
439  * the relevant node method (possibly via an instrumentation wrapper).
440  */
441 static TupleTableSlot *
443 {
444  /*
445  * Perform stack depth check during the first execution of the node. We
446  * only do so the first time round because it turns out to not be cheap on
447  * some common architectures (eg. x86). This relies on the assumption
448  * that ExecProcNode calls for a given plan node will always be made at
449  * roughly the same stack depth.
450  */
452 
453  /*
454  * If instrumentation is required, change the wrapper to one that just
455  * does instrumentation. Otherwise we can dispense with all wrappers and
456  * have ExecProcNode() directly call the relevant function from now on.
457  */
458  if (node->instrument)
460  else
461  node->ExecProcNode = node->ExecProcNodeReal;
462 
463  return node->ExecProcNode(node);
464 }
465 
466 
467 /*
468  * ExecProcNode wrapper that performs instrumentation calls. By keeping
469  * this a separate function, we avoid overhead in the normal case where
470  * no instrumentation is wanted.
471  */
472 static TupleTableSlot *
474 {
475  TupleTableSlot *result;
476 
477  InstrStartNode(node->instrument);
478 
479  result = node->ExecProcNodeReal(node);
480 
481  InstrStopNode(node->instrument, TupIsNull(result) ? 0.0 : 1.0);
482 
483  return result;
484 }
485 
486 
487 /* ----------------------------------------------------------------
488  * MultiExecProcNode
489  *
490  * Execute a node that doesn't return individual tuples
491  * (it might return a hashtable, bitmap, etc). Caller should
492  * check it got back the expected kind of Node.
493  *
494  * This has essentially the same responsibilities as ExecProcNode,
495  * but it does not do InstrStartNode/InstrStopNode (mainly because
496  * it can't tell how many returned tuples to count). Each per-node
497  * function must provide its own instrumentation support.
498  * ----------------------------------------------------------------
499  */
500 Node *
502 {
503  Node *result;
504 
506 
508 
509  if (node->chgParam != NULL) /* something changed */
510  ExecReScan(node); /* let ReScan handle this */
511 
512  switch (nodeTag(node))
513  {
514  /*
515  * Only node types that actually support multiexec will be listed
516  */
517 
518  case T_HashState:
519  result = MultiExecHash((HashState *) node);
520  break;
521 
524  break;
525 
526  case T_BitmapAndState:
527  result = MultiExecBitmapAnd((BitmapAndState *) node);
528  break;
529 
530  case T_BitmapOrState:
531  result = MultiExecBitmapOr((BitmapOrState *) node);
532  break;
533 
534  default:
535  elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
536  result = NULL;
537  break;
538  }
539 
540  return result;
541 }
542 
543 
544 /* ----------------------------------------------------------------
545  * ExecEndNode
546  *
547  * Recursively cleans up all the nodes in the plan rooted
548  * at 'node'.
549  *
550  * After this operation, the query plan will not be able to be
551  * processed any further. This should be called only after
552  * the query plan has been fully executed.
553  * ----------------------------------------------------------------
554  */
555 void
557 {
558  /*
559  * do nothing when we get to the end of a leaf on tree.
560  */
561  if (node == NULL)
562  return;
563 
564  /*
565  * Make sure there's enough stack available. Need to check here, in
566  * addition to ExecProcNode() (via ExecProcNodeFirst()), because it's not
567  * guaranteed that ExecProcNode() is reached for all nodes.
568  */
570 
571  if (node->chgParam != NULL)
572  {
573  bms_free(node->chgParam);
574  node->chgParam = NULL;
575  }
576 
577  switch (nodeTag(node))
578  {
579  /*
580  * control nodes
581  */
582  case T_ResultState:
583  ExecEndResult((ResultState *) node);
584  break;
585 
586  case T_ProjectSetState:
588  break;
589 
590  case T_ModifyTableState:
592  break;
593 
594  case T_AppendState:
595  ExecEndAppend((AppendState *) node);
596  break;
597 
598  case T_MergeAppendState:
600  break;
601 
604  break;
605 
606  case T_BitmapAndState:
608  break;
609 
610  case T_BitmapOrState:
611  ExecEndBitmapOr((BitmapOrState *) node);
612  break;
613 
614  /*
615  * scan nodes
616  */
617  case T_SeqScanState:
618  ExecEndSeqScan((SeqScanState *) node);
619  break;
620 
621  case T_SampleScanState:
623  break;
624 
625  case T_GatherState:
626  ExecEndGather((GatherState *) node);
627  break;
628 
629  case T_GatherMergeState:
631  break;
632 
633  case T_IndexScanState:
635  break;
636 
639  break;
640 
643  break;
644 
647  break;
648 
649  case T_TidScanState:
650  ExecEndTidScan((TidScanState *) node);
651  break;
652 
653  case T_TidRangeScanState:
655  break;
656 
657  case T_SubqueryScanState:
659  break;
660 
661  case T_FunctionScanState:
663  break;
664 
667  break;
668 
669  case T_ValuesScanState:
671  break;
672 
673  case T_CteScanState:
674  ExecEndCteScan((CteScanState *) node);
675  break;
676 
679  break;
680 
683  break;
684 
685  case T_ForeignScanState:
687  break;
688 
689  case T_CustomScanState:
691  break;
692 
693  /*
694  * join nodes
695  */
696  case T_NestLoopState:
697  ExecEndNestLoop((NestLoopState *) node);
698  break;
699 
700  case T_MergeJoinState:
702  break;
703 
704  case T_HashJoinState:
705  ExecEndHashJoin((HashJoinState *) node);
706  break;
707 
708  /*
709  * materialization nodes
710  */
711  case T_MaterialState:
712  ExecEndMaterial((MaterialState *) node);
713  break;
714 
715  case T_SortState:
716  ExecEndSort((SortState *) node);
717  break;
718 
721  break;
722 
723  case T_MemoizeState:
724  ExecEndMemoize((MemoizeState *) node);
725  break;
726 
727  case T_GroupState:
728  ExecEndGroup((GroupState *) node);
729  break;
730 
731  case T_AggState:
732  ExecEndAgg((AggState *) node);
733  break;
734 
735  case T_WindowAggState:
737  break;
738 
739  case T_UniqueState:
740  ExecEndUnique((UniqueState *) node);
741  break;
742 
743  case T_HashState:
744  ExecEndHash((HashState *) node);
745  break;
746 
747  case T_SetOpState:
748  ExecEndSetOp((SetOpState *) node);
749  break;
750 
751  case T_LockRowsState:
752  ExecEndLockRows((LockRowsState *) node);
753  break;
754 
755  case T_LimitState:
756  ExecEndLimit((LimitState *) node);
757  break;
758 
759  default:
760  elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
761  break;
762  }
763 }
764 
765 /*
766  * ExecShutdownNode
767  *
768  * Give execution nodes a chance to stop asynchronous resource consumption
769  * and release any resources still held.
770  */
771 bool
773 {
774  if (node == NULL)
775  return false;
776 
778 
779  /*
780  * Treat the node as running while we shut it down, but only if it's run
781  * at least once already. We don't expect much CPU consumption during
782  * node shutdown, but in the case of Gather or Gather Merge, we may shut
783  * down workers at this stage. If so, their buffer usage will get
784  * propagated into pgBufferUsage at this point, and we want to make sure
785  * that it gets associated with the Gather node. We skip this if the node
786  * has never been executed, so as to avoid incorrectly making it appear
787  * that it has.
788  */
789  if (node->instrument && node->instrument->running)
790  InstrStartNode(node->instrument);
791 
793 
794  switch (nodeTag(node))
795  {
796  case T_GatherState:
798  break;
799  case T_ForeignScanState:
801  break;
802  case T_CustomScanState:
804  break;
805  case T_GatherMergeState:
807  break;
808  case T_HashState:
809  ExecShutdownHash((HashState *) node);
810  break;
811  case T_HashJoinState:
813  break;
814  default:
815  break;
816  }
817 
818  /* Stop the node if we started it above, reporting 0 tuples. */
819  if (node->instrument && node->instrument->running)
820  InstrStopNode(node->instrument, 0);
821 
822  return false;
823 }
824 
825 /*
826  * ExecSetTupleBound
827  *
828  * Set a tuple bound for a planstate node. This lets child plan nodes
829  * optimize based on the knowledge that the maximum number of tuples that
830  * their parent will demand is limited. The tuple bound for a node may
831  * only be changed between scans (i.e., after node initialization or just
832  * before an ExecReScan call).
833  *
834  * Any negative tuples_needed value means "no limit", which should be the
835  * default assumption when this is not called at all for a particular node.
836  *
837  * Note: if this is called repeatedly on a plan tree, the exact same set
838  * of nodes must be updated with the new limit each time; be careful that
839  * only unchanging conditions are tested here.
840  */
841 void
842 ExecSetTupleBound(int64 tuples_needed, PlanState *child_node)
843 {
844  /*
845  * Since this function recurses, in principle we should check stack depth
846  * here. In practice, it's probably pointless since the earlier node
847  * initialization tree traversal would surely have consumed more stack.
848  */
849 
850  if (IsA(child_node, SortState))
851  {
852  /*
853  * If it is a Sort node, notify it that it can use bounded sort.
854  *
855  * Note: it is the responsibility of nodeSort.c to react properly to
856  * changes of these parameters. If we ever redesign this, it'd be a
857  * good idea to integrate this signaling with the parameter-change
858  * mechanism.
859  */
860  SortState *sortState = (SortState *) child_node;
861 
862  if (tuples_needed < 0)
863  {
864  /* make sure flag gets reset if needed upon rescan */
865  sortState->bounded = false;
866  }
867  else
868  {
869  sortState->bounded = true;
870  sortState->bound = tuples_needed;
871  }
872  }
873  else if (IsA(child_node, IncrementalSortState))
874  {
875  /*
876  * If it is an IncrementalSort node, notify it that it can use bounded
877  * sort.
878  *
879  * Note: it is the responsibility of nodeIncrementalSort.c to react
880  * properly to changes of these parameters. If we ever redesign this,
881  * it'd be a good idea to integrate this signaling with the
882  * parameter-change mechanism.
883  */
884  IncrementalSortState *sortState = (IncrementalSortState *) child_node;
885 
886  if (tuples_needed < 0)
887  {
888  /* make sure flag gets reset if needed upon rescan */
889  sortState->bounded = false;
890  }
891  else
892  {
893  sortState->bounded = true;
894  sortState->bound = tuples_needed;
895  }
896  }
897  else if (IsA(child_node, AppendState))
898  {
899  /*
900  * If it is an Append, we can apply the bound to any nodes that are
901  * children of the Append, since the Append surely need read no more
902  * than that many tuples from any one input.
903  */
904  AppendState *aState = (AppendState *) child_node;
905  int i;
906 
907  for (i = 0; i < aState->as_nplans; i++)
908  ExecSetTupleBound(tuples_needed, aState->appendplans[i]);
909  }
910  else if (IsA(child_node, MergeAppendState))
911  {
912  /*
913  * If it is a MergeAppend, we can apply the bound to any nodes that
914  * are children of the MergeAppend, since the MergeAppend surely need
915  * read no more than that many tuples from any one input.
916  */
917  MergeAppendState *maState = (MergeAppendState *) child_node;
918  int i;
919 
920  for (i = 0; i < maState->ms_nplans; i++)
921  ExecSetTupleBound(tuples_needed, maState->mergeplans[i]);
922  }
923  else if (IsA(child_node, ResultState))
924  {
925  /*
926  * Similarly, for a projecting Result, we can apply the bound to its
927  * child node.
928  *
929  * If Result supported qual checking, we'd have to punt on seeing a
930  * qual. Note that having a resconstantqual is not a showstopper: if
931  * that condition succeeds it affects nothing, while if it fails, no
932  * rows will be demanded from the Result child anyway.
933  */
934  if (outerPlanState(child_node))
935  ExecSetTupleBound(tuples_needed, outerPlanState(child_node));
936  }
937  else if (IsA(child_node, SubqueryScanState))
938  {
939  /*
940  * We can also descend through SubqueryScan, but only if it has no
941  * qual (otherwise it might discard rows).
942  */
943  SubqueryScanState *subqueryState = (SubqueryScanState *) child_node;
944 
945  if (subqueryState->ss.ps.qual == NULL)
946  ExecSetTupleBound(tuples_needed, subqueryState->subplan);
947  }
948  else if (IsA(child_node, GatherState))
949  {
950  /*
951  * A Gather node can propagate the bound to its workers. As with
952  * MergeAppend, no one worker could possibly need to return more
953  * tuples than the Gather itself needs to.
954  *
955  * Note: As with Sort, the Gather node is responsible for reacting
956  * properly to changes to this parameter.
957  */
958  GatherState *gstate = (GatherState *) child_node;
959 
960  gstate->tuples_needed = tuples_needed;
961 
962  /* Also pass down the bound to our own copy of the child plan */
963  ExecSetTupleBound(tuples_needed, outerPlanState(child_node));
964  }
965  else if (IsA(child_node, GatherMergeState))
966  {
967  /* Same comments as for Gather */
968  GatherMergeState *gstate = (GatherMergeState *) child_node;
969 
970  gstate->tuples_needed = tuples_needed;
971 
972  ExecSetTupleBound(tuples_needed, outerPlanState(child_node));
973  }
974 
975  /*
976  * In principle we could descend through any plan node type that is
977  * certain not to discard or combine input rows; but on seeing a node that
978  * can do that, we can't propagate the bound any further. For the moment
979  * it's unclear that any other cases are worth checking here.
980  */
981 }
void bms_free(Bitmapset *a)
Definition: bitmapset.c:208
#define ERROR
Definition: elog.h:33
#define elog(elevel,...)
Definition: elog.h:218
void ExecReScan(PlanState *node)
Definition: execAmi.c:78
void ExecSetTupleBound(int64 tuples_needed, PlanState *child_node)
Definition: execProcnode.c:842
void ExecEndNode(PlanState *node)
Definition: execProcnode.c:556
static TupleTableSlot * ExecProcNodeInstr(PlanState *node)
Definition: execProcnode.c:473
Node * MultiExecProcNode(PlanState *node)
Definition: execProcnode.c:501
static TupleTableSlot * ExecProcNodeFirst(PlanState *node)
Definition: execProcnode.c:442
void ExecSetExecProcNode(PlanState *node, ExecProcNodeMtd function)
Definition: execProcnode.c:424
PlanState * ExecInitNode(Plan *node, EState *estate, int eflags)
Definition: execProcnode.c:141
bool ExecShutdownNode(PlanState *node)
Definition: execProcnode.c:772
#define outerPlanState(node)
Definition: execnodes.h:1063
TupleTableSlot *(* ExecProcNodeMtd)(struct PlanState *pstate)
Definition: execnodes.h:954
Instrumentation * InstrAlloc(int n, int instrument_options, bool async_mode)
Definition: instrument.c:31
void InstrStartNode(Instrumentation *instr)
Definition: instrument.c:68
void InstrStopNode(Instrumentation *instr, double nTuples)
Definition: instrument.c:84
int i
Definition: isn.c:73
Assert(fmt[strlen(fmt) - 1] !='\n')
List * lappend(List *list, void *datum)
Definition: list.c:336
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:120
AggState * ExecInitAgg(Agg *node, EState *estate, int eflags)
Definition: nodeAgg.c:3155
void ExecEndAgg(AggState *node)
Definition: nodeAgg.c:4271
void ExecEndAppend(AppendState *node)
Definition: nodeAppend.c:395
AppendState * ExecInitAppend(Append *node, EState *estate, int eflags)
Definition: nodeAppend.c:109
Node * MultiExecBitmapAnd(BitmapAndState *node)
void ExecEndBitmapAnd(BitmapAndState *node)
BitmapAndState * ExecInitBitmapAnd(BitmapAnd *node, EState *estate, int eflags)
Definition: nodeBitmapAnd.c:55
void ExecEndBitmapHeapScan(BitmapHeapScanState *node)
BitmapHeapScanState * ExecInitBitmapHeapScan(BitmapHeapScan *node, EState *estate, int eflags)
BitmapIndexScanState * ExecInitBitmapIndexScan(BitmapIndexScan *node, EState *estate, int eflags)
void ExecEndBitmapIndexScan(BitmapIndexScanState *node)
Node * MultiExecBitmapIndexScan(BitmapIndexScanState *node)
void ExecEndBitmapOr(BitmapOrState *node)
Definition: nodeBitmapOr.c:196
BitmapOrState * ExecInitBitmapOr(BitmapOr *node, EState *estate, int eflags)
Definition: nodeBitmapOr.c:56
Node * MultiExecBitmapOr(BitmapOrState *node)
Definition: nodeBitmapOr.c:111
CteScanState * ExecInitCteScan(CteScan *node, EState *estate, int eflags)
Definition: nodeCtescan.c:175
void ExecEndCteScan(CteScanState *node)
Definition: nodeCtescan.c:288
void ExecShutdownCustomScan(CustomScanState *node)
Definition: nodeCustom.c:222
CustomScanState * ExecInitCustomScan(CustomScan *cscan, EState *estate, int eflags)
Definition: nodeCustom.c:29
void ExecEndCustomScan(CustomScanState *node)
Definition: nodeCustom.c:119
void ExecShutdownForeignScan(ForeignScanState *node)
ForeignScanState * ExecInitForeignScan(ForeignScan *node, EState *estate, int eflags)
void ExecEndForeignScan(ForeignScanState *node)
bool planstate_tree_walker(PlanState *planstate, bool(*walker)(), void *context)
Definition: nodeFuncs.c:3992
FunctionScanState * ExecInitFunctionScan(FunctionScan *node, EState *estate, int eflags)
void ExecEndFunctionScan(FunctionScanState *node)
GatherMergeState * ExecInitGatherMerge(GatherMerge *node, EState *estate, int eflags)
void ExecShutdownGatherMerge(GatherMergeState *node)
void ExecEndGatherMerge(GatherMergeState *node)
void ExecEndGather(GatherState *node)
Definition: nodeGather.c:249
GatherState * ExecInitGather(Gather *node, EState *estate, int eflags)
Definition: nodeGather.c:58
void ExecShutdownGather(GatherState *node)
Definition: nodeGather.c:419
GroupState * ExecInitGroup(Group *node, EState *estate, int eflags)
Definition: nodeGroup.c:162
void ExecEndGroup(GroupState *node)
Definition: nodeGroup.c:227
HashState * ExecInitHash(Hash *node, EState *estate, int eflags)
Definition: nodeHash.c:354
void ExecEndHash(HashState *node)
Definition: nodeHash.c:407
void ExecShutdownHash(HashState *node)
Definition: nodeHash.c:2661
Node * MultiExecHash(HashState *node)
Definition: nodeHash.c:106
HashJoinState * ExecInitHashJoin(HashJoin *node, EState *estate, int eflags)
Definition: nodeHashjoin.c:617
void ExecEndHashJoin(HashJoinState *node)
Definition: nodeHashjoin.c:765
void ExecShutdownHashJoin(HashJoinState *node)
IncrementalSortState * ExecInitIncrementalSort(IncrementalSort *node, EState *estate, int eflags)
void ExecEndIncrementalSort(IncrementalSortState *node)
void ExecEndIndexOnlyScan(IndexOnlyScanState *node)
IndexOnlyScanState * ExecInitIndexOnlyScan(IndexOnlyScan *node, EState *estate, int eflags)
IndexScanState * ExecInitIndexScan(IndexScan *node, EState *estate, int eflags)
void ExecEndIndexScan(IndexScanState *node)
void ExecEndLimit(LimitState *node)
Definition: nodeLimit.c:535
LimitState * ExecInitLimit(Limit *node, EState *estate, int eflags)
Definition: nodeLimit.c:448
void ExecEndLockRows(LockRowsState *node)
Definition: nodeLockRows.c:386
LockRowsState * ExecInitLockRows(LockRows *node, EState *estate, int eflags)
Definition: nodeLockRows.c:292
MaterialState * ExecInitMaterial(Material *node, EState *estate, int eflags)
Definition: nodeMaterial.c:164
void ExecEndMaterial(MaterialState *node)
Definition: nodeMaterial.c:240
MemoizeState * ExecInitMemoize(Memoize *node, EState *estate, int eflags)
Definition: nodeMemoize.c:905
void ExecEndMemoize(MemoizeState *node)
Definition: nodeMemoize.c:1030
MergeAppendState * ExecInitMergeAppend(MergeAppend *node, EState *estate, int eflags)
void ExecEndMergeAppend(MergeAppendState *node)
MergeJoinState * ExecInitMergeJoin(MergeJoin *node, EState *estate, int eflags)
void ExecEndMergeJoin(MergeJoinState *node)
void ExecEndModifyTable(ModifyTableState *node)
ModifyTableState * ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
NamedTuplestoreScanState * ExecInitNamedTuplestoreScan(NamedTuplestoreScan *node, EState *estate, int eflags)
void ExecEndNamedTuplestoreScan(NamedTuplestoreScanState *node)
void ExecEndNestLoop(NestLoopState *node)
Definition: nodeNestloop.c:362
NestLoopState * ExecInitNestLoop(NestLoop *node, EState *estate, int eflags)
Definition: nodeNestloop.c:263
ProjectSetState * ExecInitProjectSet(ProjectSet *node, EState *estate, int eflags)
void ExecEndProjectSet(ProjectSetState *node)
void ExecEndRecursiveUnion(RecursiveUnionState *node)
RecursiveUnionState * ExecInitRecursiveUnion(RecursiveUnion *node, EState *estate, int eflags)
ResultState * ExecInitResult(Result *node, EState *estate, int eflags)
Definition: nodeResult.c:181
void ExecEndResult(ResultState *node)
Definition: nodeResult.c:241
SampleScanState * ExecInitSampleScan(SampleScan *node, EState *estate, int eflags)
void ExecEndSampleScan(SampleScanState *node)
void ExecEndSeqScan(SeqScanState *node)
Definition: nodeSeqscan.c:184
SeqScanState * ExecInitSeqScan(SeqScan *node, EState *estate, int eflags)
Definition: nodeSeqscan.c:123
void ExecEndSetOp(SetOpState *node)
Definition: nodeSetOp.c:583
SetOpState * ExecInitSetOp(SetOp *node, EState *estate, int eflags)
Definition: nodeSetOp.c:481
SortState * ExecInitSort(Sort *node, EState *estate, int eflags)
Definition: nodeSort.c:214
void ExecEndSort(SortState *node)
Definition: nodeSort.c:291
SubPlanState * ExecInitSubPlan(SubPlan *subplan, PlanState *parent)
Definition: nodeSubplan.c:789
void ExecEndSubqueryScan(SubqueryScanState *node)
SubqueryScanState * ExecInitSubqueryScan(SubqueryScan *node, EState *estate, int eflags)
void ExecEndTableFuncScan(TableFuncScanState *node)
TableFuncScanState * ExecInitTableFuncScan(TableFuncScan *node, EState *estate, int eflags)
TidRangeScanState * ExecInitTidRangeScan(TidRangeScan *node, EState *estate, int eflags)
void ExecEndTidRangeScan(TidRangeScanState *node)
void ExecEndTidScan(TidScanState *node)
Definition: nodeTidscan.c:468
TidScanState * ExecInitTidScan(TidScan *node, EState *estate, int eflags)
Definition: nodeTidscan.c:498
void ExecEndUnique(UniqueState *node)
Definition: nodeUnique.c:169
UniqueState * ExecInitUnique(Unique *node, EState *estate, int eflags)
Definition: nodeUnique.c:115
ValuesScanState * ExecInitValuesScan(ValuesScan *node, EState *estate, int eflags)
void ExecEndValuesScan(ValuesScanState *node)
WindowAggState * ExecInitWindowAgg(WindowAgg *node, EState *estate, int eflags)
void ExecEndWindowAgg(WindowAggState *node)
WorkTableScanState * ExecInitWorkTableScan(WorkTableScan *node, EState *estate, int eflags)
void ExecEndWorkTableScan(WorkTableScanState *node)
#define IsA(nodeptr, _type_)
Definition: nodes.h:589
#define nodeTag(nodeptr)
Definition: nodes.h:543
@ T_Unique
Definition: nodes.h:83
@ T_HashJoinState
Definition: nodes.h:134
@ T_NamedTuplestoreScan
Definition: nodes.h:68
@ T_WorkTableScanState
Definition: nodes.h:128
@ T_MergeAppendState
Definition: nodes.h:109
@ T_IndexOnlyScanState
Definition: nodes.h:117
@ T_SeqScanState
Definition: nodes.h:114
@ T_ValuesScanState
Definition: nodes.h:125
@ T_CustomScanState
Definition: nodes.h:130
@ T_TidRangeScan
Definition: nodes.h:62
@ T_TableFuncScan
Definition: nodes.h:66
@ T_HashState
Definition: nodes.h:145
@ T_FunctionScan
Definition: nodes.h:64
@ T_TidRangeScanState
Definition: nodes.h:121
@ T_GroupState
Definition: nodes.h:139
@ T_BitmapOr
Definition: nodes.h:53
@ T_Material
Definition: nodes.h:76
@ T_SampleScanState
Definition: nodes.h:115
@ T_IndexOnlyScan
Definition: nodes.h:58
@ T_Append
Definition: nodes.h:49
@ T_Gather
Definition: nodes.h:84
@ T_BitmapIndexScan
Definition: nodes.h:59
@ T_SortState
Definition: nodes.h:137
@ T_RecursiveUnion
Definition: nodes.h:51
@ T_IncrementalSortState
Definition: nodes.h:138
@ T_SubqueryScanState
Definition: nodes.h:122
@ T_LockRows
Definition: nodes.h:88
@ T_Hash
Definition: nodes.h:86
@ T_TidScan
Definition: nodes.h:61
@ T_CteScanState
Definition: nodes.h:126
@ T_ResultState
Definition: nodes.h:105
@ T_BitmapHeapScanState
Definition: nodes.h:119
@ T_Limit
Definition: nodes.h:89
@ T_RecursiveUnionState
Definition: nodes.h:110
@ T_MaterialState
Definition: nodes.h:135
@ T_AppendState
Definition: nodes.h:108
@ T_Memoize
Definition: nodes.h:77
@ T_LockRowsState
Definition: nodes.h:147
@ T_Sort
Definition: nodes.h:78
@ T_NamedTuplestoreScanState
Definition: nodes.h:127
@ T_SeqScan
Definition: nodes.h:55
@ T_TidScanState
Definition: nodes.h:120
@ T_ModifyTableState
Definition: nodes.h:107
@ T_AggState
Definition: nodes.h:140
@ T_ProjectSetState
Definition: nodes.h:106
@ T_GatherState
Definition: nodes.h:143
@ T_BitmapOrState
Definition: nodes.h:112
@ T_WindowAgg
Definition: nodes.h:82
@ T_FunctionScanState
Definition: nodes.h:123
@ T_SetOpState
Definition: nodes.h:146
@ T_ProjectSet
Definition: nodes.h:47
@ T_MergeJoin
Definition: nodes.h:74
@ T_UniqueState
Definition: nodes.h:142
@ T_SampleScan
Definition: nodes.h:56
@ T_ValuesScan
Definition: nodes.h:65
@ T_BitmapAnd
Definition: nodes.h:52
@ T_MemoizeState
Definition: nodes.h:136
@ T_MergeAppend
Definition: nodes.h:50
@ T_MergeJoinState
Definition: nodes.h:133
@ T_Agg
Definition: nodes.h:81
@ T_BitmapAndState
Definition: nodes.h:111
@ T_CteScan
Definition: nodes.h:67
@ T_WindowAggState
Definition: nodes.h:141
@ T_NestLoop
Definition: nodes.h:73
@ T_IncrementalSort
Definition: nodes.h:79
@ T_CustomScan
Definition: nodes.h:71
@ T_Group
Definition: nodes.h:80
@ T_ModifyTable
Definition: nodes.h:48
@ T_GatherMerge
Definition: nodes.h:85
@ T_NestLoopState
Definition: nodes.h:132
@ T_TableFuncScanState
Definition: nodes.h:124
@ T_BitmapIndexScanState
Definition: nodes.h:118
@ T_SubqueryScan
Definition: nodes.h:63
@ T_IndexScanState
Definition: nodes.h:116
@ T_SetOp
Definition: nodes.h:87
@ T_GatherMergeState
Definition: nodes.h:144
@ T_ForeignScanState
Definition: nodes.h:129
@ T_Result
Definition: nodes.h:46
@ T_LimitState
Definition: nodes.h:148
@ T_IndexScan
Definition: nodes.h:57
@ T_BitmapHeapScan
Definition: nodes.h:60
@ T_WorkTableScan
Definition: nodes.h:69
@ T_ForeignScan
Definition: nodes.h:70
@ T_HashJoin
Definition: nodes.h:75
#define lfirst(lc)
Definition: pg_list.h:169
#define NIL
Definition: pg_list.h:65
void check_stack_depth(void)
Definition: postgres.c:3470
Definition: plannodes.h:864
PlanState ** appendplans
Definition: execnodes.h:1255
int es_instrument
Definition: execnodes.h:608
int64 tuples_needed
Definition: execnodes.h:2469
Definition: pg_list.h:51
PlanState ** mergeplans
Definition: execnodes.h:1298
Definition: nodes.h:539
Instrumentation * instrument
Definition: execnodes.h:977
ExecProcNodeMtd ExecProcNodeReal
Definition: execnodes.h:974
ExprState * qual
Definition: execnodes.h:988
List * initPlan
Definition: execnodes.h:992
Bitmapset * chgParam
Definition: execnodes.h:999
bool async_capable
Definition: execnodes.h:1009
ExecProcNodeMtd ExecProcNode
Definition: execnodes.h:973
List * initPlan
Definition: plannodes.h:145
PlanState ps
Definition: execnodes.h:1378
bool bounded
Definition: execnodes.h:2152
int64 bound
Definition: execnodes.h:2153
PlanState * subplan
Definition: execnodes.h:1703
#define TupIsNull(slot)
Definition: tuptable.h:292