Skip to content

Commit f1f5ec1

Browse files
robertmhaasrobertmhaas
committed
Reuse abbreviated keys in ordered [set] aggregates.
When processing ordered aggregates following a sort that could make use of the abbreviated key optimization, only call the equality operator to compare successive pairs of tuples when their abbreviated keys were not equal. Peter Geoghegan, reviewd by Andreas Karlsson and by me.
1 parent 66f5038 commit f1f5ec1

File tree

6 files changed

+92
-39
lines changed

6 files changed

+92
-39
lines changed

‎src/backend/catalog/index.c‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3063,7 +3063,7 @@ validate_index_heapscan(Relation heapRelation,
30633063
}
30643064

30653065
tuplesort_empty = !tuplesort_getdatum(state->tuplesort, true,
3066-
&ts_val, &ts_isnull);
3066+
&ts_val, &ts_isnull, NULL);
30673067
Assert(tuplesort_empty || !ts_isnull);
30683068
if (!tuplesort_empty)
30693069
{

‎src/backend/executor/nodeAgg.c‎

Lines changed: 13 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -575,7 +575,8 @@ fetch_input_tuple(AggState *aggstate)
575575

576576
if (aggstate->sort_in)
577577
{
578-
if (!tuplesort_gettupleslot(aggstate->sort_in, true, aggstate->sort_slot))
578+
if (!tuplesort_gettupleslot(aggstate->sort_in, true, aggstate->sort_slot,
579+
NULL))
579580
return NULL;
580581
slot = aggstate->sort_slot;
581582
}
@@ -1076,6 +1077,8 @@ process_ordered_aggregate_single(AggState *aggstate,
10761077
MemoryContext workcontext = aggstate->tmpcontext->ecxt_per_tuple_memory;
10771078
MemoryContext oldContext;
10781079
bool isDistinct = (pertrans->numDistinctCols > 0);
1080+
Datum newAbbrevVal = (Datum) 0;
1081+
Datum oldAbbrevVal = (Datum) 0;
10791082
FunctionCallInfo fcinfo = &pertrans->transfn_fcinfo;
10801083
Datum *newVal;
10811084
bool *isNull;
@@ -1095,7 +1098,7 @@ process_ordered_aggregate_single(AggState *aggstate,
10951098
*/
10961099

10971100
while (tuplesort_getdatum(pertrans->sortstates[aggstate->current_set],
1098-
true, newVal, isNull))
1101+
true, newVal, isNull, &newAbbrevVal))
10991102
{
11001103
/*
11011104
* Clear and select the working context for evaluation of the equality
@@ -1113,6 +1116,7 @@ process_ordered_aggregate_single(AggState *aggstate,
11131116
haveOldVal &&
11141117
((oldIsNull && *isNull) ||
11151118
(!oldIsNull && !*isNull &&
1119+
oldAbbrevVal == newAbbrevVal &&
11161120
DatumGetBool(FunctionCall2(&pertrans->equalfns[0],
11171121
oldVal, *newVal)))))
11181122
{
@@ -1128,6 +1132,7 @@ process_ordered_aggregate_single(AggState *aggstate,
11281132
pfree(DatumGetPointer(oldVal));
11291133
/* and remember the new one for subsequent equality checks */
11301134
oldVal = *newVal;
1135+
oldAbbrevVal = newAbbrevVal;
11311136
oldIsNull = *isNull;
11321137
haveOldVal = true;
11331138
}
@@ -1165,6 +1170,8 @@ process_ordered_aggregate_multi(AggState *aggstate,
11651170
TupleTableSlot *slot2 = pertrans->uniqslot;
11661171
int numTransInputs = pertrans->numTransInputs;
11671172
int numDistinctCols = pertrans->numDistinctCols;
1173+
Datum newAbbrevVal = (Datum) 0;
1174+
Datum oldAbbrevVal = (Datum) 0;
11681175
bool haveOldValue = false;
11691176
int i;
11701177

@@ -1175,7 +1182,7 @@ process_ordered_aggregate_multi(AggState *aggstate,
11751182
ExecClearTuple(slot2);
11761183

11771184
while (tuplesort_gettupleslot(pertrans->sortstates[aggstate->current_set],
1178-
true, slot1))
1185+
true, slot1, &newAbbrevVal))
11791186
{
11801187
/*
11811188
* Extract the first numTransInputs columns as datums to pass to the
@@ -1186,6 +1193,7 @@ process_ordered_aggregate_multi(AggState *aggstate,
11861193

11871194
if (numDistinctCols == 0 ||
11881195
!haveOldValue ||
1196+
newAbbrevVal != oldAbbrevVal ||
11891197
!execTuplesMatch(slot1, slot2,
11901198
numDistinctCols,
11911199
pertrans->sortColIdx,
@@ -1209,6 +1217,8 @@ process_ordered_aggregate_multi(AggState *aggstate,
12091217

12101218
slot2 = slot1;
12111219
slot1 = tmpslot;
1220+
/* avoid execTuplesMatch() calls by reusing abbreviated keys */
1221+
oldAbbrevVal = newAbbrevVal;
12121222
haveOldValue = true;
12131223
}
12141224
}

