Get rid of the separate EState for subplans, and just let them share the

parent query's EState.  Now that there's a single flat rangetable for both
the main plan and subplans, there's no need anymore for a separate EState,
and removing it allows cleaning up some crufty code in nodeSubplan.c and
nodeSubqueryscan.c.  Should be a tad faster too, although any difference
will probably be hard to measure.  This is the last bit of subsidiary
mop-up work from changing to a flat rangetable.

src/backend/executor/execMain.c

@@ -26,7 +26,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/executor/execMain.c,v 1.288 2007/02/22 22:00:22 tgl Exp $
+ *	  $PostgreSQL: pgsql/src/backend/executor/execMain.c,v 1.289 2007/02/27 01:11:25 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -70,6 +70,7 @@ static void initResultRelInfo(ResultRelInfo *resultRelInfo,
 				  List *rangeTable,
 				  CmdType operation,
 				  bool doInstrument);
+static void ExecEndPlan(PlanState *planstate, EState *estate);
 static TupleTableSlot *ExecutePlan(EState *estate, PlanState *planstate,
 			CmdType operation,
 			long numberTuples,
@@ -466,6 +467,7 @@ InitPlan(QueryDesc *queryDesc, int eflags)
 	PlanState  *planstate;
 	TupleDesc	tupType;
 	ListCell   *l;
+	int			i;
 
 	/*
 	 * Do permissions checks
@@ -551,15 +553,25 @@ InitPlan(QueryDesc *queryDesc, int eflags)
 	}
 
 	/*
-	 * initialize the executor "tuple" table.  We need slots for all the plan
+	 * Initialize the executor "tuple" table.  We need slots for all the plan
 	 * nodes, plus possibly output slots for the junkfilter(s). At this point
 	 * we aren't sure if we need junkfilters, so just add slots for them
 	 * unconditionally.  Also, if it's not a SELECT, set up a slot for use for
-	 * trigger output tuples.
+	 * trigger output tuples.  Also, one for RETURNING-list evaluation.
 	 */
 	{
-		int			nSlots = ExecCountSlotsNode(plan);
+		int			nSlots;
+
+		/* Slots for the main plan tree */
+		nSlots = ExecCountSlotsNode(plan);
+		/* Add slots for subplans and initplans */
+		foreach(l, plannedstmt->subplans)
+		{
+			Plan   *subplan = (Plan *) lfirst(l);
 
+			nSlots += ExecCountSlotsNode(subplan);
+		}
+		/* Add slots for junkfilter(s) */
 		if (plannedstmt->resultRelations != NIL)
 			nSlots += list_length(plannedstmt->resultRelations);
 		else
@@ -584,7 +596,38 @@ InitPlan(QueryDesc *queryDesc, int eflags)
 	estate->es_useEvalPlan = false;
 
 	/*
-	 * initialize the private state information for all the nodes in the query
+	 * Initialize private state information for each SubPlan.  We must do
+	 * this before running ExecInitNode on the main query tree, since
+	 * ExecInitSubPlan expects to be able to find these entries.
+	 */
+	Assert(estate->es_subplanstates == NIL);
+	i = 1;						/* subplan indices count from 1 */
+	foreach(l, plannedstmt->subplans)
+	{
+		Plan   *subplan = (Plan *) lfirst(l);
+		PlanState *subplanstate;
+		int		sp_eflags;
+
+		/*
+		 * A subplan will never need to do BACKWARD scan nor MARK/RESTORE.
+		 * If it is a parameterless subplan (not initplan), we suggest that it
+		 * be prepared to handle REWIND efficiently; otherwise there is no
+		 * need.
+		 */
+		sp_eflags = eflags & EXEC_FLAG_EXPLAIN_ONLY;
+		if (bms_is_member(i, plannedstmt->rewindPlanIDs))
+			sp_eflags |= EXEC_FLAG_REWIND;
+
+		subplanstate = ExecInitNode(subplan, estate, sp_eflags);
+
+		estate->es_subplanstates = lappend(estate->es_subplanstates,
+										   subplanstate);
+
+		i++;
+	}
+
+	/*
+	 * Initialize the private state information for all the nodes in the query
 	 * tree.  This opens files, allocates storage and leaves us ready to start
 	 * processing tuples.
 	 */
@@ -648,7 +691,6 @@ InitPlan(QueryDesc *queryDesc, int eflags)
 				PlanState **appendplans;
 				int			as_nplans;
 				ResultRelInfo *resultRelInfo;
-				int			i;
 
 				/* Top plan had better be an Append here. */
 				Assert(IsA(plan, Append));
@@ -768,20 +810,6 @@ InitPlan(QueryDesc *queryDesc, int eflags)
 									   resultRelInfo->ri_RelationDesc->rd_att);
 			resultRelInfo++;
 		}
-
-		/*
-		 * Because we already ran ExecInitNode() for the top plan node, any
-		 * subplans we just attached to it won't have been initialized; so we
-		 * have to do it here.	(Ugly, but the alternatives seem worse.)
-		 */
-		foreach(l, planstate->subPlan)
-		{
-			SubPlanState *sstate = (SubPlanState *) lfirst(l);
-
-			Assert(IsA(sstate, SubPlanState));
-			if (sstate->planstate == NULL)		/* already inited? */
-				ExecInitSubPlan(sstate, estate, eflags);
-		}
 	}
 
 	queryDesc->tupDesc = tupType;
@@ -945,7 +973,7 @@ ExecContextForcesOids(PlanState *planstate, bool *hasoids)
  * tuple tables must be cleared or dropped to ensure pins are released.
  * ----------------------------------------------------------------
  */
