>From 34dabe294394c878186a3e33a248f85097b12c33 Mon Sep 17 00:00:00 2001 From: Kyotaro Horiguchi Date: Wed, 8 Jul 2015 11:48:12 +0900 Subject: [PATCH 1/6] Add infrastructure for executor node run state. This infrastructure expands the node state from what ResultNode did to general form having four states. The states are Inited, Started, Running and Done. Running and Done are the same as what rs_done of ResultNode indicated. Inited state indiates that the node has been initialized but not executed. Started state indicates that the node has been executed but the first tuple have not received yet. Running indicates that the node is returning tuples and Done indicates that the node has no more tuple to return. The nodes Group, ModifyTable, SetOp and WindowAgg had their own run-state management so they are moved to this infrastructure by this patch. --- src/backend/commands/explain.c | 2 +- src/backend/executor/nodeAgg.c | 1 + src/backend/executor/nodeAppend.c | 1 + src/backend/executor/nodeBitmapAnd.c | 1 + src/backend/executor/nodeBitmapHeapscan.c | 1 + src/backend/executor/nodeBitmapIndexscan.c | 1 + src/backend/executor/nodeBitmapOr.c | 1 + src/backend/executor/nodeCtescan.c | 1 + src/backend/executor/nodeCustom.c | 1 + src/backend/executor/nodeForeignscan.c | 1 + src/backend/executor/nodeFunctionscan.c | 1 + src/backend/executor/nodeGroup.c | 14 +++++++++----- src/backend/executor/nodeHash.c | 1 + src/backend/executor/nodeHashjoin.c | 1 + src/backend/executor/nodeIndexonlyscan.c | 1 + src/backend/executor/nodeIndexscan.c | 1 + src/backend/executor/nodeLimit.c | 1 + src/backend/executor/nodeLockRows.c | 1 + src/backend/executor/nodeMaterial.c | 1 + src/backend/executor/nodeMergeAppend.c | 1 + src/backend/executor/nodeMergejoin.c | 1 + src/backend/executor/nodeModifyTable.c | 9 ++++++--- src/backend/executor/nodeNestloop.c | 1 + src/backend/executor/nodeRecursiveunion.c | 1 + src/backend/executor/nodeResult.c | 1 + src/backend/executor/nodeSamplescan.c | 1 + src/backend/executor/nodeSeqscan.c | 1 + src/backend/executor/nodeSetOp.c | 20 ++++++++++++-------- src/backend/executor/nodeSort.c | 1 + src/backend/executor/nodeSubqueryscan.c | 1 + src/backend/executor/nodeTidscan.c | 1 + src/backend/executor/nodeUnique.c | 1 + src/backend/executor/nodeValuesscan.c | 1 + src/backend/executor/nodeWindowAgg.c | 12 ++++++++---- src/backend/executor/nodeWorktablescan.c | 1 + src/include/nodes/execnodes.h | 26 ++++++++++++++++++++++---- 36 files changed, 88 insertions(+), 25 deletions(-) diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c index 0d1ecc2..86e3b5a 100644 --- a/src/backend/commands/explain.c +++ b/src/backend/commands/explain.c @@ -2116,7 +2116,7 @@ static void show_sort_info(SortState *sortstate, ExplainState *es) { Assert(IsA(sortstate, SortState)); - if (es->analyze && sortstate->sort_Done && + if (es->analyze && ExecNode_is_done(sortstate) && sortstate->tuplesortstate != NULL) { Tuplesortstate *state = (Tuplesortstate *) sortstate->tuplesortstate; diff --git a/src/backend/executor/nodeAgg.c b/src/backend/executor/nodeAgg.c index 2bf48c5..a48cd81 100644 --- a/src/backend/executor/nodeAgg.c +++ b/src/backend/executor/nodeAgg.c @@ -1968,6 +1968,7 @@ ExecInitAgg(Agg *node, EState *estate, int eflags) aggstate = makeNode(AggState); aggstate->ss.ps.plan = (Plan *) node; aggstate->ss.ps.state = estate; + SetNodeRunState(aggstate, Inited); aggstate->aggs = NIL; aggstate->numaggs = 0; diff --git a/src/backend/executor/nodeAppend.c b/src/backend/executor/nodeAppend.c index 2cffef8..4718c0f 100644 --- a/src/backend/executor/nodeAppend.c +++ b/src/backend/executor/nodeAppend.c @@ -140,6 +140,7 @@ ExecInitAppend(Append *node, EState *estate, int eflags) */ appendstate->ps.plan = (Plan *) node; appendstate->ps.state = estate; + SetNodeRunState(appendstate, Inited); appendstate->appendplans = appendplanstates; appendstate->as_nplans = nplans; diff --git a/src/backend/executor/nodeBitmapAnd.c b/src/backend/executor/nodeBitmapAnd.c index 205980e..8bc5bbe 100644 --- a/src/backend/executor/nodeBitmapAnd.c +++ b/src/backend/executor/nodeBitmapAnd.c @@ -63,6 +63,7 @@ ExecInitBitmapAnd(BitmapAnd *node, EState *estate, int eflags) */ bitmapandstate->ps.plan = (Plan *) node; bitmapandstate->ps.state = estate; + SetNodeRunState(bitmapandstate, Inited); bitmapandstate->bitmapplans = bitmapplanstates; bitmapandstate->nplans = nplans; diff --git a/src/backend/executor/nodeBitmapHeapscan.c b/src/backend/executor/nodeBitmapHeapscan.c index 4597437..8d10e28 100644 --- a/src/backend/executor/nodeBitmapHeapscan.c +++ b/src/backend/executor/nodeBitmapHeapscan.c @@ -555,6 +555,7 @@ ExecInitBitmapHeapScan(BitmapHeapScan *node, EState *estate, int eflags) scanstate = makeNode(BitmapHeapScanState); scanstate->ss.ps.plan = (Plan *) node; scanstate->ss.ps.state = estate; + SetNodeRunState(scanstate, Inited); scanstate->tbm = NULL; scanstate->tbmiterator = NULL; diff --git a/src/backend/executor/nodeBitmapIndexscan.c b/src/backend/executor/nodeBitmapIndexscan.c index 77fc1e5..613054f 100644 --- a/src/backend/executor/nodeBitmapIndexscan.c +++ b/src/backend/executor/nodeBitmapIndexscan.c @@ -206,6 +206,7 @@ ExecInitBitmapIndexScan(BitmapIndexScan *node, EState *estate, int eflags) indexstate = makeNode(BitmapIndexScanState); indexstate->ss.ps.plan = (Plan *) node; indexstate->ss.ps.state = estate; + SetNodeRunState(indexstate, Inited); /* normally we don't make the result bitmap till runtime */ indexstate->biss_result = NULL; diff --git a/src/backend/executor/nodeBitmapOr.c b/src/backend/executor/nodeBitmapOr.c index 353a5b6..fcdaeaf 100644 --- a/src/backend/executor/nodeBitmapOr.c +++ b/src/backend/executor/nodeBitmapOr.c @@ -64,6 +64,7 @@ ExecInitBitmapOr(BitmapOr *node, EState *estate, int eflags) */ bitmaporstate->ps.plan = (Plan *) node; bitmaporstate->ps.state = estate; + SetNodeRunState(bitmaporstate, Inited); bitmaporstate->bitmapplans = bitmapplanstates; bitmaporstate->nplans = nplans; diff --git a/src/backend/executor/nodeCtescan.c b/src/backend/executor/nodeCtescan.c index 75c1ab3..666ef91 100644 --- a/src/backend/executor/nodeCtescan.c +++ b/src/backend/executor/nodeCtescan.c @@ -191,6 +191,7 @@ ExecInitCteScan(CteScan *node, EState *estate, int eflags) scanstate = makeNode(CteScanState); scanstate->ss.ps.plan = (Plan *) node; scanstate->ss.ps.state = estate; + SetNodeRunState(scanstate, Inited); scanstate->eflags = eflags; scanstate->cte_table = NULL; scanstate->eof_cte = false; diff --git a/src/backend/executor/nodeCustom.c b/src/backend/executor/nodeCustom.c index 0a022df..e7e3b17 100644 --- a/src/backend/executor/nodeCustom.c +++ b/src/backend/executor/nodeCustom.c @@ -43,6 +43,7 @@ ExecInitCustomScan(CustomScan *cscan, EState *estate, int eflags) /* fill up fields of ScanState */ css->ss.ps.plan = &cscan->scan.plan; css->ss.ps.state = estate; + SetNodeRunState(css, Inited); /* create expression context for node */ ExecAssignExprContext(estate, &css->ss.ps); diff --git a/src/backend/executor/nodeForeignscan.c b/src/backend/executor/nodeForeignscan.c index bb28a73..3ba4196 100644 --- a/src/backend/executor/nodeForeignscan.c +++ b/src/backend/executor/nodeForeignscan.c @@ -116,6 +116,7 @@ ExecInitForeignScan(ForeignScan *node, EState *estate, int eflags) scanstate = makeNode(ForeignScanState); scanstate->ss.ps.plan = (Plan *) node; scanstate->ss.ps.state = estate; + SetNodeRunState(scanstate, Inited); /* * Miscellaneous initialization diff --git a/src/backend/executor/nodeFunctionscan.c b/src/backend/executor/nodeFunctionscan.c index f5fa2b3..849b54f 100644 --- a/src/backend/executor/nodeFunctionscan.c +++ b/src/backend/executor/nodeFunctionscan.c @@ -299,6 +299,7 @@ ExecInitFunctionScan(FunctionScan *node, EState *estate, int eflags) scanstate = makeNode(FunctionScanState); scanstate->ss.ps.plan = (Plan *) node; scanstate->ss.ps.state = estate; + SetNodeRunState(scanstate, Inited); scanstate->eflags = eflags; /* diff --git a/src/backend/executor/nodeGroup.c b/src/backend/executor/nodeGroup.c index 5e47854..1a8f669 100644 --- a/src/backend/executor/nodeGroup.c +++ b/src/backend/executor/nodeGroup.c @@ -40,10 +40,13 @@ ExecGroup(GroupState *node) TupleTableSlot *firsttupleslot; TupleTableSlot *outerslot; + /* Advance the state to running if just after initialized */ + AdvanceNodeRunStateTo(node, Running); + /* * get state info from node */ - if (node->grp_done) + if (ExecNode_is_done(node)) return NULL; econtext = node->ss.ps.ps_ExprContext; numCols = ((Group *) node->ss.ps.plan)->numCols; @@ -86,7 +89,7 @@ ExecGroup(GroupState *node) if (TupIsNull(outerslot)) { /* empty input, so return nothing */ - node->grp_done = TRUE; + SetNodeRunState(node, Done); return NULL; } /* Copy tuple into firsttupleslot */ @@ -138,7 +141,7 @@ ExecGroup(GroupState *node) if (TupIsNull(outerslot)) { /* no more groups, so we're done */ - node->grp_done = TRUE; + SetNodeRunState(node, Done); return NULL; } @@ -207,7 +210,7 @@ ExecInitGroup(Group *node, EState *estate, int eflags) grpstate = makeNode(GroupState); grpstate->ss.ps.plan = (Plan *) node; grpstate->ss.ps.state = estate; - grpstate->grp_done = FALSE; + SetNodeRunState(grpstate, Inited); /* * create expression context @@ -282,7 +285,6 @@ ExecReScanGroup(GroupState *node) { PlanState *outerPlan = outerPlanState(node); - node->grp_done = FALSE; node->ss.ps.ps_TupFromTlist = false; /* must clear first tuple */ ExecClearTuple(node->ss.ss_ScanTupleSlot); @@ -293,4 +295,6 @@ ExecReScanGroup(GroupState *node) */ if (outerPlan->chgParam == NULL) ExecReScan(outerPlan); + + SetNodeRunState(node, Inited); } diff --git a/src/backend/executor/nodeHash.c b/src/backend/executor/nodeHash.c index 906cb46..d388e17 100644 --- a/src/backend/executor/nodeHash.c +++ b/src/backend/executor/nodeHash.c @@ -182,6 +182,7 @@ ExecInitHash(Hash *node, EState *estate, int eflags) hashstate = makeNode(HashState); hashstate->ps.plan = (Plan *) node; hashstate->ps.state = estate; + SetNodeRunState(hashstate, Inited); hashstate->hashtable = NULL; hashstate->hashkeys = NIL; /* will be set by parent HashJoin */ diff --git a/src/backend/executor/nodeHashjoin.c b/src/backend/executor/nodeHashjoin.c index 1d78cdf..064421e 100644 --- a/src/backend/executor/nodeHashjoin.c +++ b/src/backend/executor/nodeHashjoin.c @@ -451,6 +451,7 @@ ExecInitHashJoin(HashJoin *node, EState *estate, int eflags) hjstate = makeNode(HashJoinState); hjstate->js.ps.plan = (Plan *) node; hjstate->js.ps.state = estate; + SetNodeRunState(hjstate, Inited); /* * Miscellaneous initialization diff --git a/src/backend/executor/nodeIndexonlyscan.c b/src/backend/executor/nodeIndexonlyscan.c index 9f54c46..0e84314 100644 --- a/src/backend/executor/nodeIndexonlyscan.c +++ b/src/backend/executor/nodeIndexonlyscan.c @@ -403,6 +403,7 @@ ExecInitIndexOnlyScan(IndexOnlyScan *node, EState *estate, int eflags) indexstate = makeNode(IndexOnlyScanState); indexstate->ss.ps.plan = (Plan *) node; indexstate->ss.ps.state = estate; + SetNodeRunState(indexstate, Inited); indexstate->ioss_HeapFetches = 0; /* diff --git a/src/backend/executor/nodeIndexscan.c b/src/backend/executor/nodeIndexscan.c index c0f14db..534d2f4 100644 --- a/src/backend/executor/nodeIndexscan.c +++ b/src/backend/executor/nodeIndexscan.c @@ -828,6 +828,7 @@ ExecInitIndexScan(IndexScan *node, EState *estate, int eflags) indexstate = makeNode(IndexScanState); indexstate->ss.ps.plan = (Plan *) node; indexstate->ss.ps.state = estate; + SetNodeRunState(indexstate, Inited); /* * Miscellaneous initialization diff --git a/src/backend/executor/nodeLimit.c b/src/backend/executor/nodeLimit.c index 40ac0d7..1b675d4 100644 --- a/src/backend/executor/nodeLimit.c +++ b/src/backend/executor/nodeLimit.c @@ -384,6 +384,7 @@ ExecInitLimit(Limit *node, EState *estate, int eflags) limitstate = makeNode(LimitState); limitstate->ps.plan = (Plan *) node; limitstate->ps.state = estate; + SetNodeRunState(limitstate, Inited); limitstate->lstate = LIMIT_INITIAL; diff --git a/src/backend/executor/nodeLockRows.c b/src/backend/executor/nodeLockRows.c index b9b0f06..eeeca0b 100644 --- a/src/backend/executor/nodeLockRows.c +++ b/src/backend/executor/nodeLockRows.c @@ -365,6 +365,7 @@ ExecInitLockRows(LockRows *node, EState *estate, int eflags) lrstate = makeNode(LockRowsState); lrstate->ps.plan = (Plan *) node; lrstate->ps.state = estate; + SetNodeRunState(lrstate, Inited); /* * Miscellaneous initialization diff --git a/src/backend/executor/nodeMaterial.c b/src/backend/executor/nodeMaterial.c index b2b5aa7..d9a67f4 100644 --- a/src/backend/executor/nodeMaterial.c +++ b/src/backend/executor/nodeMaterial.c @@ -171,6 +171,7 @@ ExecInitMaterial(Material *node, EState *estate, int eflags) matstate = makeNode(MaterialState); matstate->ss.ps.plan = (Plan *) node; matstate->ss.ps.state = estate; + SetNodeRunState(matstate, Inited); /* * We must have a tuplestore buffering the subplan output to do backward diff --git a/src/backend/executor/nodeMergeAppend.c b/src/backend/executor/nodeMergeAppend.c index bdf7680..3901255 100644 --- a/src/backend/executor/nodeMergeAppend.c +++ b/src/backend/executor/nodeMergeAppend.c @@ -83,6 +83,7 @@ ExecInitMergeAppend(MergeAppend *node, EState *estate, int eflags) */ mergestate->ps.plan = (Plan *) node; mergestate->ps.state = estate; + SetNodeRunState(mergestate, Inited); mergestate->mergeplans = mergeplanstates; mergestate->ms_nplans = nplans; diff --git a/src/backend/executor/nodeMergejoin.c b/src/backend/executor/nodeMergejoin.c index 34b6cf6..9970db1 100644 --- a/src/backend/executor/nodeMergejoin.c +++ b/src/backend/executor/nodeMergejoin.c @@ -1485,6 +1485,7 @@ ExecInitMergeJoin(MergeJoin *node, EState *estate, int eflags) mergestate = makeNode(MergeJoinState); mergestate->js.ps.plan = (Plan *) node; mergestate->js.ps.state = estate; + SetNodeRunState(mergestate, Inited); /* * Miscellaneous initialization diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index 874ca6a..25fa109 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -1269,6 +1269,9 @@ ExecModifyTable(ModifyTableState *node) HeapTupleData oldtupdata; HeapTuple oldtuple; + /* Advance the state to running if just after initialized */ + AdvanceNodeRunStateTo(node, Running); + /* * This should NOT get called during EvalPlanQual; we should have passed a * subplan tree to EvalPlanQual, instead. Use a runtime test not just @@ -1287,7 +1290,7 @@ ExecModifyTable(ModifyTableState *node) * our subplan's nodes aren't necessarily robust against being called * extra times. */ - if (node->mt_done) + if (ExecNode_is_done(node)) return NULL; /* @@ -1464,7 +1467,7 @@ ExecModifyTable(ModifyTableState *node) */ fireASTriggers(node); - node->mt_done = true; + SetNodeRunState(node, Done); return NULL; } @@ -1495,11 +1498,11 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags) mtstate = makeNode(ModifyTableState); mtstate->ps.plan = (Plan *) node; mtstate->ps.state = estate; + SetNodeRunState(mtstate, Inited); mtstate->ps.targetlist = NIL; /* not actually used */ mtstate->operation = operation; mtstate->canSetTag = node->canSetTag; - mtstate->mt_done = false; mtstate->mt_plans = (PlanState **) palloc0(sizeof(PlanState *) * nplans); mtstate->resultRelInfo = estate->es_result_relations + node->resultRelIndex; diff --git a/src/backend/executor/nodeNestloop.c b/src/backend/executor/nodeNestloop.c index e66bcda..b4c2f26 100644 --- a/src/backend/executor/nodeNestloop.c +++ b/src/backend/executor/nodeNestloop.c @@ -309,6 +309,7 @@ ExecInitNestLoop(NestLoop *node, EState *estate, int eflags) nlstate = makeNode(NestLoopState); nlstate->js.ps.plan = (Plan *) node; nlstate->js.ps.state = estate; + SetNodeRunState(nlstate, Inited); /* * Miscellaneous initialization diff --git a/src/backend/executor/nodeRecursiveunion.c b/src/backend/executor/nodeRecursiveunion.c index 8df1639..118496e 100644 --- a/src/backend/executor/nodeRecursiveunion.c +++ b/src/backend/executor/nodeRecursiveunion.c @@ -176,6 +176,7 @@ ExecInitRecursiveUnion(RecursiveUnion *node, EState *estate, int eflags) rustate = makeNode(RecursiveUnionState); rustate->ps.plan = (Plan *) node; rustate->ps.state = estate; + SetNodeRunState(rustate, Inited); rustate->eqfunctions = NULL; rustate->hashfunctions = NULL; diff --git a/src/backend/executor/nodeResult.c b/src/backend/executor/nodeResult.c index 8d3dde0..b4ee402 100644 --- a/src/backend/executor/nodeResult.c +++ b/src/backend/executor/nodeResult.c @@ -217,6 +217,7 @@ ExecInitResult(Result *node, EState *estate, int eflags) resstate = makeNode(ResultState); resstate->ps.plan = (Plan *) node; resstate->ps.state = estate; + SetNodeRunState(resstate, Inited); resstate->rs_done = false; resstate->rs_checkqual = (node->resconstantqual == NULL) ? false : true; diff --git a/src/backend/executor/nodeSamplescan.c b/src/backend/executor/nodeSamplescan.c index 4c1c523..e88735a 100644 --- a/src/backend/executor/nodeSamplescan.c +++ b/src/backend/executor/nodeSamplescan.c @@ -153,6 +153,7 @@ ExecInitSampleScan(SampleScan *node, EState *estate, int eflags) scanstate = makeNode(SampleScanState); scanstate->ss.ps.plan = (Plan *) node; scanstate->ss.ps.state = estate; + SetNodeRunState(scanstate, Inited); /* * Miscellaneous initialization diff --git a/src/backend/executor/nodeSeqscan.c b/src/backend/executor/nodeSeqscan.c index 3cb81fc..259b79a 100644 --- a/src/backend/executor/nodeSeqscan.c +++ b/src/backend/executor/nodeSeqscan.c @@ -169,6 +169,7 @@ ExecInitSeqScan(SeqScan *node, EState *estate, int eflags) scanstate = makeNode(SeqScanState); scanstate->ps.plan = (Plan *) node; scanstate->ps.state = estate; + SetNodeRunState(scanstate, Inited); /* * Miscellaneous initialization diff --git a/src/backend/executor/nodeSetOp.c b/src/backend/executor/nodeSetOp.c index 7d00cc5..123d051 100644 --- a/src/backend/executor/nodeSetOp.c +++ b/src/backend/executor/nodeSetOp.c @@ -197,6 +197,9 @@ ExecSetOp(SetOpState *node) SetOp *plannode = (SetOp *) node->ps.plan; TupleTableSlot *resultTupleSlot = node->ps.ps_ResultTupleSlot; + /* Advance the state to running if just after initialized */ + AdvanceNodeRunStateTo(node, Running); + /* * If the previously-returned tuple needs to be returned more than once, * keep returning it. @@ -208,7 +211,7 @@ ExecSetOp(SetOpState *node) } /* Otherwise, we're done if we are out of groups */ - if (node->setop_done) + if (ExecNode_is_done(node)) return NULL; /* Fetch the next tuple group according to the correct strategy */ @@ -244,7 +247,7 @@ setop_retrieve_direct(SetOpState *setopstate) /* * We loop retrieving groups until we find one we should return */ - while (!setopstate->setop_done) + while (ExecNode_is_running(setopstate)) { /* * If we don't already have the first tuple of the new group, fetch it @@ -261,7 +264,7 @@ setop_retrieve_direct(SetOpState *setopstate) else { /* outer plan produced no tuples at all */ - setopstate->setop_done = true; + SetNodeRunState(setopstate, Done); return NULL; } } @@ -293,7 +296,7 @@ setop_retrieve_direct(SetOpState *setopstate) if (TupIsNull(outerslot)) { /* no more outer-plan tuples available */ - setopstate->setop_done = true; + SetNodeRunState(setopstate, Done); break; } @@ -433,7 +436,7 @@ setop_retrieve_hash_table(SetOpState *setopstate) /* * We loop retrieving groups until we find one we should return */ - while (!setopstate->setop_done) + while (ExecNode_is_running(setopstate)) { /* * Find the next entry in the hash table @@ -442,7 +445,7 @@ setop_retrieve_hash_table(SetOpState *setopstate) if (entry == NULL) { /* No more entries in hashtable, so done */ - setopstate->setop_done = true; + SetNodeRunState(setopstate, Done); return NULL; } @@ -490,7 +493,7 @@ ExecInitSetOp(SetOp *node, EState *estate, int eflags) setopstate->eqfunctions = NULL; setopstate->hashfunctions = NULL; - setopstate->setop_done = false; + SetNodeRunState(setopstate, Inited); setopstate->numOutput = 0; setopstate->pergroup = NULL; setopstate->grp_firstTuple = NULL; @@ -601,7 +604,6 @@ void ExecReScanSetOp(SetOpState *node) { ExecClearTuple(node->ps.ps_ResultTupleSlot); - node->setop_done = false; node->numOutput = 0; if (((SetOp *) node->ps.plan)->strategy == SETOP_HASHED) @@ -651,4 +653,6 @@ ExecReScanSetOp(SetOpState *node) */ if (node->ps.lefttree->chgParam == NULL) ExecReScan(node->ps.lefttree); + + SetNodeRunState(node, Inited); } diff --git a/src/backend/executor/nodeSort.c b/src/backend/executor/nodeSort.c index af1dccf..3ae5b89 100644 --- a/src/backend/executor/nodeSort.c +++ b/src/backend/executor/nodeSort.c @@ -162,6 +162,7 @@ ExecInitSort(Sort *node, EState *estate, int eflags) sortstate = makeNode(SortState); sortstate->ss.ps.plan = (Plan *) node; sortstate->ss.ps.state = estate; + SetNodeRunState(sortstate, Inited); /* * We must have random access to the sort output to do backward scan or diff --git a/src/backend/executor/nodeSubqueryscan.c b/src/backend/executor/nodeSubqueryscan.c index e5d1e54..497d6df 100644 --- a/src/backend/executor/nodeSubqueryscan.c +++ b/src/backend/executor/nodeSubqueryscan.c @@ -117,6 +117,7 @@ ExecInitSubqueryScan(SubqueryScan *node, EState *estate, int eflags) subquerystate = makeNode(SubqueryScanState); subquerystate->ss.ps.plan = (Plan *) node; subquerystate->ss.ps.state = estate; + SetNodeRunState(subquerystate, Inited); /* * Miscellaneous initialization diff --git a/src/backend/executor/nodeTidscan.c b/src/backend/executor/nodeTidscan.c index 203f1ac..f19e735 100644 --- a/src/backend/executor/nodeTidscan.c +++ b/src/backend/executor/nodeTidscan.c @@ -461,6 +461,7 @@ ExecInitTidScan(TidScan *node, EState *estate, int eflags) tidstate = makeNode(TidScanState); tidstate->ss.ps.plan = (Plan *) node; tidstate->ss.ps.state = estate; + SetNodeRunState(tidstate, Inited); /* * Miscellaneous initialization diff --git a/src/backend/executor/nodeUnique.c b/src/backend/executor/nodeUnique.c index 1cb4a8a..f259f32 100644 --- a/src/backend/executor/nodeUnique.c +++ b/src/backend/executor/nodeUnique.c @@ -122,6 +122,7 @@ ExecInitUnique(Unique *node, EState *estate, int eflags) uniquestate = makeNode(UniqueState); uniquestate->ps.plan = (Plan *) node; uniquestate->ps.state = estate; + SetNodeRunState(uniquestate, Inited); /* * Miscellaneous initialization diff --git a/src/backend/executor/nodeValuesscan.c b/src/backend/executor/nodeValuesscan.c index a39695a..c56199c 100644 --- a/src/backend/executor/nodeValuesscan.c +++ b/src/backend/executor/nodeValuesscan.c @@ -205,6 +205,7 @@ ExecInitValuesScan(ValuesScan *node, EState *estate, int eflags) scanstate = makeNode(ValuesScanState); scanstate->ss.ps.plan = (Plan *) node; scanstate->ss.ps.state = estate; + SetNodeRunState(scanstate, Inited); /* * Miscellaneous initialization diff --git a/src/backend/executor/nodeWindowAgg.c b/src/backend/executor/nodeWindowAgg.c index ecf96f8..b91d4e6 100644 --- a/src/backend/executor/nodeWindowAgg.c +++ b/src/backend/executor/nodeWindowAgg.c @@ -1564,7 +1564,10 @@ ExecWindowAgg(WindowAggState *winstate) int i; int numfuncs; - if (winstate->all_done) + /* Advance the state to running if just after initialized */ + AdvanceNodeRunStateTo(winstate, Running); + + if (ExecNode_is_done(winstate)) return NULL; /* @@ -1686,7 +1689,7 @@ restart: } else { - winstate->all_done = true; + SetNodeRunState(winstate, Done); return NULL; } } @@ -1787,6 +1790,7 @@ ExecInitWindowAgg(WindowAgg *node, EState *estate, int eflags) winstate = makeNode(WindowAggState); winstate->ss.ps.plan = (Plan *) node; winstate->ss.ps.state = estate; + SetNodeRunState(winstate, Inited); /* * Create expression contexts. We need two, one for per-input-tuple @@ -2060,8 +2064,6 @@ ExecReScanWindowAgg(WindowAggState *node) PlanState *outerPlan = outerPlanState(node); ExprContext *econtext = node->ss.ps.ps_ExprContext; - node->all_done = false; - node->ss.ps.ps_TupFromTlist = false; node->all_first = true; @@ -2085,6 +2087,8 @@ ExecReScanWindowAgg(WindowAggState *node) */ if (outerPlan->chgParam == NULL) ExecReScan(outerPlan); + + SetNodeRunState(node, Inited); } /* diff --git a/src/backend/executor/nodeWorktablescan.c b/src/backend/executor/nodeWorktablescan.c index 618508e..799e96b 100644 --- a/src/backend/executor/nodeWorktablescan.c +++ b/src/backend/executor/nodeWorktablescan.c @@ -144,6 +144,7 @@ ExecInitWorkTableScan(WorkTableScan *node, EState *estate, int eflags) scanstate = makeNode(WorkTableScanState); scanstate->ss.ps.plan = (Plan *) node; scanstate->ss.ps.state = estate; + SetNodeRunState(scanstate, Inited); scanstate->rustate = NULL; /* we'll set this later */ /* diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 541ee18..4066341 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -344,6 +344,27 @@ typedef struct ResultRelInfo } ResultRelInfo; /* ---------------- + * Enumeration and macros for executor node running state. + */ +typedef enum ExecNodeRunState +{ + ERunState_Inited, /* Just after initialized */ + ERunState_Started, /* Execution started but needs one more call + * for the first tuple */ + ERunState_Running, /* Returning the next tuple */ + ERunState_Done /* No tuple to return */ +} ExecNodeRunState; + +#define SetNodeRunState(nd,st) (((PlanState*)nd)->runstate = (ERunState_##st)) +#define AdvanceNodeRunStateTo(nd,st) \ + do {\ + if (((PlanState*)nd)->runstate < (ERunState_##st))\ + ((PlanState*)nd)->runstate = (ERunState_##st);\ + } while(0); +#define ExecNode_is_running(nd) (((PlanState*)nd)->runstate == ERunState_Running) +#define ExecNode_is_done(nd) (((PlanState*)nd)->runstate == ERunState_Done) + +/* ---------------- * EState information * * Master working state for an Executor invocation @@ -1059,6 +1080,7 @@ typedef struct PlanState ProjectionInfo *ps_ProjInfo; /* info for doing tuple projection */ bool ps_TupFromTlist;/* state flag for processing set-valued * functions in targetlist */ + ExecNodeRunState runstate; /* Execution state of this node */ } PlanState; /* ---------------- @@ -1120,7 +1142,6 @@ typedef struct ModifyTableState PlanState ps; /* its first field is NodeTag */ CmdType operation; /* INSERT, UPDATE, or DELETE */ bool canSetTag; /* do we set the command tag/es_processed? */ - bool mt_done; /* are we done? */ PlanState **mt_plans; /* subplans (one per target rel) */ int mt_nplans; /* number of plans in the array */ int mt_whichplan; /* which one is being executed (0..n-1) */ @@ -1799,7 +1820,6 @@ typedef struct GroupState { ScanState ss; /* its first field is NodeTag */ FmgrInfo *eqfunctions; /* per-field lookup data for equality fns */ - bool grp_done; /* indicates completion of Group scan */ } GroupState; /* --------------------- @@ -1901,7 +1921,6 @@ typedef struct WindowAggState ExprContext *tmpcontext; /* short-term evaluation context */ bool all_first; /* true if the scan is starting */ - bool all_done; /* true if the scan is finished */ bool partition_spooled; /* true if all tuples in current * partition have been spooled into * tuplestore */ @@ -1968,7 +1987,6 @@ typedef struct SetOpState PlanState ps; /* its first field is NodeTag */ FmgrInfo *eqfunctions; /* per-grouping-field equality fns */ FmgrInfo *hashfunctions; /* per-grouping-field hash fns */ - bool setop_done; /* indicates completion of output scan */ long numOutput; /* number of dups left to output */ MemoryContext tempContext; /* short-term context for comparisons */ /* these fields are used in SETOP_SORTED mode: */ -- 1.8.3.1