PostgreSQL Source Code: src/backend/executor/execProcnode.c Source File

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-2025, 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"
79#include "executor/nodeBitmapHeapscan.h"
80#include "executor/nodeBitmapIndexscan.h"
81#include "executor/nodeBitmapOr.h"
82#include "executor/nodeCtescan.h"
83#include "executor/nodeCustom.h"
84#include "executor/nodeForeignscan.h"
85#include "executor/nodeFunctionscan.h"
86#include "executor/nodeGather.h"
87#include "executor/nodeGatherMerge.h"
88#include "executor/nodeGroup.h"
89#include "executor/nodeHash.h"
90#include "executor/nodeHashjoin.h"
91#include "executor/nodeIncrementalSort.h"
92#include "executor/nodeIndexonlyscan.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"
98#include "executor/nodeMergeAppend.h"
99#include "executor/nodeMergejoin.h"
100#include "executor/nodeModifyTable.h"
101#include "executor/nodeNamedtuplestorescan.h"
102#include "executor/nodeNestloop.h"
103#include "executor/nodeProjectSet.h"
104#include "executor/nodeRecursiveunion.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"
111#include "executor/nodeSubqueryscan.h"
112#include "executor/nodeTableFuncscan.h"
113#include "executor/nodeTidrangescan.h"
114#include "executor/nodeTidscan.h"
115#include "executor/nodeUnique.h"
116#include "executor/nodeValuesscan.h"
117#include "executor/nodeWindowAgg.h"
118#include "executor/nodeWorktablescan.h"
119#include "miscadmin.h"
120#include "nodes/nodeFuncs.h"
121
122static TupleTableSlot *ExecProcNodeFirst(PlanState *node);
123static TupleTableSlot *ExecProcNodeInstr(PlanState *node);
124static bool ExecShutdownNode_walker(PlanState *node, void *context);
125
126
127/* ------------------------------------------------------------------------
128 * ExecInitNode
129 *
130 * Recursively initializes all the nodes in the plan tree rooted
131 * at 'node'.
132 *
133 * Inputs:
134 * 'node' is the current node of the plan produced by the query planner
135 * 'estate' is the shared execution state for the plan tree
136 * 'eflags' is a bitwise OR of flag bits described in executor.h
137 *
138 * Returns a PlanState node corresponding to the given Plan node.
139 * ------------------------------------------------------------------------
140 */
141PlanState *
142 ExecInitNode(Plan *node, EState *estate, int eflags)
143{
144 PlanState *result;
145 List *subps;
146 ListCell *l;
147
148 /*
149 * do nothing when we get to the end of a leaf on tree.
150 */
151 if (node == NULL)
152 return NULL;
153
154 /*
155 * Make sure there's enough stack available. Need to check here, in
156 * addition to ExecProcNode() (via ExecProcNodeFirst()), to ensure the
157 * stack isn't overrun while initializing the node tree.
158 */
159 check_stack_depth();
160
161 switch (nodeTag(node))
162 {
163 /*
164 * control nodes
165 */
166 case T_Result:
167 result = (PlanState *) ExecInitResult((Result *) node,
168 estate, eflags);
169 break;
170
171 case T_ProjectSet:
172 result = (PlanState *) ExecInitProjectSet((ProjectSet *) node,
173 estate, eflags);
174 break;
175
176 case T_ModifyTable:
177 result = (PlanState *) ExecInitModifyTable((ModifyTable *) node,
178 estate, eflags);
179 break;
180
181 case T_Append:
182 result = (PlanState *) ExecInitAppend((Append *) node,
183 estate, eflags);
184 break;
185
186 case T_MergeAppend:
187 result = (PlanState *) ExecInitMergeAppend((MergeAppend *) node,
188 estate, eflags);
189 break;
190
191 case T_RecursiveUnion:
192 result = (PlanState *) ExecInitRecursiveUnion((RecursiveUnion *) node,
193 estate, eflags);
194 break;
195
196 case T_BitmapAnd:
197 result = (PlanState *) ExecInitBitmapAnd((BitmapAnd *) node,
198 estate, eflags);
199 break;
200
201 case T_BitmapOr:
202 result = (PlanState *) ExecInitBitmapOr((BitmapOr *) node,
203 estate, eflags);
204 break;
205
206 /*
207 * scan nodes
208 */
209 case T_SeqScan:
210 result = (PlanState *) ExecInitSeqScan((SeqScan *) node,
211 estate, eflags);
212 break;
213
214 case T_SampleScan:
215 result = (PlanState *) ExecInitSampleScan((SampleScan *) node,
216 estate, eflags);
217 break;
218
219 case T_IndexScan:
220 result = (PlanState *) ExecInitIndexScan((IndexScan *) node,
221 estate, eflags);
222 break;
223
224 case T_IndexOnlyScan:
225 result = (PlanState *) ExecInitIndexOnlyScan((IndexOnlyScan *) node,
226 estate, eflags);
227 break;
228
229 case T_BitmapIndexScan:
230 result = (PlanState *) ExecInitBitmapIndexScan((BitmapIndexScan *) node,
231 estate, eflags);
232 break;
233
234 case T_BitmapHeapScan:
235 result = (PlanState *) ExecInitBitmapHeapScan((BitmapHeapScan *) node,
236 estate, eflags);
237 break;
238
239 case T_TidScan:
240 result = (PlanState *) ExecInitTidScan((TidScan *) node,
241 estate, eflags);
242 break;
243
244 case T_TidRangeScan:
245 result = (PlanState *) ExecInitTidRangeScan((TidRangeScan *) node,
246 estate, eflags);
247 break;
248
249 case T_SubqueryScan:
250 result = (PlanState *) ExecInitSubqueryScan((SubqueryScan *) node,
251 estate, eflags);
252 break;
253
254 case T_FunctionScan:
255 result = (PlanState *) ExecInitFunctionScan((FunctionScan *) node,
256 estate, eflags);
257 break;
258
259 case T_TableFuncScan:
260 result = (PlanState *) ExecInitTableFuncScan((TableFuncScan *) node,
261 estate, eflags);
262 break;
263
264 case T_ValuesScan:
265 result = (PlanState *) ExecInitValuesScan((ValuesScan *) node,
266 estate, eflags);
267 break;
268
269 case T_CteScan:
270 result = (PlanState *) ExecInitCteScan((CteScan *) node,
271 estate, eflags);
272 break;
273
274 case T_NamedTuplestoreScan:
275 result = (PlanState *) ExecInitNamedTuplestoreScan((NamedTuplestoreScan *) node,
276 estate, eflags);
277 break;
278
279 case T_WorkTableScan:
280 result = (PlanState *) ExecInitWorkTableScan((WorkTableScan *) node,
281 estate, eflags);
282 break;
283
284 case T_ForeignScan:
285 result = (PlanState *) ExecInitForeignScan((ForeignScan *) node,
286 estate, eflags);
287 break;
288
289 case T_CustomScan:
290 result = (PlanState *) ExecInitCustomScan((CustomScan *) node,
291 estate, eflags);
292 break;
293
294 /*
295 * join nodes
296 */
297 case T_NestLoop:
298 result = (PlanState *) ExecInitNestLoop((NestLoop *) node,
299 estate, eflags);
300 break;
301
302 case T_MergeJoin:
303 result = (PlanState *) ExecInitMergeJoin((MergeJoin *) node,
304 estate, eflags);
305 break;
306
307 case T_HashJoin:
308 result = (PlanState *) ExecInitHashJoin((HashJoin *) node,
309 estate, eflags);
310 break;
311
312 /*
313 * materialization nodes
314 */
315 case T_Material:
316 result = (PlanState *) ExecInitMaterial((Material *) node,
317 estate, eflags);
318 break;
319
320 case T_Sort:
321 result = (PlanState *) ExecInitSort((Sort *) node,
322 estate, eflags);
323 break;
324
325 case T_IncrementalSort:
326 result = (PlanState *) ExecInitIncrementalSort((IncrementalSort *) node,
327 estate, eflags);
328 break;
329
330 case T_Memoize:
331 result = (PlanState *) ExecInitMemoize((Memoize *) node, estate,
332 eflags);
333 break;
334
335 case T_Group:
336 result = (PlanState *) ExecInitGroup((Group *) node,
337 estate, eflags);
338 break;
339
340 case T_Agg:
341 result = (PlanState *) ExecInitAgg((Agg *) node,
342 estate, eflags);
343 break;
344
345 case T_WindowAgg:
346 result = (PlanState *) ExecInitWindowAgg((WindowAgg *) node,
347 estate, eflags);
348 break;
349
350 case T_Unique:
351 result = (PlanState *) ExecInitUnique((Unique *) node,
352 estate, eflags);
353 break;
354
355 case T_Gather:
356 result = (PlanState *) ExecInitGather((Gather *) node,
357 estate, eflags);
358 break;
359
360 case T_GatherMerge:
361 result = (PlanState *) ExecInitGatherMerge((GatherMerge *) node,
362 estate, eflags);
363 break;
364
365 case T_Hash:
366 result = (PlanState *) ExecInitHash((Hash *) node,
367 estate, eflags);
368 break;
369
370 case T_SetOp:
371 result = (PlanState *) ExecInitSetOp((SetOp *) node,
372 estate, eflags);
373 break;
374
375 case T_LockRows:
376 result = (PlanState *) ExecInitLockRows((LockRows *) node,
377 estate, eflags);
378 break;
379
380 case T_Limit:
381 result = (PlanState *) ExecInitLimit((Limit *) node,
382 estate, eflags);
383 break;
384
385 default:
386 elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
387 result = NULL; /* keep compiler quiet */
388 break;
389 }
390
391 ExecSetExecProcNode(result, result->ExecProcNode);
392
393 /*
394 * Initialize any initPlans present in this node. The planner put them in
395 * a separate list for us.
396 *
397 * The defining characteristic of initplans is that they don't have
398 * arguments, so we don't need to evaluate them (in contrast to
399 * ExecInitSubPlanExpr()).
400 */
401 subps = NIL;
402 foreach(l, node->initPlan)
403 {
404 SubPlan *subplan = (SubPlan *) lfirst(l);
405 SubPlanState *sstate;
406
407 Assert(IsA(subplan, SubPlan));
408 Assert(subplan->args == NIL);
409 sstate = ExecInitSubPlan(subplan, result);
410 subps = lappend(subps, sstate);
411 }
412 result->initPlan = subps;
413
414 /* Set up instrumentation for this node if requested */
415 if (estate->es_instrument)
416 result->instrument = InstrAlloc(1, estate->es_instrument,
417 result->async_capable);
418
419 return result;
420}
421
422
423/*
424 * If a node wants to change its ExecProcNode function after ExecInitNode()
425 * has finished, it should do so with this function. That way any wrapper
426 * functions can be reinstalled, without the node having to know how that
427 * works.
428 */
429void
430 ExecSetExecProcNode(PlanState *node, ExecProcNodeMtd function)
431{
432 /*
433 * Add a wrapper around the ExecProcNode callback that checks stack depth
434 * during the first execution and maybe adds an instrumentation wrapper.
435 * When the callback is changed after execution has already begun that
436 * means we'll superfluously execute ExecProcNodeFirst, but that seems ok.
437 */
438 node->ExecProcNodeReal = function;
439 node->ExecProcNode = ExecProcNodeFirst;
440}
441
442
443/*
444 * ExecProcNode wrapper that performs some one-time checks, before calling
445 * the relevant node method (possibly via an instrumentation wrapper).
446 */
447static TupleTableSlot *
448 ExecProcNodeFirst(PlanState *node)
449{
450 /*
451 * Perform stack depth check during the first execution of the node. We
452 * only do so the first time round because it turns out to not be cheap on
453 * some common architectures (eg. x86). This relies on the assumption
454 * that ExecProcNode calls for a given plan node will always be made at
455 * roughly the same stack depth.
456 */
457 check_stack_depth();
458
459 /*
460 * If instrumentation is required, change the wrapper to one that just
461 * does instrumentation. Otherwise we can dispense with all wrappers and
462 * have ExecProcNode() directly call the relevant function from now on.
463 */
464 if (node->instrument)
465 node->ExecProcNode = ExecProcNodeInstr;
466 else
467 node->ExecProcNode = node->ExecProcNodeReal;
468
469 return node->ExecProcNode(node);
470}
471
472
473/*
474 * ExecProcNode wrapper that performs instrumentation calls. By keeping
475 * this a separate function, we avoid overhead in the normal case where
476 * no instrumentation is wanted.
477 */
478static TupleTableSlot *
479 ExecProcNodeInstr(PlanState *node)
480{
481 TupleTableSlot *result;
482
483 InstrStartNode(node->instrument);
484
485 result = node->ExecProcNodeReal(node);
486
487 InstrStopNode(node->instrument, TupIsNull(result) ? 0.0 : 1.0);
488
489 return result;
490}
491
492
493/* ----------------------------------------------------------------
494 * MultiExecProcNode
495 *
496 * Execute a node that doesn't return individual tuples
497 * (it might return a hashtable, bitmap, etc). Caller should
498 * check it got back the expected kind of Node.
499 *
500 * This has essentially the same responsibilities as ExecProcNode,
501 * but it does not do InstrStartNode/InstrStopNode (mainly because
502 * it can't tell how many returned tuples to count). Each per-node
503 * function must provide its own instrumentation support.
504 * ----------------------------------------------------------------
505 */
506Node *
507 MultiExecProcNode(PlanState *node)
508{
509 Node *result;
510
511 check_stack_depth();
512
513 CHECK_FOR_INTERRUPTS();
514
515 if (node->chgParam != NULL) /* something changed */
516 ExecReScan(node); /* let ReScan handle this */
517
518 switch (nodeTag(node))
519 {
520 /*
521 * Only node types that actually support multiexec will be listed
522 */
523
524 case T_HashState:
525 result = MultiExecHash((HashState *) node);
526 break;
527
528 case T_BitmapIndexScanState:
529 result = MultiExecBitmapIndexScan((BitmapIndexScanState *) node);
530 break;
531
532 case T_BitmapAndState:
533 result = MultiExecBitmapAnd((BitmapAndState *) node);
534 break;
535
536 case T_BitmapOrState:
537 result = MultiExecBitmapOr((BitmapOrState *) node);
538 break;
539
540 default:
541 elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
542 result = NULL;
543 break;
544 }
545
546 return result;
547}
548
549
550/* ----------------------------------------------------------------
551 * ExecEndNode
552 *
553 * Recursively cleans up all the nodes in the plan rooted
554 * at 'node'.
555 *
556 * After this operation, the query plan will not be able to be
557 * processed any further. This should be called only after
558 * the query plan has been fully executed.
559 * ----------------------------------------------------------------
560 */
561void
562 ExecEndNode(PlanState *node)
563{
564 /*
565 * do nothing when we get to the end of a leaf on tree.
566 */
567 if (node == NULL)
568 return;
569
570 /*
571 * Make sure there's enough stack available. Need to check here, in
572 * addition to ExecProcNode() (via ExecProcNodeFirst()), because it's not
573 * guaranteed that ExecProcNode() is reached for all nodes.
574 */
575 check_stack_depth();
576
577 if (node->chgParam != NULL)
578 {
579 bms_free(node->chgParam);
580 node->chgParam = NULL;
581 }
582
583 switch (nodeTag(node))
584 {
585 /*
586 * control nodes
587 */
588 case T_ResultState:
589 ExecEndResult((ResultState *) node);
590 break;
591
592 case T_ProjectSetState:
593 ExecEndProjectSet((ProjectSetState *) node);
594 break;
595
596 case T_ModifyTableState:
597 ExecEndModifyTable((ModifyTableState *) node);
598 break;
599
600 case T_AppendState:
601 ExecEndAppend((AppendState *) node);
602 break;
603
604 case T_MergeAppendState:
605 ExecEndMergeAppend((MergeAppendState *) node);
606 break;
607
608 case T_RecursiveUnionState:
609 ExecEndRecursiveUnion((RecursiveUnionState *) node);
610 break;
611
612 case T_BitmapAndState:
613 ExecEndBitmapAnd((BitmapAndState *) node);
614 break;
615
616 case T_BitmapOrState:
617 ExecEndBitmapOr((BitmapOrState *) node);
618 break;
619
620 /*
621 * scan nodes
622 */
623 case T_SeqScanState:
624 ExecEndSeqScan((SeqScanState *) node);
625 break;
626
627 case T_SampleScanState:
628 ExecEndSampleScan((SampleScanState *) node);
629 break;
630
631 case T_GatherState:
632 ExecEndGather((GatherState *) node);
633 break;
634
635 case T_GatherMergeState:
636 ExecEndGatherMerge((GatherMergeState *) node);
637 break;
638
639 case T_IndexScanState:
640 ExecEndIndexScan((IndexScanState *) node);
641 break;
642
643 case T_IndexOnlyScanState:
644 ExecEndIndexOnlyScan((IndexOnlyScanState *) node);
645 break;
646
647 case T_BitmapIndexScanState:
648 ExecEndBitmapIndexScan((BitmapIndexScanState *) node);
649 break;
650
651 case T_BitmapHeapScanState:
652 ExecEndBitmapHeapScan((BitmapHeapScanState *) node);
653 break;
654
655 case T_TidScanState:
656 ExecEndTidScan((TidScanState *) node);
657 break;
658
659 case T_TidRangeScanState:
660 ExecEndTidRangeScan((TidRangeScanState *) node);
661 break;
662
663 case T_SubqueryScanState:
664 ExecEndSubqueryScan((SubqueryScanState *) node);
665 break;
666
667 case T_FunctionScanState:
668 ExecEndFunctionScan((FunctionScanState *) node);
669 break;
670
671 case T_TableFuncScanState:
672 ExecEndTableFuncScan((TableFuncScanState *) node);
673 break;
674
675 case T_CteScanState:
676 ExecEndCteScan((CteScanState *) node);
677 break;
678
679 case T_ForeignScanState:
680 ExecEndForeignScan((ForeignScanState *) node);
681 break;
682
683 case T_CustomScanState:
684 ExecEndCustomScan((CustomScanState *) node);
685 break;
686
687 /*
688 * join nodes
689 */
690 case T_NestLoopState:
691 ExecEndNestLoop((NestLoopState *) node);
692 break;
693
694 case T_MergeJoinState:
695 ExecEndMergeJoin((MergeJoinState *) node);
696 break;
697
698 case T_HashJoinState:
699 ExecEndHashJoin((HashJoinState *) node);
700 break;
701
702 /*
703 * materialization nodes
704 */
705 case T_MaterialState:
706 ExecEndMaterial((MaterialState *) node);
707 break;
708
709 case T_SortState:
710 ExecEndSort((SortState *) node);
711 break;
712
713 case T_IncrementalSortState:
714 ExecEndIncrementalSort((IncrementalSortState *) node);
715 break;
716
717 case T_MemoizeState:
718 ExecEndMemoize((MemoizeState *) node);
719 break;
720
721 case T_GroupState:
722 ExecEndGroup((GroupState *) node);
723 break;
724
725 case T_AggState:
726 ExecEndAgg((AggState *) node);
727 break;
728
729 case T_WindowAggState:
730 ExecEndWindowAgg((WindowAggState *) node);
731 break;
732
733 case T_UniqueState:
734 ExecEndUnique((UniqueState *) node);
735 break;
736
737 case T_HashState:
738 ExecEndHash((HashState *) node);
739 break;
740
741 case T_SetOpState:
742 ExecEndSetOp((SetOpState *) node);
743 break;
744
745 case T_LockRowsState:
746 ExecEndLockRows((LockRowsState *) node);
747 break;
748
749 case T_LimitState:
750 ExecEndLimit((LimitState *) node);
751 break;
752
753 /* No clean up actions for these nodes. */
754 case T_ValuesScanState:
755 case T_NamedTuplestoreScanState:
756 case T_WorkTableScanState:
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 */
771void
772 ExecShutdownNode(PlanState *node)
773{
774 (void) ExecShutdownNode_walker(node, NULL);
775}
776
777static bool
778 ExecShutdownNode_walker(PlanState *node, void *context)
779{
780 if (node == NULL)
781 return false;
782
783 check_stack_depth();
784
785 /*
786 * Treat the node as running while we shut it down, but only if it's run
787 * at least once already. We don't expect much CPU consumption during
788 * node shutdown, but in the case of Gather or Gather Merge, we may shut
789 * down workers at this stage. If so, their buffer usage will get
790 * propagated into pgBufferUsage at this point, and we want to make sure
791 * that it gets associated with the Gather node. We skip this if the node
792 * has never been executed, so as to avoid incorrectly making it appear
793 * that it has.
794 */
795 if (node->instrument && node->instrument->running)
796 InstrStartNode(node->instrument);
797
798 planstate_tree_walker(node, ExecShutdownNode_walker, context);
799
800 switch (nodeTag(node))
801 {
802 case T_GatherState:
803 ExecShutdownGather((GatherState *) node);
804 break;
805 case T_ForeignScanState:
806 ExecShutdownForeignScan((ForeignScanState *) node);
807 break;
808 case T_CustomScanState:
809 ExecShutdownCustomScan((CustomScanState *) node);
810 break;
811 case T_GatherMergeState:
812 ExecShutdownGatherMerge((GatherMergeState *) node);
813 break;
814 case T_HashState:
815 ExecShutdownHash((HashState *) node);
816 break;
817 case T_HashJoinState:
818 ExecShutdownHashJoin((HashJoinState *) node);
819 break;
820 default:
821 break;
822 }
823
824 /* Stop the node if we started it above, reporting 0 tuples. */
825 if (node->instrument && node->instrument->running)
826 InstrStopNode(node->instrument, 0);
827
828 return false;
829}
830
831/*
832 * ExecSetTupleBound
833 *
834 * Set a tuple bound for a planstate node. This lets child plan nodes
835 * optimize based on the knowledge that the maximum number of tuples that
836 * their parent will demand is limited. The tuple bound for a node may
837 * only be changed between scans (i.e., after node initialization or just
838 * before an ExecReScan call).
839 *
840 * Any negative tuples_needed value means "no limit", which should be the
841 * default assumption when this is not called at all for a particular node.
842 *
843 * Note: if this is called repeatedly on a plan tree, the exact same set
844 * of nodes must be updated with the new limit each time; be careful that
845 * only unchanging conditions are tested here.
846 */
847void
848 ExecSetTupleBound(int64 tuples_needed, PlanState *child_node)
849{
850 /*
851 * Since this function recurses, in principle we should check stack depth
852 * here. In practice, it's probably pointless since the earlier node
853 * initialization tree traversal would surely have consumed more stack.
854 */
855
856 if (IsA(child_node, SortState))
857 {
858 /*
859 * If it is a Sort node, notify it that it can use bounded sort.
860 *
861 * Note: it is the responsibility of nodeSort.c to react properly to
862 * changes of these parameters. If we ever redesign this, it'd be a
863 * good idea to integrate this signaling with the parameter-change
864 * mechanism.
865 */
866 SortState *sortState = (SortState *) child_node;
867
868 if (tuples_needed < 0)
869 {
870 /* make sure flag gets reset if needed upon rescan */
871 sortState->bounded = false;
872 }
873 else
874 {
875 sortState->bounded = true;
876 sortState->bound = tuples_needed;
877 }
878 }
879 else if (IsA(child_node, IncrementalSortState))
880 {
881 /*
882 * If it is an IncrementalSort node, notify it that it can use bounded
883 * sort.
884 *
885 * Note: it is the responsibility of nodeIncrementalSort.c to react
886 * properly to changes of these parameters. If we ever redesign this,
887 * it'd be a good idea to integrate this signaling with the
888 * parameter-change mechanism.
889 */
890 IncrementalSortState *sortState = (IncrementalSortState *) child_node;
891
892 if (tuples_needed < 0)
893 {
894 /* make sure flag gets reset if needed upon rescan */
895 sortState->bounded = false;
896 }
897 else
898 {
899 sortState->bounded = true;
900 sortState->bound = tuples_needed;
901 }
902 }
903 else if (IsA(child_node, AppendState))
904 {
905 /*
906 * If it is an Append, we can apply the bound to any nodes that are
907 * children of the Append, since the Append surely need read no more
908 * than that many tuples from any one input.
909 */
910 AppendState *aState = (AppendState *) child_node;
911 int i;
912
913 for (i = 0; i < aState->as_nplans; i++)
914 ExecSetTupleBound(tuples_needed, aState->appendplans[i]);
915 }
916 else if (IsA(child_node, MergeAppendState))
917 {
918 /*
919 * If it is a MergeAppend, we can apply the bound to any nodes that
920 * are children of the MergeAppend, since the MergeAppend surely need
921 * read no more than that many tuples from any one input.
922 */
923 MergeAppendState *maState = (MergeAppendState *) child_node;
924 int i;
925
926 for (i = 0; i < maState->ms_nplans; i++)
927 ExecSetTupleBound(tuples_needed, maState->mergeplans[i]);
928 }
929 else if (IsA(child_node, ResultState))
930 {
931 /*
932 * Similarly, for a projecting Result, we can apply the bound to its
933 * child node.
934 *
935 * If Result supported qual checking, we'd have to punt on seeing a
936 * qual. Note that having a resconstantqual is not a showstopper: if
937 * that condition succeeds it affects nothing, while if it fails, no
938 * rows will be demanded from the Result child anyway.
939 */
940 if (outerPlanState(child_node))
941 ExecSetTupleBound(tuples_needed, outerPlanState(child_node));
942 }
943 else if (IsA(child_node, SubqueryScanState))
944 {
945 /*
946 * We can also descend through SubqueryScan, but only if it has no
947 * qual (otherwise it might discard rows).
948 */
949 SubqueryScanState *subqueryState = (SubqueryScanState *) child_node;
950
951 if (subqueryState->ss.ps.qual == NULL)
952 ExecSetTupleBound(tuples_needed, subqueryState->subplan);
953 }
954 else if (IsA(child_node, GatherState))
955 {
956 /*
957 * A Gather node can propagate the bound to its workers. As with
958 * MergeAppend, no one worker could possibly need to return more
959 * tuples than the Gather itself needs to.
960 *
961 * Note: As with Sort, the Gather node is responsible for reacting
962 * properly to changes to this parameter.
963 */
964 GatherState *gstate = (GatherState *) child_node;
965
966 gstate->tuples_needed = tuples_needed;
967
968 /* Also pass down the bound to our own copy of the child plan */
969 ExecSetTupleBound(tuples_needed, outerPlanState(child_node));
970 }
971 else if (IsA(child_node, GatherMergeState))
972 {
973 /* Same comments as for Gather */
974 GatherMergeState *gstate = (GatherMergeState *) child_node;
975
976 gstate->tuples_needed = tuples_needed;
977
978 ExecSetTupleBound(tuples_needed, outerPlanState(child_node));
979 }
980
981 /*
982 * In principle we could descend through any plan node type that is
983 * certain not to discard or combine input rows; but on seeing a node that
984 * can do that, we can't propagate the bound any further. For the moment
985 * it's unclear that any other cases are worth checking here.
986 */
987}
void bms_free(Bitmapset *a)
Definition: bitmapset.c:239
int64_t int64
Definition: c.h:535
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:226
void ExecReScan(PlanState *node)
Definition: execAmi.c:77
static bool ExecShutdownNode_walker(PlanState *node, void *context)
Definition: execProcnode.c:778
Node * MultiExecProcNode(PlanState *node)
Definition: execProcnode.c:507
void ExecSetTupleBound(int64 tuples_needed, PlanState *child_node)
Definition: execProcnode.c:848
void ExecEndNode(PlanState *node)
Definition: execProcnode.c:562
PlanState * ExecInitNode(Plan *node, EState *estate, int eflags)
Definition: execProcnode.c:142
void ExecShutdownNode(PlanState *node)
Definition: execProcnode.c:772
static TupleTableSlot * ExecProcNodeInstr(PlanState *node)
Definition: execProcnode.c:479
static TupleTableSlot * ExecProcNodeFirst(PlanState *node)
Definition: execProcnode.c:448
void ExecSetExecProcNode(PlanState *node, ExecProcNodeMtd function)
Definition: execProcnode.c:430
#define outerPlanState(node)
Definition: execnodes.h:1255
TupleTableSlot *(* ExecProcNodeMtd)(PlanState *pstate)
Definition: execnodes.h:1144
Assert(PointerIsAligned(start, uint64))
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
i
int i
Definition: isn.c:77
List * lappend(List *list, void *datum)
Definition: list.c:339
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:122
void ExecEndAgg(AggState *node)
Definition: nodeAgg.c:4399
AggState * ExecInitAgg(Agg *node, EState *estate, int eflags)
Definition: nodeAgg.c:3278
void ExecEndAppend(AppendState *node)
Definition: nodeAppend.c:401
AppendState * ExecInitAppend(Append *node, EState *estate, int eflags)
Definition: nodeAppend.c:109
BitmapAndState * ExecInitBitmapAnd(BitmapAnd *node, EState *estate, int eflags)
Definition: nodeBitmapAnd.c:55
Node * MultiExecBitmapAnd(BitmapAndState *node)
Definition: nodeBitmapAnd.c:110
void ExecEndBitmapAnd(BitmapAndState *node)
Definition: nodeBitmapAnd.c:178
void ExecEndBitmapHeapScan(BitmapHeapScanState *node)
BitmapHeapScanState * ExecInitBitmapHeapScan(BitmapHeapScan *node, EState *estate, int eflags)
Node * MultiExecBitmapIndexScan(BitmapIndexScanState *node)
void ExecEndBitmapIndexScan(BitmapIndexScanState *node)
BitmapIndexScanState * ExecInitBitmapIndexScan(BitmapIndexScan *node, EState *estate, int eflags)
void ExecEndBitmapOr(BitmapOrState *node)
Definition: nodeBitmapOr.c:196
Node * MultiExecBitmapOr(BitmapOrState *node)
Definition: nodeBitmapOr.c:111
BitmapOrState * ExecInitBitmapOr(BitmapOr *node, EState *estate, int eflags)
Definition: nodeBitmapOr.c:56
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:221
void ExecEndCustomScan(CustomScanState *node)
Definition: nodeCustom.c:125
CustomScanState * ExecInitCustomScan(CustomScan *cscan, EState *estate, int eflags)
Definition: nodeCustom.c:26
ForeignScanState * ExecInitForeignScan(ForeignScan *node, EState *estate, int eflags)
void ExecShutdownForeignScan(ForeignScanState *node)
void ExecEndForeignScan(ForeignScanState *node)
#define planstate_tree_walker(ps, w, c)
Definition: nodeFuncs.h:179
FunctionScanState * ExecInitFunctionScan(FunctionScan *node, EState *estate, int eflags)
void ExecEndFunctionScan(FunctionScanState *node)
void ExecShutdownGatherMerge(GatherMergeState *node)
GatherMergeState * ExecInitGatherMerge(GatherMerge *node, EState *estate, int eflags)
void ExecEndGatherMerge(GatherMergeState *node)
void ExecEndGather(GatherState *node)
Definition: nodeGather.c:251
void ExecShutdownGather(GatherState *node)
Definition: nodeGather.c:418
GatherState * ExecInitGather(Gather *node, EState *estate, int eflags)
Definition: nodeGather.c:53
GroupState * ExecInitGroup(Group *node, EState *estate, int eflags)
Definition: nodeGroup.c:161
void ExecEndGroup(GroupState *node)
Definition: nodeGroup.c:226
Node * MultiExecHash(HashState *node)
Definition: nodeHash.c:104
HashState * ExecInitHash(Hash *node, EState *estate, int eflags)
Definition: nodeHash.c:369
void ExecEndHash(HashState *node)
Definition: nodeHash.c:426
void ExecShutdownHash(HashState *node)
Definition: nodeHash.c:2824
void ExecEndHashJoin(HashJoinState *node)
Definition: nodeHashjoin.c:948
void ExecShutdownHashJoin(HashJoinState *node)
Definition: nodeHashjoin.c:1583
HashJoinState * ExecInitHashJoin(HashJoin *node, EState *estate, int eflags)
Definition: nodeHashjoin.c:716
void ExecEndIncrementalSort(IncrementalSortState *node)
IncrementalSortState * ExecInitIncrementalSort(IncrementalSort *node, EState *estate, int eflags)
void ExecEndIndexOnlyScan(IndexOnlyScanState *node)
IndexOnlyScanState * ExecInitIndexOnlyScan(IndexOnlyScan *node, EState *estate, int eflags)
IndexScanState * ExecInitIndexScan(IndexScan *node, EState *estate, int eflags)
Definition: nodeIndexscan.c:909
void ExecEndIndexScan(IndexScanState *node)
Definition: nodeIndexscan.c:787
LimitState * ExecInitLimit(Limit *node, EState *estate, int eflags)
Definition: nodeLimit.c:447
void ExecEndLimit(LimitState *node)
Definition: nodeLimit.c:534
LockRowsState * ExecInitLockRows(LockRows *node, EState *estate, int eflags)
Definition: nodeLockRows.c:291
void ExecEndLockRows(LockRowsState *node)
Definition: nodeLockRows.c:390
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:952
void ExecEndMemoize(MemoizeState *node)
Definition: nodeMemoize.c:1080
MergeAppendState * ExecInitMergeAppend(MergeAppend *node, EState *estate, int eflags)
void ExecEndMergeAppend(MergeAppendState *node)
MergeJoinState * ExecInitMergeJoin(MergeJoin *node, EState *estate, int eflags)
void ExecEndMergeJoin(MergeJoinState *node)
ModifyTableState * ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
void ExecEndModifyTable(ModifyTableState *node)
NamedTuplestoreScanState * ExecInitNamedTuplestoreScan(NamedTuplestoreScan *node, EState *estate, int eflags)
void ExecEndNestLoop(NestLoopState *node)
Definition: nodeNestloop.c:361
NestLoopState * ExecInitNestLoop(NestLoop *node, EState *estate, int eflags)
Definition: nodeNestloop.c:262
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:180
void ExecEndResult(ResultState *node)
Definition: nodeResult.c:240
SampleScanState * ExecInitSampleScan(SampleScan *node, EState *estate, int eflags)
Definition: nodeSamplescan.c:93
void ExecEndSampleScan(SampleScanState *node)
void ExecEndSeqScan(SeqScanState *node)
Definition: nodeSeqscan.c:293
SeqScanState * ExecInitSeqScan(SeqScan *node, EState *estate, int eflags)
Definition: nodeSeqscan.c:211
void ExecEndSetOp(SetOpState *node)
Definition: nodeSetOp.c:681
SetOpState * ExecInitSetOp(SetOp *node, EState *estate, int eflags)
Definition: nodeSetOp.c:564
SortState * ExecInitSort(Sort *node, EState *estate, int eflags)
Definition: nodeSort.c:221
void ExecEndSort(SortState *node)
Definition: nodeSort.c:301
SubPlanState * ExecInitSubPlan(SubPlan *subplan, PlanState *parent)
Definition: nodeSubplan.c:807
void ExecEndSubqueryScan(SubqueryScanState *node)
SubqueryScanState * ExecInitSubqueryScan(SubqueryScan *node, EState *estate, int eflags)
void ExecEndTableFuncScan(TableFuncScanState *node)
TableFuncScanState * ExecInitTableFuncScan(TableFuncScan *node, EState *estate, int eflags)
void ExecEndTidRangeScan(TidRangeScanState *node)
TidRangeScanState * ExecInitTidRangeScan(TidRangeScan *node, EState *estate, int eflags)
TidScanState * ExecInitTidScan(TidScan *node, EState *estate, int eflags)
Definition: nodeTidscan.c:499
void ExecEndTidScan(TidScanState *node)
Definition: nodeTidscan.c:481
void ExecEndUnique(UniqueState *node)
Definition: nodeUnique.c:168
UniqueState * ExecInitUnique(Unique *node, EState *estate, int eflags)
Definition: nodeUnique.c:114
ValuesScanState * ExecInitValuesScan(ValuesScan *node, EState *estate, int eflags)
void ExecEndWindowAgg(WindowAggState *node)
WindowAggState * ExecInitWindowAgg(WindowAgg *node, EState *estate, int eflags)
WorkTableScanState * ExecInitWorkTableScan(WorkTableScan *node, EState *estate, int eflags)
#define IsA(nodeptr, _type_)
Definition: nodes.h:164
#define nodeTag(nodeptr)
Definition: nodes.h:139
on_exit_nicely_callback function
#define lfirst(lc)
Definition: pg_list.h:172
#define NIL
Definition: pg_list.h:68
void check_stack_depth(void)
Definition: stack_depth.c:95
Definition: plannodes.h:1182
int as_nplans
Definition: execnodes.h:1492
PlanState ** appendplans
Definition: execnodes.h:1491
Definition: plannodes.h:382
Definition: execnodes.h:655
int es_instrument
Definition: execnodes.h:720
int64 tuples_needed
Definition: execnodes.h:2766
int64 tuples_needed
Definition: execnodes.h:2739
Definition: plannodes.h:1153
Definition: plannodes.h:1394
bool running
Definition: instrument.h:77
Definition: plannodes.h:1471
Definition: pg_list.h:54
PlanState ** mergeplans
Definition: execnodes.h:1535
Definition: nodes.h:135
Instrumentation * instrument
Definition: execnodes.h:1169
ExecProcNodeMtd ExecProcNodeReal
Definition: execnodes.h:1166
ExprState * qual
Definition: execnodes.h:1180
List * initPlan
Definition: execnodes.h:1184
Bitmapset * chgParam
Definition: execnodes.h:1191
bool async_capable
Definition: execnodes.h:1201
ExecProcNodeMtd ExecProcNode
Definition: execnodes.h:1165
Definition: plannodes.h:177
List * initPlan
Definition: plannodes.h:227
Definition: plannodes.h:287
PlanState ps
Definition: execnodes.h:1615
Definition: plannodes.h:1419
bool bounded
Definition: execnodes.h:2398
int64 bound
Definition: execnodes.h:2399
Definition: plannodes.h:1116
List * args
Definition: primnodes.h:1124
PlanState * subplan
Definition: execnodes.h:1948
ScanState ss
Definition: execnodes.h:1947
#define TupIsNull(slot)
Definition: tuptable.h:309
Definition: pg_list.h:46

AltStyle によって変換されたページ (->オリジナル) /