‎src/backend/executor/nodeSort.c‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -137,7 +137,7 @@ ExecSort(SortState *node)
137137
slot = node->ss.ps.ps_ResultTupleSlot;
138138
(void) tuplesort_gettupleslot(tuplesortstate,
139139
ScanDirectionIsForward(dir),
140-
slot);
140+
slot, NULL);
141141
return slot;
142142
}
143143

‎src/backend/utils/adt/orderedsetaggs.c‎

Lines changed: 23 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -453,7 +453,7 @@ percentile_disc_final(PG_FUNCTION_ARGS)
453453
elog(ERROR, "missing row in percentile_disc");
454454
}
455455

456-
if (!tuplesort_getdatum(osastate->sortstate, true, &val, &isnull))
456+
if (!tuplesort_getdatum(osastate->sortstate, true, &val, &isnull, NULL))
457457
elog(ERROR, "missing row in percentile_disc");
458458

459459
/*
@@ -553,7 +553,7 @@ percentile_cont_final_common(FunctionCallInfo fcinfo,
553553
if (!tuplesort_skiptuples(osastate->sortstate, first_row, true))
554554
elog(ERROR, "missing row in percentile_cont");
555555

556-
if (!tuplesort_getdatum(osastate->sortstate, true, &first_val, &isnull))
556+
if (!tuplesort_getdatum(osastate->sortstate, true, &first_val, &isnull, NULL))
557557
elog(ERROR, "missing row in percentile_cont");
558558
if (isnull)
559559
PG_RETURN_NULL();
@@ -564,7 +564,7 @@ percentile_cont_final_common(FunctionCallInfo fcinfo,
564564
}
565565
else
566566
{
567-
if (!tuplesort_getdatum(osastate->sortstate, true, &second_val, &isnull))
567+
if (!tuplesort_getdatum(osastate->sortstate, true, &second_val, &isnull, NULL))
568568
elog(ERROR, "missing row in percentile_cont");
569569

570570
if (isnull)
@@ -792,7 +792,7 @@ percentile_disc_multi_final(PG_FUNCTION_ARGS)
792792
if (!tuplesort_skiptuples(osastate->sortstate, target_row - rownum - 1, true))
793793
elog(ERROR, "missing row in percentile_disc");
794794

795-
if (!tuplesort_getdatum(osastate->sortstate, true, &val, &isnull))
795+
if (!tuplesort_getdatum(osastate->sortstate, true, &val, &isnull, NULL))
796796
elog(ERROR, "missing row in percentile_disc");
797797

798798
rownum = target_row;
@@ -921,7 +921,8 @@ percentile_cont_multi_final_common(FunctionCallInfo fcinfo,
921921
if (!tuplesort_skiptuples(osastate->sortstate, first_row - rownum - 1, true))
922922
elog(ERROR, "missing row in percentile_cont");
923923

924-
if (!tuplesort_getdatum(osastate->sortstate, true, &first_val, &isnull) || isnull)
924+
if (!tuplesort_getdatum(osastate->sortstate, true, &first_val,
925+
&isnull, NULL) || isnull)
925926
elog(ERROR, "missing row in percentile_cont");
926927

927928
rownum = first_row;
@@ -941,7 +942,8 @@ percentile_cont_multi_final_common(FunctionCallInfo fcinfo,
941942
/* Fetch second_row if needed */
942943
if (second_row > rownum)
943944
{
944-
if (!tuplesort_getdatum(osastate->sortstate, true, &second_val, &isnull) || isnull)
945+
if (!tuplesort_getdatum(osastate->sortstate, true, &second_val,
946+
&isnull, NULL) || isnull)
945947
elog(ERROR, "missing row in percentile_cont");
946948
rownum++;
947949
}
@@ -1016,6 +1018,8 @@ mode_final(PG_FUNCTION_ARGS)
10161018
int64 last_val_freq = 0;
10171019
bool last_val_is_mode = false;
10181020
FmgrInfo *equalfn;
1021+
Datum abbrev_val = (Datum) 0;
1022+
Datum last_abbrev_val = (Datum) 0;
10191023
bool shouldfree;
10201024

