Skip to content

Commit 1ef6bd2

Browse files
anarazelanarazel
committed
Don't require return slots for nodes without projection.
In a lot of nodes the return slot is not required. That can either be because the node doesn't do any projection (say an Append node), or because the node does perform projections but the projection is optimized away because the projection would yield an identical row. Slots aren't that small, especially for wide rows, so it's worthwhile to avoid creating them. It's not possible to just skip creating the slot - it's currently used to determine the tuple descriptor returned by ExecGetResultType(). So separate the determination of the result type from the slot creation. The work previously done internally ExecInitResultTupleSlotTL() can now also be done separately with ExecInitResultTypeTL() and ExecInitResultSlot(). That way nodes that aren't guaranteed to need a result slot, can use ExecInitResultTypeTL() to determine the result type of the node, and ExecAssignScanProjectionInfo() (via ExecConditionalAssignProjectionInfo()) determines that a result slot is needed, it is created with ExecInitResultSlot(). Besides the advantage of avoiding to create slots that then are unused, this is necessary preparation for later patches around tuple table slot abstraction. In particular separating the return descriptor and slot is a prerequisite to allow JITing of tuple deforming with knowledge of the underlying tuple format, and to avoid unnecessarily creating JITed tuple deforming for virtual slots. This commit removes a redundant argument from ExecInitResultTupleSlotTL(). While this commit touches a lot of the relevant lines anyway, it'd normally still not worthwhile to cause breakage, except that aforementioned later commits will touch *all* ExecInitResultTupleSlotTL() callers anyway (but fits worse thematically). Author: Andres Freund Discussion: https://postgr.es/m/20181105210039.hh4vvi4vwoq5ba2q@alap3.anarazel.de
1 parent 3ce1201 commit 1ef6bd2

40 files changed

+168
-117
lines changed

‎src/backend/executor/execTuples.c

Lines changed: 53 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -19,18 +19,22 @@
1919
*
2020
* At ExecutorStart()
2121
* ----------------
22-
* - ExecInitSeqScan() calls ExecInitScanTupleSlot() and
23-
* ExecInitResultTupleSlotTL() to construct TupleTableSlots
24-
* for the tuples returned by the access methods and the
25-
* tuples resulting from performing target list projections.
22+
23+
* - ExecInitSeqScan() calls ExecInitScanTupleSlot() to construct a
24+
* TupleTableSlots for the tuples returned by the access method, and
25+
* ExecInitResultTypeTL() to define the node's return
26+
* type. ExecAssignScanProjectionInfo() will, if necessary, create
27+
* another TupleTableSlot for the tuples resulting from performing
28+
* target list projections.
2629
*
2730
* During ExecutorRun()
2831
* ----------------
2932
* - SeqNext() calls ExecStoreBufferHeapTuple() to place the tuple
30-
* returned by the access methods into the scan tuple slot.
33+
* returned by the access method into the scan tuple slot.
3134
*
32-
* - ExecSeqScan() calls ExecStoreHeapTuple() to take the result
33-
* tuple from ExecProject() and place it into the result tuple slot.
35+
* - ExecSeqScan() (via ExecScan), if necessary, calls ExecProject(),
36+
* putting the result of the projection in the result tuple slot. If
37+
* not necessary, it directly returns the slot returned by SeqNext().
3438
*
3539
* - ExecutePlan() calls the output function.
3640
*
@@ -902,23 +906,14 @@ ExecCopySlot(TupleTableSlot *dstslot, TupleTableSlot *srcslot)
902906
* ----------------------------------------------------------------
903907
*/
904908

