PostgreSQL Source Code  git master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
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)
 

Function Documentation

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, NULL, 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:457
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:259
void ExecEndForeignScan(ForeignScanState *node)
void ExecEndSort(SortState *node)
Definition: nodeSort.c:228
void ExecEndBitmapIndexScan(BitmapIndexScanState *node)
void check_stack_depth(void)
Definition: postgres.c:3117
void ExecEndValuesScan(ValuesScanState *node)
void ExecEndMergeJoin(MergeJoinState *node)
void ExecEndSeqScan(SeqScanState *node)
Definition: nodeSeqscan.c:224
void ExecEndIndexOnlyScan(IndexOnlyScanState *node)
void ExecEndTidScan(TidScanState *node)
Definition: nodeTidscan.c:482
Bitmapset * chgParam
Definition: execnodes.h:875
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)
#define NULL
Definition: c.h:229
void ExecEndMergeAppend(MergeAppendState *node)
#define nodeTag(nodeptr)
Definition: nodes.h:514
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:3850
void ExecEndModifyTable(ModifyTableState *node)
void ExecEndGather(GatherState *node)
Definition: nodeGather.c:231
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, NULL, result, 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:156
#define IsA(nodeptr, _type_)
Definition: nodes.h:560
BitmapHeapScanState * ExecInitBitmapHeapScan(BitmapHeapScan *node, EState *estate, int eflags)
Definition: nodes.h:79
Instrumentation * instrument
Definition: execnodes.h:857
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:868
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:122
return result
Definition: formatting.c:1633
Definition: nodes.h:75
GatherState * ExecInitGather(Gather *node, EState *estate, int eflags)
Definition: nodeGather.c:57
SubPlanState * ExecInitSubPlan(SubPlan *subplan, PlanState *parent)
Definition: nodeSubplan.c:691
AggState * ExecInitAgg(Agg *node, EState *estate, int eflags)
Definition: nodeAgg.c:2670
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:3117
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:853
ExecProcNodeMtd ExecProcNodeReal
Definition: execnodes.h:854
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
#define NULL
Definition: c.h:229
IndexOnlyScanState * ExecInitIndexOnlyScan(IndexOnlyScan *node, EState *estate, int eflags)
#define Assert(condition)
Definition: c.h:676
#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:514
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:165
List * initPlan
Definition: plannodes.h:148
Definition: nodes.h:80
LimitState * ExecInitLimit(Limit *node, EState *estate, int eflags)
Definition: nodeLimit.c:394
WorkTableScanState * ExecInitWorkTableScan(WorkTableScan *node, EState *estate, int eflags)
Definition: plannodes.h:780
#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
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:857
void check_stack_depth(void)
Definition: postgres.c:3117
ExecProcNodeMtd ExecProcNode
Definition: execnodes.h:853
ExecProcNodeMtd ExecProcNodeReal
Definition: execnodes.h:854
static TupleTableSlot * ExecProcNodeInstr(PlanState *node)
Definition: execProcnode.c:440
static TupleTableSlot * ExecProcNodeInstr ( PlanState node)
static

Definition at line 440 of file execProcnode.c.

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

Referenced by ExecProcNodeFirst().

441 {
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:857
return result
Definition: formatting.c:1633
void InstrStartNode(Instrumentation *instr)
Definition: instrument.c:63
#define TupIsNull(slot)
Definition: tuptable.h:138
ExecProcNodeMtd ExecProcNodeReal
Definition: execnodes.h:854
bool ExecShutdownNode ( PlanState node)

Definition at line 731 of file execProcnode.c.

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

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  default:
755  break;
756  }
757 
758  return false;
759 }
bool ExecShutdownNode(PlanState *node)
Definition: execProcnode.c:731
void ExecShutdownCustomScan(CustomScanState *node)
Definition: nodeCustom.c:213
void check_stack_depth(void)
Definition: postgres.c:3117
void ExecShutdownGather(GatherState *node)
Definition: nodeGather.c:407
void ExecShutdownGatherMerge(GatherMergeState *node)
#define NULL
Definition: c.h:229
#define nodeTag(nodeptr)
Definition: nodes.h:514
void ExecShutdownForeignScan(ForeignScanState *node)
bool planstate_tree_walker(PlanState *planstate, bool(*walker)(), void *context)
Definition: nodeFuncs.c:3697
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, NULL, result, 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:509
Node * MultiExecHash(HashState *node)
Definition: nodeHash.c:74
return result
Definition: formatting.c:1633
#define ERROR
Definition: elog.h:43
void check_stack_depth(void)
Definition: postgres.c:3117
Node * MultiExecBitmapIndexScan(BitmapIndexScanState *node)
Bitmapset * chgParam
Definition: execnodes.h:875
Node * MultiExecBitmapAnd(BitmapAndState *node)
Node * MultiExecBitmapOr(BitmapOrState *node)
Definition: nodeBitmapOr.c:111
#define NULL
Definition: c.h:229
#define nodeTag(nodeptr)
Definition: nodes.h:514
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:98
#define elog
Definition: elog.h:219