10211025
Assert(AggCheckCallContext(fcinfo, NULL) == AGG_CONTEXT_AGGREGATE);
@@ -1042,7 +1046,7 @@ mode_final(PG_FUNCTION_ARGS)
10421046
tuplesort_performsort(osastate->sortstate);
10431047

10441048
/* Scan tuples and count frequencies */
1045-
while (tuplesort_getdatum(osastate->sortstate, true, &val, &isnull))
1049+
while (tuplesort_getdatum(osastate->sortstate, true, &val, &isnull, &abbrev_val))
10461050
{
10471051
/* we don't expect any nulls, but ignore them if found */
10481052
if (isnull)
@@ -1054,8 +1058,10 @@ mode_final(PG_FUNCTION_ARGS)
10541058
mode_val = last_val = val;
10551059
mode_freq = last_val_freq = 1;
10561060
last_val_is_mode = true;
1061+
last_abbrev_val = abbrev_val;
10571062
}
1058-
else if (DatumGetBool(FunctionCall2(equalfn, val, last_val)))
1063+
else if (abbrev_val == last_abbrev_val &&
1064+
DatumGetBool(FunctionCall2(equalfn, val, last_val)))
10591065
{
10601066
/* value equal to previous value, count it */
10611067
if (last_val_is_mode)
@@ -1078,6 +1084,8 @@ mode_final(PG_FUNCTION_ARGS)
10781084
if (shouldfree && !last_val_is_mode)
10791085
pfree(DatumGetPointer(last_val));
10801086
last_val = val;
1087+
/* avoid equality function calls by reusing abbreviated keys */
1088+
last_abbrev_val = abbrev_val;
10811089
last_val_freq = 1;
10821090
last_val_is_mode = false;
10831091
}
@@ -1181,7 +1189,7 @@ hypothetical_rank_common(FunctionCallInfo fcinfo, int flag,
11811189
tuplesort_performsort(osastate->sortstate);
11821190

11831191
/* iterate till we find the hypothetical row */
1184-
while (tuplesort_gettupleslot(osastate->sortstate, true, slot))
1192+
while (tuplesort_gettupleslot(osastate->sortstate, true, slot, NULL))
11851193
{
11861194
bool isnull;
11871195
Datum d = slot_getattr(slot, nargs + 1, &isnull);
@@ -1266,6 +1274,8 @@ hypothetical_dense_rank_final(PG_FUNCTION_ARGS)
12661274
int64 duplicate_count = 0;
12671275
OSAPerGroupState *osastate;
12681276
int numDistinctCols;
1277+
Datum abbrevVal = (Datum) 0;
1278+
Datum abbrevOld = (Datum) 0;
12691279
AttrNumber *sortColIdx;
12701280
FmgrInfo *equalfns;
12711281
TupleTableSlot *slot;
@@ -1342,7 +1352,7 @@ hypothetical_dense_rank_final(PG_FUNCTION_ARGS)
13421352
slot2 = extraslot;
13431353

13441354
/* iterate till we find the hypothetical row */
1345-
while (tuplesort_gettupleslot(osastate->sortstate, true, slot))
1355+
while (tuplesort_gettupleslot(osastate->sortstate, true, slot, &abbrevVal))
13461356
{
13471357
bool isnull;
13481358
Datum d = slot_getattr(slot, nargs + 1, &isnull);
@@ -1353,6 +1363,7 @@ hypothetical_dense_rank_final(PG_FUNCTION_ARGS)
13531363

13541364
/* count non-distinct tuples */
13551365
if (!TupIsNull(slot2) &&
1366+
abbrevVal == abbrevOld &&
13561367
execTuplesMatch(slot, slot2,
13571368
numDistinctCols,
13581369
sortColIdx,
@@ -1363,6 +1374,8 @@ hypothetical_dense_rank_final(PG_FUNCTION_ARGS)
13631374
tmpslot = slot2;
13641375
slot2 = slot;
13651376
slot = tmpslot;
1377+
/* avoid execTuplesMatch() calls by reusing abbreviated keys */
1378+
abbrevOld = abbrevVal;
13661379

13671380
rank++;
13681381

‎src/backend/utils/sort/tuplesort.c‎

Lines changed: 52 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -1280,7 +1280,8 @@ tuplesort_putindextuplevalues(Tuplesortstate *state, Relation rel,
12801280
* converter it won't expect NULL values, and cost model is not
12811281
* required to account for NULL, so in that case we avoid calling
12821282
* converter and just set datum1 to zeroed representation (to be
1283-
* consistent).
1283+
* consistent, and to support cheap inequality tests for NULL
1284+
* abbreviated keys).
12841285
*/
12851286
stup.datum1 = original;
12861287
}
@@ -1349,7 +1350,11 @@ tuplesort_putdatum(Tuplesortstate *state, Datum val, bool isNull)
13491350

13501351
if (isNull || state->datumTypeByVal)
13511352
{
1352-
stup.datum1 = val;
1353+
/*
1354+
* Set datum1 to zeroed representation for NULLs (to be consistent, and
1355+
* to support cheap inequality tests for NULL abbreviated keys).
1356+
*/
1357+
stup.datum1 = !isNull ? val : (Datum) 0;
13531358
stup.isnull1 = isNull;
13541359
stup.tuple = NULL; /* no separate storage */
13551360
}
@@ -1866,10 +1871,17 @@ tuplesort_gettuple_common(Tuplesortstate *state, bool forward,
18661871
* Fetch the next tuple in either forward or back direction.
18671872
* If successful, put tuple in slot and return TRUE; else, clear the slot
18681873
* and return FALSE.
1874+
*
1875+
* Caller may optionally be passed back abbreviated value (on TRUE return
1876+
* value) when abbreviation was used, which can be used to cheaply avoid
1877+
* equality checks that might otherwise be required. Caller can safely make a
1878+
* determination of "non-equal tuple" based on simple binary inequality. A
1879+
* NULL value in leading attribute will set abbreviated value to zeroed
1880+
* representation, which caller may rely on in abbreviated inequality check.
18691881
*/
18701882
bool
18711883
tuplesort_gettupleslot(Tuplesortstate *state, bool forward,
1872-
TupleTableSlot *slot)
1884+
TupleTableSlot *slot, Datum *abbrev)
18731885
{
18741886
MemoryContext oldcontext = MemoryContextSwitchTo(state->sortcontext);
18751887
SortTuple stup;
@@ -1882,6 +1894,10 @@ tuplesort_gettupleslot(Tuplesortstate *state, bool forward,
18821894

18831895
if (stup.tuple)
18841896
{
1897+
/* Record abbreviated key for caller */
1898+
if (state->sortKeys->abbrev_converter && abbrev)
1899+
*abbrev = stup.datum1;
1900+
18851901
ExecStoreMinimalTuple((MinimalTuple) stup.tuple, slot, should_free);
18861902
return true;
18871903
}
@@ -1937,10 +1953,17 @@ tuplesort_getindextuple(Tuplesortstate *state, bool forward,
19371953
*
19381954
* If the Datum is pass-by-ref type, the returned value is freshly palloc'd
19391955
* and is now owned by the caller.
1956+
*
1957+
* Caller may optionally be passed back abbreviated value (on TRUE return
1958+
* value) when abbreviation was used, which can be used to cheaply avoid
1959+
* equality checks that might otherwise be required. Caller can safely make a
1960+
* determination of "non-equal tuple" based on simple binary inequality. A
1961+
* NULL value will have a zeroed abbreviated value representation, which caller
1962+
* may rely on in abbreviated inequality check.
19401963
*/
19411964
bool
19421965
tuplesort_getdatum(Tuplesortstate *state, bool forward,
1943-
Datum *val, bool *isNull)
1966+
Datum *val, bool *isNull, Datum *abbrev)
19441967
{
19451968
MemoryContext oldcontext = MemoryContextSwitchTo(state->sortcontext);
19461969
SortTuple stup;
@@ -1952,6 +1975,10 @@ tuplesort_getdatum(Tuplesortstate *state, bool forward,
19521975
return false;
19531976
}
19541977

1978+
/* Record abbreviated key for caller */
1979+
if (state->sortKeys->abbrev_converter && abbrev)
1980+
*abbrev = stup.datum1;
1981+
19551982
if (stup.isnull1 || state->datumTypeByVal)
19561983
{
19571984
*val = stup.datum1;
@@ -2232,21 +2259,6 @@ mergeruns(Tuplesortstate *state)
22322259
Assert(state->status == TSS_BUILDRUNS);
22332260
Assert(state->memtupcount == 0);
22342261

2235-
/*
2236-
* If we produced only one initial run (quite likely if the total data
2237-
* volume is between 1X and 2X workMem), we can just use that tape as the
2238-
* finished output, rather than doing a useless merge. (This obvious
2239-
* optimization is not in Knuth's algorithm.)
2240-
*/
2241-
if (state->currentRun == 1)
2242-
{
2243-
state->result_tape = state->tp_tapenum[state->destTape];
2244-
/* must freeze and rewind the finished output tape */
2245-
LogicalTapeFreeze(state->tapeset, state->result_tape);
2246-
state->status = TSS_SORTEDONTAPE;
2247-
return;
2248-
}
2249-
22502262
if (state->sortKeys != NULL && state->sortKeys->abbrev_converter != NULL)
22512263
{
22522264
/*
@@ -2263,6 +2275,21 @@ mergeruns(Tuplesortstate *state)
22632275
state->sortKeys->abbrev_full_comparator = NULL;
22642276
}
22652277

2278+
/*
2279+
* If we produced only one initial run (quite likely if the total data
2280+
* volume is between 1X and 2X workMem), we can just use that tape as the
2281+
* finished output, rather than doing a useless merge. (This obvious
2282+
* optimization is not in Knuth's algorithm.)
2283+
*/
2284+
if (state->currentRun == 1)
2285+
{
2286+
state->result_tape = state->tp_tapenum[state->destTape];
2287+
/* must freeze and rewind the finished output tape */
2288+
LogicalTapeFreeze(state->tapeset, state->result_tape);
2289+
state->status = TSS_SORTEDONTAPE;
2290+
return;
2291+
}
2292+
22662293
/* End of step D2: rewind all output tapes to prepare for merging */
22672294
for (tapenum = 0; tapenum < state->tapeRange; tapenum++)
22682295
LogicalTapeRewind(state->tapeset, tapenum, false);
@@ -3164,7 +3191,8 @@ copytup_heap(Tuplesortstate *state, SortTuple *stup, void *tup)
31643191
* converter it won't expect NULL values, and cost model is not
31653192
* required to account for NULL, so in that case we avoid calling
31663193
* converter and just set datum1 to zeroed representation (to be
3167-
* consistent).
3194+
* consistent, and to support cheap inequality tests for NULL
3195+
* abbreviated keys).
31683196
*/
31693197
stup->datum1 = original;
31703198
}
@@ -3406,7 +3434,8 @@ copytup_cluster(Tuplesortstate *state, SortTuple *stup, void *tup)
34063434
* converter it won't expect NULL values, and cost model is not
34073435
* required to account for NULL, so in that case we avoid calling
34083436
* converter and just set datum1 to zeroed representation (to be
3409-
* consistent).
3437+
* consistent, and to support cheap inequality tests for NULL
3438+
* abbreviated keys).
34103439
*/
34113440
stup->datum1 = original;
34123441
}
@@ -3710,7 +3739,8 @@ copytup_index(Tuplesortstate *state, SortTuple *stup, void *tup)
37103739
* converter it won't expect NULL values, and cost model is not
37113740
* required to account for NULL, so in that case we avoid calling
37123741
* converter and just set datum1 to zeroed representation (to be
3713-
* consistent).
3742+
* consistent, and to support cheap inequality tests for NULL
3743+
* abbreviated keys).
37143744
*/
37153745
stup->datum1 = original;
37163746
}

0 commit comments

Comments
 (0)