Phase 1 of read-only-plans project: cause executor state nodes to point

to plan nodes, not vice-versa.  All executor state nodes now inherit from
struct PlanState.  Copying of plan trees has been simplified by not
storing a list of SubPlans in Plan nodes (eliminating duplicate links).
The executor still needs such a list, but it can build it during
ExecutorStart since it has to scan the plan tree anyway.
No initdb forced since no stored-on-disk structures changed, but you
will need a full recompile because of node-numbering changes.

1 files changed, 50 insertions, 76 deletions

diff --git a/src/backend/executor/nodeSort.c b/src/backend/executor/nodeSort.c
index 05f36427beb..e1b4db7a51d 100644
--- a/src/backend/executor/nodeSort.c
+++ b/src/backend/executor/nodeSort.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/nodeSort.c,v 1.40 2002/11/13 00:39:47 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/nodeSort.c,v 1.41 2002/12/05 15:50:33 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -88,10 +88,9 @@ ExtractSortKeys(Sort *sortnode,
  * ----------------------------------------------------------------
  */
 TupleTableSlot *
-ExecSort(Sort *node)
+ExecSort(SortState *node)
 {
 	EState	   *estate;
-	SortState  *sortstate;
 	ScanDirection dir;
 	Tuplesortstate *tuplesortstate;
 	HeapTuple	heapTuple;
@@ -104,10 +103,9 @@ ExecSort(Sort *node)
 	SO1_printf("ExecSort: %s\n",
 			   "entering routine");
 
-	sortstate = node->sortstate;
-	estate = node->plan.state;
+	estate = node->ss.ps.state;
 	dir = estate->es_direction;
-	tuplesortstate = (Tuplesortstate *) sortstate->tuplesortstate;
+	tuplesortstate = (Tuplesortstate *) node->tuplesortstate;
 
 	/*
 	 * If first time through, read all tuples from outer plan and pass
@@ -115,9 +113,10 @@ ExecSort(Sort *node)
 	 * tuplesort.
 	 */
 
-	if (!sortstate->sort_Done)
+	if (!node->sort_Done)
 	{
-		Plan	   *outerNode;
+		Sort	   *plannode = (Sort *) node->ss.ps.plan;
+		PlanState  *outerNode;
 		TupleDesc	tupDesc;
 		Oid		   *sortOperators;
 		AttrNumber *attNums;
@@ -127,8 +126,7 @@ ExecSort(Sort *node)
 
 		/*
 		 * Want to scan subplan in the forward direction while creating
-		 * the sorted data.  (Does setting my direction actually affect
-		 * the subplan?  I bet this is useless code...)
+		 * the sorted data.
 		 */
 		estate->es_direction = ForwardScanDirection;
 
@@ -138,15 +136,15 @@ ExecSort(Sort *node)
 		SO1_printf("ExecSort: %s\n",
 				   "calling tuplesort_begin");
 
-		outerNode = outerPlan((Plan *) node);
+		outerNode = outerPlanState(node);
 		tupDesc = ExecGetTupType(outerNode);
 
-		ExtractSortKeys(node, &sortOperators, &attNums);
+		ExtractSortKeys(plannode, &sortOperators, &attNums);
 
-		tuplesortstate = tuplesort_begin_heap(tupDesc, node->keycount,
+		tuplesortstate = tuplesort_begin_heap(tupDesc, plannode->keycount,
 											  sortOperators, attNums,
 											  true /* randomAccess */ );
-		sortstate->tuplesortstate = (void *) tuplesortstate;
+		node->tuplesortstate = (void *) tuplesortstate;
 
 		pfree(sortOperators);
 		pfree(attNums);
@@ -157,7 +155,7 @@ ExecSort(Sort *node)
 
 		for (;;)
 		{
-			slot = ExecProcNode(outerNode, (Plan *) node);
+			slot = ExecProcNode(outerNode);
 
 			if (TupIsNull(slot))
 				break;
@@ -178,12 +176,12 @@ ExecSort(Sort *node)
 		/*
 		 * make sure the tuple descriptor is up to date (is this needed?)
 		 */
-		ExecAssignResultType(&sortstate->csstate.cstate, tupDesc, false);
+		ExecAssignResultType(&node->ss.ps, tupDesc, false);
 
 		/*
 		 * finally set the sorted flag to true
 		 */
-		sortstate->sort_Done = true;
+		node->sort_Done = true;
 		SO1_printf("ExecSort: %s\n", "sorting done");
 	}
 
@@ -198,7 +196,7 @@ ExecSort(Sort *node)
 									   ScanDirectionIsForward(dir),
 									   &should_free);
 
-	slot = sortstate->csstate.cstate.cs_ResultTupleSlot;
+	slot = node->ss.ps.ps_ResultTupleSlot;
 	return ExecStoreTuple(heapTuple, slot, InvalidBuffer, should_free);
 }
 
@@ -209,29 +207,24 @@ ExecSort(Sort *node)
  *		produced by the planner and initailizes its outer subtree.
  * ----------------------------------------------------------------
  */
-bool
-ExecInitSort(Sort *node, EState *estate, Plan *parent)
+SortState *
+ExecInitSort(Sort *node, EState *estate)
 {
 	SortState  *sortstate;
-	Plan	   *outerPlan;
 
 	SO1_printf("ExecInitSort: %s\n",
 			   "initializing sort node");
 
 	/*
-	 * assign the node's execution state
-	 */
-	node->plan.state = estate;
-
-	/*
 	 * create state structure
 	 */
 	sortstate = makeNode(SortState);
+	sortstate->ss.ps.plan = (Plan *) node;
+	sortstate->ss.ps.state = estate;
+
 	sortstate->sort_Done = false;
 	sortstate->tuplesortstate = NULL;
 
-	node->sortstate = sortstate;
-
 	/*
 	 * Miscellaneous initialization
 	 *
@@ -246,27 +239,26 @@ ExecInitSort(Sort *node, EState *estate, Plan *parent)
 	 *
 	 * sort nodes only return scan tuples from their sorted relation.
 	 */
-	ExecInitResultTupleSlot(estate, &sortstate->csstate.cstate);
-	ExecInitScanTupleSlot(estate, &sortstate->csstate);
+	ExecInitResultTupleSlot(estate, &sortstate->ss.ps);
+	ExecInitScanTupleSlot(estate, &sortstate->ss);
 
 	/*
 	 * initializes child nodes
 	 */
-	outerPlan = outerPlan((Plan *) node);
-	ExecInitNode(outerPlan, estate, (Plan *) node);
+	outerPlanState(sortstate) = ExecInitNode(outerPlan(node), estate);
 
 	/*
 	 * initialize tuple type.  no need to initialize projection info
 	 * because this node doesn't do projections.
 	 */
-	ExecAssignResultTypeFromOuterPlan((Plan *) node, &sortstate->csstate.cstate);
-	ExecAssignScanTypeFromOuterPlan((Plan *) node, &sortstate->csstate);
-	sortstate->csstate.cstate.cs_ProjInfo = NULL;
+	ExecAssignResultTypeFromOuterPlan(&sortstate->ss.ps);
+	ExecAssignScanTypeFromOuterPlan(&sortstate->ss);
+	sortstate->ss.ps.ps_ProjInfo = NULL;
 
 	SO1_printf("ExecInitSort: %s\n",
 			   "sort node initialized");
 
-	return TRUE;
+	return sortstate;
 }
 
 int
@@ -282,39 +274,27 @@ ExecCountSlotsSort(Sort *node)
  * ----------------------------------------------------------------
  */
 void
-ExecEndSort(Sort *node)
+ExecEndSort(SortState *node)
 {
-	SortState  *sortstate;
-	Plan	   *outerPlan;
-
-	/*
-	 * get info from the sort state
-	 */
 	SO1_printf("ExecEndSort: %s\n",
 			   "shutting down sort node");
 
-	sortstate = node->sortstate;
-
 	/*
-	 * shut down the subplan
+	 * clean out the tuple table
 	 */
-	outerPlan = outerPlan((Plan *) node);
-	ExecEndNode(outerPlan, (Plan *) node);
+	ExecClearTuple(node->ss.ss_ScanTupleSlot);
 
 	/*
-	 * clean out the tuple table
+	 * shut down the subplan
 	 */
-	ExecClearTuple(sortstate->csstate.css_ScanTupleSlot);
+	ExecEndNode(outerPlanState(node));
 
 	/*
 	 * Release tuplesort resources
 	 */
-	if (sortstate->tuplesortstate != NULL)
-		tuplesort_end((Tuplesortstate *) sortstate->tuplesortstate);
-	sortstate->tuplesortstate = NULL;
-
-	pfree(sortstate);
-	node->sortstate = NULL;
+	if (node->tuplesortstate != NULL)
+		tuplesort_end((Tuplesortstate *) node->tuplesortstate);
+	node->tuplesortstate = NULL;
 
 	SO1_printf("ExecEndSort: %s\n",
 			   "sort node shutdown");
@@ -327,17 +307,15 @@ ExecEndSort(Sort *node)
  * ----------------------------------------------------------------
  */
 void
-ExecSortMarkPos(Sort *node)
+ExecSortMarkPos(SortState *node)
 {
-	SortState  *sortstate = node->sortstate;
-
 	/*
 	 * if we haven't sorted yet, just return
 	 */
-	if (!sortstate->sort_Done)
+	if (!node->sort_Done)
 		return;
 
-	tuplesort_markpos((Tuplesortstate *) sortstate->tuplesortstate);
+	tuplesort_markpos((Tuplesortstate *) node->tuplesortstate);
 }
 
 /* ----------------------------------------------------------------
@@ -347,36 +325,32 @@ ExecSortMarkPos(Sort *node)
  * ----------------------------------------------------------------
  */
 void
-ExecSortRestrPos(Sort *node)
+ExecSortRestrPos(SortState *node)
 {
-	SortState  *sortstate = node->sortstate;
-
 	/*
 	 * if we haven't sorted yet, just return.
 	 */
-	if (!sortstate->sort_Done)
+	if (!node->sort_Done)
 		return;
 
 	/*
 	 * restore the scan to the previously marked position
 	 */
-	tuplesort_restorepos((Tuplesortstate *) sortstate->tuplesortstate);
+	tuplesort_restorepos((Tuplesortstate *) node->tuplesortstate);
 }
 
 void
-ExecReScanSort(Sort *node, ExprContext *exprCtxt, Plan *parent)
+ExecReScanSort(SortState *node, ExprContext *exprCtxt)
 {
-	SortState  *sortstate = node->sortstate;
-
 	/*
 	 * If we haven't sorted yet, just return. If outerplan' chgParam is
 	 * not NULL then it will be re-scanned by ExecProcNode, else - no
 	 * reason to re-scan it at all.
 	 */
-	if (!sortstate->sort_Done)
+	if (!node->sort_Done)
 		return;
 
-	ExecClearTuple(sortstate->csstate.cstate.cs_ResultTupleSlot);
+	ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
 
 	/*
 	 * If subnode is to be rescanned then we forget previous sort results;
@@ -384,12 +358,12 @@ ExecReScanSort(Sort *node, ExprContext *exprCtxt, Plan *parent)
 	 *
 	 * Otherwise we can just rewind and rescan the sorted output.
 	 */
-	if (((Plan *) node)->lefttree->chgParam != NULL)
+	if (((PlanState *) node)->lefttree->chgParam != NULL)
 	{
-		sortstate->sort_Done = false;
-		tuplesort_end((Tuplesortstate *) sortstate->tuplesortstate);
-		sortstate->tuplesortstate = NULL;
+		node->sort_Done = false;
+		tuplesort_end((Tuplesortstate *) node->tuplesortstate);
+		node->tuplesortstate = NULL;
 	}
 	else
-		tuplesort_rescan((Tuplesortstate *) sortstate->tuplesortstate);
+		tuplesort_rescan((Tuplesortstate *) node->tuplesortstate);
 }