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

Go to the source code of this file.

Functions

static TupleTableSlotExecProcNodeFirst (PlanState *node)
 
static TupleTableSlotExecProcNodeInstr (PlanState *node)
 
PlanStateExecInitNode (Plan *node, EState *estate, int eflags)
 
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 523 of file execProcnode.c.

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

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

524 {
525  /*
526  * do nothing when we get to the end of a leaf on tree.
527  */
528  if (node == NULL)
529  return;
530 
531  /*
532  * Make sure there's enough stack available. Need to check here, in
533  * addition to ExecProcNode() (via ExecProcNodeFirst()), because it's not
534  * guaranteed that ExecProcNode() is reached for all nodes.
535  */
537 
538  if (node->chgParam != NULL)
539  {
540  bms_free(node->chgParam);
541  node->chgParam = NULL;
542  }
543 
544  switch (nodeTag(node))
545  {
546  /*
547  * control nodes
548  */
549  case T_ResultState:
550  ExecEndResult((ResultState *) node);
551  break;
552 
553  case T_ProjectSetState:
555  break;
556 
557  case T_ModifyTableState:
559  break;
560 
561  case T_AppendState:
562  ExecEndAppend((AppendState *) node);
563  break;
564 
565  case T_MergeAppendState:
567  break;
568 
571  break;
572 
573  case T_BitmapAndState:
575  break;
576 
577  case T_BitmapOrState:
578  ExecEndBitmapOr((BitmapOrState *) node);
579  break;
580 
581  /*
582  * scan nodes
583  */
584  case T_SeqScanState:
585  ExecEndSeqScan((SeqScanState *) node);
586  break;
587 
588  case T_SampleScanState:
590  break;
591 
592  case T_GatherState:
593  ExecEndGather((GatherState *) node);
594  break;
595 
596  case T_GatherMergeState:
598  break;
599 
600  case T_IndexScanState:
602  break;
603 
606  break;
607 
610  break;
611 
614  break;
615 
616  case T_TidScanState:
617  ExecEndTidScan((TidScanState *) node);
618  break;
619 
620  case T_SubqueryScanState:
622  break;
623 
624  case T_FunctionScanState:
626  break;
627 
630  break;
631 
632  case T_ValuesScanState:
634  break;
635 
636  case T_CteScanState:
637  ExecEndCteScan((CteScanState *) node);
638  break;
639 
642  break;
643 
646  break;
647 
648  case T_ForeignScanState:
650  break;
651 
652  case T_CustomScanState:
654  break;
655 
656  /*
657  * join nodes
658  */
659  case T_NestLoopState:
660  ExecEndNestLoop((NestLoopState *) node);
661  break;
662 
663  case T_MergeJoinState:
665  break;
666 
667  case T_HashJoinState:
668  ExecEndHashJoin((HashJoinState *) node);
669  break;
670 
671  /*
672  * materialization nodes
673  */
674  case T_MaterialState:
675  ExecEndMaterial((MaterialState *) node);
676  break;
677 
678  case T_SortState:
679  ExecEndSort((SortState *) node);
680  break;
681 
682  case T_GroupState:
683  ExecEndGroup((GroupState *) node);
684  break;
685 
686  case T_AggState:
687  ExecEndAgg((AggState *) node);
688  break;
689 
690  case T_WindowAggState:
692  break;
693 
694  case T_UniqueState:
695  ExecEndUnique((UniqueState *) node);
696  break;
697 
698  case T_HashState:
699  ExecEndHash((HashState *) node);
700  break;
701 
702  case T_SetOpState:
703  ExecEndSetOp((SetOpState *) node);
704  break;
705 
706  case T_LockRowsState:
707  ExecEndLockRows((LockRowsState *) node);
708  break;
709 
710  case T_LimitState:
711  ExecEndLimit((LimitState *) node);
712  break;
713 
714  default:
715  elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
716  break;
717  }
718 }
void ExecEndGroup(GroupState *node)
Definition: nodeGroup.c:231
void ExecEndSetOp(SetOpState *node)
Definition: nodeSetOp.c:582
void ExecEndFunctionScan(FunctionScanState *node)
void ExecEndNestLoop(NestLoopState *node)
Definition: nodeNestloop.c:366
void ExecEndIndexScan(IndexScanState *node)
void ExecEndLimit(LimitState *node)
Definition: nodeLimit.c:393
void ExecEndUnique(UniqueState *node)
Definition: nodeUnique.c:178
void ExecEndGatherMerge(GatherMergeState *node)
void ExecEndWorkTableScan(WorkTableScanState *node)
void ExecEndLockRows(LockRowsState *node)
Definition: nodeLockRows.c:451
void ExecEndNamedTuplestoreScan(NamedTuplestoreScanState *node)
void ExecEndBitmapAnd(BitmapAndState *node)
void ExecEndRecursiveUnion(RecursiveUnionState *node)
void ExecEndSubqueryScan(SubqueryScanState *node)
void ExecEndHashJoin(HashJoinState *node)
Definition: nodeHashjoin.c:551
void ExecEndTableFuncScan(TableFuncScanState *node)
void ExecEndResult(ResultState *node)
Definition: nodeResult.c:246
#define ERROR
Definition: elog.h:43
void ExecEndAppend(AppendState *node)
Definition: nodeAppend.c:236
void ExecEndForeignScan(ForeignScanState *node)
void ExecEndSort(SortState *node)
Definition: nodeSort.c:238
void ExecEndBitmapIndexScan(BitmapIndexScanState *node)
void check_stack_depth(void)
Definition: postgres.c:3150
void ExecEndValuesScan(ValuesScanState *node)
void ExecEndMergeJoin(MergeJoinState *node)
void ExecEndSeqScan(SeqScanState *node)
Definition: nodeSeqscan.c:225
void ExecEndIndexOnlyScan(IndexOnlyScanState *node)
void ExecEndTidScan(TidScanState *node)
Definition: nodeTidscan.c:482
Bitmapset * chgParam
Definition: execnodes.h:878
void ExecEndCteScan(CteScanState *node)
Definition: nodeCtescan.c:280
void ExecEndCustomScan(CustomScanState *node)
Definition: nodeCustom.c:122
void ExecEndBitmapOr(BitmapOrState *node)
Definition: nodeBitmapOr.c:196
void ExecEndSampleScan(SampleScanState *node)
void bms_free(Bitmapset *a)
Definition: bitmapset.c:201
void ExecEndWindowAgg(WindowAggState *node)
void ExecEndMergeAppend(MergeAppendState *node)
#define nodeTag(nodeptr)
Definition: nodes.h:517
void ExecEndHash(HashState *node)
Definition: nodeHash.c:219
void ExecEndProjectSet(ProjectSetState *node)
void ExecEndMaterial(MaterialState *node)
Definition: nodeMaterial.c:244
#define elog
Definition: elog.h:219
void ExecEndBitmapHeapScan(BitmapHeapScanState *node)
void ExecEndAgg(AggState *node)
Definition: nodeAgg.c:3946
void ExecEndModifyTable(ModifyTableState *node)
void ExecEndGather(GatherState *node)
Definition: nodeGather.c:238

◆ ExecInitNode()

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

Definition at line 139 of file execProcnode.c.

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

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

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

◆ ExecProcNodeFirst()

static TupleTableSlot * ExecProcNodeFirst ( PlanState node)
static

Definition at line 409 of file execProcnode.c.

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

Referenced by ExecInitNode().

410 {
411  /*
412  * Perform stack depth check during the first execution of the node. We
413  * only do so the first time round because it turns out to not be cheap on
414  * some common architectures (eg. x86). This relies on the assumption
415  * that ExecProcNode calls for a given plan node will always be made at
416  * roughly the same stack depth.
417  */
419 
420  /*
421  * If instrumentation is required, change the wrapper to one that just
422  * does instrumentation. Otherwise we can dispense with all wrappers and
423  * have ExecProcNode() directly call the relevant function from now on.
424  */
425  if (node->instrument)
427  else
428  node->ExecProcNode = node->ExecProcNodeReal;
429 
430  return node->ExecProcNode(node);
431 }
Instrumentation * instrument
Definition: execnodes.h:860
void check_stack_depth(void)
Definition: postgres.c:3150
ExecProcNodeMtd ExecProcNode
Definition: execnodes.h:856
ExecProcNodeMtd ExecProcNodeReal
Definition: execnodes.h:857
static TupleTableSlot * ExecProcNodeInstr(PlanState *node)
Definition: execProcnode.c:440

◆ ExecProcNodeInstr()

static TupleTableSlot * ExecProcNodeInstr ( PlanState node)
static

