mirror of
https://github.com/postgres/postgres.git
synced 2025-07-03 20:02:46 +03:00
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.
This commit is contained in:
Tom Lane
@ -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;
|
||||
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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.
|
||||
|
||||
@ -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);
|
||||
}
|
||||
|
||||
/* ----------------
|
||||
|
||||
@ -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;
|
||||
|
||||
sstate->xprstate.evalfunc = (ExprStateEvalFunc) ExecSubPlan;
|
||||
sstate->xprstate.expr = (Expr *) subplan;
|
||||
|
||||
/* 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);
|
||||
|
||||
/*
|
||||
* 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;
|
||||
|
||||
/*
|
||||
* 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;
|
||||
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
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
|
||||
*/
|
||||
|
||||
@ -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);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
|
||||
Reference in New Issue
Block a user