905-
/* --------------------------------
906-
* ExecInit{Result,Scan,Extra}TupleSlot[TL]
907-
*
908-
* These are convenience routines to initialize the specified slot
909-
* in nodes inheriting the appropriate state. ExecInitExtraTupleSlot
910-
* is used for initializing special-purpose slots.
911-
* --------------------------------
912-
*/
913-
914909
/* ----------------
915-
* ExecInitResultTupleSlotTL
910+
* ExecInitResultTypeTL
916911
*
917-
* Initialize result tuple slot, using the plan node's targetlist.
912+
* Initialize result type, using the plan node's targetlist.
918913
* ----------------
919914
*/
920915
void
921-
ExecInitResultTupleSlotTL(EState *estate, PlanState *planstate)
916+
ExecInitResultTypeTL(PlanState *planstate)
922917
{
923918
bool hasoid;
924919
TupleDesc tupDesc;
@@ -934,8 +929,46 @@ ExecInitResultTupleSlotTL(EState *estate, PlanState *planstate)
934929
}
935930

936931
tupDesc = ExecTypeFromTL(planstate->plan->targetlist, hasoid);
932+
planstate->ps_ResultTupleDesc = tupDesc;
933+
}
937934

938-
planstate->ps_ResultTupleSlot = ExecAllocTableSlot(&estate->es_tupleTable, tupDesc);
935+
/* --------------------------------
936+
* ExecInit{Result,Scan,Extra}TupleSlot[TL]
937+
*
938+
* These are convenience routines to initialize the specified slot
939+
* in nodes inheriting the appropriate state. ExecInitExtraTupleSlot
940+
* is used for initializing special-purpose slots.
941+
* --------------------------------
942+
*/
943+
944+
/* ----------------
945+
* ExecInitResultTupleSlotTL
946+
*
947+
* Initialize result tuple slot, using the tuple descriptor previously
948+
* computed with ExecInitResultTypeTL().
949+
* ----------------
950+
*/
951+
void
952+
ExecInitResultSlot(PlanState *planstate)
953+
{
954+
TupleTableSlot *slot;
955+
956+
slot = ExecAllocTableSlot(&planstate->state->es_tupleTable,
957+
planstate->ps_ResultTupleDesc);
958+
planstate->ps_ResultTupleSlot = slot;
959+
}
960+
961+
/* ----------------
962+
* ExecInitResultTupleSlotTL
963+
*
964+
* Initialize result tuple slot, using the plan node's targetlist.
965+
* ----------------
966+
*/
967+
void
968+
ExecInitResultTupleSlotTL(PlanState *planstate)
969+
{
970+
ExecInitResultTypeTL(planstate);
971+
ExecInitResultSlot(planstate);
939972
}
940973

941974
/* ----------------

‎src/backend/executor/execUtils.c

Lines changed: 5 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -451,9 +451,7 @@ ExecAssignExprContext(EState *estate, PlanState *planstate)
451451
TupleDesc
452452
ExecGetResultType(PlanState *planstate)
453453
{
454-
TupleTableSlot *slot = planstate->ps_ResultTupleSlot;
455-
456-
return slot->tts_tupleDescriptor;
454+
return planstate->ps_ResultTupleDesc;
457455
}
458456

459457

@@ -496,7 +494,11 @@ ExecConditionalAssignProjectionInfo(PlanState *planstate, TupleDesc inputDesc,
496494
inputDesc))
497495
planstate->ps_ProjInfo = NULL;
498496
else
497+
{
498+
if (!planstate->ps_ResultTupleSlot)
499+
ExecInitResultSlot(planstate);
499500
ExecAssignProjectionInfo(planstate, inputDesc);
501+
}
500502
}
501503

502504
static bool

‎src/backend/executor/nodeAgg.c

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2219,7 +2219,7 @@ ExecInitAgg(Agg *node, EState *estate, int eflags)
22192219
/*
22202220
* Initialize result type, slot and projection.
22212221
*/
2222-
ExecInitResultTupleSlotTL(estate, &aggstate->ss.ps);
2222+
ExecInitResultTupleSlotTL(&aggstate->ss.ps);
22232223
ExecAssignProjectionInfo(&aggstate->ss.ps, NULL);
22242224

22252225
/*

‎src/backend/executor/nodeAppend.c

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -196,7 +196,7 @@ ExecInitAppend(Append *node, EState *estate, int eflags)
196196
/*
197197
* Initialize result tuple type and slot.
198198
*/
199-
ExecInitResultTupleSlotTL(estate, &appendstate->ps);
199+
ExecInitResultTupleSlotTL(&appendstate->ps);
200200