Definition at line 440 of file execProcnode.c.

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

Referenced by ExecProcNodeFirst().

441 {
442  TupleTableSlot *result;
443 
444  InstrStartNode(node->instrument);
445 
446  result = node->ExecProcNodeReal(node);
447 
448  InstrStopNode(node->instrument, TupIsNull(result) ? 0.0 : 1.0);
449 
450  return result;
451 }
void InstrStopNode(Instrumentation *instr, double nTuples)
Definition: instrument.c:80
Instrumentation * instrument
Definition: execnodes.h:860
void InstrStartNode(Instrumentation *instr)
Definition: instrument.c:63
#define TupIsNull(slot)
Definition: tuptable.h:138
ExecProcNodeMtd ExecProcNodeReal
Definition: execnodes.h:857

◆ ExecSetTupleBound()

void ExecSetTupleBound ( int64  tuples_needed,
PlanState child_node 
)

Definition at line 781 of file execProcnode.c.

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

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

782 {
783  /*
784  * Since this function recurses, in principle we should check stack depth
785  * here. In practice, it's probably pointless since the earlier node
786  * initialization tree traversal would surely have consumed more stack.
787  */
788 
789  if (IsA(child_node, SortState))
790  {
791  /*
792  * If it is a Sort node, notify it that it can use bounded sort.
793  *
794  * Note: it is the responsibility of nodeSort.c to react properly to
795  * changes of these parameters. If we ever redesign this, it'd be a
796  * good idea to integrate this signaling with the parameter-change
797  * mechanism.
798  */
799  SortState *sortState = (SortState *) child_node;
800 
801  if (tuples_needed < 0)
802  {
803  /* make sure flag gets reset if needed upon rescan */
804  sortState->bounded = false;
805  }
806  else
807  {
808  sortState->bounded = true;
809  sortState->bound = tuples_needed;
810  }
811  }
812  else if (IsA(child_node, MergeAppendState))
813  {
814  /*
815  * If it is a MergeAppend, we can apply the bound to any nodes that
816  * are children of the MergeAppend, since the MergeAppend surely need
817  * read no more than that many tuples from any one input.
818  */
819  MergeAppendState *maState = (MergeAppendState *) child_node;
820  int i;
821 
822  for (i = 0; i < maState->ms_nplans; i++)
823  ExecSetTupleBound(tuples_needed, maState->mergeplans[i]);
824  }
825  else if (IsA(child_node, ResultState))
826  {
827  /*
828  * Similarly, for a projecting Result, we can apply the bound to its
829  * child node.
830  *
831  * If Result supported qual checking, we'd have to punt on seeing a
832  * qual. Note that having a resconstantqual is not a showstopper: if
833  * that condition succeeds it affects nothing, while if it fails, no
834  * rows will be demanded from the Result child anyway.
835  */
836  if (outerPlanState(child_node))
837  ExecSetTupleBound(tuples_needed, outerPlanState(child_node));
838  }
839  else if (IsA(child_node, SubqueryScanState))
840  {
841  /*
842  * We can also descend through SubqueryScan, but only if it has no
843  * qual (otherwise it might discard rows).
844  */
845  SubqueryScanState *subqueryState = (SubqueryScanState *) child_node;
846 
847  if (subqueryState->ss.ps.qual == NULL)
848  ExecSetTupleBound(tuples_needed, subqueryState->subplan);
849  }
850  else if (IsA(child_node, GatherState))
851  {
852  /*
853  * A Gather node can propagate the bound to its workers. As with
854  * MergeAppend, no one worker could possibly need to return more
855  * tuples than the Gather itself needs to.
856  *
857  * Note: As with Sort, the Gather node is responsible for reacting
858  * properly to changes to this parameter.
859  */
860  GatherState *gstate = (GatherState *) child_node;
861 
862  gstate->tuples_needed = tuples_needed;
863 
864  /* Also pass down the bound to our own copy of the child plan */
865  ExecSetTupleBound(tuples_needed, outerPlanState(child_node));
866  }
867  else if (IsA(child_node, GatherMergeState))
868  {
869  /* Same comments as for Gather */
870  GatherMergeState *gstate = (GatherMergeState *) child_node;
871 
872  gstate->tuples_needed = tuples_needed;
873 
874  ExecSetTupleBound(tuples_needed, outerPlanState(child_node));
875  }
876 
877  /*
878  * In principle we could descend through any plan node type that is
879  * certain not to discard or combine input rows; but on seeing a node that
880  * can do that, we can't propagate the bound any further. For the moment
881  * it's unclear that any other cases are worth checking here.
882  */
883 }
#define IsA(nodeptr, _type_)
Definition: nodes.h:563
bool bounded
Definition: execnodes.h:1774
int64 bound
Definition: execnodes.h:1775
void ExecSetTupleBound(int64 tuples_needed, PlanState *child_node)
Definition: execProcnode.c:781
PlanState ps
Definition: execnodes.h:1113
#define outerPlanState(node)
Definition: execnodes.h:896
PlanState ** mergeplans
Definition: execnodes.h:1035
PlanState * subplan
Definition: execnodes.h:1417
ExprState * qual
Definition: execnodes.h:868
int i
int64 tuples_needed
Definition: execnodes.h:1950

