From c7ff7663e47fc4e295700101912f2b7dd53c1f4b Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Tue, 27 Feb 2007 01:11:26 +0000 Subject: [PATCH] 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 | 118 ++++++++++++---- src/backend/executor/execProcnode.c | 27 +--- src/backend/executor/execQual.c | 47 +------ src/backend/executor/execUtils.c | 49 +------ src/backend/executor/nodeSubplan.c | 179 +++++++++--------------- src/backend/executor/nodeSubqueryscan.c | 59 ++------ src/backend/nodes/copyfuncs.c | 3 +- src/backend/nodes/outfuncs.c | 4 +- src/backend/optimizer/plan/planner.c | 4 +- src/backend/optimizer/plan/subselect.c | 93 +++++++----- src/include/executor/executor.h | 5 +- src/include/executor/nodeSubplan.h | 6 +- src/include/nodes/execnodes.h | 12 +- src/include/nodes/plannodes.h | 4 +- src/include/nodes/relation.h | 4 +- 15 files changed, 257 insertions(+), 357 deletions(-) diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c index d0df0ea6f4..333edf6944 100644 --- a/src/backend/executor/execMain.c +++ b/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; diff --git a/src/backend/executor/execProcnode.c b/src/backend/executor/execProcnode.c index 0a3539204a..c4fbf9d399 100644 --- a/src/backend/executor/execProcnode.c +++ b/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); diff --git a/src/backend/executor/execQual.c b/src/backend/executor/execQual.c index 3c0536eb8a..234441c0f6 100644 --- a/src/backend/executor/execQual.c +++ b/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. diff --git a/src/backend/executor/execUtils.c b/src/backend/executor/execUtils.c index d188a38489..493df3ef9a 100644 --- a/src/backend/executor/execUtils.c +++ b/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); } /* ---------------- diff --git a/src/backend/executor/nodeSubplan.c b/src/backend/executor/nodeSubplan.c index 9bc96921f4..bb0508d6bc 100644 --- a/src/backend/executor/nodeSubplan.c +++ b/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 */ diff --git a/src/backend/executor/nodeSubqueryscan.c b/src/backend/executor/nodeSubqueryscan.c index 6d58a8cad4..159ee1b34d 100644 --- a/src/backend/executor/nodeSubqueryscan.c +++ b/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); } /* ---------------------------------------------------------------- diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c index efa1f86945..19cb0b0b6f 100644 --- a/src/backend/nodes/copyfuncs.c +++ b/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); diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c index 64f235201d..ca3c79812c 100644 --- a/src/backend/nodes/outfuncs.c +++ b/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); } diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c index b45288dc5b..9bf5516ca4 100644 --- a/src/backend/optimizer/plan/planner.c +++ b/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); diff --git a/src/backend/optimizer/plan/subselect.c b/src/backend/optimizer/plan/subselect.c index d19e9d298c..27db5c0433 100644 --- a/src/backend/optimizer/plan/subselect.c +++ b/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; } diff --git a/src/include/executor/executor.h b/src/include/executor/executor.h index 7dfcabf5ac..f9d8d107b3 100644 --- a/src/include/executor/executor.h +++ b/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); diff --git a/src/include/executor/nodeSubplan.h b/src/include/executor/nodeSubplan.h index 4a0f50fa3e..ff4c7f3796 100644 --- a/src/include/executor/nodeSubplan.h +++ b/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); diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index d0d47a8fd2..fe9ce9a4bf 100644 --- a/src/include/nodes/execnodes.h +++ b/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; /* ---------------- diff --git a/src/include/nodes/plannodes.h b/src/include/nodes/plannodes.h index 5a7445f69c..aecfb51939 100644 --- a/src/include/nodes/plannodes.h +++ b/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 diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h index 19bcb51ea0..5617c15159 100644 --- a/src/include/nodes/relation.h +++ b/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; -- 2.40.0