Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Commit1ef6bd2

Browse files
committed
Don't require return slots for nodes without projection.
In a lot of nodes the return slot is not required. That can either bebecause the node doesn't do any projection (say an Append node), orbecause the node does perform projections but the projection isoptimized away because the projection would yield an identical row.Slots aren't that small, especially for wide rows, so it's worthwhileto avoid creating them. It's not possible to just skip creating theslot - it's currently used to determine the tuple descriptor returnedby ExecGetResultType(). So separate the determination of the resulttype from the slot creation. The work previously done internallyExecInitResultTupleSlotTL() can now also be done separately withExecInitResultTypeTL() and ExecInitResultSlot(). That way nodes thataren't guaranteed to need a result slot, can useExecInitResultTypeTL() to determine the result type of the node, andExecAssignScanProjectionInfo() (viaExecConditionalAssignProjectionInfo()) determines that a result slotis needed, it is created with ExecInitResultSlot().Besides the advantage of avoiding to create slots that then areunused, this is necessary preparation for later patches around tupletable slot abstraction. In particular separating the return descriptorand slot is a prerequisite to allow JITing of tuple deforming withknowledge of the underlying tuple format, and to avoid unnecessarilycreating JITed tuple deforming for virtual slots.This commit removes a redundant argument fromExecInitResultTupleSlotTL(). While this commit touches a lot of therelevant lines anyway, it'd normally still not worthwhile to causebreakage, except that aforementioned later commits will touch *all*ExecInitResultTupleSlotTL() callers anyway (but fits worsethematically).Author: Andres FreundDiscussion:https://postgr.es/m/20181105210039.hh4vvi4vwoq5ba2q@alap3.anarazel.de
1 parent3ce1201 commit1ef6bd2

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 accessmethods into the scan tuple slot.
33+
* returned by the accessmethod 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 resulttuple slot, using the plan node's targetlist.
912+
*Initialize resulttype, using the plan node's targetlist.
918913
* ----------------
919914
*/
920915
void
921-
ExecInitResultTupleSlotTL(EState*estate,PlanState*planstate)
916+
ExecInitResultTypeTL(PlanState*planstate)
922917
{
923918
boolhasoid;
924919
TupleDesctupDesc;
@@ -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-
returnslot->tts_tupleDescriptor;
454+
returnplanstate->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
staticbool

‎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 resultslot,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 resultslot,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
inti;
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 resultslot,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 resultslot,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 resultslot,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)
[8]ページ先頭
©2009-2025 Movatter.jp