◆ ExecShutdownNode()

bool ExecShutdownNode ( PlanState node)

Definition at line 731 of file execProcnode.c.

References check_stack_depth(), ExecShutdownCustomScan(), ExecShutdownForeignScan(), ExecShutdownGather(), ExecShutdownGatherMerge(), ExecShutdownHash(), ExecShutdownNode(), nodeTag, planstate_tree_walker(), T_CustomScanState, T_ForeignScanState, T_GatherMergeState, T_GatherState, and T_HashState.

Referenced by ExecShutdownNode(), and ExecutePlan().

732 {
733  if (node == NULL)
734  return false;
735 
737 
739 
740  switch (nodeTag(node))
741  {
742  case T_GatherState:
744  break;
745  case T_ForeignScanState:
747  break;
748  case T_CustomScanState:
750  break;
751  case T_GatherMergeState:
753  break;
754  case T_HashState:
755  ExecShutdownHash((HashState *) node);
756  break;
757  default:
758  break;
759  }
760 
761  return false;
762 }
bool ExecShutdownNode(PlanState *node)
Definition: execProcnode.c:731
void ExecShutdownCustomScan(CustomScanState *node)
Definition: nodeCustom.c:229
void ExecShutdownHash(HashState *node)
Definition: nodeHash.c:1706
void check_stack_depth(void)
Definition: postgres.c:3150
void ExecShutdownGather(GatherState *node)
Definition: nodeGather.c:392
void ExecShutdownGatherMerge(GatherMergeState *node)
#define nodeTag(nodeptr)
Definition: nodes.h:517
void ExecShutdownForeignScan(ForeignScanState *node)
bool planstate_tree_walker(PlanState *planstate, bool(*walker)(), void *context)
Definition: nodeFuncs.c:3697

◆ MultiExecProcNode()

Node* MultiExecProcNode ( PlanState node)

Definition at line 468 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(), ExecHashJoin(), MultiExecBitmapAnd(), and MultiExecBitmapOr().

469 {
470  Node *result;
471 
473 
475 
476  if (node->chgParam != NULL) /* something changed */
477  ExecReScan(node); /* let ReScan handle this */
478 
479  switch (nodeTag(node))
480  {
481  /*
482  * Only node types that actually support multiexec will be listed
483  */
484 
485  case T_HashState:
486  result = MultiExecHash((HashState *) node);
487  break;
488 
491  break;
492 
493  case T_BitmapAndState:
494  result = MultiExecBitmapAnd((BitmapAndState *) node);
495  break;
496 
497  case T_BitmapOrState:
498  result = MultiExecBitmapOr((BitmapOrState *) node);
499  break;
500 
501  default:
502  elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
503  result = NULL;
504  break;
505  }
506 
507  return result;
508 }
void ExecReScan(PlanState *node)
Definition: execAmi.c:76
Definition: nodes.h:512
Node * MultiExecHash(HashState *node)
Definition: nodeHash.c:74
#define ERROR
Definition: elog.h:43
void check_stack_depth(void)
Definition: postgres.c:3150
Node * MultiExecBitmapIndexScan(BitmapIndexScanState *node)
Bitmapset * chgParam
Definition: execnodes.h:878
Node * MultiExecBitmapAnd(BitmapAndState *node)
Node * MultiExecBitmapOr(BitmapOrState *node)
Definition: nodeBitmapOr.c:111
#define nodeTag(nodeptr)
Definition: nodes.h:517
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:98
#define elog
Definition: elog.h:219