Skip to content

Commit 2c0ef97

Browse files
tglsfdctglsfdc
committed
Extend the ExecInitNode API so that plan nodes receive a set of flag
bits indicating which optional capabilities can actually be exercised at runtime. This will allow Sort and Material nodes, and perhaps later other nodes, to avoid unnecessary overhead in common cases. This commit just adds the infrastructure and arranges to pass the correct flag values down to plan nodes; none of the actual optimizations are here yet. I'm committing this separately in case anyone wants to measure the added overhead. (It should be negligible.) Simon Riggs and Tom Lane
1 parent 7f4f42f commit 2c0ef97

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

53 files changed

+336
-174
lines changed

‎src/backend/commands/explain.c

Lines changed: 9 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@
77
* Portions Copyright (c) 1994-5, Regents of the University of California
88
*
99
* IDENTIFICATION
10-
* $PostgreSQL: pgsql/src/backend/commands/explain.c,v 1.143 2006/02/05 02:59:16 tgl Exp $
10+
* $PostgreSQL: pgsql/src/backend/commands/explain.c,v 1.144 2006/02/28 04:10:27 tgl Exp $
1111
*
1212
*-------------------------------------------------------------------------
1313
*/
@@ -233,15 +233,22 @@ ExplainOnePlan(QueryDesc *queryDesc, ExplainStmt *stmt,
233233
double totaltime = 0;
234234
ExplainState *es;
235235
StringInfo str;
236+
int eflags;
236237

237238
INSTR_TIME_SET_CURRENT(starttime);
238239

239240
/* If analyzing, we need to cope with queued triggers */
240241
if (stmt->analyze)
241242
AfterTriggerBeginQuery();
242243

244+
/* Select execution options */
245+
if (stmt->analyze)
246+
eflags = 0; /* default run-to-completion flags */
247+
else
248+
eflags = EXEC_FLAG_EXPLAIN_ONLY;
249+
243250
/* call ExecutorStart to prepare the plan for execution */
244-
ExecutorStart(queryDesc, !stmt->analyze);
251+
ExecutorStart(queryDesc, eflags);
245252

246253
/* Execute the plan for statistics if asked for */
247254
if (stmt->analyze)

‎src/backend/executor/execMain.c

Lines changed: 11 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -26,7 +26,7 @@
2626
*
2727
*
2828
* IDENTIFICATION
29-
* $PostgreSQL: pgsql/src/backend/executor/execMain.c,v 1.267 2006/02/21 23:01:54 neilc Exp $
29+
* $PostgreSQL: pgsql/src/backend/executor/execMain.c,v 1.268 2006/02/28 04:10:27 tgl Exp $
3030
*
3131
*-------------------------------------------------------------------------
3232
*/
@@ -63,7 +63,7 @@ typedef struct evalPlanQual
6363
} evalPlanQual;
6464

