*
*
* 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 $
*
*-------------------------------------------------------------------------
*/
List *rangeTable,
CmdType operation,
bool doInstrument);
+static void ExecEndPlan(PlanState *planstate, EState *estate);
static TupleTableSlot *ExecutePlan(EState *estate, PlanState *planstate,
CmdType operation,
long numberTuples,
PlanState *planstate;
TupleDesc tupType;
ListCell *l;
+ int i;
/*
* Do permissions checks
}
/*
- * 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
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.
*/
PlanState **appendplans;
int as_nplans;
ResultRelInfo *resultRelInfo;
- int i;
/* Top plan had better be an Append here. */
Assert(IsA(plan, Append));
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;
* tuple tables must be cleared or dropped to ensure pins are released.
* ----------------------------------------------------------------
*/
-void
+static void
ExecEndPlan(PlanState *planstate, EState *estate)
{
ResultRelInfo *resultRelInfo;
*/
ExecEndNode(planstate);
+ /*
+ * for subplans too
+ */
+ foreach(l, estate->es_subplanstates)
+ {
+ PlanState *subplanstate = (PlanState *) lfirst(l);
+
+ ExecEndNode(subplanstate);
+ }
+
/*
* destroy the executor "tuple" table.
*/
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);
/* 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);
{
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;
*
*
* 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 $
*
*-------------------------------------------------------------------------
*/
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);
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);
*
*
* 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 $
*
*-------------------------------------------------------------------------
*/
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;
}
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.
*
*
* 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
int NIndexTupleProcessed;
-static EState *InternalCreateExecutorState(MemoryContext qcontext,
- bool is_subquery);
static void ShutdownExprContext(ExprContext *econtext);
EState *
CreateExecutorState(void)
{
+ EState *estate;
MemoryContext qcontext;
+ MemoryContext oldcontext;
/*
* Create the per-query context for this Executor run.
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.
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;
/*
* 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);
}
/* ----------------
* 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 $
*
*-------------------------------------------------------------------------
*/
* INTERFACE ROUTINES
* ExecSubPlan - process a subselect
* ExecInitSubPlan - initialize a subselect
- * ExecEndSubPlan - shut down a subselect
*/
#include "postgres.h"
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);
* 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
/*
* 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
* 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 */
* 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;
/*
* 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.
/* ----------------------------------------------------------------
* 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
int paramid = lfirst_int(lst);
ParamExecData *prm = &(estate->es_param_exec_vals[paramid]);
- prm->execPlan = node;
+ prm->execPlan = sstate;
}
}
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
* 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)
{
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++;
}
tupDesc = ExecTypeFromTL(leftptlist, false);
slot = ExecAllocTableSlot(tupTable);
ExecSetSlotDescriptor(slot, tupDesc);
- node->projLeft = ExecBuildProjectionInfo(lefttlist,
+ sstate->projLeft = ExecBuildProjectionInfo(lefttlist,
NULL,
slot,
NULL);
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;
}
/* ----------------------------------------------------------------
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)
* 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
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
*/
*
*
* 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 $
*
*-------------------------------------------------------------------------
*/
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.
/*
* Get the next tuple from the sub-query.
*/
- node->sss_SubEState->es_direction = direction;
-
slot = ExecProcNode(node->subplan);
/*
ExecInitSubqueryScan(SubqueryScan *node, EState *estate, int eflags)
{
SubqueryScanState *subquerystate;
- EState *sp_estate;
/* check for unsupported flags */
Assert(!(eflags & EXEC_FLAG_MARK));
/*
* 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.
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;
}
/*
* close down subquery
*/
- ExecEndPlan(node->subplan, node->sss_SubEState);
-
- FreeExecutorState(node->sss_SubEState);
+ ExecEndNode(node->subplan);
}
/* ----------------------------------------------------------------
* 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 $
*
*-------------------------------------------------------------------------
*/
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);
*
*
* 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*
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);
WRITE_NODE_FIELD(paramlist);
WRITE_NODE_FIELD(subplans);
WRITE_NODE_FIELD(subrtables);
+ WRITE_BITMAPSET_FIELD(rewindPlanIDs);
WRITE_NODE_FIELD(finalrtable);
}
*
*
* 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 $
*
*-------------------------------------------------------------------------
*/
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 */
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);
* 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 $
*
*-------------------------------------------------------------------------
*/
{
Query *subquery = (Query *) (slink->subselect);
double tuple_fraction;
- SubPlan *node;
+ SubPlan *splan;
Plan *plan;
PlannerInfo *subroot;
+ bool isInitPlan;
Bitmapset *tmpset;
int paramid;
Node *result;
/*
* 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
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);
* 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;
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;
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
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
* 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
* 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;
}
/*
- * 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));
*/
args = lappend(args, copyObject(pitem->item));
}
- node->args = args;
+ splan->args = args;
- result = (Node *) node;
+ result = (Node *) splan;
+ isInitPlan = false;
}
/*
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;
}
* 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 $
*
*-------------------------------------------------------------------------
*/
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);
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);
* 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);
* 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 $
*
*-------------------------------------------------------------------------
*/
#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);
* 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 $
*
*-------------------------------------------------------------------------
*/
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
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 */
* 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;
/* ----------------
* 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 $
*
*-------------------------------------------------------------------------
*/
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
* 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 $
*
*-------------------------------------------------------------------------
*/
List *subrtables; /* Rangetables for SubPlan nodes */
+ Bitmapset *rewindPlanIDs; /* indices of subplans that require REWIND */
+
List *finalrtable; /* "flat" rangetable for executor */
} PlannerGlobal;
projects / postgresql.git / commitdiff