201201
appendplanstates = (PlanState **) palloc(nplans *
202202
sizeof(PlanState *));

‎src/backend/executor/nodeBitmapHeapscan.c

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -800,7 +800,8 @@ ExecEndBitmapHeapScan(BitmapHeapScanState *node)
800800
/*
801801
* clear out tuple table slots
802802
*/
803-
ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
803+
if (node->ss.ps.ps_ResultTupleSlot)
804+
ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
804805
ExecClearTuple(node->ss.ss_ScanTupleSlot);
805806

806807
/*
@@ -916,9 +917,9 @@ ExecInitBitmapHeapScan(BitmapHeapScan *node, EState *estate, int eflags)
916917

917918

918919
/*
919-
* Initialize result slot, type and projection.
920+
* Initialize result type and projection.
920921
*/
921-
ExecInitResultTupleSlotTL(estate, &scanstate->ss.ps);
922+
ExecInitResultTypeTL(&scanstate->ss.ps);
922923
ExecAssignScanProjectionInfo(&scanstate->ss);
923924

924925
/*

‎src/backend/executor/nodeCtescan.c

Lines changed: 6 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -263,9 +263,9 @@ ExecInitCteScan(CteScan *node, EState *estate, int eflags)
263263
ExecGetResultType(scanstate->cteplanstate));
264264

265265
/*
266-
* Initialize result slot, type and projection.
266+
* Initialize result type and projection.
267267
*/
268-
ExecInitResultTupleSlotTL(estate, &scanstate->ss.ps);
268+
ExecInitResultTypeTL(&scanstate->ss.ps);
269269
ExecAssignScanProjectionInfo(&scanstate->ss);
270270

271271
/*
@@ -294,7 +294,8 @@ ExecEndCteScan(CteScanState *node)
294294
/*
295295
* clean out the tuple table
296296
*/
297-
ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
297+
if (node->ss.ps.ps_ResultTupleSlot)
298+
ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
298299
ExecClearTuple(node->ss.ss_ScanTupleSlot);
299300

300301
/*
@@ -318,7 +319,8 @@ ExecReScanCteScan(CteScanState *node)
318319
{
319320
Tuplestorestate *tuplestorestate = node->leader->cte_table;
320321

321-
ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
322+
if (node->ss.ps.ps_ResultTupleSlot)
323+
ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
322324

323325
ExecScanReScan(&node->ss);
324326

‎src/backend/executor/nodeCustom.c

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -87,7 +87,7 @@ ExecInitCustomScan(CustomScan *cscan, EState *estate, int eflags)
8787
/*
8888
* Initialize result slot, type and projection.
8989
*/
90-
ExecInitResultTupleSlotTL(estate, &css->ss.ps);
90+
ExecInitResultTupleSlotTL(&css->ss.ps);
9191
ExecAssignScanProjectionInfoWithVarno(&css->ss, tlistvarno);
9292

9393
/* initialize child expressions */

‎src/backend/executor/nodeForeignscan.c

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -198,7 +198,7 @@ ExecInitForeignScan(ForeignScan *node, EState *estate, int eflags)
198198
/*
199199
* Initialize result slot, type and projection.
200200
*/
201-
ExecInitResultTupleSlotTL(estate, &scanstate->ss.ps);
201+
ExecInitResultTypeTL(&scanstate->ss.ps);
202202
ExecAssignScanProjectionInfoWithVarno(&scanstate->ss, tlistvarno);
203203

204204
/*
@@ -256,7 +256,8 @@ ExecEndForeignScan(ForeignScanState *node)
256256
ExecFreeExprContext(&node->ss.ps);
257257

258258
/* clean out the tuple table */
259-
ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
259+
if (node->ss.ps.ps_ResultTupleSlot)
260+
ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
260261
ExecClearTuple(node->ss.ss_ScanTupleSlot);
261262
}
262263

‎src/backend/executor/nodeFunctionscan.c

