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

Go to the source code of this file.

Functions

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

Function Documentation

◆ ExecEndNode()

void ExecEndNode ( PlanState node)

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

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

◆ ExecInitNode()

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

Definition at line 139 of file execProcnode.c.

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

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

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

◆ ExecProcNodeFirst()

static TupleTableSlot * ExecProcNodeFirst ( PlanState node)
static

Definition at line 425 of file execProcnode.c.

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

Referenced by ExecSetExecProcNode().

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

◆ ExecProcNodeInstr()

static TupleTableSlot * ExecProcNodeInstr ( PlanState node)
static

Definition at line 456 of file execProcnode.c.

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

Referenced by ExecProcNodeFirst().

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

◆ ExecSetExecProcNode()

void ExecSetExecProcNode ( PlanState node,
ExecProcNodeMtd  function 
)

Definition at line 406 of file execProcnode.c.

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

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

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

◆ ExecSetTupleBound()

void ExecSetTupleBound ( int64  tuples_needed,
PlanState child_node 
)

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

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

◆ ExecShutdownNode()

bool ExecShutdownNode ( PlanState node)

Definition at line 747 of file execProcnode.c.

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

Referenced by ExecShutdownNode(), and ExecutePlan().

748 {
749  if (node == NULL)
750  return false;
751 
753 
755 
756  switch (nodeTag(node))
757  {
758  case T_GatherState:
760  break;
761  case T_ForeignScanState:
763  break;
764  case T_CustomScanState:
766  break;
767  case T_GatherMergeState:
769  break;
770  case T_HashState:
771  ExecShutdownHash((HashState *) node);
772  break;
773  case T_HashJoinState:
775  break;
776  default:
777  break;
778  }
779 
780  return false;
781 }
bool ExecShutdownNode(PlanState *node)
Definition: execProcnode.c:747
void ExecShutdownCustomScan(CustomScanState *node)
Definition: nodeCustom.c:225
void ExecShutdownHashJoin(HashJoinState *node)
void ExecShutdownHash(HashState *node)
Definition: nodeHash.c:2604
void check_stack_depth(void)
Definition: postgres.c:3154
void ExecShutdownGather(GatherState *node)
Definition: nodeGather.c:396
void ExecShutdownGatherMerge(GatherMergeState *node)
#define nodeTag(nodeptr)
Definition: nodes.h:518
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 484 of file execProcnode.c.

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

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

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