-void
+static void
 ExecEndPlan(PlanState *planstate, EState *estate)
 {
 	ResultRelInfo *resultRelInfo;
@@ -963,6 +991,16 @@ ExecEndPlan(PlanState *planstate, EState *estate)
 	 */
 	ExecEndNode(planstate);
 
+	/*
+	 * for subplans too
+	 */
+	foreach(l, estate->es_subplanstates)
+	{
+		PlanState *subplanstate = (PlanState *) lfirst(l);
+
+		ExecEndNode(subplanstate);
+	}
+
 	/*
 	 * destroy the executor "tuple" table.
 	 */
@@ -2205,13 +2243,10 @@ EvalPlanQualStart(evalPlanQual *epq, EState *estate, evalPlanQual *priorepq)
 	EState	   *epqstate;
 	int			rtsize;
 	MemoryContext oldcontext;
+	ListCell   *l;
 
 	rtsize = list_length(estate->es_range_table);
 
-	/*
-	 * It's tempting to think about using CreateSubExecutorState here, but
-	 * at present we can't because of memory leakage concerns ...
-	 */
 	epq->estate = epqstate = CreateExecutorState();
 
 	oldcontext = MemoryContextSwitchTo(epqstate->es_query_cxt);
@@ -2256,9 +2291,34 @@ EvalPlanQualStart(evalPlanQual *epq, EState *estate, evalPlanQual *priorepq)
 		/* later stack entries share the same storage */
 		epqstate->es_evTuple = priorepq->estate->es_evTuple;
 
+	/*
+	 * Create sub-tuple-table; we needn't redo the CountSlots work though.
+	 */
 	epqstate->es_tupleTable =
 		ExecCreateTupleTable(estate->es_tupleTable->size);
 
+	/*
+	 * Initialize private state information for each SubPlan.  We must do
+	 * this before running ExecInitNode on the main query tree, since
+	 * ExecInitSubPlan expects to be able to find these entries.
+	 */
+	Assert(epqstate->es_subplanstates == NIL);
+	foreach(l, estate->es_plannedstmt->subplans)
+	{
+		Plan   *subplan = (Plan *) lfirst(l);
+		PlanState *subplanstate;
+
+		subplanstate = ExecInitNode(subplan, epqstate, 0);
+
+		epqstate->es_subplanstates = lappend(epqstate->es_subplanstates,
+											 subplanstate);
+	}
+
+	/*
+	 * Initialize the private state information for all the nodes in the query
+	 * tree.  This opens files, allocates storage and leaves us ready to start
+	 * processing tuples.
+	 */
 	epq->planstate = ExecInitNode(estate->es_plannedstmt->planTree, epqstate, 0);
 
 	MemoryContextSwitchTo(oldcontext);
@@ -2276,11 +2336,19 @@ EvalPlanQualStop(evalPlanQual *epq)
 {
 	EState	   *epqstate = epq->estate;
 	MemoryContext oldcontext;
+	ListCell   *l;
 
 	oldcontext = MemoryContextSwitchTo(epqstate->es_query_cxt);
 
 	ExecEndNode(epq->planstate);
 
+	foreach(l, epqstate->es_subplanstates)
+	{
+		PlanState *subplanstate = (PlanState *) lfirst(l);
+
+		ExecEndNode(subplanstate);
+	}
+
 	ExecDropTupleTable(epqstate->es_tupleTable, true);
 	epqstate->es_tupleTable = NULL;
 

src/backend/executor/execProcnode.c

@@ -12,7 +12,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/executor/execProcnode.c,v 1.60 2007/01/05 22:19:27 momjian Exp $
+ *	  $PostgreSQL: pgsql/src/backend/executor/execProcnode.c,v 1.61 2007/02/27 01:11:25 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -278,26 +278,11 @@ ExecInitNode(Plan *node, EState *estate, int eflags)
 		SubPlanState *sstate;
 
 		Assert(IsA(subplan, SubPlan));
-		sstate = ExecInitExprInitPlan(subplan, result);
-		ExecInitSubPlan(sstate, estate, eflags);
+		sstate = ExecInitSubPlan(subplan, result);
 		subps = lappend(subps, sstate);
 	}
 	result->initPlan = subps;
 
-	/*
-	 * Initialize any subPlans present in this node.  These were found by
-	 * ExecInitExpr during initialization of the PlanState.  Note we must do
-	 * this after initializing initPlans, in case their arguments contain
-	 * subPlans (is that actually possible? perhaps not).
-	 */
-	foreach(l, result->subPlan)
-	{
-		SubPlanState *sstate = (SubPlanState *) lfirst(l);
-
-		Assert(IsA(sstate, SubPlanState));
-		ExecInitSubPlan(sstate, estate, eflags);
-	}
-
 	/* Set up instrumentation for this node if requested */
 	if (estate->es_instrument)
 		result->instrument = InstrAlloc(1);
@@ -610,20 +595,12 @@ ExecCountSlotsNode(Plan *node)
 void
 ExecEndNode(PlanState *node)
 {
-	ListCell   *subp;
-
 	/*
 	 * do nothing when we get to the end of a leaf on tree.
 	 */
 	if (node == NULL)
 		return;
 
-	/* Clean up initPlans and subPlans */
-	foreach(subp, node->initPlan)
-		ExecEndSubPlan((SubPlanState *) lfirst(subp));
-	foreach(subp, node->subPlan)
-		ExecEndSubPlan((SubPlanState *) lfirst(subp));
-
 	if (node->chgParam != NULL)
 	{
 		bms_free(node->chgParam);

src/backend/executor/execQual.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/executor/execQual.c,v 1.213 2007/02/06 17:35:20 tgl Exp $
+ *	  $PostgreSQL: pgsql/src/backend/executor/execQual.c,v 1.214 2007/02/27 01:11:25 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -3723,27 +3723,16 @@ ExecInitExpr(Expr *node, PlanState *parent)
 			break;
 		case T_SubPlan:
 			{
-				/* Keep this in sync with ExecInitExprInitPlan, below */
 				SubPlan    *subplan = (SubPlan *) node;
-				SubPlanState *sstate = makeNode(SubPlanState);
-
-				sstate->xprstate.evalfunc = (ExprStateEvalFunc) ExecSubPlan;
+				SubPlanState *sstate;
 
 				if (!parent)
 					elog(ERROR, "SubPlan found with no parent plan");
 
-				/*
-				 * Here we just add the SubPlanState nodes to parent->subPlan.
-				 * The subplans will be initialized later.
-				 */
-				parent->subPlan = lcons(sstate, parent->subPlan);
-				sstate->sub_estate = NULL;
-				sstate->planstate = NULL;
+				sstate = ExecInitSubPlan(subplan, parent);
 
-				sstate->testexpr =
-					ExecInitExpr((Expr *) subplan->testexpr, parent);
-				sstate->args = (List *)
-					ExecInitExpr((Expr *) subplan->args, parent);
+				/* Add SubPlanState nodes to parent->subPlan */
+				parent->subPlan = lcons(sstate, parent->subPlan);
 
 				state = (ExprState *) sstate;
 			}
@@ -4157,32 +4146,6 @@ ExecInitExpr(Expr *node, PlanState *parent)
 	return state;
 }
 
-/*
- * ExecInitExprInitPlan --- initialize a subplan expr that's being handled
- * as an InitPlan.	This is identical to ExecInitExpr's handling of a regular
- * subplan expr, except we do NOT want to add the node to the parent's
- * subplan list.
- */
-SubPlanState *
-ExecInitExprInitPlan(SubPlan *node, PlanState *parent)
-{
-	SubPlanState *sstate = makeNode(SubPlanState);
-
-	if (!parent)
-		elog(ERROR, "SubPlan found with no parent plan");
-
-	/* The subplan's state will be initialized later */
-	sstate->sub_estate = NULL;
-	sstate->planstate = NULL;
-
-	sstate->testexpr = ExecInitExpr((Expr *) node->testexpr, parent);
-	sstate->args = (List *) ExecInitExpr((Expr *) node->args, parent);
-
-	sstate->xprstate.expr = (Expr *) node;
-
-	return sstate;
-}
-
 /*
  * ExecPrepareExpr --- initialize for expression execution outside a normal
  * Plan tree context.

src/backend/executor/execUtils.c

@@ -8,14 +8,13 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/executor/execUtils.c,v 1.146 2007/02/22 22:00:22 tgl Exp $
+ *	  $PostgreSQL: pgsql/src/backend/executor/execUtils.c,v 1.147 2007/02/27 01:11:25 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
 /*
  * INTERFACE ROUTINES
  *		CreateExecutorState		Create/delete executor working state
- *		CreateSubExecutorState
  *		FreeExecutorState
  *		CreateExprContext
  *		CreateStandaloneExprContext
@@ -66,8 +65,6 @@ int			NIndexTupleInserted;
 int			NIndexTupleProcessed;
 
 
-static EState *InternalCreateExecutorState(MemoryContext qcontext,
-										   bool is_subquery);
 static void ShutdownExprContext(ExprContext *econtext);
 
 
@@ -152,7 +149,9 @@ DisplayTupleCount(FILE *statfp)
 EState *
 CreateExecutorState(void)
 {
+	EState	   *estate;
 	MemoryContext qcontext;
+	MemoryContext oldcontext;
 
 	/*
 	 * Create the per-query context for this Executor run.
@@ -163,37 +162,6 @@ CreateExecutorState(void)
 									 ALLOCSET_DEFAULT_INITSIZE,
 									 ALLOCSET_DEFAULT_MAXSIZE);
 
-	return InternalCreateExecutorState(qcontext, false);
-}
-
-/* ----------------
- *		CreateSubExecutorState
- *
- *		Create and initialize an EState node for a sub-query.
- *
- * Ideally, sub-queries probably shouldn't have their own EState at all,
- * but right now this is necessary because they have their own rangetables
- * and we access the rangetable via the EState.  It is critical that a
- * sub-query share the parent's es_query_cxt, else structures allocated by
- * the sub-query (especially its result tuple descriptor) may disappear
- * too soon during executor shutdown.
- * ----------------
- */
-EState *
-CreateSubExecutorState(EState *parent_estate)
-{
-	return InternalCreateExecutorState(parent_estate->es_query_cxt, true);
-}
-
-/*
- * Guts of CreateExecutorState/CreateSubExecutorState
- */
-static EState *
-InternalCreateExecutorState(MemoryContext qcontext, bool is_subquery)
-{
-	EState	   *estate;
-	MemoryContext oldcontext;
-
 	/*
 	 * Make the EState node within the per-query context.  This way, we don't
 	 * need a separate pfree() operation for it at shutdown.
@@ -232,14 +200,14 @@ InternalCreateExecutorState(MemoryContext qcontext, bool is_subquery)
 	estate->es_lastoid = InvalidOid;
 	estate->es_rowMarks = NIL;
 
-	estate->es_is_subquery = is_subquery;
-
 	estate->es_instrument = false;
 	estate->es_select_into = false;
 	estate->es_into_oids = false;
 
 	estate->es_exprcontexts = NIL;
 
+	estate->es_subplanstates = NIL;
+
 	estate->es_per_tuple_exprcontext = NULL;
 
 	estate->es_plannedstmt = NULL;
@@ -292,12 +260,9 @@ FreeExecutorState(EState *estate)
 
 	/*
 	 * Free the per-query memory context, thereby releasing all working
-	 * memory, including the EState node itself.  In a subquery, we don't
-	 * do this, leaving the memory cleanup to happen when the topmost query
-	 * is closed down.
+	 * memory, including the EState node itself.
 	 */
-	if (!estate->es_is_subquery)
-		MemoryContextDelete(estate->es_query_cxt);
+	MemoryContextDelete(estate->es_query_cxt);
 }
 
 /* ----------------

src/backend/executor/nodeSubplan.c

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/executor/nodeSubplan.c,v 1.86 2007/02/22 22:00:23 tgl Exp $
+ *	  $PostgreSQL: pgsql/src/backend/executor/nodeSubplan.c,v 1.87 2007/02/27 01:11:25 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -15,7 +15,6 @@
  *	 INTERFACE ROUTINES
  *		ExecSubPlan  - process a subselect
  *		ExecInitSubPlan - initialize a subselect
- *		ExecEndSubPlan	- shut down a subselect
  */
 #include "postgres.h"
 
@@ -37,7 +36,7 @@ static Datum ExecHashSubPlan(SubPlanState *node,
 static Datum ExecScanSubPlan(SubPlanState *node,
 				ExprContext *econtext,
 				bool *isNull);
-static void buildSubPlanHash(SubPlanState *node);
+static void buildSubPlanHash(SubPlanState *node, ExprContext *econtext);
 static bool findPartialMatch(TupleHashTable hashtable, TupleTableSlot *slot);
 static bool slotAllNulls(TupleTableSlot *slot);
 static bool slotNoNulls(TupleTableSlot *slot);
@@ -91,7 +90,7 @@ ExecHashSubPlan(SubPlanState *node,
 	 * table.
 	 */
 	if (node->hashtable == NULL || planstate->chgParam != NULL)
-		buildSubPlanHash(node);
+		buildSubPlanHash(node, econtext);
 
 	/*
 	 * The result for an empty subplan is always FALSE; no need to evaluate
@@ -219,10 +218,10 @@ ExecScanSubPlan(SubPlanState *node,
 
 	/*
 	 * We are probably in a short-lived expression-evaluation context. Switch
-	 * to the child plan's per-query context for manipulating its chgParam,
+	 * to the per-query context for manipulating the child plan's chgParam,
 	 * calling ExecProcNode on it, etc.
 	 */
-	oldcontext = MemoryContextSwitchTo(node->sub_estate->es_query_cxt);
+	oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
 
 	/*
 	 * Set Params of this plan from parent plan correlation values. (Any
@@ -299,11 +298,9 @@ ExecScanSubPlan(SubPlanState *node,
 			 * node->curTuple keeps track of the copied tuple for eventual
 			 * freeing.
 			 */
-			MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
 			if (node->curTuple)
 				heap_freetuple(node->curTuple);
 			node->curTuple = ExecCopySlotTuple(slot);
-			MemoryContextSwitchTo(node->sub_estate->es_query_cxt);
 
 			result = heap_getattr(node->curTuple, 1, tdesc, isNull);
 			/* keep scanning subplan to make sure there's only one tuple */
@@ -416,7 +413,7 @@ ExecScanSubPlan(SubPlanState *node,
  * buildSubPlanHash: load hash table by scanning subplan output.
  */
 static void
-buildSubPlanHash(SubPlanState *node)
+buildSubPlanHash(SubPlanState *node, ExprContext *econtext)
 {
 	SubPlan    *subplan = (SubPlan *) node->xprstate.expr;
 	PlanState  *planstate = node->planstate;
@@ -485,9 +482,9 @@ buildSubPlanHash(SubPlanState *node)
 
 	/*
 	 * We are probably in a short-lived expression-evaluation context. Switch
-	 * to the child plan's per-query context for calling ExecProcNode.
+	 * to the per-query context for manipulating the child plan.
 	 */
-	oldcontext = MemoryContextSwitchTo(node->sub_estate->es_query_cxt);
+	oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
 
 	/*
 	 * Reset subplan to start.
@@ -628,72 +625,45 @@ slotNoNulls(TupleTableSlot *slot)
 /* ----------------------------------------------------------------
  *		ExecInitSubPlan
  *
- * Note: the eflags are those passed to the parent plan node of this
- * subplan; they don't directly describe the execution conditions the
- * subplan will face.
+ * Create a SubPlanState for a SubPlan; this is the SubPlan-specific part
+ * of ExecInitExpr().  We split it out so that it can be used for InitPlans
+ * as well as regular SubPlans.  Note that we don't link the SubPlan into
+ * the parent's subPlan list, because that shouldn't happen for InitPlans.
+ * Instead, ExecInitExpr() does that one part.
  * ----------------------------------------------------------------
  */
-void
-ExecInitSubPlan(SubPlanState *node, EState *estate, int eflags)
+SubPlanState *
+ExecInitSubPlan(SubPlan *subplan, PlanState *parent)
 {
-	SubPlan    *subplan = (SubPlan *) node->xprstate.expr;
-	Plan	   *plan = exec_subplan_get_plan(estate->es_plannedstmt, subplan);
-	EState	   *sp_estate;
+	SubPlanState *sstate = makeNode(SubPlanState);
+	EState	   *estate = parent->state;
 
-	/*
-	 * initialize my state
-	 */
-	node->needShutdown = false;
-	node->curTuple = NULL;
-	node->projLeft = NULL;
-	node->projRight = NULL;
-	node->hashtable = NULL;
-	node->hashnulls = NULL;
-	node->tablecxt = NULL;
-	node->innerecontext = NULL;
-	node->keyColIdx = NULL;
-	node->tab_hash_funcs = NULL;
-	node->tab_eq_funcs = NULL;
-	node->lhs_hash_funcs = NULL;
-	node->cur_eq_funcs = NULL;
+	sstate->xprstate.evalfunc = (ExprStateEvalFunc) ExecSubPlan;
+	sstate->xprstate.expr = (Expr *) subplan;
 
-	/*
-	 * create an EState for the subplan
-	 *
-	 * The subquery needs its own EState because it has its own rangetable. It
-	 * shares our Param ID space and es_query_cxt, however.  XXX if rangetable
-	 * access were done differently, the subquery could share our EState,
-	 * which would eliminate some thrashing about in this module...
-	 *
-	 * XXX make that happen!
-	 */
-	sp_estate = CreateSubExecutorState(estate);
-	node->sub_estate = sp_estate;
-
-	sp_estate->es_range_table = estate->es_range_table;
-	sp_estate->es_param_list_info = estate->es_param_list_info;
-	sp_estate->es_param_exec_vals = estate->es_param_exec_vals;
-	sp_estate->es_tupleTable =
-		ExecCreateTupleTable(ExecCountSlotsNode(plan) + 10);
-	sp_estate->es_snapshot = estate->es_snapshot;
-	sp_estate->es_crosscheck_snapshot = estate->es_crosscheck_snapshot;
-	sp_estate->es_instrument = estate->es_instrument;
-	sp_estate->es_plannedstmt = estate->es_plannedstmt;
+	/* Link the SubPlanState to already-initialized subplan */
+	sstate->planstate = (PlanState *) list_nth(estate->es_subplanstates,
+											   subplan->plan_id - 1);
+
+	/* Initialize subexpressions */
+	sstate->testexpr = ExecInitExpr((Expr *) subplan->testexpr, parent);
+	sstate->args = (List *) ExecInitExpr((Expr *) subplan->args, parent);
 
 	/*
-	 * Start up the subplan (this is a very cut-down form of InitPlan())
-	 *
-	 * The subplan will never need to do BACKWARD scan or MARK/RESTORE. If it
-	 * is a parameterless subplan (not initplan), we suggest that it be
-	 * prepared to handle REWIND efficiently; otherwise there is no need.
+	 * initialize my state
 	 */
-	eflags &= EXEC_FLAG_EXPLAIN_ONLY;
-	if (subplan->parParam == NIL && subplan->setParam == NIL)
-		eflags |= EXEC_FLAG_REWIND;
-
-	node->planstate = ExecInitNode(plan, sp_estate, eflags);
-
-	node->needShutdown = true;	/* now we need to shutdown the subplan */
+	sstate->curTuple = NULL;
+	sstate->projLeft = NULL;
+	sstate->projRight = NULL;
+	sstate->hashtable = NULL;
+	sstate->hashnulls = NULL;
+	sstate->tablecxt = NULL;
+	sstate->innerecontext = NULL;
+	sstate->keyColIdx = NULL;
+	sstate->tab_hash_funcs = NULL;
+	sstate->tab_eq_funcs = NULL;
+	sstate->lhs_hash_funcs = NULL;
+	sstate->cur_eq_funcs = NULL;
 
 	/*
 	 * If this plan is un-correlated or undirect correlated one and want to
@@ -712,7 +682,7 @@ ExecInitSubPlan(SubPlanState *node, EState *estate, int eflags)
 			int			paramid = lfirst_int(lst);
 			ParamExecData *prm = &(estate->es_param_exec_vals[paramid]);
 
-			prm->execPlan = node;
+			prm->execPlan = sstate;
 		}
 	}
 
@@ -735,19 +705,19 @@ ExecInitSubPlan(SubPlanState *node, EState *estate, int eflags)
 		ListCell   *l;
 
 		/* We need a memory context to hold the hash table(s) */
-		node->tablecxt =
+		sstate->tablecxt =
 			AllocSetContextCreate(CurrentMemoryContext,
 								  "Subplan HashTable Context",
 								  ALLOCSET_DEFAULT_MINSIZE,
 								  ALLOCSET_DEFAULT_INITSIZE,
 								  ALLOCSET_DEFAULT_MAXSIZE);
 		/* and a short-lived exprcontext for function evaluation */
-		node->innerecontext = CreateExprContext(estate);
+		sstate->innerecontext = CreateExprContext(estate);
 		/* Silly little array of column numbers 1..n */
 		ncols = list_length(subplan->paramIds);
-		node->keyColIdx = (AttrNumber *) palloc(ncols * sizeof(AttrNumber));
+		sstate->keyColIdx = (AttrNumber *) palloc(ncols * sizeof(AttrNumber));
 		for (i = 0; i < ncols; i++)
-			node->keyColIdx[i] = i + 1;
+			sstate->keyColIdx[i] = i + 1;
 
 		/*
 		 * We use ExecProject to evaluate the lefthand and righthand
@@ -763,32 +733,32 @@ ExecInitSubPlan(SubPlanState *node, EState *estate, int eflags)
 		 * We also extract the combining operators themselves to initialize
 		 * the equality and hashing functions for the hash tables.
 		 */
-		if (IsA(node->testexpr->expr, OpExpr))
+		if (IsA(sstate->testexpr->expr, OpExpr))
 		{
 			/* single combining operator */
-			oplist = list_make1(node->testexpr);
+			oplist = list_make1(sstate->testexpr);
 		}
-		else if (and_clause((Node *) node->testexpr->expr))
+		else if (and_clause((Node *) sstate->testexpr->expr))
 		{
 			/* multiple combining operators */
-			Assert(IsA(node->testexpr, BoolExprState));
-			oplist = ((BoolExprState *) node->testexpr)->args;
+			Assert(IsA(sstate->testexpr, BoolExprState));
+			oplist = ((BoolExprState *) sstate->testexpr)->args;
 		}
 		else
 		{
 			/* shouldn't see anything else in a hashable subplan */
 			elog(ERROR, "unrecognized testexpr type: %d",
-				 (int) nodeTag(node->testexpr->expr));
+				 (int) nodeTag(sstate->testexpr->expr));
 			oplist = NIL;		/* keep compiler quiet */
 		}
 		Assert(list_length(oplist) == ncols);
 
 		lefttlist = righttlist = NIL;
 		leftptlist = rightptlist = NIL;
-		node->tab_hash_funcs = (FmgrInfo *) palloc(ncols * sizeof(FmgrInfo));
-		node->tab_eq_funcs = (FmgrInfo *) palloc(ncols * sizeof(FmgrInfo));
-		node->lhs_hash_funcs = (FmgrInfo *) palloc(ncols * sizeof(FmgrInfo));
-		node->cur_eq_funcs = (FmgrInfo *) palloc(ncols * sizeof(FmgrInfo));
+		sstate->tab_hash_funcs = (FmgrInfo *) palloc(ncols * sizeof(FmgrInfo));
+		sstate->tab_eq_funcs = (FmgrInfo *) palloc(ncols * sizeof(FmgrInfo));
+		sstate->lhs_hash_funcs = (FmgrInfo *) palloc(ncols * sizeof(FmgrInfo));
+		sstate->cur_eq_funcs = (FmgrInfo *) palloc(ncols * sizeof(FmgrInfo));
 		i = 1;
 		foreach(l, oplist)
 		{
@@ -835,23 +805,23 @@ ExecInitSubPlan(SubPlanState *node, EState *estate, int eflags)
 			rightptlist = lappend(rightptlist, tle);
 
 			/* Lookup the equality function (potentially cross-type) */
-			fmgr_info(opexpr->opfuncid, &node->cur_eq_funcs[i - 1]);
-			node->cur_eq_funcs[i - 1].fn_expr = (Node *) opexpr;
+			fmgr_info(opexpr->opfuncid, &sstate->cur_eq_funcs[i - 1]);
+			sstate->cur_eq_funcs[i - 1].fn_expr = (Node *) opexpr;
 
 			/* Look up the equality function for the RHS type */
 			if (!get_compatible_hash_operators(opexpr->opno,
 											   NULL, &rhs_eq_oper))
 				elog(ERROR, "could not find compatible hash operator for operator %u",
 					 opexpr->opno);
-			fmgr_info(get_opcode(rhs_eq_oper), &node->tab_eq_funcs[i - 1]);
+			fmgr_info(get_opcode(rhs_eq_oper), &sstate->tab_eq_funcs[i - 1]);
 
 			/* Lookup the associated hash functions */
 			if (!get_op_hash_functions(opexpr->opno,
 									   &left_hashfn, &right_hashfn))
 				elog(ERROR, "could not find hash function for hash operator %u",
 					 opexpr->opno);
-			fmgr_info(left_hashfn, &node->lhs_hash_funcs[i - 1]);
-			fmgr_info(right_hashfn, &node->tab_hash_funcs[i - 1]);
+			fmgr_info(left_hashfn, &sstate->lhs_hash_funcs[i - 1]);
+			fmgr_info(right_hashfn, &sstate->tab_hash_funcs[i - 1]);
 
 			i++;
 		}
@@ -876,7 +846,7 @@ ExecInitSubPlan(SubPlanState *node, EState *estate, int eflags)
 		tupDesc = ExecTypeFromTL(leftptlist, false);
 		slot = ExecAllocTableSlot(tupTable);
 		ExecSetSlotDescriptor(slot, tupDesc);
-		node->projLeft = ExecBuildProjectionInfo(lefttlist,
+		sstate->projLeft = ExecBuildProjectionInfo(lefttlist,
 												 NULL,
 												 slot,
 												 NULL);
@@ -884,11 +854,13 @@ ExecInitSubPlan(SubPlanState *node, EState *estate, int eflags)
 		tupDesc = ExecTypeFromTL(rightptlist, false);
 		slot = ExecAllocTableSlot(tupTable);
 		ExecSetSlotDescriptor(slot, tupDesc);
-		node->projRight = ExecBuildProjectionInfo(righttlist,
-												  node->innerecontext,
+		sstate->projRight = ExecBuildProjectionInfo(righttlist,
+												  sstate->innerecontext,
 												  slot,
 												  NULL);
 	}
+
+	return sstate;
 }
 
 /* ----------------------------------------------------------------
@@ -917,9 +889,9 @@ ExecSetParamPlan(SubPlanState *node, ExprContext *econtext)
 	ArrayBuildState *astate = NULL;
 
 	/*
-	 * Must switch to child query's per-query memory context.
+	 * Must switch to per-query memory context.
 	 */
-	oldcontext = MemoryContextSwitchTo(node->sub_estate->es_query_cxt);
+	oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
 
 	if (subLinkType == ANY_SUBLINK ||
 		subLinkType == ALL_SUBLINK)
@@ -978,11 +950,9 @@ ExecSetParamPlan(SubPlanState *node, ExprContext *econtext)
 		 * the param structs will point at this copied tuple! node->curTuple
 		 * keeps track of the copied tuple for eventual freeing.
 		 */
-		MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
 		if (node->curTuple)
 			heap_freetuple(node->curTuple);
 		node->curTuple = ExecCopySlotTuple(slot);
-		MemoryContextSwitchTo(node->sub_estate->es_query_cxt);
 
 		/*
 		 * Now set all the setParam params from the columns of the tuple
@@ -1040,23 +1010,6 @@ ExecSetParamPlan(SubPlanState *node, ExprContext *econtext)
 	MemoryContextSwitchTo(oldcontext);
 }
 
-/* ----------------------------------------------------------------
- *		ExecEndSubPlan
- * ----------------------------------------------------------------
- */
-void
-ExecEndSubPlan(SubPlanState *node)
-{
-	if (node->needShutdown)
-	{
-		ExecEndPlan(node->planstate, node->sub_estate);
-		FreeExecutorState(node->sub_estate);
-		node->sub_estate = NULL;
-		node->planstate = NULL;
-		node->needShutdown = false;
-	}
-}
-
 /*
  * Mark an initplan as needing recalculation
  */

src/backend/executor/nodeSubqueryscan.c

@@ -12,7 +12,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/executor/nodeSubqueryscan.c,v 1.36 2007/02/22 22:00:23 tgl Exp $
+ *	  $PostgreSQL: pgsql/src/backend/executor/nodeSubqueryscan.c,v 1.37 2007/02/27 01:11:25 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -45,16 +45,8 @@ static TupleTableSlot *SubqueryNext(SubqueryScanState *node);
 static TupleTableSlot *
 SubqueryNext(SubqueryScanState *node)
 {
-	EState	   *estate;
-	ScanDirection direction;
 	TupleTableSlot *slot;
 
-	/*
-	 * get information from the estate and scan state
-	 */
-	estate = node->ss.ps.state;
-	direction = estate->es_direction;
-
 	/*
 	 * We need not support EvalPlanQual here, since we are not scanning a real
 	 * relation.
@@ -63,8 +55,6 @@ SubqueryNext(SubqueryScanState *node)
 	/*
 	 * Get the next tuple from the sub-query.
 	 */
-	node->sss_SubEState->es_direction = direction;
-
 	slot = ExecProcNode(node->subplan);
 
 	/*
@@ -103,7 +93,6 @@ SubqueryScanState *
 ExecInitSubqueryScan(SubqueryScan *node, EState *estate, int eflags)
 {
 	SubqueryScanState *subquerystate;
-	EState	   *sp_estate;
 
 	/* check for unsupported flags */
 	Assert(!(eflags & EXEC_FLAG_MARK));
@@ -150,44 +139,16 @@ ExecInitSubqueryScan(SubqueryScan *node, EState *estate, int eflags)
 
 	/*
 	 * initialize subquery
-	 *
-	 * This should agree with ExecInitSubPlan
-	 *
-	 * The subquery needs its own EState because it has its own rangetable. It
-	 * shares our Param ID space and es_query_cxt, however.  XXX if rangetable
-	 * access were done differently, the subquery could share our EState,
-	 * which would eliminate some thrashing about in this module...
-	 *
-	 * XXX make that happen!
 	 */
-	sp_estate = CreateSubExecutorState(estate);
-	subquerystate->sss_SubEState = sp_estate;
-
-	sp_estate->es_range_table = estate->es_range_table;
-	sp_estate->es_param_list_info = estate->es_param_list_info;
-	sp_estate->es_param_exec_vals = estate->es_param_exec_vals;
-	sp_estate->es_tupleTable =
-		ExecCreateTupleTable(ExecCountSlotsNode(node->subplan) + 10);
-	sp_estate->es_snapshot = estate->es_snapshot;
-	sp_estate->es_crosscheck_snapshot = estate->es_crosscheck_snapshot;
-	sp_estate->es_instrument = estate->es_instrument;
-	sp_estate->es_plannedstmt = estate->es_plannedstmt;
-
-	/*
-	 * Start up the subplan (this is a very cut-down form of InitPlan())
-	 */
-	subquerystate->subplan = ExecInitNode(node->subplan, sp_estate, eflags);
+	subquerystate->subplan = ExecInitNode(node->subplan, estate, eflags);
 
 	subquerystate->ss.ps.ps_TupFromTlist = false;
 
 	/*
-	 * Initialize scan tuple type (needed by ExecAssignScanProjectionInfo).
-	 * Because the subplan is in its own memory context, we need to copy its
-	 * result tuple type not just link to it; else the tupdesc will disappear
-	 * too soon during shutdown.
+	 * Initialize scan tuple type (needed by ExecAssignScanProjectionInfo)
 	 */
 	ExecAssignScanType(&subquerystate->ss,
-			 CreateTupleDescCopy(ExecGetResultType(subquerystate->subplan)));
+					   ExecGetResultType(subquerystate->subplan));
 
 	/*
 	 * Initialize result tuple type and projection info.
@@ -201,11 +162,9 @@ ExecInitSubqueryScan(SubqueryScan *node, EState *estate, int eflags)
 int
 ExecCountSlotsSubqueryScan(SubqueryScan *node)
 {
-	/*
-	 * The subplan has its own tuple table and must not be counted here!
-	 */
-	return ExecCountSlotsNode(outerPlan(node)) +
-		ExecCountSlotsNode(innerPlan(node)) +
+	Assert(outerPlan(node) == NULL);
+	Assert(innerPlan(node) == NULL);
+	return ExecCountSlotsNode(node->subplan) +
 		SUBQUERYSCAN_NSLOTS;
 }
 
@@ -232,9 +191,7 @@ ExecEndSubqueryScan(SubqueryScanState *node)
 	/*
 	 * close down subquery
 	 */
-	ExecEndPlan(node->subplan, node->sss_SubEState);
-
-	FreeExecutorState(node->sss_SubEState);
+	ExecEndNode(node->subplan);
 }
 
 /* ----------------------------------------------------------------

src/backend/nodes/copyfuncs.c

@@ -15,7 +15,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/nodes/copyfuncs.c,v 1.368 2007/02/22 22:00:23 tgl Exp $
+ *	  $PostgreSQL: pgsql/src/backend/nodes/copyfuncs.c,v 1.369 2007/02/27 01:11:25 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -79,6 +79,7 @@ _copyPlannedStmt(PlannedStmt *from)
 	COPY_NODE_FIELD(resultRelations);
 	COPY_NODE_FIELD(into);
 	COPY_NODE_FIELD(subplans);
+	COPY_BITMAPSET_FIELD(rewindPlanIDs);
 	COPY_NODE_FIELD(returningLists);
 	COPY_NODE_FIELD(rowMarks);
 	COPY_SCALAR_FIELD(nParamExec);

src/backend/nodes/outfuncs.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/nodes/outfuncs.c,v 1.301 2007/02/22 22:00:23 tgl Exp $
+ *	  $PostgreSQL: pgsql/src/backend/nodes/outfuncs.c,v 1.302 2007/02/27 01:11:25 tgl Exp $
  *
  * NOTES
  *	  Every node type that can appear in stored rules' parsetrees *must*
@@ -246,6 +246,7 @@ _outPlannedStmt(StringInfo str, PlannedStmt *node)
 	WRITE_NODE_FIELD(resultRelations);
 	WRITE_NODE_FIELD(into);
 	WRITE_NODE_FIELD(subplans);
+	WRITE_BITMAPSET_FIELD(rewindPlanIDs);
 	WRITE_NODE_FIELD(returningLists);
 	WRITE_NODE_FIELD(rowMarks);
 	WRITE_INT_FIELD(nParamExec);
@@ -1262,6 +1263,7 @@ _outPlannerGlobal(StringInfo str, PlannerGlobal *node)
 	WRITE_NODE_FIELD(paramlist);
 	WRITE_NODE_FIELD(subplans);
 	WRITE_NODE_FIELD(subrtables);
+	WRITE_BITMAPSET_FIELD(rewindPlanIDs);
 	WRITE_NODE_FIELD(finalrtable);
 }
 

src/backend/optimizer/plan/planner.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/optimizer/plan/planner.c,v 1.215 2007/02/22 22:00:24 tgl Exp $
+ *	  $PostgreSQL: pgsql/src/backend/optimizer/plan/planner.c,v 1.216 2007/02/27 01:11:25 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -103,6 +103,7 @@ planner(Query *parse, bool isCursor, int cursorOptions,
 	glob->paramlist = NIL;
 	glob->subplans = NIL;
 	glob->subrtables = NIL;
+	glob->rewindPlanIDs = NULL;
 	glob->finalrtable = NIL;
 
 	/* Determine what fraction of the plan is likely to be scanned */
@@ -158,6 +159,7 @@ planner(Query *parse, bool isCursor, int cursorOptions,
 	result->resultRelations = root->resultRelations;
 	result->into = parse->into;
 	result->subplans = glob->subplans;
+	result->rewindPlanIDs = glob->rewindPlanIDs;
 	result->returningLists = root->returningLists;
 	result->rowMarks = parse->rowMarks;
 	result->nParamExec = list_length(glob->paramlist);

src/backend/optimizer/plan/subselect.c

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/optimizer/plan/subselect.c,v 1.121 2007/02/22 22:00:24 tgl Exp $
+ *	  $PostgreSQL: pgsql/src/backend/optimizer/plan/subselect.c,v 1.122 2007/02/27 01:11:25 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -241,9 +241,10 @@ make_subplan(PlannerInfo *root, SubLink *slink, Node *testexpr, bool isTopQual)
 {
 	Query	   *subquery = (Query *) (slink->subselect);
 	double		tuple_fraction;
-	SubPlan    *node;
+	SubPlan    *splan;
 	Plan	   *plan;
 	PlannerInfo *subroot;
+	bool		isInitPlan;
 	Bitmapset  *tmpset;
 	int			paramid;
 	Node	   *result;
@@ -295,17 +296,17 @@ make_subplan(PlannerInfo *root, SubLink *slink, Node *testexpr, bool isTopQual)
 	/*
 	 * Initialize the SubPlan node.  Note plan_id isn't set yet.
 	 */
-	node = makeNode(SubPlan);
-	node->subLinkType = slink->subLinkType;
-	node->testexpr = NULL;
-	node->paramIds = NIL;
-	node->firstColType = get_first_col_type(plan);
-	node->useHashTable = false;
+	splan = makeNode(SubPlan);
+	splan->subLinkType = slink->subLinkType;
+	splan->testexpr = NULL;
+	splan->paramIds = NIL;
+	splan->firstColType = get_first_col_type(plan);
+	splan->useHashTable = false;
 	/* At top level of a qual, can treat UNKNOWN the same as FALSE */
-	node->unknownEqFalse = isTopQual;
-	node->setParam = NIL;
-	node->parParam = NIL;
-	node->args = NIL;
+	splan->unknownEqFalse = isTopQual;
+	splan->setParam = NIL;
+	splan->parParam = NIL;
+	splan->args = NIL;
 
 	/*
 	 * Make parParam list of params that current query level will pass to this
@@ -317,7 +318,7 @@ make_subplan(PlannerInfo *root, SubLink *slink, Node *testexpr, bool isTopQual)
 		PlannerParamItem *pitem = list_nth(root->glob->paramlist, paramid);
 
 		if (pitem->abslevel == root->query_level)
-			node->parParam = lappend_int(node->parParam, paramid);
+			splan->parParam = lappend_int(splan->parParam, paramid);
 	}
 	bms_free(tmpset);
 
@@ -329,16 +330,16 @@ make_subplan(PlannerInfo *root, SubLink *slink, Node *testexpr, bool isTopQual)
 	 * PARAM_EXEC Params instead of the PARAM_SUBLINK Params emitted by the
 	 * parser.
 	 */
-	if (node->parParam == NIL && slink->subLinkType == EXISTS_SUBLINK)
+	if (splan->parParam == NIL && slink->subLinkType == EXISTS_SUBLINK)
 	{
 		Param	   *prm;
 
 		prm = generate_new_param(root, BOOLOID, -1);
-		node->setParam = list_make1_int(prm->paramid);
-		root->init_plans = lappend(root->init_plans, node);
+		splan->setParam = list_make1_int(prm->paramid);
+		isInitPlan = true;
 		result = (Node *) prm;
 	}
-	else if (node->parParam == NIL && slink->subLinkType == EXPR_SUBLINK)
+	else if (splan->parParam == NIL && slink->subLinkType == EXPR_SUBLINK)
 	{
 		TargetEntry *te = linitial(plan->targetlist);
 		Param	   *prm;
@@ -347,11 +348,11 @@ make_subplan(PlannerInfo *root, SubLink *slink, Node *testexpr, bool isTopQual)
 		prm = generate_new_param(root,
 								 exprType((Node *) te->expr),
 								 exprTypmod((Node *) te->expr));
-		node->setParam = list_make1_int(prm->paramid);
-		root->init_plans = lappend(root->init_plans, node);
+		splan->setParam = list_make1_int(prm->paramid);
+		isInitPlan = true;
 		result = (Node *) prm;
 	}
-	else if (node->parParam == NIL && slink->subLinkType == ARRAY_SUBLINK)
+	else if (splan->parParam == NIL && slink->subLinkType == ARRAY_SUBLINK)
 	{
 		TargetEntry *te = linitial(plan->targetlist);
 		Oid			arraytype;
@@ -365,19 +366,19 @@ make_subplan(PlannerInfo *root, SubLink *slink, Node *testexpr, bool isTopQual)
 		prm = generate_new_param(root,
 								 arraytype,
 								 exprTypmod((Node *) te->expr));
-		node->setParam = list_make1_int(prm->paramid);
-		root->init_plans = lappend(root->init_plans, node);
+		splan->setParam = list_make1_int(prm->paramid);
+		isInitPlan = true;
 		result = (Node *) prm;
 	}
-	else if (node->parParam == NIL && slink->subLinkType == ROWCOMPARE_SUBLINK)
+	else if (splan->parParam == NIL && slink->subLinkType == ROWCOMPARE_SUBLINK)
 	{
 		/* Adjust the Params */
 		result = convert_testexpr(root,
 								  testexpr,
 								  0,
-								  &node->paramIds);
-		node->setParam = list_copy(node->paramIds);
-		root->init_plans = lappend(root->init_plans, node);
+								  &splan->paramIds);
+		splan->setParam = list_copy(splan->paramIds);
+		isInitPlan = true;
 
 		/*
 		 * The executable expression is returned to become part of the outer
@@ -390,10 +391,10 @@ make_subplan(PlannerInfo *root, SubLink *slink, Node *testexpr, bool isTopQual)
 		ListCell   *l;
 
 		/* Adjust the Params */
-		node->testexpr = convert_testexpr(root,
-										  testexpr,
-										  0,
-										  &node->paramIds);
+		splan->testexpr = convert_testexpr(root,
+										   testexpr,
+										   0,
+										   &splan->paramIds);
 
 		/*
 		 * We can't convert subplans of ALL_SUBLINK or ANY_SUBLINK types to
@@ -402,8 +403,8 @@ make_subplan(PlannerInfo *root, SubLink *slink, Node *testexpr, bool isTopQual)
 		 * tuple.  But if it's an IN (= ANY) test, we might be able to use a
 		 * hashtable to avoid comparing all the tuples.
 		 */
-		if (subplan_is_hashable(slink, node, plan))
-			node->useHashTable = true;
+		if (subplan_is_hashable(slink, splan, plan))
+			splan->useHashTable = true;
 
 		/*
 		 * Otherwise, we have the option to tack a MATERIAL node onto the top
@@ -413,7 +414,7 @@ make_subplan(PlannerInfo *root, SubLink *slink, Node *testexpr, bool isTopQual)
 		 * correlated subplans, we add MATERIAL unless the subplan's top plan
 		 * node would materialize its output anyway.
 		 */
-		else if (node->parParam == NIL)
+		else if (splan->parParam == NIL)
 		{
 			bool		use_material;
 
@@ -433,10 +434,10 @@ make_subplan(PlannerInfo *root, SubLink *slink, Node *testexpr, bool isTopQual)
 		}
 
 		/*
-		 * Make node->args from parParam.
+		 * Make splan->args from parParam.
 		 */
 		args = NIL;
-		foreach(l, node->parParam)
+		foreach(l, splan->parParam)
 		{
 			PlannerParamItem *pitem = list_nth(root->glob->paramlist,
 											   lfirst_int(l));
@@ -448,9 +449,10 @@ make_subplan(PlannerInfo *root, SubLink *slink, Node *testexpr, bool isTopQual)
 			 */
 			args = lappend(args, copyObject(pitem->item));
 		}
-		node->args = args;
+		splan->args = args;
 
-		result = (Node *) node;
+		result = (Node *) splan;
+		isInitPlan = false;
 	}
 
 	/*
@@ -460,7 +462,22 @@ make_subplan(PlannerInfo *root, SubLink *slink, Node *testexpr, bool isTopQual)
 								   plan);
 	root->glob->subrtables = lappend(root->glob->subrtables,
 									 subroot->parse->rtable);
-	node->plan_id = list_length(root->glob->subplans);
+	splan->plan_id = list_length(root->glob->subplans);
+
+	if (isInitPlan)
+		root->init_plans = lappend(root->init_plans, splan);
+
+	/*
+	 * A parameterless subplan (not initplan) should be prepared to handle
+	 * REWIND efficiently.  If it has direct parameters then there's no point
+	 * since it'll be reset on each scan anyway; and if it's an initplan
+	 * then there's no point since it won't get re-run without parameter
+	 * changes anyway.  The input of a hashed subplan doesn't need REWIND
+	 * either.
+	 */
+	if (splan->parParam == NIL && !isInitPlan && !splan->useHashTable)
+		root->glob->rewindPlanIDs = bms_add_member(root->glob->rewindPlanIDs,
+												   splan->plan_id);
 
 	return result;
 }

src/include/executor/executor.h

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2007, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $PostgreSQL: pgsql/src/include/executor/executor.h,v 1.138 2007/02/22 22:00:25 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/executor/executor.h,v 1.139 2007/02/27 01:11:25 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -130,7 +130,6 @@ extern TupleTableSlot *ExecutorRun(QueryDesc *queryDesc,
 			ScanDirection direction, long count);
 extern void ExecutorEnd(QueryDesc *queryDesc);
 extern void ExecutorRewind(QueryDesc *queryDesc);
-extern void ExecEndPlan(PlanState *planstate, EState *estate);
 extern bool ExecContextForcesOids(PlanState *planstate, bool *hasoids);
 extern void ExecConstraints(ResultRelInfo *resultRelInfo,
 				TupleTableSlot *slot, EState *estate);
@@ -167,7 +166,6 @@ extern Tuplestorestate *ExecMakeTableFunctionResult(ExprState *funcexpr,
 extern Datum ExecEvalExprSwitchContext(ExprState *expression, ExprContext *econtext,
 						  bool *isNull, ExprDoneCond *isDone);
 extern ExprState *ExecInitExpr(Expr *node, PlanState *parent);
-extern SubPlanState *ExecInitExprInitPlan(SubPlan *node, PlanState *parent);
 extern ExprState *ExecPrepareExpr(Expr *node, EState *estate);
 extern bool ExecQual(List *qual, ExprContext *econtext, bool resultForNull);
 extern int	ExecTargetListLength(List *targetlist);
@@ -227,7 +225,6 @@ extern void end_tup_output(TupOutputState *tstate);
  * prototypes from functions in execUtils.c
  */
 extern EState *CreateExecutorState(void);
-extern EState *CreateSubExecutorState(EState *parent_estate);
 extern void FreeExecutorState(EState *estate);
 extern ExprContext *CreateExprContext(EState *estate);
 extern ExprContext *CreateStandaloneExprContext(void);

src/include/executor/nodeSubplan.h

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2007, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $PostgreSQL: pgsql/src/include/executor/nodeSubplan.h,v 1.25 2007/01/05 22:19:54 momjian Exp $
+ * $PostgreSQL: pgsql/src/include/executor/nodeSubplan.h,v 1.26 2007/02/27 01:11:26 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -16,12 +16,12 @@
 
 #include "nodes/execnodes.h"
 
-extern void ExecInitSubPlan(SubPlanState *node, EState *estate, int eflags);
+extern SubPlanState *ExecInitSubPlan(SubPlan *subplan, PlanState *parent);
 extern Datum ExecSubPlan(SubPlanState *node,
 			ExprContext *econtext,
 			bool *isNull,
 			ExprDoneCond *isDone);
-extern void ExecEndSubPlan(SubPlanState *node);
+
 extern void ExecReScanSetParamPlan(SubPlanState *node, PlanState *parent);
 
 extern void ExecSetParamPlan(SubPlanState *node, ExprContext *econtext);

src/include/nodes/execnodes.h

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2007, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $PostgreSQL: pgsql/src/include/nodes/execnodes.h,v 1.169 2007/02/22 22:00:25 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/nodes/execnodes.h,v 1.170 2007/02/27 01:11:26 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -328,14 +328,14 @@ typedef struct EState
 	Oid			es_lastoid;		/* last oid processed (by INSERT) */
 	List	   *es_rowMarks;	/* not good place, but there is no other */
 
-	bool		es_is_subquery;	/* true if subquery (es_query_cxt not mine) */
-
 	bool		es_instrument;	/* true requests runtime instrumentation */
 	bool		es_select_into; /* true if doing SELECT INTO */
 	bool		es_into_oids;	/* true to generate OIDs in SELECT INTO */
 
 	List	   *es_exprcontexts;	/* List of ExprContexts within EState */
 
+	List	   *es_subplanstates;	/* List of PlanState for SubPlans */
+
 	/*
 	 * this ExprContext is for per-output-tuple operations, such as constraint
 	 * checks and index-value computations.  It will be reset for each output
@@ -582,11 +582,9 @@ typedef struct BoolExprState
 typedef struct SubPlanState
 {
 	ExprState	xprstate;
-	EState	   *sub_estate;		/* subselect plan has its own EState */
 	struct PlanState *planstate;	/* subselect plan's state tree */
 	ExprState  *testexpr;		/* state of combining expression */
 	List	   *args;			/* states of argument expression(s) */
-	bool		needShutdown;	/* TRUE = need to shutdown subplan */
 	HeapTuple	curTuple;		/* copy of most recent tuple from subplan */
 	/* these are used when hashing the subselect's output: */
 	ProjectionInfo *projLeft;	/* for projecting lefthand exprs */
@@ -1060,17 +1058,13 @@ typedef struct TidScanState
  *	 SubqueryScanState information
  *
  *		SubqueryScanState is used for scanning a sub-query in the range table.
- *		The sub-query will have its own EState, which we save here.
  *		ScanTupleSlot references the current output tuple of the sub-query.
- *
- *		SubEState		   exec state for sub-query
  * ----------------
  */
 typedef struct SubqueryScanState
 {
 	ScanState	ss;				/* its first field is NodeTag */
 	PlanState  *subplan;
-	EState	   *sss_SubEState;
 } SubqueryScanState;
 
 /* ----------------

src/include/nodes/plannodes.h

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2007, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $PostgreSQL: pgsql/src/include/nodes/plannodes.h,v 1.92 2007/02/22 22:00:25 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/nodes/plannodes.h,v 1.93 2007/02/27 01:11:26 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -50,6 +50,8 @@ typedef struct PlannedStmt
 
 	List	   *subplans;		/* Plan trees for SubPlan expressions */
 
+	Bitmapset  *rewindPlanIDs;	/* indices of subplans that require REWIND */
+
 	/*
 	 * If the query has a returningList then the planner will store a list of
 	 * processed targetlists (one per result relation) here.  We must have a

src/include/nodes/relation.h

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2007, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $PostgreSQL: pgsql/src/include/nodes/relation.h,v 1.138 2007/02/22 22:00:26 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/nodes/relation.h,v 1.139 2007/02/27 01:11:26 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -68,6 +68,8 @@ typedef struct PlannerGlobal
 
 	List	   *subrtables;		/* Rangetables for SubPlan nodes */
 
+	Bitmapset  *rewindPlanIDs;	/* indices of subplans that require REWIND */
+
 	List	   *finalrtable;	/* "flat" rangetable for executor */
 } PlannerGlobal;