Lines changed: 5 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -487,7 +487,7 @@ ExecInitFunctionScan(FunctionScan *node, EState *estate, int eflags)
487487
/*
488488
* Initialize result slot, type and projection.
489489
*/
490-
ExecInitResultTupleSlotTL(estate, &scanstate->ss.ps);
490+
ExecInitResultTypeTL(&scanstate->ss.ps);
491491
ExecAssignScanProjectionInfo(&scanstate->ss);
492492

493493
/*
@@ -529,7 +529,8 @@ ExecEndFunctionScan(FunctionScanState *node)
529529
/*
530530
* clean out the tuple table
531531
*/
532-
ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
532+
if (node->ss.ps.ps_ResultTupleSlot)
533+
ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
533534
ExecClearTuple(node->ss.ss_ScanTupleSlot);
534535

535536
/*
@@ -563,7 +564,8 @@ ExecReScanFunctionScan(FunctionScanState *node)
563564
int i;
564565
Bitmapset *chgparam = node->ss.ps.chgParam;
565566

566-
ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
567+
if (node->ss.ps.ps_ResultTupleSlot)
568+
ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
567569
for (i = 0; i < node->nfuncs; i++)
568570
{
569571
FunctionScanPerFuncState *fs = &node->funcstates[i];

‎src/backend/executor/nodeGather.c

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -92,9 +92,9 @@ ExecInitGather(Gather *node, EState *estate, int eflags)
9292
tupDesc = ExecGetResultType(outerPlanState(gatherstate));
9393

9494
/*
95-
* Initialize result slot, type and projection.
95+
* Initialize result type and projection.
9696
*/
97-
ExecInitResultTupleSlotTL(estate, &gatherstate->ps);
97+
ExecInitResultTypeTL(&gatherstate->ps);
9898
ExecConditionalAssignProjectionInfo(&gatherstate->ps, tupDesc, OUTER_VAR);
9999

100100
/*
@@ -231,7 +231,8 @@ ExecEndGather(GatherState *node)
231231
ExecEndNode(outerPlanState(node)); /* let children clean up first */
232232
ExecShutdownGather(node);
233233
ExecFreeExprContext(&node->ps);
234-
ExecClearTuple(node->ps.ps_ResultTupleSlot);
234+
if (node->ps.ps_ResultTupleSlot)
235+
ExecClearTuple(node->ps.ps_ResultTupleSlot);
235236
}
236237

237238
/*

‎src/backend/executor/nodeGatherMerge.c

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -117,9 +117,9 @@ ExecInitGatherMerge(GatherMerge *node, EState *estate, int eflags)
117117
gm_state->tupDesc = tupDesc;
118118

119119
/*
120-
* Initialize result slot, type and projection.
120+
* Initialize result type and projection.
121121
*/
122-
ExecInitResultTupleSlotTL(estate, &gm_state->ps);
122+
ExecInitResultTypeTL(&gm_state->ps);
123123
ExecConditionalAssignProjectionInfo(&gm_state->ps, tupDesc, OUTER_VAR);
124124

125125
/*
@@ -272,7 +272,8 @@ ExecEndGatherMerge(GatherMergeState *node)
272272
ExecEndNode(outerPlanState(node)); /* let children clean up first */
273273
ExecShutdownGatherMerge(node);
274274
ExecFreeExprContext(&node->ps);
275-
ExecClearTuple(node->ps.ps_ResultTupleSlot);
275+
if (node->ps.ps_ResultTupleSlot)
276+
ExecClearTuple(node->ps.ps_ResultTupleSlot);
276277
}
277278

278279
/* ----------------------------------------------------------------

‎src/backend/executor/nodeGroup.c

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -193,7 +193,7 @@ ExecInitGroup(Group *node, EState *estate, int eflags)
193193
/*
194194
* Initialize result slot, type and projection.
195195
*/
196-
ExecInitResultTupleSlotTL(estate, &grpstate->ss.ps);
196+
ExecInitResultTupleSlotTL(&grpstate->ss.ps);
197197
ExecAssignProjectionInfo(&grpstate->ss.ps, NULL);
198198