6565
/* decls for local routines only used within this module */
66-
static void InitPlan(QueryDesc *queryDesc, bool explainOnly);
66+
static void InitPlan(QueryDesc *queryDesc, int eflags);
6767
static void initResultRelInfo(ResultRelInfo *resultRelInfo,
6868
Index resultRelationIndex,
6969
List *rangeTable,
@@ -105,15 +105,14 @@ static void EvalPlanQualStop(evalPlanQual *epq);
105105
* field of the QueryDesc is filled in to describe the tuples that will be
106106
* returned, and the internal fields (estate and planstate) are set up.
107107
*
108-
* If explainOnly is true, we are not actually intending to run the plan,
109-
* only to set up for EXPLAIN; so skip unwanted side-effects.
108+
* eflags contains flag bits as described in executor.h.
110109
*
111110
* NB: the CurrentMemoryContext when this is called will become the parent
112111
* of the per-query context used for this Executor invocation.
113112
* ----------------------------------------------------------------
114113
*/
115114
void
116-
ExecutorStart(QueryDesc *queryDesc, bool explainOnly)
115+
ExecutorStart(QueryDesc *queryDesc, int eflags)
117116
{
118117
EState *estate;
119118
MemoryContext oldcontext;
@@ -124,9 +123,9 @@ ExecutorStart(QueryDesc *queryDesc, bool explainOnly)
124123

125124
/*
126125
* If the transaction is read-only, we need to check if any writes are
127-
* planned to non-temporary tables.
126+
* planned to non-temporary tables. EXPLAIN is considered read-only.
128127
*/
129-
if (XactReadOnly && !explainOnly)
128+
if (XactReadOnly && !(eflags & EXEC_FLAG_EXPLAIN_ONLY))
130129
ExecCheckXactReadOnly(queryDesc->parsetree);
131130

132131
/*
@@ -156,7 +155,7 @@ ExecutorStart(QueryDesc *queryDesc, bool explainOnly)
156155
/*
157156
* Initialize the plan state tree
158157
*/
159-
InitPlan(queryDesc, explainOnly);
158+
InitPlan(queryDesc, eflags);
160159

161160
MemoryContextSwitchTo(oldcontext);
162161
}
@@ -442,7 +441,7 @@ ExecCheckXactReadOnly(Query *parsetree)
442441
* ----------------------------------------------------------------
443442
*/
444443
static void
445-
InitPlan(QueryDesc *queryDesc, bool explainOnly)
444+
InitPlan(QueryDesc *queryDesc, int eflags)
446445
{
447446
CmdType operation = queryDesc->operation;
448447
Query *parseTree = queryDesc->parsetree;
@@ -608,7 +607,7 @@ InitPlan(QueryDesc *queryDesc, bool explainOnly)
608607
* tree. This opens files, allocates storage and leaves us ready to start
609608
* processing tuples.
610609
*/
611-
planstate = ExecInitNode(plan, estate);
610+
planstate = ExecInitNode(plan, estate, eflags);
612611

613612
/*
614613
* Get the tuple descriptor describing the type of tuples to return. (this
@@ -727,7 +726,7 @@ InitPlan(QueryDesc *queryDesc, bool explainOnly)
727726
*/
728727
intoRelationDesc = NULL;
729728

730-
if (do_select_into && !explainOnly)
729+
if (do_select_into && !(eflags & EXEC_FLAG_EXPLAIN_ONLY))
731730
{
732731
char *intoName;
733732
Oid namespaceId;
@@ -2283,7 +2282,7 @@ EvalPlanQualStart(evalPlanQual *epq, EState *estate, evalPlanQual *priorepq)
22832282
epqstate->es_tupleTable =
22842283
ExecCreateTupleTable(estate->es_tupleTable->size);
22852284

2286-
epq->planstate = ExecInitNode(estate->es_topPlan, epqstate);
2285+
epq->planstate = ExecInitNode(estate->es_topPlan, epqstate, 0);
22872286

22882287
MemoryContextSwitchTo(oldcontext);
22892288
}

‎src/backend/executor/execProcnode.c

Lines changed: 54 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,7 @@
1212
*
1313
*
1414
* IDENTIFICATION
15-
* $PostgreSQL: pgsql/src/backend/executor/execProcnode.c,v 1.52 2005/12/07 15:27:42 tgl Exp $
15+
* $PostgreSQL: pgsql/src/backend/executor/execProcnode.c,v 1.53 2006/02/28 04:10:27 tgl Exp $
1616
*
1717
*-------------------------------------------------------------------------
1818
*/
@@ -45,7 +45,7 @@
4545
* DEPT EMP
4646
* (name = "shoe")
4747
*
48-
* ExecStart() is called first.
48+
* ExecutorStart() is called first.
4949
* It calls InitPlan() which calls ExecInitNode() on
5050
* the root of the plan -- the nest loop node.
5151
*
@@ -108,18 +108,19 @@
108108
/* ------------------------------------------------------------------------
109109
* ExecInitNode
110110
*
111-
* Recursively initializes all the nodes in the plan rooted
111+
* Recursively initializes all the nodes in the plan tree rooted
112112
* at 'node'.
113113
*
114-
* Initial States:
115-
* 'node' is the plan produced by the query planner
116-
* 'estate' is the shared execution state for the query tree
114+
* Inputs:
115+
* 'node' is the current node of the plan produced by the query planner
116+
* 'estate' is the shared execution state for the plan tree
117+
* 'eflags' is a bitwise OR of flag bits described in executor.h
117118
*
118119
* Returns a PlanState node corresponding to the given Plan node.
119120
* ------------------------------------------------------------------------
120121
*/
121122
PlanState *
122-
ExecInitNode(Plan *node, EState *estate)
123+
ExecInitNode(Plan *node, EState *estate, int eflags)
123124
{
124125
PlanState *result;
125126
List *subps;
@@ -137,100 +138,122 @@ ExecInitNode(Plan *node, EState *estate)
137138
* control nodes
138139
*/
139140
case T_Result:
140-
result = (PlanState *) ExecInitResult((Result *) node, estate);
141+
result = (PlanState *) ExecInitResult((Result *) node,
142+
estate, eflags);
141143
break;
142144

143145
case T_Append:
144-
result = (PlanState *) ExecInitAppend((Append *) node, estate);
146+
result = (PlanState *) ExecInitAppend((Append *) node,
147+
estate, eflags);
145148
break;
146149

147150
case T_BitmapAnd:
148-
result = (PlanState *) ExecInitBitmapAnd((BitmapAnd *) node, estate);
151+
result = (PlanState *) ExecInitBitmapAnd((BitmapAnd *) node,
152+
estate, eflags);
149153
break;
150154

151155
case T_BitmapOr:
152-
result = (PlanState *) ExecInitBitmapOr((BitmapOr *) node, estate);
156+
result = (PlanState *) ExecInitBitmapOr((BitmapOr *) node,
157+
estate, eflags);
153158
break;
154159

155160
/*
156161
* scan nodes
157162
*/
158163
case T_SeqScan:
159-
result = (PlanState *) ExecInitSeqScan((SeqScan *) node, estate);
164+
result = (PlanState *) ExecInitSeqScan((SeqScan *) node,
165+
estate, eflags);
160166
break;
161167

162168
case T_IndexScan:
163-
result = (PlanState *) ExecInitIndexScan((IndexScan *) node, estate);
169+
result = (PlanState *) ExecInitIndexScan((IndexScan *) node,
170+
estate, eflags);
164171
break;
165172

166173
case T_BitmapIndexScan:
167-
result = (PlanState *) ExecInitBitmapIndexScan((BitmapIndexScan *) node, estate);
174+
result = (PlanState *) ExecInitBitmapIndexScan((BitmapIndexScan *) node,
175+
estate, eflags);
168176
break;
169177

170178
case T_BitmapHeapScan:
171-
result = (PlanState *) ExecInitBitmapHeapScan((BitmapHeapScan *) node, estate);
179+
result = (PlanState *) ExecInitBitmapHeapScan((BitmapHeapScan *) node,
180+
estate, eflags);
172181
break;
173182

174183
case T_TidScan:
175-
result = (PlanState *) ExecInitTidScan((TidScan *) node, estate);
184+
result = (PlanState *) ExecInitTidScan((TidScan *) node,
185+
estate, eflags);
176186
break;
177187

178188
case T_SubqueryScan:
179-
result = (PlanState *) ExecInitSubqueryScan((SubqueryScan *) node, estate);
189+
result = (PlanState *) ExecInitSubqueryScan((SubqueryScan *) node,
190+
estate, eflags);
180191
break;
181192

182193
case T_FunctionScan:
183-
result = (PlanState *) ExecInitFunctionScan((FunctionScan *) node, estate);
194+
result = (PlanState *) ExecInitFunctionScan((FunctionScan *) node,
195+
estate, eflags);
184196
break;
185197

186198
/*
187199
* join nodes
188200
*/
189201
case T_NestLoop:
190-
result = (PlanState *) ExecInitNestLoop((NestLoop *) node, estate);
202+
result = (PlanState *) ExecInitNestLoop((NestLoop *) node,
203+
estate, eflags);
191204
break;
192205

193206
case T_MergeJoin:
194-
result = (PlanState *) ExecInitMergeJoin((MergeJoin *) node, estate);
207+
result = (PlanState *) ExecInitMergeJoin((MergeJoin *) node,
208+
estate, eflags);
195209
break;
196210

197211
case T_HashJoin:
198-
result = (PlanState *) ExecInitHashJoin((HashJoin *) node, estate);
212+
result = (PlanState *) ExecInitHashJoin((HashJoin *) node,
213+
estate, eflags);
199214
break;
200215

201216
/*
202217
* materialization nodes
203218
*/
204219
case T_Material:
205-
result = (PlanState *) ExecInitMaterial((Material *) node, estate);
220+
result = (PlanState *) ExecInitMaterial((Material *) node,
221+
estate, eflags);
206222
break;
207223

208224
case T_Sort:
209-
result = (PlanState *) ExecInitSort((Sort *) node, estate);
225+
result = (PlanState *) ExecInitSort((Sort *) node,
226+
estate, eflags);
210227
break;
211228

212229
case T_Group:
213-
result = (PlanState *) ExecInitGroup((Group *) node, estate);
230+
result = (PlanState *) ExecInitGroup((Group *) node,
231+
estate, eflags);
214232
break;
215233

216234
case T_Agg:
217-
result = (PlanState *) ExecInitAgg((Agg *) node, estate);
235+
result = (PlanState *) ExecInitAgg((Agg *) node,
236+
estate, eflags);
218237
break;
219238

220239
case T_Unique:
221-
result = (PlanState *) ExecInitUnique((Unique *) node, estate);
240+
result = (PlanState *) ExecInitUnique((Unique *) node,
241+
estate, eflags);
222242
break;
223243

224244
case T_Hash:
225-
result = (PlanState *) ExecInitHash((Hash *) node, estate);
245+
result = (PlanState *) ExecInitHash((Hash *) node,
246+
estate, eflags);
226247
break;
227248

228249
case T_SetOp:
229-
result = (PlanState *) ExecInitSetOp((SetOp *) node, estate);
250+
result = (PlanState *) ExecInitSetOp((SetOp *) node,
251+
estate, eflags);
230252
break;
231253

232254
case T_Limit:
233-
result = (PlanState *) ExecInitLimit((Limit *) node, estate);
255+
result = (PlanState *) ExecInitLimit((Limit *) node,
256+
estate, eflags);
234257
break;
235258

236259
default:
@@ -251,7 +274,7 @@ ExecInitNode(Plan *node, EState *estate)
251274

252275
Assert(IsA(subplan, SubPlan));
253276
sstate = ExecInitExprInitPlan(subplan, result);
254-
ExecInitSubPlan(sstate, estate);
277+
ExecInitSubPlan(sstate, estate, eflags);
255278
subps = lappend(subps, sstate);
256279
}
257280
result->initPlan = subps;
@@ -267,7 +290,7 @@ ExecInitNode(Plan *node, EState *estate)
267290
SubPlanState *sstate = (SubPlanState *) lfirst(l);
268291

269292
Assert(IsA(sstate, SubPlanState));
270-
ExecInitSubPlan(sstate, estate);
293+
ExecInitSubPlan(sstate, estate, eflags);
271294
}
272295

273296
/* Set up instrumentation for this node if requested */

‎src/backend/executor/functions.c

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@
88
*
99
*
1010
* IDENTIFICATION
11-
* $PostgreSQL: pgsql/src/backend/executor/functions.c,v 1.99 2005/11/22 18:17:10 momjian Exp $
11+
* $PostgreSQL: pgsql/src/backend/executor/functions.c,v 1.100 2006/02/28 04:10:27 tgl Exp $
1212
*
1313
*-------------------------------------------------------------------------
1414
*/
@@ -330,7 +330,7 @@ postquel_start(execution_state *es, SQLFunctionCachePtr fcache)
330330
if (es->qd->operation != CMD_UTILITY)
331331
{
332332
AfterTriggerBeginQuery();
333-
ExecutorStart(es->qd, false);
333+
ExecutorStart(es->qd, 0);
334334
}
335335

336336
es->status = F_EXEC_RUN;

‎src/backend/executor/nodeAgg.c

Lines changed: 11 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -61,7 +61,7 @@
6161
* Portions Copyright (c) 1994, Regents of the University of California
6262
*
6363
* IDENTIFICATION
64-
* $PostgreSQL: pgsql/src/backend/executor/nodeAgg.c,v 1.136 2005/11/22 18:17:10 momjian Exp $
64+
* $PostgreSQL: pgsql/src/backend/executor/nodeAgg.c,v 1.137 2006/02/28 04:10:27 tgl Exp $
6565
*
6666
*-------------------------------------------------------------------------
6767
*/
@@ -1031,7 +1031,7 @@ agg_retrieve_hash_table(AggState *aggstate)
10311031
* -----------------
10321032
*/
10331033
AggState *
1034-
ExecInitAgg(Agg *node, EState *estate)
1034+
ExecInitAgg(Agg *node, EState *estate, int eflags)
10351035
{
10361036
AggState *aggstate;
10371037
AggStatePerAgg peragg;
@@ -1041,6 +1041,9 @@ ExecInitAgg(Agg *node, EState *estate)
10411041
aggno;
10421042
ListCell *l;
10431043

1044+
/* check for unsupported flags */
1045+
Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
1046+
10441047
/*
10451048
* create state structure
10461049
*/
@@ -1107,9 +1110,14 @@ ExecInitAgg(Agg *node, EState *estate)
11071110

11081111
/*
11091112
* initialize child nodes
1113+
*
1114+
* If we are doing a hashed aggregation then the child plan does not
1115+
* need to handle REWIND efficiently; see ExecReScanAgg.
11101116
*/
1117+
if (node->aggstrategy == AGG_HASHED)
1118+
eflags &= ~EXEC_FLAG_REWIND;
11111119
outerPlan = outerPlan(node);
1112-
outerPlanState(aggstate) = ExecInitNode(outerPlan, estate);
1120+
outerPlanState(aggstate) = ExecInitNode(outerPlan, estate, eflags);
11131121

11141122
/*
11151123
* initialize source tuple type.

0 commit comments

Comments
 (0)