open-dsi
/
postgres
mirror of https://github.com/postgres/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
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.
REL8_3_STABLE
Tom Lane 19 years ago
parent 4756ff3dca
commit c7ff7663e4
15 changed files with 257 additions and 357 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 118
      src/backend/executor/execMain.c
  2. 27
      src/backend/executor/execProcnode.c
  3. 47
      src/backend/executor/execQual.c
  4. 49
      src/backend/executor/execUtils.c
  5. 179
      src/backend/executor/nodeSubplan.c
  6. 59
      src/backend/executor/nodeSubqueryscan.c
  7. 3
      src/backend/nodes/copyfuncs.c
  8. 4
      src/backend/nodes/outfuncs.c
  9. 4
      src/backend/optimizer/plan/planner.c
  10. 93
      src/backend/optimizer/plan/subselect.c
  11. 5
      src/include/executor/executor.h
  12. 6
      src/include/executor/nodeSubplan.h
  13. 12
      src/include/nodes/execnodes.h
  14. 4
      src/include/nodes/plannodes.h
  15. 4
      src/include/nodes/relation.h

118
src/backend/executor/execMain.c
Unescape View File

@ -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;

27
src/backend/executor/execProcnode.c
Unescape View File

@ -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);

47
src/backend/executor/execQual.c
Unescape View File

@ -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.

49
src/backend/executor/execUtils.c
Unescape View File

@ -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);
}
/* ----------------

179
src/backend/executor/nodeSubplan.c
Unescape View File

@ -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
*/

59
src/backend/executor/nodeSubqueryscan.c
Unescape View File

@ -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);
}
/* ----------------------------------------------------------------

3
src/backend/nodes/copyfuncs.c
Unescape View File

@ -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);

4
src/backend/nodes/outfuncs.c
Unescape View File

@ -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);
}

4
src/backend/optimizer/plan/planner.c
Unescape View File

@ -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);

93
src/backend/optimizer/plan/subselect.c
Unescape View File

@ -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;
}

5
src/include/executor/executor.h
Unescape View File

@ -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);

6
src/include/executor/nodeSubplan.h
Unescape View File

@ -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);

12
src/include/nodes/execnodes.h
Unescape View File

@ -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;
/* ----------------

4
src/include/nodes/plannodes.h
Unescape View File

@ -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

4
src/include/nodes/relation.h
Unescape View File

@ -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;

Write Preview
Loading…
Cancel
Save