199199
/*

‎src/backend/executor/nodeHash.c

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -382,7 +382,7 @@ ExecInitHash(Hash *node, EState *estate, int eflags)
382382
* initialize our result slot and type. No need to build projection
383383
* because this node doesn't do projections.
384384
*/
385-
ExecInitResultTupleSlotTL(estate, &hashstate->ps);
385+
ExecInitResultTupleSlotTL(&hashstate->ps);
386386
hashstate->ps.ps_ProjInfo = NULL;
387387

388388
/*

‎src/backend/executor/nodeHashjoin.c

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -644,7 +644,7 @@ ExecInitHashJoin(HashJoin *node, EState *estate, int eflags)
644644
/*
645645
* Initialize result slot, type and projection.
646646
*/
647-
ExecInitResultTupleSlotTL(estate, &hjstate->js.ps);
647+
ExecInitResultTupleSlotTL(&hjstate->js.ps);
648648
ExecAssignProjectionInfo(&hjstate->js.ps, NULL);
649649

650650
/*

‎src/backend/executor/nodeIndexonlyscan.c

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -399,7 +399,8 @@ ExecEndIndexOnlyScan(IndexOnlyScanState *node)
399399
/*
400400
* clear out tuple table slots
401401
*/
402-
ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
402+
if (node->ss.ps.ps_ResultTupleSlot)
403+
ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
403404
ExecClearTuple(node->ss.ss_ScanTupleSlot);
404405

405406
/*
@@ -529,11 +530,10 @@ ExecInitIndexOnlyScan(IndexOnlyScan *node, EState *estate, int eflags)
529530
ExecInitScanTupleSlot(estate, &indexstate->ss, tupDesc);
530531

531532
/*
532-
* Initialize result slot, type and projection info. The node's
533-
* targetlist will contain Vars with varno = INDEX_VAR, referencing the
534-
* scan tuple.
533+
* Initialize result type and projection info. The node's targetlist will
534+
* contain Vars with varno = INDEX_VAR, referencing the scan tuple.
535535
*/
536-
ExecInitResultTupleSlotTL(estate, &indexstate->ss.ps);
536+
ExecInitResultTypeTL(&indexstate->ss.ps);
537537
ExecAssignScanProjectionInfoWithVarno(&indexstate->ss, INDEX_VAR);
538538

539539
/*

‎src/backend/executor/nodeIndexscan.c

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -822,7 +822,8 @@ ExecEndIndexScan(IndexScanState *node)
822822
/*
823823
* clear out tuple table slots
824824
*/
825-
ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
825+
if (node->ss.ps.ps_ResultTupleSlot)
826+
ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
826827
ExecClearTuple(node->ss.ss_ScanTupleSlot);
827828

828829
/*
@@ -947,9 +948,9 @@ ExecInitIndexScan(IndexScan *node, EState *estate, int eflags)
947948
RelationGetDescr(currentRelation));
948949

949950
/*
950-
* Initialize result slot, type and projection.
951+
* Initialize result type and projection.
951952
*/
952-
ExecInitResultTupleSlotTL(estate, &indexstate->ss.ps);
953+
ExecInitResultTypeTL(&indexstate->ss.ps);
953954
ExecAssignScanProjectionInfo(&indexstate->ss);
954955

955956
/*

‎src/backend/executor/nodeLimit.c

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -376,10 +376,9 @@ ExecInitLimit(Limit *node, EState *estate, int eflags)
376376
(PlanState *) limitstate);
377377

378378
/*
379-
* Initialize result slot and type. (XXX not actually used, but upper
380-
* nodes access it to get this node's result tupledesc...)
379+
* Initialize result type.
381380
*/
382-
ExecInitResultTupleSlotTL(estate, &limitstate->ps);
381+
ExecInitResultTypeTL(&limitstate->ps);
383382

384383
/*
385384
* limit nodes do no projections, so initialize projection info for this

0 commit comments

Comments
 (0)