Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * orderedsetaggs.c
4 : * Ordered-set aggregate functions.
5 : *
6 : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
7 : * Portions Copyright (c) 1994, Regents of the University of California
8 : *
9 : *
10 : * IDENTIFICATION
11 : * src/backend/utils/adt/orderedsetaggs.c
12 : *
13 : *-------------------------------------------------------------------------
14 : */
15 : #include "postgres.h"
16 :
17 : #include <math.h>
18 :
19 : #include "catalog/pg_aggregate.h"
20 : #include "catalog/pg_operator.h"
21 : #include "catalog/pg_type.h"
22 : #include "executor/executor.h"
23 : #include "miscadmin.h"
24 : #include "nodes/nodeFuncs.h"
25 : #include "optimizer/optimizer.h"
26 : #include "utils/array.h"
27 : #include "utils/fmgrprotos.h"
28 : #include "utils/lsyscache.h"
29 : #include "utils/tuplesort.h"
30 :
31 :
32 : /*
33 : * Generic support for ordered-set aggregates
34 : *
35 : * The state for an ordered-set aggregate is divided into a per-group struct
36 : * (which is the internal-type transition state datum returned to nodeAgg.c)
37 : * and a per-query struct, which contains data and sub-objects that we can
38 : * create just once per query because they will not change across groups.
39 : * The per-query struct and subsidiary data live in the executor's per-query
40 : * memory context, and go away implicitly at ExecutorEnd().
41 : *
42 : * These structs are set up during the first call of the transition function.
43 : * Because we allow nodeAgg.c to merge ordered-set aggregates (but not
44 : * hypothetical aggregates) with identical inputs and transition functions,
45 : * this info must not depend on the particular aggregate (ie, particular
46 : * final-function), nor on the direct argument(s) of the aggregate.
47 : */
48 :
49 : typedef struct OSAPerQueryState
50 : {
51 : /* Representative Aggref for this aggregate: */
52 : Aggref *aggref;
53 : /* Memory context containing this struct and other per-query data: */
54 : MemoryContext qcontext;
55 : /* Context for expression evaluation */
56 : ExprContext *econtext;
57 : /* Do we expect multiple final-function calls within one group? */
58 : bool rescan_needed;
59 :
60 : /* These fields are used only when accumulating tuples: */
61 :
62 : /* Tuple descriptor for tuples inserted into sortstate: */
63 : TupleDesc tupdesc;
64 : /* Tuple slot we can use for inserting/extracting tuples: */
65 : TupleTableSlot *tupslot;
66 : /* Per-sort-column sorting information */
67 : int numSortCols;
68 : AttrNumber *sortColIdx;
69 : Oid *sortOperators;
70 : Oid *eqOperators;
71 : Oid *sortCollations;
72 : bool *sortNullsFirsts;
73 : /* Equality operator call info, created only if needed: */
74 : ExprState *compareTuple;
75 :
76 : /* These fields are used only when accumulating datums: */
77 :
78 : /* Info about datatype of datums being sorted: */
79 : Oid sortColType;
80 : int16 typLen;
81 : bool typByVal;
82 : char typAlign;
83 : /* Info about sort ordering: */
84 : Oid sortOperator;
85 : Oid eqOperator;
86 : Oid sortCollation;
87 : bool sortNullsFirst;
88 : /* Equality operator call info, created only if needed: */
89 : FmgrInfo equalfn;
90 : } OSAPerQueryState;
91 :
92 : typedef struct OSAPerGroupState
93 : {
94 : /* Link to the per-query state for this aggregate: */
95 : OSAPerQueryState *qstate;
96 : /* Memory context containing per-group data: */
97 : MemoryContext gcontext;
98 : /* Sort object we're accumulating data in: */
99 : Tuplesortstate *sortstate;
100 : /* Number of normal rows inserted into sortstate: */
101 : int64 number_of_rows;
102 : /* Have we already done tuplesort_performsort? */
103 : bool sort_done;
104 : } OSAPerGroupState;
105 :
106 : static void ordered_set_shutdown(Datum arg);
107 :
108 :
109 : /*
110 : * Set up working state for an ordered-set aggregate
111 : */
112 : static OSAPerGroupState *
113 433 : ordered_set_startup(FunctionCallInfo fcinfo, bool use_tuples)
114 : {
115 : OSAPerGroupState *osastate;
116 : OSAPerQueryState *qstate;
117 : MemoryContext gcontext;
118 : MemoryContext oldcontext;
119 : int tuplesortopt;
120 :
121 : /*
122 : * Check we're called as aggregate (and not a window function), and get
123 : * the Agg node's group-lifespan context (which might change from group to
124 : * group, so we shouldn't cache it in the per-query state).
125 : */
126 433 : if (AggCheckCallContext(fcinfo, &gcontext) != AGG_CONTEXT_AGGREGATE)
127 0 : elog(ERROR, "ordered-set aggregate called in non-aggregate context");
128 :
129 : /*
130 : * We keep a link to the per-query state in fn_extra; if it's not there,
131 : * create it, and do the per-query setup we need.
132 : */
133 433 : qstate = (OSAPerQueryState *) fcinfo->flinfo->fn_extra;
134 433 : if (qstate == NULL)
135 : {
136 : Aggref *aggref;
137 : MemoryContext qcontext;
138 : List *sortlist;
139 : int numSortCols;
140 :
141 : /* Get the Aggref so we can examine aggregate's arguments */
142 163 : aggref = AggGetAggref(fcinfo);
143 163 : if (!aggref)
144 0 : elog(ERROR, "ordered-set aggregate called in non-aggregate context");
145 163 : if (!AGGKIND_IS_ORDERED_SET(aggref->aggkind))
146 0 : elog(ERROR, "ordered-set aggregate support function called for non-ordered-set aggregate");
147 :
148 : /*
149 : * Prepare per-query structures in the fn_mcxt, which we assume is the
150 : * executor's per-query context; in any case it's the right place to
151 : * keep anything found via fn_extra.
152 : */
153 163 : qcontext = fcinfo->flinfo->fn_mcxt;
154 163 : oldcontext = MemoryContextSwitchTo(qcontext);
155 :
156 163 : qstate = palloc0_object(OSAPerQueryState);
157 163 : qstate->aggref = aggref;
158 163 : qstate->qcontext = qcontext;
159 :
160 : /* We need to support rescans if the trans state is shared */
161 163 : qstate->rescan_needed = AggStateIsShared(fcinfo);
162 :
163 : /* Extract the sort information */
164 163 : sortlist = aggref->aggorder;
165 163 : numSortCols = list_length(sortlist);
166 :
167 163 : if (use_tuples)
168 : {
169 66 : bool ishypothetical = (aggref->aggkind == AGGKIND_HYPOTHETICAL);
170 : ListCell *lc;
171 : int i;
172 :
173 66 : if (ishypothetical)
174 66 : numSortCols++; /* make space for flag column */
175 66 : qstate->numSortCols = numSortCols;
176 66 : qstate->sortColIdx = (AttrNumber *) palloc(numSortCols * sizeof(AttrNumber));
177 66 : qstate->sortOperators = (Oid *) palloc(numSortCols * sizeof(Oid));
178 66 : qstate->eqOperators = (Oid *) palloc(numSortCols * sizeof(Oid));
179 66 : qstate->sortCollations = (Oid *) palloc(numSortCols * sizeof(Oid));
180 66 : qstate->sortNullsFirsts = (bool *) palloc(numSortCols * sizeof(bool));
181 :
182 66 : i = 0;
183 165 : foreach(lc, sortlist)
184 : {
185 99 : SortGroupClause *sortcl = (SortGroupClause *) lfirst(lc);
186 99 : TargetEntry *tle = get_sortgroupclause_tle(sortcl,
187 : aggref->args);
188 :
189 : /* the parser should have made sure of this */
190 : Assert(OidIsValid(sortcl->sortop));
191 :
192 99 : qstate->sortColIdx[i] = tle->resno;
193 99 : qstate->sortOperators[i] = sortcl->sortop;
194 99 : qstate->eqOperators[i] = sortcl->eqop;
195 99 : qstate->sortCollations[i] = exprCollation((Node *) tle->expr);
196 99 : qstate->sortNullsFirsts[i] = sortcl->nulls_first;
197 99 : i++;
198 : }
199 :
200 66 : if (ishypothetical)
201 : {
202 : /* Add an integer flag column as the last sort column */
203 66 : qstate->sortColIdx[i] = list_length(aggref->args) + 1;
204 66 : qstate->sortOperators[i] = Int4LessOperator;
205 66 : qstate->eqOperators[i] = Int4EqualOperator;
206 66 : qstate->sortCollations[i] = InvalidOid;
207 66 : qstate->sortNullsFirsts[i] = false;
208 66 : i++;
209 : }
210 :
211 : Assert(i == numSortCols);
212 :
213 : /*
214 : * Get a tupledesc corresponding to the aggregated inputs
215 : * (including sort expressions) of the agg.
216 : */
217 66 : qstate->tupdesc = ExecTypeFromTL(aggref->args);
218 :
219 : /* If we need a flag column, hack the tupledesc to include that */
220 66 : if (ishypothetical)
221 : {
222 : TupleDesc newdesc;
223 66 : int natts = qstate->tupdesc->natts;
224 :
225 66 : newdesc = CreateTemplateTupleDesc(natts + 1);
226 165 : for (i = 1; i <= natts; i++)
227 99 : TupleDescCopyEntry(newdesc, i, qstate->tupdesc, i);
228 :
229 66 : TupleDescInitEntry(newdesc,
230 66 : (AttrNumber) ++natts,
231 : "flag",
232 : INT4OID,
233 : -1,
234 : 0);
235 :
236 66 : TupleDescFinalize(newdesc);
237 66 : FreeTupleDesc(qstate->tupdesc);
238 66 : qstate->tupdesc = newdesc;
239 : }
240 :
241 : /* Create slot we'll use to store/retrieve rows */
242 66 : qstate->tupslot = MakeSingleTupleTableSlot(qstate->tupdesc,
243 : &TTSOpsMinimalTuple);
244 : }
245 : else
246 : {
247 : /* Sort single datums */
248 : SortGroupClause *sortcl;
249 : TargetEntry *tle;
250 :
251 97 : if (numSortCols != 1 || aggref->aggkind == AGGKIND_HYPOTHETICAL)
252 0 : elog(ERROR, "ordered-set aggregate support function does not support multiple aggregated columns");
253 :
254 97 : sortcl = (SortGroupClause *) linitial(sortlist);
255 97 : tle = get_sortgroupclause_tle(sortcl, aggref->args);
256 :
257 : /* the parser should have made sure of this */
258 : Assert(OidIsValid(sortcl->sortop));
259 :
260 : /* Save sort ordering info */
261 97 : qstate->sortColType = exprType((Node *) tle->expr);
262 97 : qstate->sortOperator = sortcl->sortop;
263 97 : qstate->eqOperator = sortcl->eqop;
264 97 : qstate->sortCollation = exprCollation((Node *) tle->expr);
265 97 : qstate->sortNullsFirst = sortcl->nulls_first;
266 :
267 : /* Save datatype info */
268 97 : get_typlenbyvalalign(qstate->sortColType,
269 : &qstate->typLen,
270 : &qstate->typByVal,
271 : &qstate->typAlign);
272 : }
273 :
274 163 : fcinfo->flinfo->fn_extra = qstate;
275 :
276 163 : MemoryContextSwitchTo(oldcontext);
277 : }
278 :
279 : /* Now build the stuff we need in group-lifespan context */
280 433 : oldcontext = MemoryContextSwitchTo(gcontext);
281 :
282 433 : osastate = palloc_object(OSAPerGroupState);
283 433 : osastate->qstate = qstate;
284 433 : osastate->gcontext = gcontext;
285 :
286 433 : tuplesortopt = TUPLESORT_NONE;
287 :
288 433 : if (qstate->rescan_needed)
289 16 : tuplesortopt |= TUPLESORT_RANDOMACCESS;
290 :
291 : /*
292 : * Initialize tuplesort object.
293 : */
294 433 : if (use_tuples)
295 179 : osastate->sortstate = tuplesort_begin_heap(qstate->tupdesc,
296 : qstate->numSortCols,
297 : qstate->sortColIdx,
298 : qstate->sortOperators,
299 : qstate->sortCollations,
300 : qstate->sortNullsFirsts,
301 : work_mem,
302 : NULL,
303 : tuplesortopt);
304 : else
305 254 : osastate->sortstate = tuplesort_begin_datum(qstate->sortColType,
306 : qstate->sortOperator,
307 : qstate->sortCollation,
308 254 : qstate->sortNullsFirst,
309 : work_mem,
310 : NULL,
311 : tuplesortopt);
312 :
313 433 : osastate->number_of_rows = 0;
314 433 : osastate->sort_done = false;
315 :
316 : /* Now register a shutdown callback to clean things up at end of group */
317 433 : AggRegisterCallback(fcinfo,
318 : ordered_set_shutdown,
319 : PointerGetDatum(osastate));
320 :
321 433 : MemoryContextSwitchTo(oldcontext);
322 :
323 433 : return osastate;
324 : }
325 :
326 : /*
327 : * Clean up when evaluation of an ordered-set aggregate is complete.
328 : *
329 : * We don't need to bother freeing objects in the per-group memory context,
330 : * since that will get reset anyway by nodeAgg.c; nor should we free anything
331 : * in the per-query context, which will get cleared (if this was the last
332 : * group) by ExecutorEnd. But we must take care to release any potential
333 : * non-memory resources.
334 : *
335 : * In the case where we're not expecting multiple finalfn calls, we could
336 : * arguably rely on the finalfn to clean up; but it's easier and more testable
337 : * if we just do it the same way in either case.
338 : */
339 : static void
340 433 : ordered_set_shutdown(Datum arg)
341 : {
342 433 : OSAPerGroupState *osastate = (OSAPerGroupState *) DatumGetPointer(arg);
343 :
344 : /* Tuplesort object might have temp files. */
345 433 : if (osastate->sortstate)
346 433 : tuplesort_end(osastate->sortstate);
347 433 : osastate->sortstate = NULL;
348 : /* The tupleslot probably can't be holding a pin, but let's be safe. */
349 433 : if (osastate->qstate->tupslot)
350 179 : ExecClearTuple(osastate->qstate->tupslot);
351 433 : }
352 :
353 :
354 : /*
355 : * Generic transition function for ordered-set aggregates
356 : * with a single input column in which we want to suppress nulls
357 : */
358 : Datum
359 802132 : ordered_set_transition(PG_FUNCTION_ARGS)
360 : {
361 : OSAPerGroupState *osastate;
362 :
363 : /* If first call, create the transition state workspace */
364 802132 : if (PG_ARGISNULL(0))
365 254 : osastate = ordered_set_startup(fcinfo, false);
366 : else
367 801878 : osastate = (OSAPerGroupState *) PG_GETARG_POINTER(0);
368 :
369 : /* Load the datum into the tuplesort object, but only if it's not null */
370 802132 : if (!PG_ARGISNULL(1))
371 : {
372 802084 : tuplesort_putdatum(osastate->sortstate, PG_GETARG_DATUM(1), false);
373 802084 : osastate->number_of_rows++;
374 : }
375 :
376 802132 : PG_RETURN_POINTER(osastate);
377 : }
378 :
379 : /*
380 : * Generic transition function for ordered-set aggregates
381 : * with (potentially) multiple aggregated input columns
382 : */
383 : Datum
384 201525 : ordered_set_transition_multi(PG_FUNCTION_ARGS)
385 : {
386 : OSAPerGroupState *osastate;
387 : TupleTableSlot *slot;
388 : int nargs;
389 : int i;
390 :
391 : /* If first call, create the transition state workspace */
392 201525 : if (PG_ARGISNULL(0))
393 179 : osastate = ordered_set_startup(fcinfo, true);
394 : else
395 201346 : osastate = (OSAPerGroupState *) PG_GETARG_POINTER(0);
396 :
397 : /* Form a tuple from all the other inputs besides the transition value */
398 201525 : slot = osastate->qstate->tupslot;
399 201525 : ExecClearTuple(slot);
400 201525 : nargs = PG_NARGS() - 1;
401 803483 : for (i = 0; i < nargs; i++)
402 : {
403 601958 : slot->tts_values[i] = PG_GETARG_DATUM(i + 1);
404 601958 : slot->tts_isnull[i] = PG_ARGISNULL(i + 1);
405 : }
406 201525 : if (osastate->qstate->aggref->aggkind == AGGKIND_HYPOTHETICAL)
407 : {
408 : /* Add a zero flag value to mark this row as a normal input row */
409 201525 : slot->tts_values[i] = Int32GetDatum(0);
410 201525 : slot->tts_isnull[i] = false;
411 201525 : i++;
412 : }
413 : Assert(i == slot->tts_tupleDescriptor->natts);
414 201525 : ExecStoreVirtualTuple(slot);
415 :
416 : /* Load the row into the tuplesort object */
417 201525 : tuplesort_puttupleslot(osastate->sortstate, slot);
418 201525 : osastate->number_of_rows++;
419 :
420 201525 : PG_RETURN_POINTER(osastate);
421 : }
422 :
423 :
424 : /*
425 : * percentile_disc(float8) within group(anyelement) - discrete percentile
426 : */
427 : Datum
428 180 : percentile_disc_final(PG_FUNCTION_ARGS)
429 : {
430 : OSAPerGroupState *osastate;
431 : double percentile;
432 : Datum val;
433 : bool isnull;
434 : int64 rownum;
435 :
436 : Assert(AggCheckCallContext(fcinfo, NULL) == AGG_CONTEXT_AGGREGATE);
437 :
438 : /* Get and check the percentile argument */
439 180 : if (PG_ARGISNULL(1))
440 0 : PG_RETURN_NULL();
441 :
442 180 : percentile = PG_GETARG_FLOAT8(1);
443 :
444 180 : if (percentile < 0 || percentile > 1 || isnan(percentile))
445 0 : ereport(ERROR,
446 : (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
447 : errmsg("percentile value %g is not between 0 and 1",
448 : percentile)));
449 :
450 : /* If there were no regular rows, the result is NULL */
451 180 : if (PG_ARGISNULL(0))
452 36 : PG_RETURN_NULL();
453 :
454 144 : osastate = (OSAPerGroupState *) PG_GETARG_POINTER(0);
455 :
456 : /* number_of_rows could be zero if we only saw NULL input values */
457 144 : if (osastate->number_of_rows == 0)
458 0 : PG_RETURN_NULL();
459 :
460 : /* Finish the sort, or rescan if we already did */
461 144 : if (!osastate->sort_done)
462 : {
463 128 : tuplesort_performsort(osastate->sortstate);
464 128 : osastate->sort_done = true;
465 : }
466 : else
467 16 : tuplesort_rescan(osastate->sortstate);
468 :
469 : /*----------
470 : * We need the smallest K such that (K/N) >= percentile.
471 : * N>0, therefore K >= N*percentile, therefore K = ceil(N*percentile).
472 : * So we skip K-1 rows (if K>0) and return the next row fetched.
473 : *----------
474 : */
475 144 : rownum = (int64) ceil(percentile * osastate->number_of_rows);
476 : Assert(rownum <= osastate->number_of_rows);
477 :
478 144 : if (rownum > 1)
479 : {
480 104 : if (!tuplesort_skiptuples(osastate->sortstate, rownum - 1, true))
481 0 : elog(ERROR, "missing row in percentile_disc");
482 : }
483 :
484 144 : if (!tuplesort_getdatum(osastate->sortstate, true, true, &val, &isnull,
485 : NULL))
486 0 : elog(ERROR, "missing row in percentile_disc");
487 :
488 : /* We shouldn't have stored any nulls, but do the right thing anyway */
489 144 : if (isnull)
490 0 : PG_RETURN_NULL();
491 : else
492 144 : PG_RETURN_DATUM(val);
493 : }
494 :
495 :
496 : /*
497 : * For percentile_cont, we need a way to interpolate between consecutive
498 : * values. Use a helper function for that, so that we can share the rest
499 : * of the code between types.
500 : */
501 : typedef Datum (*LerpFunc) (Datum lo, Datum hi, double pct);
502 :
503 : static Datum
504 85 : float8_lerp(Datum lo, Datum hi, double pct)
505 : {
506 85 : double loval = DatumGetFloat8(lo);
507 85 : double hival = DatumGetFloat8(hi);
508 :
509 85 : return Float8GetDatum(loval + (pct * (hival - loval)));
510 : }
511 :
512 : static Datum
513 0 : interval_lerp(Datum lo, Datum hi, double pct)
514 : {
515 0 : Datum diff_result = DirectFunctionCall2(interval_mi, hi, lo);
516 0 : Datum mul_result = DirectFunctionCall2(interval_mul,
517 : diff_result,
518 : Float8GetDatumFast(pct));
519 :
520 0 : return DirectFunctionCall2(interval_pl, mul_result, lo);
521 : }
522 :
523 : /*
524 : * Continuous percentile
525 : */
526 : static Datum
527 66 : percentile_cont_final_common(FunctionCallInfo fcinfo,
528 : Oid expect_type,
529 : LerpFunc lerpfunc)
530 : {
531 : OSAPerGroupState *osastate;
532 : double percentile;
533 66 : int64 first_row = 0;
534 66 : int64 second_row = 0;
535 : Datum val;
536 : Datum first_val;
537 : Datum second_val;
538 : double proportion;
539 : bool isnull;
540 :
541 : Assert(AggCheckCallContext(fcinfo, NULL) == AGG_CONTEXT_AGGREGATE);
542 :
543 : /* Get and check the percentile argument */
544 66 : if (PG_ARGISNULL(1))
545 0 : PG_RETURN_NULL();
546 :
547 66 : percentile = PG_GETARG_FLOAT8(1);
548 :
549 66 : if (percentile < 0 || percentile > 1 || isnan(percentile))
550 0 : ereport(ERROR,
551 : (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
552 : errmsg("percentile value %g is not between 0 and 1",
553 : percentile)));
554 :
555 : /* If there were no regular rows, the result is NULL */
556 66 : if (PG_ARGISNULL(0))
557 0 : PG_RETURN_NULL();
558 :
559 66 : osastate = (OSAPerGroupState *) PG_GETARG_POINTER(0);
560 :
561 : /* number_of_rows could be zero if we only saw NULL input values */
562 66 : if (osastate->number_of_rows == 0)
563 0 : PG_RETURN_NULL();
564 :
565 : Assert(expect_type == osastate->qstate->sortColType);
566 :
567 : /* Finish the sort, or rescan if we already did */
568 66 : if (!osastate->sort_done)
569 : {
570 66 : tuplesort_performsort(osastate->sortstate);
571 66 : osastate->sort_done = true;
572 : }
573 : else
574 0 : tuplesort_rescan(osastate->sortstate);
575 :
576 66 : first_row = floor(percentile * (osastate->number_of_rows - 1));
577 66 : second_row = ceil(percentile * (osastate->number_of_rows - 1));
578 :
579 : Assert(first_row < osastate->number_of_rows);
580 :
581 66 : if (!tuplesort_skiptuples(osastate->sortstate, first_row, true))
582 0 : elog(ERROR, "missing row in percentile_cont");
583 :
584 66 : if (!tuplesort_getdatum(osastate->sortstate, true, true, &first_val,
585 : &isnull, NULL))
586 0 : elog(ERROR, "missing row in percentile_cont");
587 66 : if (isnull)
588 0 : PG_RETURN_NULL();
589 :
590 66 : if (first_row == second_row)
591 : {
592 21 : val = first_val;
593 : }
594 : else
595 : {
596 45 : if (!tuplesort_getdatum(osastate->sortstate, true, true, &second_val,
597 : &isnull, NULL))
598 0 : elog(ERROR, "missing row in percentile_cont");
599 :
600 45 : if (isnull)
601 0 : PG_RETURN_NULL();
602 :
603 45 : proportion = (percentile * (osastate->number_of_rows - 1)) - first_row;
604 45 : val = lerpfunc(first_val, second_val, proportion);
605 : }
606 :
607 66 : PG_RETURN_DATUM(val);
608 : }
609 :
610 : /*
611 : * percentile_cont(float8) within group (float8) - continuous percentile
612 : */
613 : Datum
614 66 : percentile_cont_float8_final(PG_FUNCTION_ARGS)
615 : {
616 66 : return percentile_cont_final_common(fcinfo, FLOAT8OID, float8_lerp);
617 : }
618 :
619 : /*
620 : * percentile_cont(float8) within group (interval) - continuous percentile
621 : */
622 : Datum
623 0 : percentile_cont_interval_final(PG_FUNCTION_ARGS)
624 : {
625 0 : return percentile_cont_final_common(fcinfo, INTERVALOID, interval_lerp);
626 : }
627 :
628 :
629 : /*
630 : * Support code for handling arrays of percentiles
631 : *
632 : * Note: in each pct_info entry, second_row should be equal to or
633 : * exactly one more than first_row.
634 : */
635 : struct pct_info
636 : {
637 : int64 first_row; /* first row to sample */
638 : int64 second_row; /* possible second row to sample */
639 : double proportion; /* interpolation fraction */
640 : int idx; /* index of this item in original array */
641 : };
642 :
643 : /*
644 : * Sort comparator to sort pct_infos by first_row then second_row
645 : */
646 : static int
647 200 : pct_info_cmp(const void *pa, const void *pb)
648 : {
649 200 : const struct pct_info *a = (const struct pct_info *) pa;
650 200 : const struct pct_info *b = (const struct pct_info *) pb;
651 :
652 200 : if (a->first_row != b->first_row)
653 172 : return (a->first_row < b->first_row) ? -1 : 1;
654 28 : if (a->second_row != b->second_row)
655 4 : return (a->second_row < b->second_row) ? -1 : 1;
656 24 : return 0;
657 : }
658 :
659 : /*
660 : * Construct array showing which rows to sample for percentiles.
661 : */
662 : static struct pct_info *
663 20 : setup_pct_info(int num_percentiles,
664 : const Datum *percentiles_datum,
665 : const bool *percentiles_null,
666 : int64 rowcount,
667 : bool continuous)
668 : {
669 : struct pct_info *pct_info;
670 : int i;
671 :
672 20 : pct_info = (struct pct_info *) palloc(num_percentiles * sizeof(struct pct_info));
673 :
674 148 : for (i = 0; i < num_percentiles; i++)
675 : {
676 128 : pct_info[i].idx = i;
677 :
678 128 : if (percentiles_null[i])
679 : {
680 : /* dummy entry for any NULL in array */
681 8 : pct_info[i].first_row = 0;
682 8 : pct_info[i].second_row = 0;
683 8 : pct_info[i].proportion = 0;
684 : }
685 : else
686 : {
687 120 : double p = DatumGetFloat8(percentiles_datum[i]);
688 :
689 120 : if (p < 0 || p > 1 || isnan(p))
690 0 : ereport(ERROR,
691 : (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
692 : errmsg("percentile value %g is not between 0 and 1",
693 : p)));
694 :
695 120 : if (continuous)
696 : {
697 64 : pct_info[i].first_row = 1 + floor(p * (rowcount - 1));
698 64 : pct_info[i].second_row = 1 + ceil(p * (rowcount - 1));
699 64 : pct_info[i].proportion = (p * (rowcount - 1)) - floor(p * (rowcount - 1));
700 : }
701 : else
702 : {
703 : /*----------
704 : * We need the smallest K such that (K/N) >= percentile.
705 : * N>0, therefore K >= N*percentile, therefore
706 : * K = ceil(N*percentile); but not less than 1.
707 : *----------
708 : */
709 56 : int64 row = (int64) ceil(p * rowcount);
710 :
711 56 : row = Max(1, row);
712 56 : pct_info[i].first_row = row;
713 56 : pct_info[i].second_row = row;
714 56 : pct_info[i].proportion = 0;
715 : }
716 : }
717 : }
718 :
719 : /*
720 : * The parameter array wasn't necessarily in sorted order, but we need to
721 : * visit the rows in order, so sort by first_row/second_row.
722 : */
723 20 : qsort(pct_info, num_percentiles, sizeof(struct pct_info), pct_info_cmp);
724 :
725 20 : return pct_info;
726 : }
727 :
728 : /*
729 : * percentile_disc(float8[]) within group (anyelement) - discrete percentiles
730 : */
731 : Datum
732 12 : percentile_disc_multi_final(PG_FUNCTION_ARGS)
733 : {
734 : OSAPerGroupState *osastate;
735 : ArrayType *param;
736 : Datum *percentiles_datum;
737 : bool *percentiles_null;
738 : int num_percentiles;
739 : struct pct_info *pct_info;
740 : Datum *result_datum;
741 : bool *result_isnull;
742 12 : int64 rownum = 0;
743 12 : Datum val = (Datum) 0;
744 12 : bool isnull = true;
745 : int i;
746 :
747 : Assert(AggCheckCallContext(fcinfo, NULL) == AGG_CONTEXT_AGGREGATE);
748 :
749 : /* If there were no regular rows, the result is NULL */
750 12 : if (PG_ARGISNULL(0))
751 0 : PG_RETURN_NULL();
752 :
753 12 : osastate = (OSAPerGroupState *) PG_GETARG_POINTER(0);
754 :
755 : /* number_of_rows could be zero if we only saw NULL input values */
756 12 : if (osastate->number_of_rows == 0)
757 0 : PG_RETURN_NULL();
758 :
759 : /* Deconstruct the percentile-array input */
760 12 : if (PG_ARGISNULL(1))
761 0 : PG_RETURN_NULL();
762 12 : param = PG_GETARG_ARRAYTYPE_P(1);
763 :
764 12 : deconstruct_array_builtin(param, FLOAT8OID,
765 : &percentiles_datum,
766 : &percentiles_null,
767 : &num_percentiles);
768 :
769 12 : if (num_percentiles == 0)
770 0 : PG_RETURN_POINTER(construct_empty_array(osastate->qstate->sortColType));
771 :
772 12 : pct_info = setup_pct_info(num_percentiles,
773 : percentiles_datum,
774 : percentiles_null,
775 : osastate->number_of_rows,
776 : false);
777 :
778 12 : result_datum = (Datum *) palloc(num_percentiles * sizeof(Datum));
779 12 : result_isnull = (bool *) palloc(num_percentiles * sizeof(bool));
780 :
781 : /*
782 : * Start by dealing with any nulls in the param array - those are sorted
783 : * to the front on row=0, so set the corresponding result indexes to null
784 : */
785 20 : for (i = 0; i < num_percentiles; i++)
786 : {
787 20 : int idx = pct_info[i].idx;
788 :
789 20 : if (pct_info[i].first_row > 0)
790 12 : break;
791 :
792 8 : result_datum[idx] = (Datum) 0;
793 8 : result_isnull[idx] = true;
794 : }
795 :
796 : /*
797 : * If there's anything left after doing the nulls, then grind the input
798 : * and extract the needed values
799 : */
800 12 : if (i < num_percentiles)
801 : {
802 : /* Finish the sort, or rescan if we already did */
803 12 : if (!osastate->sort_done)
804 : {
805 12 : tuplesort_performsort(osastate->sortstate);
806 12 : osastate->sort_done = true;
807 : }
808 : else
809 0 : tuplesort_rescan(osastate->sortstate);
810 :
811 68 : for (; i < num_percentiles; i++)
812 : {
813 56 : int64 target_row = pct_info[i].first_row;
814 56 : int idx = pct_info[i].idx;
815 :
816 : /* Advance to target row, if not already there */
817 56 : if (target_row > rownum)
818 : {
819 56 : if (!tuplesort_skiptuples(osastate->sortstate, target_row - rownum - 1, true))
820 0 : elog(ERROR, "missing row in percentile_disc");
821 :
822 56 : if (!tuplesort_getdatum(osastate->sortstate, true, true, &val,
823 : &isnull, NULL))
824 0 : elog(ERROR, "missing row in percentile_disc");
825 :
826 56 : rownum = target_row;
827 : }
828 :
829 56 : result_datum[idx] = val;
830 56 : result_isnull[idx] = isnull;
831 : }
832 : }
833 :
834 : /* We make the output array the same shape as the input */
835 12 : PG_RETURN_POINTER(construct_md_array(result_datum, result_isnull,
836 : ARR_NDIM(param),
837 : ARR_DIMS(param),
838 : ARR_LBOUND(param),
839 : osastate->qstate->sortColType,
840 : osastate->qstate->typLen,
841 : osastate->qstate->typByVal,
842 : osastate->qstate->typAlign));
843 : }
844 :
845 : /*
846 : * percentile_cont(float8[]) within group () - continuous percentiles
847 : */
848 : static Datum
849 8 : percentile_cont_multi_final_common(FunctionCallInfo fcinfo,
850 : Oid expect_type,
851 : int16 typLen, bool typByVal, char typAlign,
852 : LerpFunc lerpfunc)
853 : {
854 : OSAPerGroupState *osastate;
855 : ArrayType *param;
856 : Datum *percentiles_datum;
857 : bool *percentiles_null;
858 : int num_percentiles;
859 : struct pct_info *pct_info;
860 : Datum *result_datum;
861 : bool *result_isnull;
862 8 : int64 rownum = 0;
863 8 : Datum first_val = (Datum) 0;
864 8 : Datum second_val = (Datum) 0;
865 : bool isnull;
866 : int i;
867 :
868 : Assert(AggCheckCallContext(fcinfo, NULL) == AGG_CONTEXT_AGGREGATE);
869 :
870 : /* If there were no regular rows, the result is NULL */
871 8 : if (PG_ARGISNULL(0))
872 0 : PG_RETURN_NULL();
873 :
874 8 : osastate = (OSAPerGroupState *) PG_GETARG_POINTER(0);
875 :
876 : /* number_of_rows could be zero if we only saw NULL input values */
877 8 : if (osastate->number_of_rows == 0)
878 0 : PG_RETURN_NULL();
879 :
880 : Assert(expect_type == osastate->qstate->sortColType);
881 :
882 : /* Deconstruct the percentile-array input */
883 8 : if (PG_ARGISNULL(1))
884 0 : PG_RETURN_NULL();
885 8 : param = PG_GETARG_ARRAYTYPE_P(1);
886 :
887 8 : deconstruct_array_builtin(param, FLOAT8OID,
888 : &percentiles_datum,
889 : &percentiles_null,
890 : &num_percentiles);
891 :
892 8 : if (num_percentiles == 0)
893 0 : PG_RETURN_POINTER(construct_empty_array(osastate->qstate->sortColType));
894 :
895 8 : pct_info = setup_pct_info(num_percentiles,
896 : percentiles_datum,
897 : percentiles_null,
898 : osastate->number_of_rows,
899 : true);
900 :
901 8 : result_datum = (Datum *) palloc(num_percentiles * sizeof(Datum));
902 8 : result_isnull = (bool *) palloc(num_percentiles * sizeof(bool));
903 :
904 : /*
905 : * Start by dealing with any nulls in the param array - those are sorted
906 : * to the front on row=0, so set the corresponding result indexes to null
907 : */
908 8 : for (i = 0; i < num_percentiles; i++)
909 : {
910 8 : int idx = pct_info[i].idx;
911 :
912 8 : if (pct_info[i].first_row > 0)
913 8 : break;
914 :
915 0 : result_datum[idx] = (Datum) 0;
916 0 : result_isnull[idx] = true;
917 : }
918 :
919 : /*
920 : * If there's anything left after doing the nulls, then grind the input
921 : * and extract the needed values
922 : */
923 8 : if (i < num_percentiles)
924 : {
925 : /* Finish the sort, or rescan if we already did */
926 8 : if (!osastate->sort_done)
927 : {
928 8 : tuplesort_performsort(osastate->sortstate);
929 8 : osastate->sort_done = true;
930 : }
931 : else
932 0 : tuplesort_rescan(osastate->sortstate);
933 :
934 72 : for (; i < num_percentiles; i++)
935 : {
936 64 : int64 first_row = pct_info[i].first_row;
937 64 : int64 second_row = pct_info[i].second_row;
938 64 : int idx = pct_info[i].idx;
939 :
940 : /*
941 : * Advance to first_row, if not already there. Note that we might
942 : * already have rownum beyond first_row, in which case first_val
943 : * is already correct. (This occurs when interpolating between
944 : * the same two input rows as for the previous percentile.)
945 : */
946 64 : if (first_row > rownum)
947 : {
948 32 : if (!tuplesort_skiptuples(osastate->sortstate, first_row - rownum - 1, true))
949 0 : elog(ERROR, "missing row in percentile_cont");
950 :
951 32 : if (!tuplesort_getdatum(osastate->sortstate, true, true,
952 32 : &first_val, &isnull, NULL) || isnull)
953 0 : elog(ERROR, "missing row in percentile_cont");
954 :
955 32 : rownum = first_row;
956 : /* Always advance second_val to be latest input value */
957 32 : second_val = first_val;
958 : }
959 32 : else if (first_row == rownum)
960 : {
961 : /*
962 : * We are already at the desired row, so we must previously
963 : * have read its value into second_val (and perhaps first_val
964 : * as well, but this assignment is harmless in that case).
965 : */
966 16 : first_val = second_val;
967 : }
968 :
969 : /* Fetch second_row if needed */
970 64 : if (second_row > rownum)
971 : {
972 24 : if (!tuplesort_getdatum(osastate->sortstate, true, true,
973 24 : &second_val, &isnull, NULL) || isnull)
974 0 : elog(ERROR, "missing row in percentile_cont");
975 24 : rownum++;
976 : }
977 : /* We should now certainly be on second_row exactly */
978 : Assert(second_row == rownum);
979 :
980 : /* Compute appropriate result */
981 64 : if (second_row > first_row)
982 40 : result_datum[idx] = lerpfunc(first_val, second_val,
983 40 : pct_info[i].proportion);
984 : else
985 24 : result_datum[idx] = first_val;
986 :
987 64 : result_isnull[idx] = false;
988 : }
989 : }
990 :
991 : /* We make the output array the same shape as the input */
992 8 : PG_RETURN_POINTER(construct_md_array(result_datum, result_isnull,
993 : ARR_NDIM(param),
994 : ARR_DIMS(param), ARR_LBOUND(param),
995 : expect_type,
996 : typLen,
997 : typByVal,
998 : typAlign));
999 : }
1000 :
1001 : /*
1002 : * percentile_cont(float8[]) within group (float8) - continuous percentiles
1003 : */
1004 : Datum
1005 8 : percentile_cont_float8_multi_final(PG_FUNCTION_ARGS)
1006 : {
1007 8 : return percentile_cont_multi_final_common(fcinfo,
1008 : FLOAT8OID,
1009 : /* hard-wired info on type float8 */
1010 : sizeof(float8),
1011 : true,
1012 : TYPALIGN_DOUBLE,
1013 : float8_lerp);
1014 : }
1015 :
1016 : /*
1017 : * percentile_cont(float8[]) within group (interval) - continuous percentiles
1018 : */
1019 : Datum
1020 0 : percentile_cont_interval_multi_final(PG_FUNCTION_ARGS)
1021 : {
1022 0 : return percentile_cont_multi_final_common(fcinfo,
1023 : INTERVALOID,
1024 : /* hard-wired info on type interval */
1025 : 16, false, TYPALIGN_DOUBLE,
1026 : interval_lerp);
1027 : }
1028 :
1029 :
1030 : /*
1031 : * mode() within group (anyelement) - most common value
1032 : */
1033 : Datum
1034 40 : mode_final(PG_FUNCTION_ARGS)
1035 : {
1036 : OSAPerGroupState *osastate;
1037 : Datum val;
1038 : bool isnull;
1039 40 : Datum mode_val = (Datum) 0;
1040 40 : int64 mode_freq = 0;
1041 40 : Datum last_val = (Datum) 0;
1042 40 : int64 last_val_freq = 0;
1043 40 : bool last_val_is_mode = false;
1044 : FmgrInfo *equalfn;
1045 40 : Datum abbrev_val = (Datum) 0;
1046 40 : Datum last_abbrev_val = (Datum) 0;
1047 : bool shouldfree;
1048 :
1049 : Assert(AggCheckCallContext(fcinfo, NULL) == AGG_CONTEXT_AGGREGATE);
1050 :
1051 : /* If there were no regular rows, the result is NULL */
1052 40 : if (PG_ARGISNULL(0))
1053 0 : PG_RETURN_NULL();
1054 :
1055 40 : osastate = (OSAPerGroupState *) PG_GETARG_POINTER(0);
1056 :
1057 : /* number_of_rows could be zero if we only saw NULL input values */
1058 40 : if (osastate->number_of_rows == 0)
1059 0 : PG_RETURN_NULL();
1060 :
1061 : /* Look up the equality function for the datatype, if we didn't already */
1062 40 : equalfn = &(osastate->qstate->equalfn);
1063 40 : if (!OidIsValid(equalfn->fn_oid))
1064 4 : fmgr_info_cxt(get_opcode(osastate->qstate->eqOperator), equalfn,
1065 4 : osastate->qstate->qcontext);
1066 :
1067 40 : shouldfree = !(osastate->qstate->typByVal);
1068 :
1069 : /* Finish the sort, or rescan if we already did */
1070 40 : if (!osastate->sort_done)
1071 : {
1072 40 : tuplesort_performsort(osastate->sortstate);
1073 40 : osastate->sort_done = true;
1074 : }
1075 : else
1076 0 : tuplesort_rescan(osastate->sortstate);
1077 :
1078 : /* Scan tuples and count frequencies */
1079 40040 : while (tuplesort_getdatum(osastate->sortstate, true, true, &val, &isnull,
1080 : &abbrev_val))
1081 : {
1082 : /* we don't expect any nulls, but ignore them if found */
1083 40000 : if (isnull)
1084 0 : continue;
1085 :
1086 40000 : if (last_val_freq == 0)
1087 : {
1088 : /* first nonnull value - it's the mode for now */
1089 40 : mode_val = last_val = val;
1090 40 : mode_freq = last_val_freq = 1;
1091 40 : last_val_is_mode = true;
1092 40 : last_abbrev_val = abbrev_val;
1093 : }
1094 79920 : else if (abbrev_val == last_abbrev_val &&
1095 39960 : DatumGetBool(FunctionCall2Coll(equalfn, PG_GET_COLLATION(), val, last_val)))
1096 : {
1097 : /* value equal to previous value, count it */
1098 39840 : if (last_val_is_mode)
1099 10616 : mode_freq++; /* needn't maintain last_val_freq */
1100 29224 : else if (++last_val_freq > mode_freq)
1101 : {
1102 : /* last_val becomes new mode */
1103 44 : if (shouldfree)
1104 44 : pfree(DatumGetPointer(mode_val));
1105 44 : mode_val = last_val;
1106 44 : mode_freq = last_val_freq;
1107 44 : last_val_is_mode = true;
1108 : }
1109 39840 : if (shouldfree)
1110 39840 : pfree(DatumGetPointer(val));
1111 : }
1112 : else
1113 : {
1114 : /* val should replace last_val */
1115 120 : if (shouldfree && !last_val_is_mode)
1116 48 : pfree(DatumGetPointer(last_val));
1117 120 : last_val = val;
1118 : /* avoid equality function calls by reusing abbreviated keys */
1119 120 : last_abbrev_val = abbrev_val;
1120 120 : last_val_freq = 1;
1121 120 : last_val_is_mode = false;
1122 : }
1123 :
1124 40000 : CHECK_FOR_INTERRUPTS();
1125 : }
1126 :
1127 40 : if (shouldfree && !last_val_is_mode)
1128 28 : pfree(DatumGetPointer(last_val));
1129 :
1130 40 : if (mode_freq)
1131 40 : PG_RETURN_DATUM(mode_val);
1132 : else
1133 0 : PG_RETURN_NULL();
1134 : }
1135 :
1136 :
1137 : /*
1138 : * Common code to sanity-check args for hypothetical-set functions. No need
1139 : * for friendly errors, these can only happen if someone's messing up the
1140 : * aggregate definitions. The checks are needed for security, however.
1141 : */
1142 : static void
1143 179 : hypothetical_check_argtypes(FunctionCallInfo fcinfo, int nargs,
1144 : TupleDesc tupdesc)
1145 : {
1146 : int i;
1147 :
1148 : /* check that we have an int4 flag column */
1149 179 : if (!tupdesc ||
1150 179 : (nargs + 1) != tupdesc->natts ||
1151 179 : TupleDescAttr(tupdesc, nargs)->atttypid != INT4OID)
1152 0 : elog(ERROR, "type mismatch in hypothetical-set function");
1153 :
1154 : /* check that direct args match in type with aggregated args */
1155 551 : for (i = 0; i < nargs; i++)
1156 : {
1157 372 : Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
1158 :
1159 372 : if (get_fn_expr_argtype(fcinfo->flinfo, i + 1) != attr->atttypid)
1160 0 : elog(ERROR, "type mismatch in hypothetical-set function");
1161 : }
1162 179 : }
1163 :
1164 : /*
1165 : * compute rank of hypothetical row
1166 : *
1167 : * flag should be -1 to sort hypothetical row ahead of its peers, or +1
1168 : * to sort behind.
1169 : * total number of regular rows is returned into *number_of_rows.
1170 : */
1171 : static int64
1172 163 : hypothetical_rank_common(FunctionCallInfo fcinfo, int flag,
1173 : int64 *number_of_rows)
1174 : {
1175 163 : int nargs = PG_NARGS() - 1;
1176 163 : int64 rank = 1;
1177 : OSAPerGroupState *osastate;
1178 : TupleTableSlot *slot;
1179 : int i;
1180 :
1181 : Assert(AggCheckCallContext(fcinfo, NULL) == AGG_CONTEXT_AGGREGATE);
1182 :
1183 : /* If there were no regular rows, the rank is always 1 */
1184 163 : if (PG_ARGISNULL(0))
1185 : {
1186 4 : *number_of_rows = 0;
1187 4 : return 1;
1188 : }
1189 :
1190 159 : osastate = (OSAPerGroupState *) PG_GETARG_POINTER(0);
1191 159 : *number_of_rows = osastate->number_of_rows;
1192 :
1193 : /* Adjust nargs to be the number of direct (or aggregated) args */
1194 159 : if (nargs % 2 != 0)
1195 0 : elog(ERROR, "wrong number of arguments in hypothetical-set function");
1196 159 : nargs /= 2;
1197 :
1198 159 : hypothetical_check_argtypes(fcinfo, nargs, osastate->qstate->tupdesc);
1199 :
1200 : /* because we need a hypothetical row, we can't share transition state */
1201 : Assert(!osastate->sort_done);
1202 :
1203 : /* insert the hypothetical row into the sort */
1204 159 : slot = osastate->qstate->tupslot;
1205 159 : ExecClearTuple(slot);
1206 511 : for (i = 0; i < nargs; i++)
1207 : {
1208 352 : slot->tts_values[i] = PG_GETARG_DATUM(i + 1);
1209 352 : slot->tts_isnull[i] = PG_ARGISNULL(i + 1);
1210 : }
1211 159 : slot->tts_values[i] = Int32GetDatum(flag);
1212 159 : slot->tts_isnull[i] = false;
1213 159 : ExecStoreVirtualTuple(slot);
1214 :
1215 159 : tuplesort_puttupleslot(osastate->sortstate, slot);
1216 :
1217 : /* finish the sort */
1218 159 : tuplesort_performsort(osastate->sortstate);
1219 159 : osastate->sort_done = true;
1220 :
1221 : /* iterate till we find the hypothetical row */
1222 2779 : while (tuplesort_gettupleslot(osastate->sortstate, true, true, slot, NULL))
1223 : {
1224 : bool isnull;
1225 2779 : Datum d = slot_getattr(slot, nargs + 1, &isnull);
1226 :
1227 2779 : if (!isnull && DatumGetInt32(d) != 0)
1228 159 : break;
1229 :
1230 2620 : rank++;
1231 :
1232 2620 : CHECK_FOR_INTERRUPTS();
1233 : }
1234 :
1235 159 : ExecClearTuple(slot);
1236 :
1237 159 : return rank;
1238 : }
1239 :
1240 :
1241 : /*
1242 : * rank() - rank of hypothetical row
1243 : */
1244 : Datum
1245 151 : hypothetical_rank_final(PG_FUNCTION_ARGS)
1246 : {
1247 : int64 rank;
1248 : int64 rowcount;
1249 :
1250 151 : rank = hypothetical_rank_common(fcinfo, -1, &rowcount);
1251 :
1252 151 : PG_RETURN_INT64(rank);
1253 : }
1254 :
1255 : /*
1256 : * percent_rank() - percentile rank of hypothetical row
1257 : */
1258 : Datum
1259 8 : hypothetical_percent_rank_final(PG_FUNCTION_ARGS)
1260 : {
1261 : int64 rank;
1262 : int64 rowcount;
1263 : double result_val;
1264 :
1265 8 : rank = hypothetical_rank_common(fcinfo, -1, &rowcount);
1266 :
1267 8 : if (rowcount == 0)
1268 4 : PG_RETURN_FLOAT8(0);
1269 :
1270 4 : result_val = (double) (rank - 1) / (double) (rowcount);
1271 :
1272 4 : PG_RETURN_FLOAT8(result_val);
1273 : }
1274 :
1275 : /*
1276 : * cume_dist() - cumulative distribution of hypothetical row
1277 : */
1278 : Datum
1279 4 : hypothetical_cume_dist_final(PG_FUNCTION_ARGS)
1280 : {
1281 : int64 rank;
1282 : int64 rowcount;
1283 : double result_val;
1284 :
1285 4 : rank = hypothetical_rank_common(fcinfo, 1, &rowcount);
1286 :
1287 4 : result_val = (double) (rank) / (double) (rowcount + 1);
1288 :
1289 4 : PG_RETURN_FLOAT8(result_val);
1290 : }
1291 :
1292 : /*
1293 : * dense_rank() - rank of hypothetical row without gaps in ranking
1294 : */
1295 : Datum
1296 20 : hypothetical_dense_rank_final(PG_FUNCTION_ARGS)
1297 : {
1298 : ExprContext *econtext;
1299 : ExprState *compareTuple;
1300 20 : int nargs = PG_NARGS() - 1;
1301 20 : int64 rank = 1;
1302 20 : int64 duplicate_count = 0;
1303 : OSAPerGroupState *osastate;
1304 : int numDistinctCols;
1305 20 : Datum abbrevVal = (Datum) 0;
1306 20 : Datum abbrevOld = (Datum) 0;
1307 : TupleTableSlot *slot;
1308 : TupleTableSlot *extraslot;
1309 : TupleTableSlot *slot2;
1310 : int i;
1311 :
1312 : Assert(AggCheckCallContext(fcinfo, NULL) == AGG_CONTEXT_AGGREGATE);
1313 :
1314 : /* If there were no regular rows, the rank is always 1 */
1315 20 : if (PG_ARGISNULL(0))
1316 0 : PG_RETURN_INT64(rank);
1317 :
1318 20 : osastate = (OSAPerGroupState *) PG_GETARG_POINTER(0);
1319 20 : econtext = osastate->qstate->econtext;
1320 20 : if (!econtext)
1321 : {
1322 : MemoryContext oldcontext;
1323 :
1324 : /* Make sure to we create econtext under correct parent context. */
1325 12 : oldcontext = MemoryContextSwitchTo(osastate->qstate->qcontext);
1326 12 : osastate->qstate->econtext = CreateStandaloneExprContext();
1327 12 : econtext = osastate->qstate->econtext;
1328 12 : MemoryContextSwitchTo(oldcontext);
1329 : }
1330 :
1331 : /* Adjust nargs to be the number of direct (or aggregated) args */
1332 20 : if (nargs % 2 != 0)
1333 0 : elog(ERROR, "wrong number of arguments in hypothetical-set function");
1334 20 : nargs /= 2;
1335 :
1336 20 : hypothetical_check_argtypes(fcinfo, nargs, osastate->qstate->tupdesc);
1337 :
1338 : /*
1339 : * When comparing tuples, we can omit the flag column since we will only
1340 : * compare rows with flag == 0.
1341 : */
1342 20 : numDistinctCols = osastate->qstate->numSortCols - 1;
1343 :
1344 : /* Build tuple comparator, if we didn't already */
1345 20 : compareTuple = osastate->qstate->compareTuple;
1346 20 : if (compareTuple == NULL)
1347 : {
1348 12 : AttrNumber *sortColIdx = osastate->qstate->sortColIdx;
1349 : MemoryContext oldContext;
1350 :
1351 12 : oldContext = MemoryContextSwitchTo(osastate->qstate->qcontext);
1352 12 : compareTuple = execTuplesMatchPrepare(osastate->qstate->tupdesc,
1353 : numDistinctCols,
1354 : sortColIdx,
1355 12 : osastate->qstate->eqOperators,
1356 12 : osastate->qstate->sortCollations,
1357 : NULL);
1358 12 : MemoryContextSwitchTo(oldContext);
1359 12 : osastate->qstate->compareTuple = compareTuple;
1360 : }
1361 :
1362 : /* because we need a hypothetical row, we can't share transition state */
1363 : Assert(!osastate->sort_done);
1364 :
1365 : /* insert the hypothetical row into the sort */
1366 20 : slot = osastate->qstate->tupslot;
1367 20 : ExecClearTuple(slot);
1368 40 : for (i = 0; i < nargs; i++)
1369 : {
1370 20 : slot->tts_values[i] = PG_GETARG_DATUM(i + 1);
1371 20 : slot->tts_isnull[i] = PG_ARGISNULL(i + 1);
1372 : }
1373 20 : slot->tts_values[i] = Int32GetDatum(-1);
1374 20 : slot->tts_isnull[i] = false;
1375 20 : ExecStoreVirtualTuple(slot);
1376 :
1377 20 : tuplesort_puttupleslot(osastate->sortstate, slot);
1378 :
1379 : /* finish the sort */
1380 20 : tuplesort_performsort(osastate->sortstate);
1381 20 : osastate->sort_done = true;
1382 :
1383 : /*
1384 : * We alternate fetching into tupslot and extraslot so that we have the
1385 : * previous row available for comparisons. This is accomplished by
1386 : * swapping the slot pointer variables after each row.
1387 : */
1388 20 : extraslot = MakeSingleTupleTableSlot(osastate->qstate->tupdesc,
1389 : &TTSOpsMinimalTuple);
1390 20 : slot2 = extraslot;
1391 :
1392 : /* iterate till we find the hypothetical row */
1393 44 : while (tuplesort_gettupleslot(osastate->sortstate, true, true, slot,
1394 : &abbrevVal))
1395 : {
1396 : bool isnull;
1397 44 : Datum d = slot_getattr(slot, nargs + 1, &isnull);
1398 : TupleTableSlot *tmpslot;
1399 :
1400 44 : if (!isnull && DatumGetInt32(d) != 0)
1401 20 : break;
1402 :
1403 : /* count non-distinct tuples */
1404 24 : econtext->ecxt_outertuple = slot;
1405 24 : econtext->ecxt_innertuple = slot2;
1406 :
1407 24 : if (!TupIsNull(slot2) &&
1408 32 : abbrevVal == abbrevOld &&
1409 16 : ExecQualAndReset(compareTuple, econtext))
1410 8 : duplicate_count++;
1411 :
1412 24 : tmpslot = slot2;
1413 24 : slot2 = slot;
1414 24 : slot = tmpslot;
1415 : /* avoid ExecQual() calls by reusing abbreviated keys */
1416 24 : abbrevOld = abbrevVal;
1417 :
1418 24 : rank++;
1419 :
1420 24 : CHECK_FOR_INTERRUPTS();
1421 : }
1422 :
1423 20 : ExecClearTuple(slot);
1424 20 : ExecClearTuple(slot2);
1425 :
1426 20 : ExecDropSingleTupleTableSlot(extraslot);
1427 :
1428 20 : rank = rank - duplicate_count;
1429 :
1430 20 : PG_RETURN_INT64(rank);
1431 : }
|
