Remove stray references to lefttree/righttree in the executor.
The general convention in the executor is to refer to child plans
and planstates via the outerPlan[State] and innerPlan[State]
macros, but a few places didn't do it like that. For consistency
and readability, convert all the stragglers to use the macros.
(See also commit 40f42d2a3
, which did some similar cleanup a few
years ago, but missed these cases.)
Richard Guo
Discussion: https://postgr.es/m/CAMbWs4-vYhh1xsa_veah4PUed2Xq=Ed_YH3=Mqt5A3Y=EgfCEg@mail.gmail.com
This commit is contained in:
parent
62c46eee22
commit
8821054210
|
@ -117,11 +117,11 @@ ExecReScan(PlanState *node)
|
|||
if (splan->plan->extParam != NULL)
|
||||
UpdateChangedParamSet(splan, node->chgParam);
|
||||
}
|
||||
/* Well. Now set chgParam for left/right trees. */
|
||||
if (node->lefttree != NULL)
|
||||
UpdateChangedParamSet(node->lefttree, node->chgParam);
|
||||
if (node->righttree != NULL)
|
||||
UpdateChangedParamSet(node->righttree, node->chgParam);
|
||||
/* Well. Now set chgParam for child trees. */
|
||||
if (outerPlanState(node) != NULL)
|
||||
UpdateChangedParamSet(outerPlanState(node), node->chgParam);
|
||||
if (innerPlanState(node) != NULL)
|
||||
UpdateChangedParamSet(innerPlanState(node), node->chgParam);
|
||||
}
|
||||
|
||||
/* Call expression callbacks */
|
||||
|
|
|
@ -396,7 +396,7 @@ search_plan_tree(PlanState *node, Oid table_oid,
|
|||
*/
|
||||
case T_ResultState:
|
||||
case T_LimitState:
|
||||
result = search_plan_tree(node->lefttree,
|
||||
result = search_plan_tree(outerPlanState(node),
|
||||
table_oid,
|
||||
pending_rescan);
|
||||
break;
|
||||
|
|
|
@ -3388,7 +3388,7 @@ ExecInitAgg(Agg *node, EState *estate, int eflags)
|
|||
if (phaseidx > 0)
|
||||
{
|
||||
aggnode = list_nth_node(Agg, node->chain, phaseidx - 1);
|
||||
sortnode = castNode(Sort, aggnode->plan.lefttree);
|
||||
sortnode = castNode(Sort, outerPlan(aggnode));
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
|
@ -168,13 +168,13 @@ ExecGather(PlanState *pstate)
|
|||
|
||||
/* Initialize, or re-initialize, shared state needed by workers. */
|
||||
if (!node->pei)
|
||||
node->pei = ExecInitParallelPlan(node->ps.lefttree,
|
||||
node->pei = ExecInitParallelPlan(outerPlanState(node),
|
||||
estate,
|
||||
gather->initParam,
|
||||
gather->num_workers,
|
||||
node->tuples_needed);
|
||||
else
|
||||
ExecParallelReinitialize(node->ps.lefttree,
|
||||
ExecParallelReinitialize(outerPlanState(node),
|
||||
node->pei,
|
||||
gather->initParam);
|
||||
|
||||
|
|
|
@ -212,13 +212,13 @@ ExecGatherMerge(PlanState *pstate)
|
|||
|
||||
/* Initialize, or re-initialize, shared state needed by workers. */
|
||||
if (!node->pei)
|
||||
node->pei = ExecInitParallelPlan(node->ps.lefttree,
|
||||
node->pei = ExecInitParallelPlan(outerPlanState(node),
|
||||
estate,
|
||||
gm->initParam,
|
||||
gm->num_workers,
|
||||
node->tuples_needed);
|
||||
else
|
||||
ExecParallelReinitialize(node->ps.lefttree,
|
||||
ExecParallelReinitialize(outerPlanState(node),
|
||||
node->pei,
|
||||
gm->initParam);
|
||||
|
||||
|
|
|
@ -2212,12 +2212,14 @@ ExecHashTableResetMatchFlags(HashJoinTable hashtable)
|
|||
void
|
||||
ExecReScanHash(HashState *node)
|
||||
{
|
||||
PlanState *outerPlan = outerPlanState(node);
|
||||
|
||||
/*
|
||||
* if chgParam of subnode is not null then plan will be re-scanned by
|
||||
* first ExecProcNode.
|
||||
*/
|
||||
if (node->ps.lefttree->chgParam == NULL)
|
||||
ExecReScan(node->ps.lefttree);
|
||||
if (outerPlan->chgParam == NULL)
|
||||
ExecReScan(outerPlan);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -1290,6 +1290,9 @@ ExecHashJoinGetSavedTuple(HashJoinState *hjstate,
|
|||
void
|
||||
ExecReScanHashJoin(HashJoinState *node)
|
||||
{
|
||||
PlanState *outerPlan = outerPlanState(node);
|
||||
PlanState *innerPlan = innerPlanState(node);
|
||||
|
||||
/*
|
||||
* In a multi-batch join, we currently have to do rescans the hard way,
|
||||
* primarily because batch temp files may have already been released. But
|
||||
|
@ -1300,7 +1303,7 @@ ExecReScanHashJoin(HashJoinState *node)
|
|||
if (node->hj_HashTable != NULL)
|
||||
{
|
||||
if (node->hj_HashTable->nbatch == 1 &&
|
||||
node->js.ps.righttree->chgParam == NULL)
|
||||
innerPlan->chgParam == NULL)
|
||||
{
|
||||
/*
|
||||
* Okay to reuse the hash table; needn't rescan inner, either.
|
||||
|
@ -1328,7 +1331,7 @@ ExecReScanHashJoin(HashJoinState *node)
|
|||
else
|
||||
{
|
||||
/* must destroy and rebuild hash table */
|
||||
HashState *hashNode = castNode(HashState, innerPlanState(node));
|
||||
HashState *hashNode = castNode(HashState, innerPlan);
|
||||
|
||||
Assert(hashNode->hashtable == node->hj_HashTable);
|
||||
/* accumulate stats from old hash table, if wanted */
|
||||
|
@ -1350,8 +1353,8 @@ ExecReScanHashJoin(HashJoinState *node)
|
|||
* if chgParam of subnode is not null then plan will be re-scanned
|
||||
* by first ExecProcNode.
|
||||
*/
|
||||
if (node->js.ps.righttree->chgParam == NULL)
|
||||
ExecReScan(node->js.ps.righttree);
|
||||
if (innerPlan->chgParam == NULL)
|
||||
ExecReScan(innerPlan);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1368,8 +1371,8 @@ ExecReScanHashJoin(HashJoinState *node)
|
|||
* if chgParam of subnode is not null then plan will be re-scanned by
|
||||
* first ExecProcNode.
|
||||
*/
|
||||
if (node->js.ps.lefttree->chgParam == NULL)
|
||||
ExecReScan(node->js.ps.lefttree);
|
||||
if (outerPlan->chgParam == NULL)
|
||||
ExecReScan(outerPlan);
|
||||
}
|
||||
|
||||
void
|
||||
|
|
|
@ -542,6 +542,8 @@ ExecEndLimit(LimitState *node)
|
|||
void
|
||||
ExecReScanLimit(LimitState *node)
|
||||
{
|
||||
PlanState *outerPlan = outerPlanState(node);
|
||||
|
||||
/*
|
||||
* Recompute limit/offset in case parameters changed, and reset the state
|
||||
* machine. We must do this before rescanning our child node, in case
|
||||
|
@ -553,6 +555,6 @@ ExecReScanLimit(LimitState *node)
|
|||
* if chgParam of subnode is not null then plan will be re-scanned by
|
||||
* first ExecProcNode.
|
||||
*/
|
||||
if (node->ps.lefttree->chgParam == NULL)
|
||||
ExecReScan(node->ps.lefttree);
|
||||
if (outerPlan->chgParam == NULL)
|
||||
ExecReScan(outerPlan);
|
||||
}
|
||||
|
|
|
@ -394,10 +394,12 @@ ExecEndLockRows(LockRowsState *node)
|
|||
void
|
||||
ExecReScanLockRows(LockRowsState *node)
|
||||
{
|
||||
PlanState *outerPlan = outerPlanState(node);
|
||||
|
||||
/*
|
||||
* if chgParam of subnode is not null then plan will be re-scanned by
|
||||
* first ExecProcNode.
|
||||
*/
|
||||
if (node->ps.lefttree->chgParam == NULL)
|
||||
ExecReScan(node->ps.lefttree);
|
||||
if (outerPlan->chgParam == NULL)
|
||||
ExecReScan(outerPlan);
|
||||
}
|
||||
|
|
|
@ -1658,6 +1658,9 @@ ExecEndMergeJoin(MergeJoinState *node)
|
|||
void
|
||||
ExecReScanMergeJoin(MergeJoinState *node)
|
||||
{
|
||||
PlanState *outerPlan = outerPlanState(node);
|
||||
PlanState *innerPlan = innerPlanState(node);
|
||||
|
||||
ExecClearTuple(node->mj_MarkedTupleSlot);
|
||||
|
||||
node->mj_JoinState = EXEC_MJ_INITIALIZE_OUTER;
|
||||
|
@ -1670,8 +1673,8 @@ ExecReScanMergeJoin(MergeJoinState *node)
|
|||
* if chgParam of subnodes is not null then plans will be re-scanned by
|
||||
* first ExecProcNode.
|
||||
*/
|
||||
if (node->js.ps.lefttree->chgParam == NULL)
|
||||
ExecReScan(node->js.ps.lefttree);
|
||||
if (node->js.ps.righttree->chgParam == NULL)
|
||||
ExecReScan(node->js.ps.righttree);
|
||||
if (outerPlan->chgParam == NULL)
|
||||
ExecReScan(outerPlan);
|
||||
if (innerPlan->chgParam == NULL)
|
||||
ExecReScan(innerPlan);
|
||||
}
|
||||
|
|
|
@ -339,6 +339,8 @@ ExecEndProjectSet(ProjectSetState *node)
|
|||
void
|
||||
ExecReScanProjectSet(ProjectSetState *node)
|
||||
{
|
||||
PlanState *outerPlan = outerPlanState(node);
|
||||
|
||||
/* Forget any incompletely-evaluated SRFs */
|
||||
node->pending_srf_tuples = false;
|
||||
|
||||
|
@ -346,6 +348,6 @@ ExecReScanProjectSet(ProjectSetState *node)
|
|||
* If chgParam of subnode is not null then plan will be re-scanned by
|
||||
* first ExecProcNode.
|
||||
*/
|
||||
if (node->ps.lefttree->chgParam == NULL)
|
||||
ExecReScan(node->ps.lefttree);
|
||||
if (outerPlan->chgParam == NULL)
|
||||
ExecReScan(outerPlan);
|
||||
}
|
||||
|
|
|
@ -259,6 +259,8 @@ ExecEndResult(ResultState *node)
|
|||
void
|
||||
ExecReScanResult(ResultState *node)
|
||||
{
|
||||
PlanState *outerPlan = outerPlanState(node);
|
||||
|
||||
node->rs_done = false;
|
||||
node->rs_checkqual = (node->resconstantqual != NULL);
|
||||
|
||||
|
@ -266,7 +268,6 @@ ExecReScanResult(ResultState *node)
|
|||
* If chgParam of subnode is not null then plan will be re-scanned by
|
||||
* first ExecProcNode.
|
||||
*/
|
||||
if (node->ps.lefttree &&
|
||||
node->ps.lefttree->chgParam == NULL)
|
||||
ExecReScan(node->ps.lefttree);
|
||||
if (outerPlan && outerPlan->chgParam == NULL)
|
||||
ExecReScan(outerPlan);
|
||||
}
|
||||
|
|
|
@ -597,6 +597,8 @@ ExecEndSetOp(SetOpState *node)
|
|||
void
|
||||
ExecReScanSetOp(SetOpState *node)
|
||||
{
|
||||
PlanState *outerPlan = outerPlanState(node);
|
||||
|
||||
ExecClearTuple(node->ps.ps_ResultTupleSlot);
|
||||
node->setop_done = false;
|
||||
node->numOutput = 0;
|
||||
|
@ -617,7 +619,7 @@ ExecReScanSetOp(SetOpState *node)
|
|||
* parameter changes, then we can just rescan the existing hash table;
|
||||
* no need to build it again.
|
||||
*/
|
||||
if (node->ps.lefttree->chgParam == NULL)
|
||||
if (outerPlan->chgParam == NULL)
|
||||
{
|
||||
ResetTupleHashIterator(node->hashtable, &node->hashiter);
|
||||
return;
|
||||
|
@ -646,6 +648,6 @@ ExecReScanSetOp(SetOpState *node)
|
|||
* if chgParam of subnode is not null then plan will be re-scanned by
|
||||
* first ExecProcNode.
|
||||
*/
|
||||
if (node->ps.lefttree->chgParam == NULL)
|
||||
ExecReScan(node->ps.lefttree);
|
||||
if (outerPlan->chgParam == NULL)
|
||||
ExecReScan(outerPlan);
|
||||
}
|
||||
|
|
|
@ -180,6 +180,8 @@ ExecEndUnique(UniqueState *node)
|
|||
void
|
||||
ExecReScanUnique(UniqueState *node)
|
||||
{
|
||||
PlanState *outerPlan = outerPlanState(node);
|
||||
|
||||
/* must clear result tuple so first input tuple is returned */
|
||||
ExecClearTuple(node->ps.ps_ResultTupleSlot);
|
||||
|
||||
|
@ -187,6 +189,6 @@ ExecReScanUnique(UniqueState *node)
|
|||
* if chgParam of subnode is not null then plan will be re-scanned by
|
||||
* first ExecProcNode.
|
||||
*/
|
||||
if (node->ps.lefttree->chgParam == NULL)
|
||||
ExecReScan(node->ps.lefttree);
|
||||
if (outerPlan->chgParam == NULL)
|
||||
ExecReScan(outerPlan);
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue