PostgreSQL Source Code  git master
nodeWindowAgg.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * nodeWindowAgg.c
4  * routines to handle WindowAgg nodes.
5  *
6  * A WindowAgg node evaluates "window functions" across suitable partitions
7  * of the input tuple set. Any one WindowAgg works for just a single window
8  * specification, though it can evaluate multiple window functions sharing
9  * identical window specifications. The input tuples are required to be
10  * delivered in sorted order, with the PARTITION BY columns (if any) as
11  * major sort keys and the ORDER BY columns (if any) as minor sort keys.
12  * (The planner generates a stack of WindowAggs with intervening Sort nodes
13  * as needed, if a query involves more than one window specification.)
14  *
15  * Since window functions can require access to any or all of the rows in
16  * the current partition, we accumulate rows of the partition into a
17  * tuplestore. The window functions are called using the WindowObject API
18  * so that they can access those rows as needed.
19  *
20  * We also support using plain aggregate functions as window functions.
21  * For these, the regular Agg-node environment is emulated for each partition.
22  * As required by the SQL spec, the output represents the value of the
23  * aggregate function over all rows in the current row's window frame.
24  *
25  *
26  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
27  * Portions Copyright (c) 1994, Regents of the University of California
28  *
29  * IDENTIFICATION
30  * src/backend/executor/nodeWindowAgg.c
31  *
32  *-------------------------------------------------------------------------
33  */
34 #include "postgres.h"
35 
36 #include "access/htup_details.h"
37 #include "catalog/objectaccess.h"
38 #include "catalog/pg_aggregate.h"
39 #include "catalog/pg_proc.h"
40 #include "executor/executor.h"
41 #include "executor/nodeWindowAgg.h"
42 #include "miscadmin.h"
43 #include "nodes/nodeFuncs.h"
44 #include "optimizer/clauses.h"
45 #include "optimizer/optimizer.h"
46 #include "parser/parse_agg.h"
47 #include "parser/parse_coerce.h"
48 #include "utils/acl.h"
49 #include "utils/builtins.h"
50 #include "utils/datum.h"
51 #include "utils/expandeddatum.h"
52 #include "utils/lsyscache.h"
53 #include "utils/memutils.h"
54 #include "utils/regproc.h"
55 #include "utils/syscache.h"
56 #include "windowapi.h"
57 
58 /*
59  * All the window function APIs are called with this object, which is passed
60  * to window functions as fcinfo->context.
61  */
62 typedef struct WindowObjectData
63 {
65  WindowAggState *winstate; /* parent WindowAggState */
66  List *argstates; /* ExprState trees for fn's arguments */
67  void *localmem; /* WinGetPartitionLocalMemory's chunk */
68  int markptr; /* tuplestore mark pointer for this fn */
69  int readptr; /* tuplestore read pointer for this fn */
70  int64 markpos; /* row that markptr is positioned on */
71  int64 seekpos; /* row that readptr is positioned on */
73 
74 /*
75  * We have one WindowStatePerFunc struct for each window function and
76  * window aggregate handled by this node.
77  */
78 typedef struct WindowStatePerFuncData
79 {
80  /* Links to WindowFunc expr and state nodes this working state is for */
83 
84  int numArguments; /* number of arguments */
85 
86  FmgrInfo flinfo; /* fmgr lookup data for window function */
87 
88  Oid winCollation; /* collation derived for window function */
89 
90  /*
91  * We need the len and byval info for the result of each function in order
92  * to know how to copy/delete values.
93  */
96 
97  bool plain_agg; /* is it just a plain aggregate function? */
98  int aggno; /* if so, index of its WindowStatePerAggData */
99 
100  WindowObject winobj; /* object used in window function API */
102 
103 /*
104  * For plain aggregate window functions, we also have one of these.
105  */
106 typedef struct WindowStatePerAggData
107 {
108  /* Oids of transition functions */
110  Oid invtransfn_oid; /* may be InvalidOid */
111  Oid finalfn_oid; /* may be InvalidOid */
112 
113  /*
114  * fmgr lookup data for transition functions --- only valid when
115  * corresponding oid is not InvalidOid. Note in particular that fn_strict
116  * flags are kept here.
117  */
121 
122  int numFinalArgs; /* number of arguments to pass to finalfn */
123 
124  /*
125  * initial value from pg_aggregate entry
126  */
129 
130  /*
131  * cached value for current frame boundaries
132  */
135 
136  /*
137  * We need the len and byval info for the agg's input, result, and
138  * transition data types in order to know how to copy/delete values.
139  */
146 
147  int wfuncno; /* index of associated WindowStatePerFuncData */
148 
149  /* Context holding transition value and possibly other subsidiary data */
150  MemoryContext aggcontext; /* may be private, or winstate->aggcontext */
151 
152  /* Current transition value */
153  Datum transValue; /* current transition value */
155 
156  int64 transValueCount; /* number of currently-aggregated rows */
157 
158  /* Data local to eval_windowaggregates() */
159  bool restart; /* need to restart this agg in this cycle? */
161 
162 static void initialize_windowaggregate(WindowAggState *winstate,
163  WindowStatePerFunc perfuncstate,
164  WindowStatePerAgg peraggstate);
165 static void advance_windowaggregate(WindowAggState *winstate,
166  WindowStatePerFunc perfuncstate,
167  WindowStatePerAgg peraggstate);
168 static bool advance_windowaggregate_base(WindowAggState *winstate,
169  WindowStatePerFunc perfuncstate,
170  WindowStatePerAgg peraggstate);
171 static void finalize_windowaggregate(WindowAggState *winstate,
172  WindowStatePerFunc perfuncstate,
173  WindowStatePerAgg peraggstate,
174  Datum *result, bool *isnull);
175 
176 static void eval_windowaggregates(WindowAggState *winstate);
177 static void eval_windowfunction(WindowAggState *winstate,
178  WindowStatePerFunc perfuncstate,
179  Datum *result, bool *isnull);
180 
181 static void begin_partition(WindowAggState *winstate);
182 static void spool_tuples(WindowAggState *winstate, int64 pos);
183 static void release_partition(WindowAggState *winstate);
184 
185 static int row_is_in_frame(WindowAggState *winstate, int64 pos,
186  TupleTableSlot *slot);
187 static void update_frameheadpos(WindowAggState *winstate);
188 static void update_frametailpos(WindowAggState *winstate);
189 static void update_grouptailpos(WindowAggState *winstate);
190 
192  WindowFunc *wfunc,
193  WindowStatePerAgg peraggstate);
194 static Datum GetAggInitVal(Datum textInitVal, Oid transtype);
195 
196 static bool are_peers(WindowAggState *winstate, TupleTableSlot *slot1,
197  TupleTableSlot *slot2);
198 static bool window_gettupleslot(WindowObject winobj, int64 pos,
199  TupleTableSlot *slot);
200 
201 
202 /*
203  * initialize_windowaggregate
204  * parallel to initialize_aggregates in nodeAgg.c
205  */
206 static void
208  WindowStatePerFunc perfuncstate,
209  WindowStatePerAgg peraggstate)
210 {
211  MemoryContext oldContext;
212 
213  /*
214  * If we're using a private aggcontext, we may reset it here. But if the
215  * context is shared, we don't know which other aggregates may still need
216  * it, so we must leave it to the caller to reset at an appropriate time.
217  */
218  if (peraggstate->aggcontext != winstate->aggcontext)
219  MemoryContextReset(peraggstate->aggcontext);
220 
221  if (peraggstate->initValueIsNull)
222  peraggstate->transValue = peraggstate->initValue;
223  else
224  {
225  oldContext = MemoryContextSwitchTo(peraggstate->aggcontext);
226  peraggstate->transValue = datumCopy(peraggstate->initValue,
227  peraggstate->transtypeByVal,
228  peraggstate->transtypeLen);
229  MemoryContextSwitchTo(oldContext);
230  }
231  peraggstate->transValueIsNull = peraggstate->initValueIsNull;
232  peraggstate->transValueCount = 0;
233  peraggstate->resultValue = (Datum) 0;
234  peraggstate->resultValueIsNull = true;
235 }
236 
237 /*
238  * advance_windowaggregate
239  * parallel to advance_aggregates in nodeAgg.c
240  */
241 static void
243  WindowStatePerFunc perfuncstate,
244  WindowStatePerAgg peraggstate)
245 {
246  LOCAL_FCINFO(fcinfo, FUNC_MAX_ARGS);
247  WindowFuncExprState *wfuncstate = perfuncstate->wfuncstate;
248  int numArguments = perfuncstate->numArguments;
249  Datum newVal;
250  ListCell *arg;
251  int i;
252  MemoryContext oldContext;
253  ExprContext *econtext = winstate->tmpcontext;
254  ExprState *filter = wfuncstate->aggfilter;
255 
256  oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
257 
258  /* Skip anything FILTERed out */
259  if (filter)
260  {
261  bool isnull;
262  Datum res = ExecEvalExpr(filter, econtext, &isnull);
263 
264  if (isnull || !DatumGetBool(res))
265  {
266  MemoryContextSwitchTo(oldContext);
267  return;
268  }
269  }
270 
271  /* We start from 1, since the 0th arg will be the transition value */
272  i = 1;
273  foreach(arg, wfuncstate->args)
274  {
275  ExprState *argstate = (ExprState *) lfirst(arg);
276 
277  fcinfo->args[i].value = ExecEvalExpr(argstate, econtext,
278  &fcinfo->args[i].isnull);
279  i++;
280  }
281 
282  if (peraggstate->transfn.fn_strict)
283  {
284  /*
285  * For a strict transfn, nothing happens when there's a NULL input; we
286  * just keep the prior transValue. Note transValueCount doesn't
287  * change either.
288  */
289  for (i = 1; i <= numArguments; i++)
290  {
291  if (fcinfo->args[i].isnull)
292  {
293  MemoryContextSwitchTo(oldContext);
294  return;
295  }
296  }
297 
298  /*
299  * For strict transition functions with initial value NULL we use the
300  * first non-NULL input as the initial state. (We already checked
301  * that the agg's input type is binary-compatible with its transtype,
302  * so straight copy here is OK.)
303  *
304  * We must copy the datum into aggcontext if it is pass-by-ref. We do
305  * not need to pfree the old transValue, since it's NULL.
306  */
307  if (peraggstate->transValueCount == 0 && peraggstate->transValueIsNull)
308  {
309  MemoryContextSwitchTo(peraggstate->aggcontext);
310  peraggstate->transValue = datumCopy(fcinfo->args[1].value,
311  peraggstate->transtypeByVal,
312  peraggstate->transtypeLen);
313  peraggstate->transValueIsNull = false;
314  peraggstate->transValueCount = 1;
315  MemoryContextSwitchTo(oldContext);
316  return;
317  }
318 
319  if (peraggstate->transValueIsNull)
320  {
321  /*
322  * Don't call a strict function with NULL inputs. Note it is
323  * possible to get here despite the above tests, if the transfn is
324  * strict *and* returned a NULL on a prior cycle. If that happens
325  * we will propagate the NULL all the way to the end. That can
326  * only happen if there's no inverse transition function, though,
327  * since we disallow transitions back to NULL when there is one.
328  */
329  MemoryContextSwitchTo(oldContext);
330  Assert(!OidIsValid(peraggstate->invtransfn_oid));
331  return;
332  }
333  }
334 
335  /*
336  * OK to call the transition function. Set winstate->curaggcontext while
337  * calling it, for possible use by AggCheckCallContext.
338  */
339  InitFunctionCallInfoData(*fcinfo, &(peraggstate->transfn),
340  numArguments + 1,
341  perfuncstate->winCollation,
342  (void *) winstate, NULL);
343  fcinfo->args[0].value = peraggstate->transValue;
344  fcinfo->args[0].isnull = peraggstate->transValueIsNull;
345  winstate->curaggcontext = peraggstate->aggcontext;
346  newVal = FunctionCallInvoke(fcinfo);
347  winstate->curaggcontext = NULL;
348 
349  /*
350  * Moving-aggregate transition functions must not return null, see
351  * advance_windowaggregate_base().
352  */
353  if (fcinfo->isnull && OidIsValid(peraggstate->invtransfn_oid))
354  ereport(ERROR,
355  (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
356  errmsg("moving-aggregate transition function must not return null")));
357 
358  /*
359  * We must track the number of rows included in transValue, since to
360  * remove the last input, advance_windowaggregate_base() mustn't call the
361  * inverse transition function, but simply reset transValue back to its
362  * initial value.
363  */
364  peraggstate->transValueCount++;
365 
366  /*
367  * If pass-by-ref datatype, must copy the new value into aggcontext and
368  * free the prior transValue. But if transfn returned a pointer to its
369  * first input, we don't need to do anything. Also, if transfn returned a
370  * pointer to a R/W expanded object that is already a child of the
371  * aggcontext, assume we can adopt that value without copying it. (See
372  * comments for ExecAggCopyTransValue, which this code duplicates.)
373  */
374  if (!peraggstate->transtypeByVal &&
375  DatumGetPointer(newVal) != DatumGetPointer(peraggstate->transValue))
376  {
377  if (!fcinfo->isnull)
378  {
379  MemoryContextSwitchTo(peraggstate->aggcontext);
381  false,
382  peraggstate->transtypeLen) &&
384  /* do nothing */ ;
385  else
386  newVal = datumCopy(newVal,
387  peraggstate->transtypeByVal,
388  peraggstate->transtypeLen);
389  }
390  if (!peraggstate->transValueIsNull)
391  {
393  false,
394  peraggstate->transtypeLen))
395  DeleteExpandedObject(peraggstate->transValue);
396  else
397  pfree(DatumGetPointer(peraggstate->transValue));
398  }
399  }
400 
401  MemoryContextSwitchTo(oldContext);
402  peraggstate->transValue = newVal;
403  peraggstate->transValueIsNull = fcinfo->isnull;
404 }
405 
406 /*
407  * advance_windowaggregate_base
408  * Remove the oldest tuple from an aggregation.
409  *
410  * This is very much like advance_windowaggregate, except that we will call
411  * the inverse transition function (which caller must have checked is
412  * available).
413  *
414  * Returns true if we successfully removed the current row from this
415  * aggregate, false if not (in the latter case, caller is responsible
416  * for cleaning up by restarting the aggregation).
417  */
418 static bool
420  WindowStatePerFunc perfuncstate,
421  WindowStatePerAgg peraggstate)
422 {
423  LOCAL_FCINFO(fcinfo, FUNC_MAX_ARGS);
424  WindowFuncExprState *wfuncstate = perfuncstate->wfuncstate;
425  int numArguments = perfuncstate->numArguments;
426  Datum newVal;
427  ListCell *arg;
428  int i;
429  MemoryContext oldContext;
430  ExprContext *econtext = winstate->tmpcontext;
431  ExprState *filter = wfuncstate->aggfilter;
432 
433  oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
434 
435  /* Skip anything FILTERed out */
436  if (filter)
437  {
438  bool isnull;
439  Datum res = ExecEvalExpr(filter, econtext, &isnull);
440 
441  if (isnull || !DatumGetBool(res))
442  {
443  MemoryContextSwitchTo(oldContext);
444  return true;
445  }
446  }
447 
448  /* We start from 1, since the 0th arg will be the transition value */
449  i = 1;
450  foreach(arg, wfuncstate->args)
451  {
452  ExprState *argstate = (ExprState *) lfirst(arg);
453 
454  fcinfo->args[i].value = ExecEvalExpr(argstate, econtext,
455  &fcinfo->args[i].isnull);
456  i++;
457  }
458 
459  if (peraggstate->invtransfn.fn_strict)
460  {
461  /*
462  * For a strict (inv)transfn, nothing happens when there's a NULL
463  * input; we just keep the prior transValue. Note transValueCount
464  * doesn't change either.
465  */
466  for (i = 1; i <= numArguments; i++)
467  {
468  if (fcinfo->args[i].isnull)
469  {
470  MemoryContextSwitchTo(oldContext);
471  return true;
472  }
473  }
474  }
475 
476  /* There should still be an added but not yet removed value */
477  Assert(peraggstate->transValueCount > 0);
478 
479  /*
480  * In moving-aggregate mode, the state must never be NULL, except possibly
481  * before any rows have been aggregated (which is surely not the case at
482  * this point). This restriction allows us to interpret a NULL result
483  * from the inverse function as meaning "sorry, can't do an inverse
484  * transition in this case". We already checked this in
485  * advance_windowaggregate, but just for safety, check again.
486  */
487  if (peraggstate->transValueIsNull)
488  elog(ERROR, "aggregate transition value is NULL before inverse transition");
489 
490  /*
491  * We mustn't use the inverse transition function to remove the last
492  * input. Doing so would yield a non-NULL state, whereas we should be in
493  * the initial state afterwards which may very well be NULL. So instead,
494  * we simply re-initialize the aggregate in this case.
495  */
496  if (peraggstate->transValueCount == 1)
497  {
498  MemoryContextSwitchTo(oldContext);
500  &winstate->perfunc[peraggstate->wfuncno],
501  peraggstate);
502  return true;
503  }
504 
505  /*
506  * OK to call the inverse transition function. Set
507  * winstate->curaggcontext while calling it, for possible use by
508  * AggCheckCallContext.
509  */
510  InitFunctionCallInfoData(*fcinfo, &(peraggstate->invtransfn),
511  numArguments + 1,
512  perfuncstate->winCollation,
513  (void *) winstate, NULL);
514  fcinfo->args[0].value = peraggstate->transValue;
515  fcinfo->args[0].isnull = peraggstate->transValueIsNull;
516  winstate->curaggcontext = peraggstate->aggcontext;
517  newVal = FunctionCallInvoke(fcinfo);
518  winstate->curaggcontext = NULL;
519 
520  /*
521  * If the function returns NULL, report failure, forcing a restart.
522  */
523  if (fcinfo->isnull)
524  {
525  MemoryContextSwitchTo(oldContext);
526  return false;
527  }
528 
529  /* Update number of rows included in transValue */
530  peraggstate->transValueCount--;
531 
532  /*
533  * If pass-by-ref datatype, must copy the new value into aggcontext and
534  * free the prior transValue. But if invtransfn returned a pointer to its
535  * first input, we don't need to do anything. Also, if invtransfn
536  * returned a pointer to a R/W expanded object that is already a child of
537  * the aggcontext, assume we can adopt that value without copying it. (See
538  * comments for ExecAggCopyTransValue, which this code duplicates.)
539  *
540  * Note: the checks for null values here will never fire, but it seems
541  * best to have this stanza look just like advance_windowaggregate.
542  */
543  if (!peraggstate->transtypeByVal &&
544  DatumGetPointer(newVal) != DatumGetPointer(peraggstate->transValue))
545  {
546  if (!fcinfo->isnull)
547  {
548  MemoryContextSwitchTo(peraggstate->aggcontext);
550  false,
551  peraggstate->transtypeLen) &&
553  /* do nothing */ ;
554  else
555  newVal = datumCopy(newVal,
556  peraggstate->transtypeByVal,
557  peraggstate->transtypeLen);
558  }
559  if (!peraggstate->transValueIsNull)
560  {
562  false,
563  peraggstate->transtypeLen))
564  DeleteExpandedObject(peraggstate->transValue);
565  else
566  pfree(DatumGetPointer(peraggstate->transValue));
567  }
568  }
569 
570  MemoryContextSwitchTo(oldContext);
571  peraggstate->transValue = newVal;
572  peraggstate->transValueIsNull = fcinfo->isnull;
573 
574  return true;
575 }
576 
577 /*
578  * finalize_windowaggregate
579  * parallel to finalize_aggregate in nodeAgg.c
580  */
581 static void
583  WindowStatePerFunc perfuncstate,
584  WindowStatePerAgg peraggstate,
585  Datum *result, bool *isnull)
586 {
587  MemoryContext oldContext;
588 
590 
591  /*
592  * Apply the agg's finalfn if one is provided, else return transValue.
593  */
594  if (OidIsValid(peraggstate->finalfn_oid))
595  {
596  LOCAL_FCINFO(fcinfo, FUNC_MAX_ARGS);
597  int numFinalArgs = peraggstate->numFinalArgs;
598  bool anynull;
599  int i;
600 
601  InitFunctionCallInfoData(fcinfodata.fcinfo, &(peraggstate->finalfn),
602  numFinalArgs,
603  perfuncstate->winCollation,
604  (void *) winstate, NULL);
605  fcinfo->args[0].value =
607  peraggstate->transValueIsNull,
608  peraggstate->transtypeLen);
609  fcinfo->args[0].isnull = peraggstate->transValueIsNull;
610  anynull = peraggstate->transValueIsNull;
611 
612  /* Fill any remaining argument positions with nulls */
613  for (i = 1; i < numFinalArgs; i++)
614  {
615  fcinfo->args[i].value = (Datum) 0;
616  fcinfo->args[i].isnull = true;
617  anynull = true;
618  }
619 
620  if (fcinfo->flinfo->fn_strict && anynull)
621  {
622  /* don't call a strict function with NULL inputs */
623  *result = (Datum) 0;
624  *isnull = true;
625  }
626  else
627  {
628  Datum res;
629 
630  winstate->curaggcontext = peraggstate->aggcontext;
631  res = FunctionCallInvoke(fcinfo);
632  winstate->curaggcontext = NULL;
633  *isnull = fcinfo->isnull;
635  fcinfo->isnull,
636  peraggstate->resulttypeLen);
637  }
638  }
639  else
640  {
641  *result =
643  peraggstate->transValueIsNull,
644  peraggstate->transtypeLen);
645  *isnull = peraggstate->transValueIsNull;
646  }
647 
648  MemoryContextSwitchTo(oldContext);
649 }
650 
651 /*
652  * eval_windowaggregates
653  * evaluate plain aggregates being used as window functions
654  *
655  * This differs from nodeAgg.c in two ways. First, if the window's frame
656  * start position moves, we use the inverse transition function (if it exists)
657  * to remove rows from the transition value. And second, we expect to be
658  * able to call aggregate final functions repeatedly after aggregating more
659  * data onto the same transition value. This is not a behavior required by
660  * nodeAgg.c.
661  */
662 static void
664 {
665  WindowStatePerAgg peraggstate;
666  int wfuncno,
667  numaggs,
668  numaggs_restart,
669  i;
670  int64 aggregatedupto_nonrestarted;
671  MemoryContext oldContext;
672  ExprContext *econtext;
673  WindowObject agg_winobj;
674  TupleTableSlot *agg_row_slot;
675  TupleTableSlot *temp_slot;
676 
677  numaggs = winstate->numaggs;
678  if (numaggs == 0)
679  return; /* nothing to do */
680 
681  /* final output execution is in ps_ExprContext */
682  econtext = winstate->ss.ps.ps_ExprContext;
683  agg_winobj = winstate->agg_winobj;
684  agg_row_slot = winstate->agg_row_slot;
685  temp_slot = winstate->temp_slot_1;
686 
687  /*
688  * If the window's frame start clause is UNBOUNDED_PRECEDING and no
689  * exclusion clause is specified, then the window frame consists of a
690  * contiguous group of rows extending forward from the start of the
691  * partition, and rows only enter the frame, never exit it, as the current
692  * row advances forward. This makes it possible to use an incremental
693  * strategy for evaluating aggregates: we run the transition function for
694  * each row added to the frame, and run the final function whenever we
695  * need the current aggregate value. This is considerably more efficient
696  * than the naive approach of re-running the entire aggregate calculation
697  * for each current row. It does assume that the final function doesn't
698  * damage the running transition value, but we have the same assumption in
699  * nodeAgg.c too (when it rescans an existing hash table).
700  *
701  * If the frame start does sometimes move, we can still optimize as above
702  * whenever successive rows share the same frame head, but if the frame
703  * head moves beyond the previous head we try to remove those rows using
704  * the aggregate's inverse transition function. This function restores
705  * the aggregate's current state to what it would be if the removed row
706  * had never been aggregated in the first place. Inverse transition
707  * functions may optionally return NULL, indicating that the function was
708  * unable to remove the tuple from aggregation. If this happens, or if
709  * the aggregate doesn't have an inverse transition function at all, we
710  * must perform the aggregation all over again for all tuples within the
711  * new frame boundaries.
712  *
713  * If there's any exclusion clause, then we may have to aggregate over a
714  * non-contiguous set of rows, so we punt and recalculate for every row.
715  * (For some frame end choices, it might be that the frame is always
716  * contiguous anyway, but that's an optimization to investigate later.)
717  *
718  * In many common cases, multiple rows share the same frame and hence the
719  * same aggregate value. (In particular, if there's no ORDER BY in a RANGE
720  * window, then all rows are peers and so they all have window frame equal
721  * to the whole partition.) We optimize such cases by calculating the
722  * aggregate value once when we reach the first row of a peer group, and
723  * then returning the saved value for all subsequent rows.
724  *
725  * 'aggregatedupto' keeps track of the first row that has not yet been
726  * accumulated into the aggregate transition values. Whenever we start a
727  * new peer group, we accumulate forward to the end of the peer group.
728  */
729 
730  /*
731  * First, update the frame head position.
732  *
733  * The frame head should never move backwards, and the code below wouldn't
734  * cope if it did, so for safety we complain if it does.
735  */
736  update_frameheadpos(winstate);
737  if (winstate->frameheadpos < winstate->aggregatedbase)
738  elog(ERROR, "window frame head moved backward");
739 
740  /*
741  * If the frame didn't change compared to the previous row, we can re-use
742  * the result values that were previously saved at the bottom of this
743  * function. Since we don't know the current frame's end yet, this is not
744  * possible to check for fully. But if the frame end mode is UNBOUNDED
745  * FOLLOWING or CURRENT ROW, no exclusion clause is specified, and the
746  * current row lies within the previous row's frame, then the two frames'
747  * ends must coincide. Note that on the first row aggregatedbase ==
748  * aggregatedupto, meaning this test must fail, so we don't need to check
749  * the "there was no previous row" case explicitly here.
750  */
751  if (winstate->aggregatedbase == winstate->frameheadpos &&
754  !(winstate->frameOptions & FRAMEOPTION_EXCLUSION) &&
755  winstate->aggregatedbase <= winstate->currentpos &&
756  winstate->aggregatedupto > winstate->currentpos)
757  {
758  for (i = 0; i < numaggs; i++)
759  {
760  peraggstate = &winstate->peragg[i];
761  wfuncno = peraggstate->wfuncno;
762  econtext->ecxt_aggvalues[wfuncno] = peraggstate->resultValue;
763  econtext->ecxt_aggnulls[wfuncno] = peraggstate->resultValueIsNull;
764  }
765  return;
766  }
767 
768  /*----------
769  * Initialize restart flags.
770  *
771  * We restart the aggregation:
772  * - if we're processing the first row in the partition, or
773  * - if the frame's head moved and we cannot use an inverse
774  * transition function, or
775  * - we have an EXCLUSION clause, or
776  * - if the new frame doesn't overlap the old one
777  *
778  * Note that we don't strictly need to restart in the last case, but if
779  * we're going to remove all rows from the aggregation anyway, a restart
780  * surely is faster.
781  *----------
782  */
783  numaggs_restart = 0;
784  for (i = 0; i < numaggs; i++)
785  {
786  peraggstate = &winstate->peragg[i];
787  if (winstate->currentpos == 0 ||
788  (winstate->aggregatedbase != winstate->frameheadpos &&
789  !OidIsValid(peraggstate->invtransfn_oid)) ||
790  (winstate->frameOptions & FRAMEOPTION_EXCLUSION) ||
791  winstate->aggregatedupto <= winstate->frameheadpos)
792  {
793  peraggstate->restart = true;
794  numaggs_restart++;
795  }
796  else
797  peraggstate->restart = false;
798  }
799 
800  /*
801  * If we have any possibly-moving aggregates, attempt to advance
802  * aggregatedbase to match the frame's head by removing input rows that
803  * fell off the top of the frame from the aggregations. This can fail,
804  * i.e. advance_windowaggregate_base() can return false, in which case
805  * we'll restart that aggregate below.
806  */
807  while (numaggs_restart < numaggs &&
808  winstate->aggregatedbase < winstate->frameheadpos)
809  {
810  /*
811  * Fetch the next tuple of those being removed. This should never fail
812  * as we should have been here before.
813  */
814  if (!window_gettupleslot(agg_winobj, winstate->aggregatedbase,
815  temp_slot))
816  elog(ERROR, "could not re-fetch previously fetched frame row");
817 
818  /* Set tuple context for evaluation of aggregate arguments */
819  winstate->tmpcontext->ecxt_outertuple = temp_slot;
820 
821  /*
822  * Perform the inverse transition for each aggregate function in the
823  * window, unless it has already been marked as needing a restart.
824  */
825  for (i = 0; i < numaggs; i++)
826  {
827  bool ok;
828 
829  peraggstate = &winstate->peragg[i];
830  if (peraggstate->restart)
831  continue;
832 
833  wfuncno = peraggstate->wfuncno;
834  ok = advance_windowaggregate_base(winstate,
835  &winstate->perfunc[wfuncno],
836  peraggstate);
837  if (!ok)
838  {
839  /* Inverse transition function has failed, must restart */
840  peraggstate->restart = true;
841  numaggs_restart++;
842  }
843  }
844 
845  /* Reset per-input-tuple context after each tuple */
846  ResetExprContext(winstate->tmpcontext);
847 
848  /* And advance the aggregated-row state */
849  winstate->aggregatedbase++;
850  ExecClearTuple(temp_slot);
851  }
852 
853  /*
854  * If we successfully advanced the base rows of all the aggregates,
855  * aggregatedbase now equals frameheadpos; but if we failed for any, we
856  * must forcibly update aggregatedbase.
857  */
858  winstate->aggregatedbase = winstate->frameheadpos;
859 
860  /*
861  * If we created a mark pointer for aggregates, keep it pushed up to frame
862  * head, so that tuplestore can discard unnecessary rows.
863  */
864  if (agg_winobj->markptr >= 0)
865  WinSetMarkPosition(agg_winobj, winstate->frameheadpos);
866 
867  /*
868  * Now restart the aggregates that require it.
869  *
870  * We assume that aggregates using the shared context always restart if
871  * *any* aggregate restarts, and we may thus clean up the shared
872  * aggcontext if that is the case. Private aggcontexts are reset by
873  * initialize_windowaggregate() if their owning aggregate restarts. If we
874  * aren't restarting an aggregate, we need to free any previously saved
875  * result for it, else we'll leak memory.
876  */
877  if (numaggs_restart > 0)
878  MemoryContextReset(winstate->aggcontext);
879  for (i = 0; i < numaggs; i++)
880  {
881  peraggstate = &winstate->peragg[i];
882 
883  /* Aggregates using the shared ctx must restart if *any* agg does */
884  Assert(peraggstate->aggcontext != winstate->aggcontext ||
885  numaggs_restart == 0 ||
886  peraggstate->restart);
887 
888  if (peraggstate->restart)
889  {
890  wfuncno = peraggstate->wfuncno;
892  &winstate->perfunc[wfuncno],
893  peraggstate);
894  }
895  else if (!peraggstate->resultValueIsNull)
896  {
897  if (!peraggstate->resulttypeByVal)
898  pfree(DatumGetPointer(peraggstate->resultValue));
899  peraggstate->resultValue = (Datum) 0;
900  peraggstate->resultValueIsNull = true;
901  }
902  }
903 
904  /*
905  * Non-restarted aggregates now contain the rows between aggregatedbase
906  * (i.e., frameheadpos) and aggregatedupto, while restarted aggregates
907  * contain no rows. If there are any restarted aggregates, we must thus
908  * begin aggregating anew at frameheadpos, otherwise we may simply
909  * continue at aggregatedupto. We must remember the old value of
910  * aggregatedupto to know how long to skip advancing non-restarted
911  * aggregates. If we modify aggregatedupto, we must also clear
912  * agg_row_slot, per the loop invariant below.
913  */
914  aggregatedupto_nonrestarted = winstate->aggregatedupto;
915  if (numaggs_restart > 0 &&
916  winstate->aggregatedupto != winstate->frameheadpos)
917  {
918  winstate->aggregatedupto = winstate->frameheadpos;
919  ExecClearTuple(agg_row_slot);
920  }
921 
922  /*
923  * Advance until we reach a row not in frame (or end of partition).
924  *
925  * Note the loop invariant: agg_row_slot is either empty or holds the row
926  * at position aggregatedupto. We advance aggregatedupto after processing
927  * a row.
928  */
929  for (;;)
930  {
931  int ret;
932 
933  /* Fetch next row if we didn't already */
934  if (TupIsNull(agg_row_slot))
935  {
936  if (!window_gettupleslot(agg_winobj, winstate->aggregatedupto,
937  agg_row_slot))
938  break; /* must be end of partition */
939  }
940 
941  /*
942  * Exit loop if no more rows can be in frame. Skip aggregation if
943  * current row is not in frame but there might be more in the frame.
944  */
945  ret = row_is_in_frame(winstate, winstate->aggregatedupto, agg_row_slot);
946  if (ret < 0)
947  break;
948  if (ret == 0)
949  goto next_tuple;
950 
951  /* Set tuple context for evaluation of aggregate arguments */
952  winstate->tmpcontext->ecxt_outertuple = agg_row_slot;
953 
954  /* Accumulate row into the aggregates */
955  for (i = 0; i < numaggs; i++)
956  {
957  peraggstate = &winstate->peragg[i];
958 
959  /* Non-restarted aggs skip until aggregatedupto_nonrestarted */
960  if (!peraggstate->restart &&
961  winstate->aggregatedupto < aggregatedupto_nonrestarted)
962  continue;
963 
964  wfuncno = peraggstate->wfuncno;
965  advance_windowaggregate(winstate,
966  &winstate->perfunc[wfuncno],
967  peraggstate);
968  }
969 
970 next_tuple:
971  /* Reset per-input-tuple context after each tuple */
972  ResetExprContext(winstate->tmpcontext);
973 
974  /* And advance the aggregated-row state */
975  winstate->aggregatedupto++;
976  ExecClearTuple(agg_row_slot);
977  }
978 
979  /* The frame's end is not supposed to move backwards, ever */
980  Assert(aggregatedupto_nonrestarted <= winstate->aggregatedupto);
981 
982  /*
983  * finalize aggregates and fill result/isnull fields.
984  */
985  for (i = 0; i < numaggs; i++)
986  {
987  Datum *result;
988  bool *isnull;
989 
990  peraggstate = &winstate->peragg[i];
991  wfuncno = peraggstate->wfuncno;
992  result = &econtext->ecxt_aggvalues[wfuncno];
993  isnull = &econtext->ecxt_aggnulls[wfuncno];
994  finalize_windowaggregate(winstate,
995  &winstate->perfunc[wfuncno],
996  peraggstate,
997  result, isnull);
998 
999  /*
1000  * save the result in case next row shares the same frame.
1001  *
1002  * XXX in some framing modes, eg ROWS/END_CURRENT_ROW, we can know in
1003  * advance that the next row can't possibly share the same frame. Is
1004  * it worth detecting that and skipping this code?
1005  */
1006  if (!peraggstate->resulttypeByVal && !*isnull)
1007  {
1008  oldContext = MemoryContextSwitchTo(peraggstate->aggcontext);
1009  peraggstate->resultValue =
1010  datumCopy(*result,
1011  peraggstate->resulttypeByVal,
1012  peraggstate->resulttypeLen);
1013  MemoryContextSwitchTo(oldContext);
1014  }
1015  else
1016  {
1017  peraggstate->resultValue = *result;
1018  }
1019  peraggstate->resultValueIsNull = *isnull;
1020  }
1021 }
1022 
1023 /*
1024  * eval_windowfunction
1025  *
1026  * Arguments of window functions are not evaluated here, because a window
1027  * function can need random access to arbitrary rows in the partition.
1028  * The window function uses the special WinGetFuncArgInPartition and
1029  * WinGetFuncArgInFrame functions to evaluate the arguments for the rows
1030  * it wants.
1031  */
1032 static void
1034  Datum *result, bool *isnull)
1035 {
1036  LOCAL_FCINFO(fcinfo, FUNC_MAX_ARGS);
1037  MemoryContext oldContext;
1038 
1040 
1041  /*
1042  * We don't pass any normal arguments to a window function, but we do pass
1043  * it the number of arguments, in order to permit window function
1044  * implementations to support varying numbers of arguments. The real info
1045  * goes through the WindowObject, which is passed via fcinfo->context.
1046  */
1047  InitFunctionCallInfoData(*fcinfo, &(perfuncstate->flinfo),
1048  perfuncstate->numArguments,
1049  perfuncstate->winCollation,
1050  (void *) perfuncstate->winobj, NULL);
1051  /* Just in case, make all the regular argument slots be null */
1052  for (int argno = 0; argno < perfuncstate->numArguments; argno++)
1053  fcinfo->args[argno].isnull = true;
1054  /* Window functions don't have a current aggregate context, either */
1055  winstate->curaggcontext = NULL;
1056 
1057  *result = FunctionCallInvoke(fcinfo);
1058  *isnull = fcinfo->isnull;
1059 
1060  /*
1061  * The window function might have returned a pass-by-ref result that's
1062  * just a pointer into one of the WindowObject's temporary slots. That's
1063  * not a problem if it's the only window function using the WindowObject;
1064  * but if there's more than one function, we'd better copy the result to
1065  * ensure it's not clobbered by later window functions.
1066  */
1067  if (!perfuncstate->resulttypeByVal && !fcinfo->isnull &&
1068  winstate->numfuncs > 1)
1069  *result = datumCopy(*result,
1070  perfuncstate->resulttypeByVal,
1071  perfuncstate->resulttypeLen);
1072 
1073  MemoryContextSwitchTo(oldContext);
1074 }
1075 
1076 /*
1077  * begin_partition
1078  * Start buffering rows of the next partition.
1079  */
1080 static void
1082 {
1083  WindowAgg *node = (WindowAgg *) winstate->ss.ps.plan;
1084  PlanState *outerPlan = outerPlanState(winstate);
1085  int frameOptions = winstate->frameOptions;
1086  int numfuncs = winstate->numfuncs;
1087  int i;
1088 
1089  winstate->partition_spooled = false;
1090  winstate->framehead_valid = false;
1091  winstate->frametail_valid = false;
1092  winstate->grouptail_valid = false;
1093  winstate->spooled_rows = 0;
1094  winstate->currentpos = 0;
1095  winstate->frameheadpos = 0;
1096  winstate->frametailpos = 0;
1097  winstate->currentgroup = 0;
1098  winstate->frameheadgroup = 0;
1099  winstate->frametailgroup = 0;
1100  winstate->groupheadpos = 0;
1101  winstate->grouptailpos = -1; /* see update_grouptailpos */
1102  ExecClearTuple(winstate->agg_row_slot);
1103  if (winstate->framehead_slot)
1104  ExecClearTuple(winstate->framehead_slot);
1105  if (winstate->frametail_slot)
1106  ExecClearTuple(winstate->frametail_slot);
1107 
1108  /*
1109  * If this is the very first partition, we need to fetch the first input
1110  * row to store in first_part_slot.
1111  */
1112  if (TupIsNull(winstate->first_part_slot))
1113  {
1114  TupleTableSlot *outerslot = ExecProcNode(outerPlan);
1115 
1116  if (!TupIsNull(outerslot))
1117  ExecCopySlot(winstate->first_part_slot, outerslot);
1118  else
1119  {
1120  /* outer plan is empty, so we have nothing to do */
1121  winstate->partition_spooled = true;
1122  winstate->more_partitions = false;
1123  return;
1124  }
1125  }
1126 
1127  /* Create new tuplestore for this partition */
1128  winstate->buffer = tuplestore_begin_heap(false, false, work_mem);
1129 
1130  /*
1131  * Set up read pointers for the tuplestore. The current pointer doesn't
1132  * need BACKWARD capability, but the per-window-function read pointers do,
1133  * and the aggregate pointer does if we might need to restart aggregation.
1134  */
1135  winstate->current_ptr = 0; /* read pointer 0 is pre-allocated */
1136 
1137  /* reset default REWIND capability bit for current ptr */
1138  tuplestore_set_eflags(winstate->buffer, 0);
1139 
1140  /* create read pointers for aggregates, if needed */
1141  if (winstate->numaggs > 0)
1142  {
1143  WindowObject agg_winobj = winstate->agg_winobj;
1144  int readptr_flags = 0;
1145 
1146  /*
1147  * If the frame head is potentially movable, or we have an EXCLUSION
1148  * clause, we might need to restart aggregation ...
1149  */
1150  if (!(frameOptions & FRAMEOPTION_START_UNBOUNDED_PRECEDING) ||
1151  (frameOptions & FRAMEOPTION_EXCLUSION))
1152  {
1153  /* ... so create a mark pointer to track the frame head */
1154  agg_winobj->markptr = tuplestore_alloc_read_pointer(winstate->buffer, 0);
1155  /* and the read pointer will need BACKWARD capability */
1156  readptr_flags |= EXEC_FLAG_BACKWARD;
1157  }
1158 
1159  agg_winobj->readptr = tuplestore_alloc_read_pointer(winstate->buffer,
1160  readptr_flags);
1161  agg_winobj->markpos = -1;
1162  agg_winobj->seekpos = -1;
1163 
1164  /* Also reset the row counters for aggregates */
1165  winstate->aggregatedbase = 0;
1166  winstate->aggregatedupto = 0;
1167  }
1168 
1169  /* create mark and read pointers for each real window function */
1170  for (i = 0; i < numfuncs; i++)
1171  {
1172  WindowStatePerFunc perfuncstate = &(winstate->perfunc[i]);
1173 
1174  if (!perfuncstate->plain_agg)
1175  {
1176  WindowObject winobj = perfuncstate->winobj;
1177 
1178  winobj->markptr = tuplestore_alloc_read_pointer(winstate->buffer,
1179  0);
1180  winobj->readptr = tuplestore_alloc_read_pointer(winstate->buffer,
1182  winobj->markpos = -1;
1183  winobj->seekpos = -1;
1184  }
1185  }
1186 
1187  /*
1188  * If we are in RANGE or GROUPS mode, then determining frame boundaries
1189  * requires physical access to the frame endpoint rows, except in certain
1190  * degenerate cases. We create read pointers to point to those rows, to
1191  * simplify access and ensure that the tuplestore doesn't discard the
1192  * endpoint rows prematurely. (Must create pointers in exactly the same
1193  * cases that update_frameheadpos and update_frametailpos need them.)
1194  */
1195  winstate->framehead_ptr = winstate->frametail_ptr = -1; /* if not used */
1196 
1197  if (frameOptions & (FRAMEOPTION_RANGE | FRAMEOPTION_GROUPS))
1198  {
1199  if (((frameOptions & FRAMEOPTION_START_CURRENT_ROW) &&
1200  node->ordNumCols != 0) ||
1201  (frameOptions & FRAMEOPTION_START_OFFSET))
1202  winstate->framehead_ptr =
1203  tuplestore_alloc_read_pointer(winstate->buffer, 0);
1204  if (((frameOptions & FRAMEOPTION_END_CURRENT_ROW) &&
1205  node->ordNumCols != 0) ||
1206  (frameOptions & FRAMEOPTION_END_OFFSET))
1207  winstate->frametail_ptr =
1208  tuplestore_alloc_read_pointer(winstate->buffer, 0);
1209  }
1210 
1211  /*
1212  * If we have an exclusion clause that requires knowing the boundaries of
1213  * the current row's peer group, we create a read pointer to track the
1214  * tail position of the peer group (i.e., first row of the next peer
1215  * group). The head position does not require its own pointer because we
1216  * maintain that as a side effect of advancing the current row.
1217  */
1218  winstate->grouptail_ptr = -1;
1219 
1220  if ((frameOptions & (FRAMEOPTION_EXCLUDE_GROUP |
1222  node->ordNumCols != 0)
1223  {
1224  winstate->grouptail_ptr =
1225  tuplestore_alloc_read_pointer(winstate->buffer, 0);
1226  }
1227 
1228  /*
1229  * Store the first tuple into the tuplestore (it's always available now;
1230  * we either read it above, or saved it at the end of previous partition)
1231  */
1232  tuplestore_puttupleslot(winstate->buffer, winstate->first_part_slot);
1233  winstate->spooled_rows++;
1234 }
1235 
1236 /*
1237  * Read tuples from the outer node, up to and including position 'pos', and
1238  * store them into the tuplestore. If pos is -1, reads the whole partition.
1239  */
1240 static void
1241 spool_tuples(WindowAggState *winstate, int64 pos)
1242 {
1243  WindowAgg *node = (WindowAgg *) winstate->ss.ps.plan;
1245  TupleTableSlot *outerslot;
1246  MemoryContext oldcontext;
1247 
1248  if (!winstate->buffer)
1249  return; /* just a safety check */
1250  if (winstate->partition_spooled)
1251  return; /* whole partition done already */
1252 
1253  /*
1254  * When in pass-through mode we can just exhaust all tuples in the current
1255  * partition. We don't need these tuples for any further window function
1256  * evaluation, however, we do need to keep them around if we're not the
1257  * top-level window as another WindowAgg node above must see these.
1258  */
1259  if (winstate->status != WINDOWAGG_RUN)
1260  {
1261  Assert(winstate->status == WINDOWAGG_PASSTHROUGH ||
1262  winstate->status == WINDOWAGG_PASSTHROUGH_STRICT);
1263 
1264  pos = -1;
1265  }
1266 
1267  /*
1268  * If the tuplestore has spilled to disk, alternate reading and writing
1269  * becomes quite expensive due to frequent buffer flushes. It's cheaper
1270  * to force the entire partition to get spooled in one go.
1271  *
1272  * XXX this is a horrid kluge --- it'd be better to fix the performance
1273  * problem inside tuplestore. FIXME
1274  */
1275  else if (!tuplestore_in_memory(winstate->buffer))
1276  pos = -1;
1277 
1278  outerPlan = outerPlanState(winstate);
1279 
1280  /* Must be in query context to call outerplan */
1282 
1283  while (winstate->spooled_rows <= pos || pos == -1)
1284  {
1285  outerslot = ExecProcNode(outerPlan);
1286  if (TupIsNull(outerslot))
1287  {
1288  /* reached the end of the last partition */
1289  winstate->partition_spooled = true;
1290  winstate->more_partitions = false;
1291  break;
1292  }
1293 
1294  if (node->partNumCols > 0)
1295  {
1296  ExprContext *econtext = winstate->tmpcontext;
1297 
1298  econtext->ecxt_innertuple = winstate->first_part_slot;
1299  econtext->ecxt_outertuple = outerslot;
1300 
1301  /* Check if this tuple still belongs to the current partition */
1302  if (!ExecQualAndReset(winstate->partEqfunction, econtext))
1303  {
1304  /*
1305  * end of partition; copy the tuple for the next cycle.
1306  */
1307  ExecCopySlot(winstate->first_part_slot, outerslot);
1308  winstate->partition_spooled = true;
1309  winstate->more_partitions = true;
1310  break;
1311  }
1312  }
1313 
1314  /*
1315  * Remember the tuple unless we're the top-level window and we're in
1316  * pass-through mode.
1317  */
1318  if (winstate->status != WINDOWAGG_PASSTHROUGH_STRICT)
1319  {
1320  /* Still in partition, so save it into the tuplestore */
1321  tuplestore_puttupleslot(winstate->buffer, outerslot);
1322  winstate->spooled_rows++;
1323  }
1324  }
1325 
1326  MemoryContextSwitchTo(oldcontext);
1327 }
1328 
1329 /*
1330  * release_partition
1331  * clear information kept within a partition, including
1332  * tuplestore and aggregate results.
1333  */
1334 static void
1336 {
1337  int i;
1338 
1339  for (i = 0; i < winstate->numfuncs; i++)
1340  {
1341  WindowStatePerFunc perfuncstate = &(winstate->perfunc[i]);
1342 
1343  /* Release any partition-local state of this window function */
1344  if (perfuncstate->winobj)
1345  perfuncstate->winobj->localmem = NULL;
1346  }
1347 
1348  /*
1349  * Release all partition-local memory (in particular, any partition-local
1350  * state that we might have trashed our pointers to in the above loop, and
1351  * any aggregate temp data). We don't rely on retail pfree because some
1352  * aggregates might have allocated data we don't have direct pointers to.
1353  */
1354  MemoryContextReset(winstate->partcontext);
1355  MemoryContextReset(winstate->aggcontext);
1356  for (i = 0; i < winstate->numaggs; i++)
1357  {
1358  if (winstate->peragg[i].aggcontext != winstate->aggcontext)
1359  MemoryContextReset(winstate->peragg[i].aggcontext);
1360  }
1361 
1362  if (winstate->buffer)
1363  tuplestore_end(winstate->buffer);
1364  winstate->buffer = NULL;
1365  winstate->partition_spooled = false;
1366 }
1367 
1368 /*
1369  * row_is_in_frame
1370  * Determine whether a row is in the current row's window frame according
1371  * to our window framing rule
1372  *
1373  * The caller must have already determined that the row is in the partition
1374  * and fetched it into a slot. This function just encapsulates the framing
1375  * rules.
1376  *
1377  * Returns:
1378  * -1, if the row is out of frame and no succeeding rows can be in frame
1379  * 0, if the row is out of frame but succeeding rows might be in frame
1380  * 1, if the row is in frame
1381  *
1382  * May clobber winstate->temp_slot_2.
1383  */
1384 static int
1385 row_is_in_frame(WindowAggState *winstate, int64 pos, TupleTableSlot *slot)
1386 {
1387  int frameOptions = winstate->frameOptions;
1388 
1389  Assert(pos >= 0); /* else caller error */
1390 
1391  /*
1392  * First, check frame starting conditions. We might as well delegate this
1393  * to update_frameheadpos always; it doesn't add any notable cost.
1394  */
1395  update_frameheadpos(winstate);
1396  if (pos < winstate->frameheadpos)
1397  return 0;
1398 
1399  /*
1400  * Okay so far, now check frame ending conditions. Here, we avoid calling
1401  * update_frametailpos in simple cases, so as not to spool tuples further
1402  * ahead than necessary.
1403  */
1404  if (frameOptions & FRAMEOPTION_END_CURRENT_ROW)
1405  {
1406  if (frameOptions & FRAMEOPTION_ROWS)
1407  {
1408  /* rows after current row are out of frame */
1409  if (pos > winstate->currentpos)
1410  return -1;
1411  }
1412  else if (frameOptions & (FRAMEOPTION_RANGE | FRAMEOPTION_GROUPS))
1413  {
1414  /* following row that is not peer is out of frame */
1415  if (pos > winstate->currentpos &&
1416  !are_peers(winstate, slot, winstate->ss.ss_ScanTupleSlot))
1417  return -1;
1418  }
1419  else
1420  Assert(false);
1421  }
1422  else if (frameOptions & FRAMEOPTION_END_OFFSET)
1423  {
1424  if (frameOptions & FRAMEOPTION_ROWS)
1425  {
1426  int64 offset = DatumGetInt64(winstate->endOffsetValue);
1427 
1428  /* rows after current row + offset are out of frame */
1429  if (frameOptions & FRAMEOPTION_END_OFFSET_PRECEDING)
1430  offset = -offset;
1431 
1432  if (pos > winstate->currentpos + offset)
1433  return -1;
1434  }
1435  else if (frameOptions & (FRAMEOPTION_RANGE | FRAMEOPTION_GROUPS))
1436  {
1437  /* hard cases, so delegate to update_frametailpos */
1438  update_frametailpos(winstate);
1439  if (pos >= winstate->frametailpos)
1440  return -1;
1441  }
1442  else
1443  Assert(false);
1444  }
1445 
1446  /* Check exclusion clause */
1447  if (frameOptions & FRAMEOPTION_EXCLUDE_CURRENT_ROW)
1448  {
1449  if (pos == winstate->currentpos)
1450  return 0;
1451  }
1452  else if ((frameOptions & FRAMEOPTION_EXCLUDE_GROUP) ||
1453  ((frameOptions & FRAMEOPTION_EXCLUDE_TIES) &&
1454  pos != winstate->currentpos))
1455  {
1456  WindowAgg *node = (WindowAgg *) winstate->ss.ps.plan;
1457 
1458  /* If no ORDER BY, all rows are peers with each other */
1459  if (node->ordNumCols == 0)
1460  return 0;
1461  /* Otherwise, check the group boundaries */
1462  if (pos >= winstate->groupheadpos)
1463  {
1464  update_grouptailpos(winstate);
1465  if (pos < winstate->grouptailpos)
1466  return 0;
1467  }
1468  }
1469 
1470  /* If we get here, it's in frame */
1471  return 1;
1472 }
1473 
1474 /*
1475  * update_frameheadpos
1476  * make frameheadpos valid for the current row
1477  *
1478  * Note that frameheadpos is computed without regard for any window exclusion
1479  * clause; the current row and/or its peers are considered part of the frame
1480  * for this purpose even if they must be excluded later.
1481  *
1482  * May clobber winstate->temp_slot_2.
1483  */
1484 static void
1486 {
1487  WindowAgg *node = (WindowAgg *) winstate->ss.ps.plan;
1488  int frameOptions = winstate->frameOptions;
1489  MemoryContext oldcontext;
1490 
1491  if (winstate->framehead_valid)
1492  return; /* already known for current row */
1493 
1494  /* We may be called in a short-lived context */
1496 
1497  if (frameOptions & FRAMEOPTION_START_UNBOUNDED_PRECEDING)
1498  {
1499  /* In UNBOUNDED PRECEDING mode, frame head is always row 0 */
1500  winstate->frameheadpos = 0;
1501  winstate->framehead_valid = true;
1502  }
1503  else if (frameOptions & FRAMEOPTION_START_CURRENT_ROW)
1504  {
1505  if (frameOptions & FRAMEOPTION_ROWS)
1506  {
1507  /* In ROWS mode, frame head is the same as current */
1508  winstate->frameheadpos = winstate->currentpos;
1509  winstate->framehead_valid = true;
1510  }
1511  else if (frameOptions & (FRAMEOPTION_RANGE | FRAMEOPTION_GROUPS))
1512  {
1513  /* If no ORDER BY, all rows are peers with each other */
1514  if (node->ordNumCols == 0)
1515  {
1516  winstate->frameheadpos = 0;
1517  winstate->framehead_valid = true;
1518  MemoryContextSwitchTo(oldcontext);
1519  return;
1520  }
1521 
1522  /*
1523  * In RANGE or GROUPS START_CURRENT_ROW mode, frame head is the
1524  * first row that is a peer of current row. We keep a copy of the
1525  * last-known frame head row in framehead_slot, and advance as
1526  * necessary. Note that if we reach end of partition, we will
1527  * leave frameheadpos = end+1 and framehead_slot empty.
1528  */
1530  winstate->framehead_ptr);
1531  if (winstate->frameheadpos == 0 &&
1532  TupIsNull(winstate->framehead_slot))
1533  {
1534  /* fetch first row into framehead_slot, if we didn't already */
1535  if (!tuplestore_gettupleslot(winstate->buffer, true, true,
1536  winstate->framehead_slot))
1537  elog(ERROR, "unexpected end of tuplestore");
1538  }
1539 
1540  while (!TupIsNull(winstate->framehead_slot))
1541  {
1542  if (are_peers(winstate, winstate->framehead_slot,
1543  winstate->ss.ss_ScanTupleSlot))
1544  break; /* this row is the correct frame head */
1545  /* Note we advance frameheadpos even if the fetch fails */
1546  winstate->frameheadpos++;
1547  spool_tuples(winstate, winstate->frameheadpos);
1548  if (!tuplestore_gettupleslot(winstate->buffer, true, true,
1549  winstate->framehead_slot))
1550  break; /* end of partition */
1551  }
1552  winstate->framehead_valid = true;
1553  }
1554  else
1555  Assert(false);
1556  }
1557  else if (frameOptions & FRAMEOPTION_START_OFFSET)
1558  {
1559  if (frameOptions & FRAMEOPTION_ROWS)
1560  {
1561  /* In ROWS mode, bound is physically n before/after current */
1562  int64 offset = DatumGetInt64(winstate->startOffsetValue);
1563 
1564  if (frameOptions & FRAMEOPTION_START_OFFSET_PRECEDING)
1565  offset = -offset;
1566 
1567  winstate->frameheadpos = winstate->currentpos + offset;
1568  /* frame head can't go before first row */
1569  if (winstate->frameheadpos < 0)
1570  winstate->frameheadpos = 0;
1571  else if (winstate->frameheadpos > winstate->currentpos + 1)
1572  {
1573  /* make sure frameheadpos is not past end of partition */
1574  spool_tuples(winstate, winstate->frameheadpos - 1);
1575  if (winstate->frameheadpos > winstate->spooled_rows)
1576  winstate->frameheadpos = winstate->spooled_rows;
1577  }
1578  winstate->framehead_valid = true;
1579  }
1580  else if (frameOptions & FRAMEOPTION_RANGE)
1581  {
1582  /*
1583  * In RANGE START_OFFSET mode, frame head is the first row that
1584  * satisfies the in_range constraint relative to the current row.
1585  * We keep a copy of the last-known frame head row in
1586  * framehead_slot, and advance as necessary. Note that if we
1587  * reach end of partition, we will leave frameheadpos = end+1 and
1588  * framehead_slot empty.
1589  */
1590  int sortCol = node->ordColIdx[0];
1591  bool sub,
1592  less;
1593 
1594  /* We must have an ordering column */
1595  Assert(node->ordNumCols == 1);
1596 
1597  /* Precompute flags for in_range checks */
1598  if (frameOptions & FRAMEOPTION_START_OFFSET_PRECEDING)
1599  sub = true; /* subtract startOffset from current row */
1600  else
1601  sub = false; /* add it */
1602  less = false; /* normally, we want frame head >= sum */
1603  /* If sort order is descending, flip both flags */
1604  if (!winstate->inRangeAsc)
1605  {
1606  sub = !sub;
1607  less = true;
1608  }
1609 
1611  winstate->framehead_ptr);
1612  if (winstate->frameheadpos == 0 &&
1613  TupIsNull(winstate->framehead_slot))
1614  {
1615  /* fetch first row into framehead_slot, if we didn't already */
1616  if (!tuplestore_gettupleslot(winstate->buffer, true, true,
1617  winstate->framehead_slot))
1618  elog(ERROR, "unexpected end of tuplestore");
1619  }
1620 
1621  while (!TupIsNull(winstate->framehead_slot))
1622  {
1623  Datum headval,
1624  currval;
1625  bool headisnull,
1626  currisnull;
1627 
1628  headval = slot_getattr(winstate->framehead_slot, sortCol,
1629  &headisnull);
1630  currval = slot_getattr(winstate->ss.ss_ScanTupleSlot, sortCol,
1631  &currisnull);
1632  if (headisnull || currisnull)
1633  {
1634  /* order of the rows depends only on nulls_first */
1635  if (winstate->inRangeNullsFirst)
1636  {
1637  /* advance head if head is null and curr is not */
1638  if (!headisnull || currisnull)
1639  break;
1640  }
1641  else
1642  {
1643  /* advance head if head is not null and curr is null */
1644  if (headisnull || !currisnull)
1645  break;
1646  }
1647  }
1648  else
1649  {
1651  winstate->inRangeColl,
1652  headval,
1653  currval,
1654  winstate->startOffsetValue,
1655  BoolGetDatum(sub),
1656  BoolGetDatum(less))))
1657  break; /* this row is the correct frame head */
1658  }
1659  /* Note we advance frameheadpos even if the fetch fails */
1660  winstate->frameheadpos++;
1661  spool_tuples(winstate, winstate->frameheadpos);
1662  if (!tuplestore_gettupleslot(winstate->buffer, true, true,
1663  winstate->framehead_slot))
1664  break; /* end of partition */
1665  }
1666  winstate->framehead_valid = true;
1667  }
1668  else if (frameOptions & FRAMEOPTION_GROUPS)
1669  {
1670  /*
1671  * In GROUPS START_OFFSET mode, frame head is the first row of the
1672  * first peer group whose number satisfies the offset constraint.
1673  * We keep a copy of the last-known frame head row in
1674  * framehead_slot, and advance as necessary. Note that if we
1675  * reach end of partition, we will leave frameheadpos = end+1 and
1676  * framehead_slot empty.
1677  */
1678  int64 offset = DatumGetInt64(winstate->startOffsetValue);
1679  int64 minheadgroup;
1680 
1681  if (frameOptions & FRAMEOPTION_START_OFFSET_PRECEDING)
1682  minheadgroup = winstate->currentgroup - offset;
1683  else
1684  minheadgroup = winstate->currentgroup + offset;
1685 
1687  winstate->framehead_ptr);
1688  if (winstate->frameheadpos == 0 &&
1689  TupIsNull(winstate->framehead_slot))
1690  {
1691  /* fetch first row into framehead_slot, if we didn't already */
1692  if (!tuplestore_gettupleslot(winstate->buffer, true, true,
1693  winstate->framehead_slot))
1694  elog(ERROR, "unexpected end of tuplestore");
1695  }
1696 
1697  while (!TupIsNull(winstate->framehead_slot))
1698  {
1699  if (winstate->frameheadgroup >= minheadgroup)
1700  break; /* this row is the correct frame head */
1701  ExecCopySlot(winstate->temp_slot_2, winstate->framehead_slot);
1702  /* Note we advance frameheadpos even if the fetch fails */
1703  winstate->frameheadpos++;
1704  spool_tuples(winstate, winstate->frameheadpos);
1705  if (!tuplestore_gettupleslot(winstate->buffer, true, true,
1706  winstate->framehead_slot))
1707  break; /* end of partition */
1708  if (!are_peers(winstate, winstate->temp_slot_2,
1709  winstate->framehead_slot))
1710  winstate->frameheadgroup++;
1711  }
1712  ExecClearTuple(winstate->temp_slot_2);
1713  winstate->framehead_valid = true;
1714  }
1715  else
1716  Assert(false);
1717  }
1718  else
1719  Assert(false);
1720 
1721  MemoryContextSwitchTo(oldcontext);
1722 }
1723 
1724 /*
1725  * update_frametailpos
1726  * make frametailpos valid for the current row
1727  *
1728  * Note that frametailpos is computed without regard for any window exclusion
1729  * clause; the current row and/or its peers are considered part of the frame
1730  * for this purpose even if they must be excluded later.
1731  *
1732  * May clobber winstate->temp_slot_2.
1733  */
1734 static void
1736 {
1737  WindowAgg *node = (WindowAgg *) winstate->ss.ps.plan;
1738  int frameOptions = winstate->frameOptions;
1739  MemoryContext oldcontext;
1740 
1741  if (winstate->frametail_valid)
1742  return; /* already known for current row */
1743 
1744  /* We may be called in a short-lived context */
1746 
1747  if (frameOptions & FRAMEOPTION_END_UNBOUNDED_FOLLOWING)
1748  {
1749  /* In UNBOUNDED FOLLOWING mode, all partition rows are in frame */
1750  spool_tuples(winstate, -1);
1751  winstate->frametailpos = winstate->spooled_rows;
1752  winstate->frametail_valid = true;
1753  }
1754  else if (frameOptions & FRAMEOPTION_END_CURRENT_ROW)
1755  {
1756  if (frameOptions & FRAMEOPTION_ROWS)
1757  {
1758  /* In ROWS mode, exactly the rows up to current are in frame */
1759  winstate->frametailpos = winstate->currentpos + 1;
1760  winstate->frametail_valid = true;
1761  }
1762  else if (frameOptions & (FRAMEOPTION_RANGE | FRAMEOPTION_GROUPS))
1763  {
1764  /* If no ORDER BY, all rows are peers with each other */
1765  if (node->ordNumCols == 0)
1766  {
1767  spool_tuples(winstate, -1);
1768  winstate->frametailpos = winstate->spooled_rows;
1769  winstate->frametail_valid = true;
1770  MemoryContextSwitchTo(oldcontext);
1771  return;
1772  }
1773 
1774  /*
1775  * In RANGE or GROUPS END_CURRENT_ROW mode, frame end is the last
1776  * row that is a peer of current row, frame tail is the row after
1777  * that (if any). We keep a copy of the last-known frame tail row
1778  * in frametail_slot, and advance as necessary. Note that if we
1779  * reach end of partition, we will leave frametailpos = end+1 and
1780  * frametail_slot empty.
1781  */
1783  winstate->frametail_ptr);
1784  if (winstate->frametailpos == 0 &&
1785  TupIsNull(winstate->frametail_slot))
1786  {
1787  /* fetch first row into frametail_slot, if we didn't already */
1788  if (!tuplestore_gettupleslot(winstate->buffer, true, true,
1789  winstate->frametail_slot))
1790  elog(ERROR, "unexpected end of tuplestore");
1791  }
1792 
1793  while (!TupIsNull(winstate->frametail_slot))
1794  {
1795  if (winstate->frametailpos > winstate->currentpos &&
1796  !are_peers(winstate, winstate->frametail_slot,
1797  winstate->ss.ss_ScanTupleSlot))
1798  break; /* this row is the frame tail */
1799  /* Note we advance frametailpos even if the fetch fails */
1800  winstate->frametailpos++;
1801  spool_tuples(winstate, winstate->frametailpos);
1802  if (!tuplestore_gettupleslot(winstate->buffer, true, true,
1803  winstate->frametail_slot))
1804  break; /* end of partition */
1805  }
1806  winstate->frametail_valid = true;
1807  }
1808  else
1809  Assert(false);
1810  }
1811  else if (frameOptions & FRAMEOPTION_END_OFFSET)
1812  {
1813  if (frameOptions & FRAMEOPTION_ROWS)
1814  {
1815  /* In ROWS mode, bound is physically n before/after current */
1816  int64 offset = DatumGetInt64(winstate->endOffsetValue);
1817 
1818  if (frameOptions & FRAMEOPTION_END_OFFSET_PRECEDING)
1819  offset = -offset;
1820 
1821  winstate->frametailpos = winstate->currentpos + offset + 1;
1822  /* smallest allowable value of frametailpos is 0 */
1823  if (winstate->frametailpos < 0)
1824  winstate->frametailpos = 0;
1825  else if (winstate->frametailpos > winstate->currentpos + 1)
1826  {
1827  /* make sure frametailpos is not past end of partition */
1828  spool_tuples(winstate, winstate->frametailpos - 1);
1829  if (winstate->frametailpos > winstate->spooled_rows)
1830  winstate->frametailpos = winstate->spooled_rows;
1831  }
1832  winstate->frametail_valid = true;
1833  }
1834  else if (frameOptions & FRAMEOPTION_RANGE)
1835  {
1836  /*
1837  * In RANGE END_OFFSET mode, frame end is the last row that
1838  * satisfies the in_range constraint relative to the current row,
1839  * frame tail is the row after that (if any). We keep a copy of
1840  * the last-known frame tail row in frametail_slot, and advance as
1841  * necessary. Note that if we reach end of partition, we will
1842  * leave frametailpos = end+1 and frametail_slot empty.
1843  */
1844  int sortCol = node->ordColIdx[0];
1845  bool sub,
1846  less;
1847 
1848  /* We must have an ordering column */
1849  Assert(node->ordNumCols == 1);
1850 
1851  /* Precompute flags for in_range checks */
1852  if (frameOptions & FRAMEOPTION_END_OFFSET_PRECEDING)
1853  sub = true; /* subtract endOffset from current row */
1854  else
1855  sub = false; /* add it */
1856  less = true; /* normally, we want frame tail <= sum */
1857  /* If sort order is descending, flip both flags */
1858  if (!winstate->inRangeAsc)
1859  {
1860  sub = !sub;
1861  less = false;
1862  }
1863 
1865  winstate->frametail_ptr);
1866  if (winstate->frametailpos == 0 &&
1867  TupIsNull(winstate->frametail_slot))
1868  {
1869  /* fetch first row into frametail_slot, if we didn't already */
1870  if (!tuplestore_gettupleslot(winstate->buffer, true, true,
1871  winstate->frametail_slot))
1872  elog(ERROR, "unexpected end of tuplestore");
1873  }
1874 
1875  while (!TupIsNull(winstate->frametail_slot))
1876  {
1877  Datum tailval,
1878  currval;
1879  bool tailisnull,
1880  currisnull;
1881 
1882  tailval = slot_getattr(winstate->frametail_slot, sortCol,
1883  &tailisnull);
1884  currval = slot_getattr(winstate->ss.ss_ScanTupleSlot, sortCol,
1885  &currisnull);
1886  if (tailisnull || currisnull)
1887  {
1888  /* order of the rows depends only on nulls_first */
1889  if (winstate->inRangeNullsFirst)
1890  {
1891  /* advance tail if tail is null or curr is not */
1892  if (!tailisnull)
1893  break;
1894  }
1895  else
1896  {
1897  /* advance tail if tail is not null or curr is null */
1898  if (!currisnull)
1899  break;
1900  }
1901  }
1902  else
1903  {
1905  winstate->inRangeColl,
1906  tailval,
1907  currval,
1908  winstate->endOffsetValue,
1909  BoolGetDatum(sub),
1910  BoolGetDatum(less))))
1911  break; /* this row is the correct frame tail */
1912  }
1913  /* Note we advance frametailpos even if the fetch fails */
1914  winstate->frametailpos++;
1915  spool_tuples(winstate, winstate->frametailpos);
1916  if (!tuplestore_gettupleslot(winstate->buffer, true, true,
1917  winstate->frametail_slot))
1918  break; /* end of partition */
1919  }
1920  winstate->frametail_valid = true;
1921  }
1922  else if (frameOptions & FRAMEOPTION_GROUPS)
1923  {
1924  /*
1925  * In GROUPS END_OFFSET mode, frame end is the last row of the
1926  * last peer group whose number satisfies the offset constraint,
1927  * and frame tail is the row after that (if any). We keep a copy
1928  * of the last-known frame tail row in frametail_slot, and advance
1929  * as necessary. Note that if we reach end of partition, we will
1930  * leave frametailpos = end+1 and frametail_slot empty.
1931  */
1932  int64 offset = DatumGetInt64(winstate->endOffsetValue);
1933  int64 maxtailgroup;
1934 
1935  if (frameOptions & FRAMEOPTION_END_OFFSET_PRECEDING)
1936  maxtailgroup = winstate->currentgroup - offset;
1937  else
1938  maxtailgroup = winstate->currentgroup + offset;
1939 
1941  winstate->frametail_ptr);
1942  if (winstate->frametailpos == 0 &&
1943  TupIsNull(winstate->frametail_slot))
1944  {
1945  /* fetch first row into frametail_slot, if we didn't already */
1946  if (!tuplestore_gettupleslot(winstate->buffer, true, true,
1947  winstate->frametail_slot))
1948  elog(ERROR, "unexpected end of tuplestore");
1949  }
1950 
1951  while (!TupIsNull(winstate->frametail_slot))
1952  {
1953  if (winstate->frametailgroup > maxtailgroup)
1954  break; /* this row is the correct frame tail */
1955  ExecCopySlot(winstate->temp_slot_2, winstate->frametail_slot);
1956  /* Note we advance frametailpos even if the fetch fails */
1957  winstate->frametailpos++;
1958  spool_tuples(winstate, winstate->frametailpos);
1959  if (!tuplestore_gettupleslot(winstate->buffer, true, true,
1960  winstate->frametail_slot))
1961  break; /* end of partition */
1962  if (!are_peers(winstate, winstate->temp_slot_2,
1963  winstate->frametail_slot))
1964  winstate->frametailgroup++;
1965  }
1966  ExecClearTuple(winstate->temp_slot_2);
1967  winstate->frametail_valid = true;
1968  }
1969  else
1970  Assert(false);
1971  }
1972  else
1973  Assert(false);
1974 
1975  MemoryContextSwitchTo(oldcontext);
1976 }
1977 
1978 /*
1979  * update_grouptailpos
1980  * make grouptailpos valid for the current row
1981  *
1982  * May clobber winstate->temp_slot_2.
1983  */
1984 static void
1986 {
1987  WindowAgg *node = (WindowAgg *) winstate->ss.ps.plan;
1988  MemoryContext oldcontext;
1989 
1990  if (winstate->grouptail_valid)
1991  return; /* already known for current row */
1992 
1993  /* We may be called in a short-lived context */
1995 
1996  /* If no ORDER BY, all rows are peers with each other */
1997  if (node->ordNumCols == 0)
1998  {
1999  spool_tuples(winstate, -1);
2000  winstate->grouptailpos = winstate->spooled_rows;
2001  winstate->grouptail_valid = true;
2002  MemoryContextSwitchTo(oldcontext);
2003  return;
2004  }
2005 
2006  /*
2007  * Because grouptail_valid is reset only when current row advances into a
2008  * new peer group, we always reach here knowing that grouptailpos needs to
2009  * be advanced by at least one row. Hence, unlike the otherwise similar
2010  * case for frame tail tracking, we do not need persistent storage of the
2011  * group tail row.
2012  */
2013  Assert(winstate->grouptailpos <= winstate->currentpos);
2015  winstate->grouptail_ptr);
2016  for (;;)
2017  {
2018  /* Note we advance grouptailpos even if the fetch fails */
2019  winstate->grouptailpos++;
2020  spool_tuples(winstate, winstate->grouptailpos);
2021  if (!tuplestore_gettupleslot(winstate->buffer, true, true,
2022  winstate->temp_slot_2))
2023  break; /* end of partition */
2024  if (winstate->grouptailpos > winstate->currentpos &&
2025  !are_peers(winstate, winstate->temp_slot_2,
2026  winstate->ss.ss_ScanTupleSlot))
2027  break; /* this row is the group tail */
2028  }
2029  ExecClearTuple(winstate->temp_slot_2);
2030  winstate->grouptail_valid = true;
2031 
2032  MemoryContextSwitchTo(oldcontext);
2033 }
2034 
2035 
2036 /* -----------------
2037  * ExecWindowAgg
2038  *
2039  * ExecWindowAgg receives tuples from its outer subplan and
2040  * stores them into a tuplestore, then processes window functions.
2041  * This node doesn't reduce nor qualify any row so the number of
2042  * returned rows is exactly the same as its outer subplan's result.
2043  * -----------------
2044  */
2045 static TupleTableSlot *
2047 {
2048  WindowAggState *winstate = castNode(WindowAggState, pstate);
2049  TupleTableSlot *slot;
2050  ExprContext *econtext;
2051  int i;
2052  int numfuncs;
2053 
2055 
2056  if (winstate->status == WINDOWAGG_DONE)
2057  return NULL;
2058 
2059  /*
2060  * Compute frame offset values, if any, during first call (or after a
2061  * rescan). These are assumed to hold constant throughout the scan; if
2062  * user gives us a volatile expression, we'll only use its initial value.
2063  */
2064  if (winstate->all_first)
2065  {
2066  int frameOptions = winstate->frameOptions;
2067  Datum value;
2068  bool isnull;
2069  int16 len;
2070  bool byval;
2071 
2072  econtext = winstate->ss.ps.ps_ExprContext;
2073 
2074  if (frameOptions & FRAMEOPTION_START_OFFSET)
2075  {
2076  Assert(winstate->startOffset != NULL);
2078  econtext,
2079  &isnull);
2080  if (isnull)
2081  ereport(ERROR,
2082  (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
2083  errmsg("frame starting offset must not be null")));
2084  /* copy value into query-lifespan context */
2085  get_typlenbyval(exprType((Node *) winstate->startOffset->expr),
2086  &len, &byval);
2087  winstate->startOffsetValue = datumCopy(value, byval, len);
2088  if (frameOptions & (FRAMEOPTION_ROWS | FRAMEOPTION_GROUPS))
2089  {
2090  /* value is known to be int8 */
2091  int64 offset = DatumGetInt64(value);
2092 
2093  if (offset < 0)
2094  ereport(ERROR,
2095  (errcode(ERRCODE_INVALID_PRECEDING_OR_FOLLOWING_SIZE),
2096  errmsg("frame starting offset must not be negative")));
2097  }
2098  }
2099  if (frameOptions & FRAMEOPTION_END_OFFSET)
2100  {
2101  Assert(winstate->endOffset != NULL);
2103  econtext,
2104  &isnull);
2105  if (isnull)
2106  ereport(ERROR,
2107  (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
2108  errmsg("frame ending offset must not be null")));
2109  /* copy value into query-lifespan context */
2110  get_typlenbyval(exprType((Node *) winstate->endOffset->expr),
2111  &len, &byval);
2112  winstate->endOffsetValue = datumCopy(value, byval, len);
2113  if (frameOptions & (FRAMEOPTION_ROWS | FRAMEOPTION_GROUPS))
2114  {
2115  /* value is known to be int8 */
2116  int64 offset = DatumGetInt64(value);
2117 
2118  if (offset < 0)
2119  ereport(ERROR,
2120  (errcode(ERRCODE_INVALID_PRECEDING_OR_FOLLOWING_SIZE),
2121  errmsg("frame ending offset must not be negative")));
2122  }
2123  }
2124  winstate->all_first = false;
2125  }
2126 
2127  /* We need to loop as the runCondition or qual may filter out tuples */
2128  for (;;)
2129  {
2130  if (winstate->buffer == NULL)
2131  {
2132  /* Initialize for first partition and set current row = 0 */
2133  begin_partition(winstate);
2134  /* If there are no input rows, we'll detect that and exit below */
2135  }
2136  else
2137  {
2138  /* Advance current row within partition */
2139  winstate->currentpos++;
2140  /* This might mean that the frame moves, too */
2141  winstate->framehead_valid = false;
2142  winstate->frametail_valid = false;
2143  /* we don't need to invalidate grouptail here; see below */
2144  }
2145 
2146  /*
2147  * Spool all tuples up to and including the current row, if we haven't
2148  * already
2149  */
2150  spool_tuples(winstate, winstate->currentpos);
2151 
2152  /* Move to the next partition if we reached the end of this partition */
2153  if (winstate->partition_spooled &&
2154  winstate->currentpos >= winstate->spooled_rows)
2155  {
2156  release_partition(winstate);
2157 
2158  if (winstate->more_partitions)
2159  {
2160  begin_partition(winstate);
2161  Assert(winstate->spooled_rows > 0);
2162 
2163  /* Come out of pass-through mode when changing partition */
2164  winstate->status = WINDOWAGG_RUN;
2165  }
2166  else
2167  {
2168  /* No further partitions? We're done */
2169  winstate->status = WINDOWAGG_DONE;
2170  return NULL;
2171  }
2172  }
2173 
2174  /* final output execution is in ps_ExprContext */
2175  econtext = winstate->ss.ps.ps_ExprContext;
2176 
2177  /* Clear the per-output-tuple context for current row */
2178  ResetExprContext(econtext);
2179 
2180  /*
2181  * Read the current row from the tuplestore, and save in
2182  * ScanTupleSlot. (We can't rely on the outerplan's output slot
2183  * because we may have to read beyond the current row. Also, we have
2184  * to actually copy the row out of the tuplestore, since window
2185  * function evaluation might cause the tuplestore to dump its state to
2186  * disk.)
2187  *
2188  * In GROUPS mode, or when tracking a group-oriented exclusion clause,
2189  * we must also detect entering a new peer group and update associated
2190  * state when that happens. We use temp_slot_2 to temporarily hold
2191  * the previous row for this purpose.
2192  *
2193  * Current row must be in the tuplestore, since we spooled it above.
2194  */
2195  tuplestore_select_read_pointer(winstate->buffer, winstate->current_ptr);
2196  if ((winstate->frameOptions & (FRAMEOPTION_GROUPS |
2199  winstate->currentpos > 0)
2200  {
2201  ExecCopySlot(winstate->temp_slot_2, winstate->ss.ss_ScanTupleSlot);
2202  if (!tuplestore_gettupleslot(winstate->buffer, true, true,
2203  winstate->ss.ss_ScanTupleSlot))
2204  elog(ERROR, "unexpected end of tuplestore");
2205  if (!are_peers(winstate, winstate->temp_slot_2,
2206  winstate->ss.ss_ScanTupleSlot))
2207  {
2208  winstate->currentgroup++;
2209  winstate->groupheadpos = winstate->currentpos;
2210  winstate->grouptail_valid = false;
2211  }
2212  ExecClearTuple(winstate->temp_slot_2);
2213  }
2214  else
2215  {
2216  if (!tuplestore_gettupleslot(winstate->buffer, true, true,
2217  winstate->ss.ss_ScanTupleSlot))
2218  elog(ERROR, "unexpected end of tuplestore");
2219  }
2220 
2221  /* don't evaluate the window functions when we're in pass-through mode */
2222  if (winstate->status == WINDOWAGG_RUN)
2223  {
2224  /*
2225  * Evaluate true window functions
2226  */
2227  numfuncs = winstate->numfuncs;
2228  for (i = 0; i < numfuncs; i++)
2229  {
2230  WindowStatePerFunc perfuncstate = &(winstate->perfunc[i]);
2231 
2232  if (perfuncstate->plain_agg)
2233  continue;
2234  eval_windowfunction(winstate, perfuncstate,
2235  &(econtext->ecxt_aggvalues[perfuncstate->wfuncstate->wfuncno]),
2236  &(econtext->ecxt_aggnulls[perfuncstate->wfuncstate->wfuncno]));
2237  }
2238 
2239  /*
2240  * Evaluate aggregates
2241  */
2242  if (winstate->numaggs > 0)
2243  eval_windowaggregates(winstate);
2244  }
2245 
2246  /*
2247  * If we have created auxiliary read pointers for the frame or group
2248  * boundaries, force them to be kept up-to-date, because we don't know
2249  * whether the window function(s) will do anything that requires that.
2250  * Failing to advance the pointers would result in being unable to
2251  * trim data from the tuplestore, which is bad. (If we could know in
2252  * advance whether the window functions will use frame boundary info,
2253  * we could skip creating these pointers in the first place ... but
2254  * unfortunately the window function API doesn't require that.)
2255  */
2256  if (winstate->framehead_ptr >= 0)
2257  update_frameheadpos(winstate);
2258  if (winstate->frametail_ptr >= 0)
2259  update_frametailpos(winstate);
2260  if (winstate->grouptail_ptr >= 0)
2261  update_grouptailpos(winstate);
2262 
2263  /*
2264  * Truncate any no-longer-needed rows from the tuplestore.
2265  */
2266  tuplestore_trim(winstate->buffer);
2267 
2268  /*
2269  * Form and return a projection tuple using the windowfunc results and
2270  * the current row. Setting ecxt_outertuple arranges that any Vars
2271  * will be evaluated with respect to that row.
2272  */
2273  econtext->ecxt_outertuple = winstate->ss.ss_ScanTupleSlot;
2274 
2275  slot = ExecProject(winstate->ss.ps.ps_ProjInfo);
2276 
2277  if (winstate->status == WINDOWAGG_RUN)
2278  {
2279  econtext->ecxt_scantuple = slot;
2280 
2281  /*
2282  * Now evaluate the run condition to see if we need to go into
2283  * pass-through mode, or maybe stop completely.
2284  */
2285  if (!ExecQual(winstate->runcondition, econtext))
2286  {
2287  /*
2288  * Determine which mode to move into. If there is no
2289  * PARTITION BY clause and we're the top-level WindowAgg then
2290  * we're done. This tuple and any future tuples cannot
2291  * possibly match the runcondition. However, when there is a
2292  * PARTITION BY clause or we're not the top-level window we
2293  * can't just stop as we need to either process other
2294  * partitions or ensure WindowAgg nodes above us receive all
2295  * of the tuples they need to process their WindowFuncs.
2296  */
2297  if (winstate->use_pass_through)
2298  {
2299  /*
2300  * STRICT pass-through mode is required for the top window
2301  * when there is a PARTITION BY clause. Otherwise we must
2302  * ensure we store tuples that don't match the
2303  * runcondition so they're available to WindowAggs above.
2304  */
2305  if (winstate->top_window)
2306  {
2308  continue;
2309  }
2310  else
2311  {
2312  winstate->status = WINDOWAGG_PASSTHROUGH;
2313 
2314  /*
2315  * If we're not the top-window, we'd better NULLify
2316  * the aggregate results. In pass-through mode we no
2317  * longer update these and this avoids the old stale
2318  * results lingering. Some of these might be byref
2319  * types so we can't have them pointing to free'd
2320  * memory. The planner insisted that quals used in
2321  * the runcondition are strict, so the top-level
2322  * WindowAgg will filter these NULLs out in the filter
2323  * clause.
2324  */
2325  numfuncs = winstate->numfuncs;
2326  for (i = 0; i < numfuncs; i++)
2327  {
2328  econtext->ecxt_aggvalues[i] = (Datum) 0;
2329  econtext->ecxt_aggnulls[i] = true;
2330  }
2331  }
2332  }
2333  else
2334  {
2335  /*
2336  * Pass-through not required. We can just return NULL.
2337  * Nothing else will match the runcondition.
2338  */
2339  winstate->status = WINDOWAGG_DONE;
2340  return NULL;
2341  }
2342  }
2343 
2344  /*
2345  * Filter out any tuples we don't need in the top-level WindowAgg.
2346  */
2347  if (!ExecQual(winstate->ss.ps.qual, econtext))
2348  {
2349  InstrCountFiltered1(winstate, 1);
2350  continue;
2351  }
2352 
2353  break;
2354  }
2355 
2356  /*
2357  * When not in WINDOWAGG_RUN mode, we must still return this tuple if
2358  * we're anything apart from the top window.
2359  */
2360  else if (!winstate->top_window)
2361  break;
2362  }
2363 
2364  return slot;
2365 }
2366 
2367 /* -----------------
2368  * ExecInitWindowAgg
2369  *
2370  * Creates the run-time information for the WindowAgg node produced by the
2371  * planner and initializes its outer subtree
2372  * -----------------
2373  */
2375 ExecInitWindowAgg(WindowAgg *node, EState *estate, int eflags)
2376 {
2377  WindowAggState *winstate;
2378  Plan *outerPlan;
2379  ExprContext *econtext;
2380  ExprContext *tmpcontext;
2381  WindowStatePerFunc perfunc;
2382  WindowStatePerAgg peragg;
2383  int frameOptions = node->frameOptions;
2384  int numfuncs,
2385  wfuncno,
2386  numaggs,
2387  aggno;
2388  TupleDesc scanDesc;
2389  ListCell *l;
2390 
2391  /* check for unsupported flags */
2392  Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
2393 
2394  /*
2395  * create state structure
2396  */
2397  winstate = makeNode(WindowAggState);
2398  winstate->ss.ps.plan = (Plan *) node;
2399  winstate->ss.ps.state = estate;
2400  winstate->ss.ps.ExecProcNode = ExecWindowAgg;
2401 
2402  /* copy frame options to state node for easy access */
2403  winstate->frameOptions = frameOptions;
2404 
2405  /*
2406  * Create expression contexts. We need two, one for per-input-tuple
2407  * processing and one for per-output-tuple processing. We cheat a little
2408  * by using ExecAssignExprContext() to build both.
2409  */
2410  ExecAssignExprContext(estate, &winstate->ss.ps);
2411  tmpcontext = winstate->ss.ps.ps_ExprContext;
2412  winstate->tmpcontext = tmpcontext;
2413  ExecAssignExprContext(estate, &winstate->ss.ps);
2414 
2415  /* Create long-lived context for storage of partition-local memory etc */
2416  winstate->partcontext =
2418  "WindowAgg Partition",
2420 
2421  /*
2422  * Create mid-lived context for aggregate trans values etc.
2423  *
2424  * Note that moving aggregates each use their own private context, not
2425  * this one.
2426  */
2427  winstate->aggcontext =
2429  "WindowAgg Aggregates",
2431 
2432  /* Only the top-level WindowAgg may have a qual */
2433  Assert(node->plan.qual == NIL || node->topWindow);
2434 
2435  /* Initialize the qual */
2436  winstate->ss.ps.qual = ExecInitQual(node->plan.qual,
2437  (PlanState *) winstate);
2438 
2439  /*
2440  * Setup the run condition, if we received one from the query planner.
2441  * When set, this may allow us to move into pass-through mode so that we
2442  * don't have to perform any further evaluation of WindowFuncs in the
2443  * current partition or possibly stop returning tuples altogether when all
2444  * tuples are in the same partition.
2445  */
2446  winstate->runcondition = ExecInitQual(node->runCondition,
2447  (PlanState *) winstate);
2448 
2449  /*
2450  * When we're not the top-level WindowAgg node or we are but have a
2451  * PARTITION BY clause we must move into one of the WINDOWAGG_PASSTHROUGH*
2452  * modes when the runCondition becomes false.
2453  */
2454  winstate->use_pass_through = !node->topWindow || node->partNumCols > 0;
2455 
2456  /* remember if we're the top-window or we are below the top-window */
2457  winstate->top_window = node->topWindow;
2458 
2459  /*
2460  * initialize child nodes
2461  */
2462  outerPlan = outerPlan(node);
2463  outerPlanState(winstate) = ExecInitNode(outerPlan, estate, eflags);
2464 
2465  /*
2466  * initialize source tuple type (which is also the tuple type that we'll
2467  * store in the tuplestore and use in all our working slots).
2468  */
2470  scanDesc = winstate->ss.ss_ScanTupleSlot->tts_tupleDescriptor;
2471 
2472  /* the outer tuple isn't the child's tuple, but always a minimal tuple */
2473  winstate->ss.ps.outeropsset = true;
2474  winstate->ss.ps.outerops = &TTSOpsMinimalTuple;
2475  winstate->ss.ps.outeropsfixed = true;
2476 
2477  /*
2478  * tuple table initialization
2479  */
2480  winstate->first_part_slot = ExecInitExtraTupleSlot(estate, scanDesc,
2482  winstate->agg_row_slot = ExecInitExtraTupleSlot(estate, scanDesc,
2484  winstate->temp_slot_1 = ExecInitExtraTupleSlot(estate, scanDesc,
2486  winstate->temp_slot_2 = ExecInitExtraTupleSlot(estate, scanDesc,
2488 
2489  /*
2490  * create frame head and tail slots only if needed (must create slots in
2491  * exactly the same cases that update_frameheadpos and update_frametailpos
2492  * need them)
2493  */
2494  winstate->framehead_slot = winstate->frametail_slot = NULL;
2495 
2496  if (frameOptions & (FRAMEOPTION_RANGE | FRAMEOPTION_GROUPS))
2497  {
2498  if (((frameOptions & FRAMEOPTION_START_CURRENT_ROW) &&
2499  node->ordNumCols != 0) ||
2500  (frameOptions & FRAMEOPTION_START_OFFSET))
2501  winstate->framehead_slot = ExecInitExtraTupleSlot(estate, scanDesc,
2503  if (((frameOptions & FRAMEOPTION_END_CURRENT_ROW) &&
2504  node->ordNumCols != 0) ||
2505  (frameOptions & FRAMEOPTION_END_OFFSET))
2506  winstate->frametail_slot = ExecInitExtraTupleSlot(estate, scanDesc,
2508  }
2509 
2510  /*
2511  * Initialize result slot, type and projection.
2512  */
2514  ExecAssignProjectionInfo(&winstate->ss.ps, NULL);
2515 
2516  /* Set up data for comparing tuples */
2517  if (node->partNumCols > 0)
2518  winstate->partEqfunction =
2519  execTuplesMatchPrepare(scanDesc,
2520  node->partNumCols,
2521  node->partColIdx,
2522  node->partOperators,
2523  node->partCollations,
2524  &winstate->ss.ps);
2525 
2526  if (node->ordNumCols > 0)
2527  winstate->ordEqfunction =
2528  execTuplesMatchPrepare(scanDesc,
2529  node->ordNumCols,
2530  node->ordColIdx,
2531  node->ordOperators,
2532  node->ordCollations,
2533  &winstate->ss.ps);
2534 
2535  /*
2536  * WindowAgg nodes use aggvalues and aggnulls as well as Agg nodes.
2537  */
2538  numfuncs = winstate->numfuncs;
2539  numaggs = winstate->numaggs;
2540  econtext = winstate->ss.ps.ps_ExprContext;
2541  econtext->ecxt_aggvalues = (Datum *) palloc0(sizeof(Datum) * numfuncs);
2542  econtext->ecxt_aggnulls = (bool *) palloc0(sizeof(bool) * numfuncs);
2543 
2544  /*
2545  * allocate per-wfunc/per-agg state information.
2546  */
2547  perfunc = (WindowStatePerFunc) palloc0(sizeof(WindowStatePerFuncData) * numfuncs);
2548  peragg = (WindowStatePerAgg) palloc0(sizeof(WindowStatePerAggData) * numaggs);
2549  winstate->perfunc = perfunc;
2550  winstate->peragg = peragg;
2551 
2552  wfuncno = -1;
2553  aggno = -1;
2554  foreach(l, winstate->funcs)
2555  {
2556  WindowFuncExprState *wfuncstate = (WindowFuncExprState *) lfirst(l);
2557  WindowFunc *wfunc = wfuncstate->wfunc;
2558  WindowStatePerFunc perfuncstate;
2559  AclResult aclresult;
2560  int i;
2561 
2562  if (wfunc->winref != node->winref) /* planner screwed up? */
2563  elog(ERROR, "WindowFunc with winref %u assigned to WindowAgg with winref %u",
2564  wfunc->winref, node->winref);
2565 
2566  /* Look for a previous duplicate window function */
2567  for (i = 0; i <= wfuncno; i++)
2568  {
2569  if (equal(wfunc, perfunc[i].wfunc) &&
2570  !contain_volatile_functions((Node *) wfunc))
2571  break;
2572  }
2573  if (i <= wfuncno)
2574  {
2575  /* Found a match to an existing entry, so just mark it */
2576  wfuncstate->wfuncno = i;
2577  continue;
2578  }
2579 
2580  /* Nope, so assign a new PerAgg record */
2581  perfuncstate = &perfunc[++wfuncno];
2582 
2583  /* Mark WindowFunc state node with assigned index in the result array */
2584  wfuncstate->wfuncno = wfuncno;
2585 
2586  /* Check permission to call window function */
2587  aclresult = object_aclcheck(ProcedureRelationId, wfunc->winfnoid, GetUserId(),
2588  ACL_EXECUTE);
2589  if (aclresult != ACLCHECK_OK)
2590  aclcheck_error(aclresult, OBJECT_FUNCTION,
2591  get_func_name(wfunc->winfnoid));
2593 
2594  /* Fill in the perfuncstate data */
2595  perfuncstate->wfuncstate = wfuncstate;
2596  perfuncstate->wfunc = wfunc;
2597  perfuncstate->numArguments = list_length(wfuncstate->args);
2598  perfuncstate->winCollation = wfunc->inputcollid;
2599 
2600  get_typlenbyval(wfunc->wintype,
2601  &perfuncstate->resulttypeLen,
2602  &perfuncstate->resulttypeByVal);
2603 
2604  /*
2605  * If it's really just a plain aggregate function, we'll emulate the
2606  * Agg environment for it.
2607  */
2608  perfuncstate->plain_agg = wfunc->winagg;
2609  if (wfunc->winagg)
2610  {
2611  WindowStatePerAgg peraggstate;
2612 
2613  perfuncstate->aggno = ++aggno;
2614  peraggstate = &winstate->peragg[aggno];
2615  initialize_peragg(winstate, wfunc, peraggstate);
2616  peraggstate->wfuncno = wfuncno;
2617  }
2618  else
2619  {
2621 
2622  winobj->winstate = winstate;
2623  winobj->argstates = wfuncstate->args;
2624  winobj->localmem = NULL;
2625  perfuncstate->winobj = winobj;
2626 
2627  /* It's a real window function, so set up to call it. */
2628  fmgr_info_cxt(wfunc->winfnoid, &perfuncstate->flinfo,
2629  econtext->ecxt_per_query_memory);
2630  fmgr_info_set_expr((Node *) wfunc, &perfuncstate->flinfo);
2631  }
2632  }
2633 
2634  /* Update numfuncs, numaggs to match number of unique functions found */
2635  winstate->numfuncs = wfuncno + 1;
2636  winstate->numaggs = aggno + 1;
2637 
2638  /* Set up WindowObject for aggregates, if needed */
2639  if (winstate->numaggs > 0)
2640  {
2641  WindowObject agg_winobj = makeNode(WindowObjectData);
2642 
2643  agg_winobj->winstate = winstate;
2644  agg_winobj->argstates = NIL;
2645  agg_winobj->localmem = NULL;
2646  /* make sure markptr = -1 to invalidate. It may not get used */
2647  agg_winobj->markptr = -1;
2648  agg_winobj->readptr = -1;
2649  winstate->agg_winobj = agg_winobj;
2650  }
2651 
2652  /* Set the status to running */
2653  winstate->status = WINDOWAGG_RUN;
2654 
2655  /* initialize frame bound offset expressions */
2656  winstate->startOffset = ExecInitExpr((Expr *) node->startOffset,
2657  (PlanState *) winstate);
2658  winstate->endOffset = ExecInitExpr((Expr *) node->endOffset,
2659  (PlanState *) winstate);
2660 
2661  /* Lookup in_range support functions if needed */
2662  if (OidIsValid(node->startInRangeFunc))
2663  fmgr_info(node->startInRangeFunc, &winstate->startInRangeFunc);
2664  if (OidIsValid(node->endInRangeFunc))
2665  fmgr_info(node->endInRangeFunc, &winstate->endInRangeFunc);
2666  winstate->inRangeColl = node->inRangeColl;
2667  winstate->inRangeAsc = node->inRangeAsc;
2668  winstate->inRangeNullsFirst = node->inRangeNullsFirst;
2669 
2670  winstate->all_first = true;
2671  winstate->partition_spooled = false;
2672  winstate->more_partitions = false;
2673 
2674  return winstate;
2675 }
2676 
2677 /* -----------------
2678  * ExecEndWindowAgg
2679  * -----------------
2680  */
2681 void
2683 {
2685  int i;
2686 
2687  release_partition(node);
2688 
2689  for (i = 0; i < node->numaggs; i++)
2690  {
2691  if (node->peragg[i].aggcontext != node->aggcontext)
2693  }
2696 
2697  pfree(node->perfunc);
2698  pfree(node->peragg);
2699 
2700  outerPlan = outerPlanState(node);
2702 }
2703 
2704 /* -----------------
2705  * ExecReScanWindowAgg
2706  * -----------------
2707  */
2708 void
2710 {
2712  ExprContext *econtext = node->ss.ps.ps_ExprContext;
2713 
2714  node->status = WINDOWAGG_RUN;
2715  node->all_first = true;
2716 
2717  /* release tuplestore et al */
2718  release_partition(node);
2719 
2720  /* release all temp tuples, but especially first_part_slot */
2724  ExecClearTuple(node->temp_slot_1);
2725  ExecClearTuple(node->temp_slot_2);
2726  if (node->framehead_slot)
2728  if (node->frametail_slot)
2730 
2731  /* Forget current wfunc values */
2732  MemSet(econtext->ecxt_aggvalues, 0, sizeof(Datum) * node->numfuncs);
2733  MemSet(econtext->ecxt_aggnulls, 0, sizeof(bool) * node->numfuncs);
2734 
2735  /*
2736  * if chgParam of subnode is not null then plan will be re-scanned by
2737  * first ExecProcNode.
2738  */
2739  if (outerPlan->chgParam == NULL)
2741 }
2742 
2743 /*
2744  * initialize_peragg
2745  *
2746  * Almost same as in nodeAgg.c, except we don't support DISTINCT currently.
2747  */
2748 static WindowStatePerAggData *
2750  WindowStatePerAgg peraggstate)
2751 {
2752  Oid inputTypes[FUNC_MAX_ARGS];
2753  int numArguments;
2754  HeapTuple aggTuple;
2755  Form_pg_aggregate aggform;
2756  Oid aggtranstype;
2757  AttrNumber initvalAttNo;
2758  AclResult aclresult;
2759  bool use_ma_code;
2760  Oid transfn_oid,
2761  invtransfn_oid,
2762  finalfn_oid;
2763  bool finalextra;
2764  char finalmodify;
2765  Expr *transfnexpr,
2766  *invtransfnexpr,
2767  *finalfnexpr;
2768  Datum textInitVal;
2769  int i;
2770  ListCell *lc;
2771 
2772  numArguments = list_length(wfunc->args);
2773 
2774  i = 0;
2775  foreach(lc, wfunc->args)
2776  {
2777  inputTypes[i++] = exprType((Node *) lfirst(lc));
2778  }
2779 
2780  aggTuple = SearchSysCache1(AGGFNOID, ObjectIdGetDatum(wfunc->winfnoid));
2781  if (!HeapTupleIsValid(aggTuple))
2782  elog(ERROR, "cache lookup failed for aggregate %u",
2783  wfunc->winfnoid);
2784  aggform = (Form_pg_aggregate) GETSTRUCT(aggTuple);
2785 
2786  /*
2787  * Figure out whether we want to use the moving-aggregate implementation,
2788  * and collect the right set of fields from the pg_aggregate entry.
2789  *
2790  * It's possible that an aggregate would supply a safe moving-aggregate
2791  * implementation and an unsafe normal one, in which case our hand is
2792  * forced. Otherwise, if the frame head can't move, we don't need
2793  * moving-aggregate code. Even if we'd like to use it, don't do so if the
2794  * aggregate's arguments (and FILTER clause if any) contain any calls to
2795  * volatile functions. Otherwise, the difference between restarting and
2796  * not restarting the aggregation would be user-visible.
2797  *
2798  * We also don't risk using moving aggregates when there are subplans in
2799  * the arguments or FILTER clause. This is partly because
2800  * contain_volatile_functions() doesn't look inside subplans; but there
2801  * are other reasons why a subplan's output might be volatile. For
2802  * example, syncscan mode can render the results nonrepeatable.
2803  */
2804  if (!OidIsValid(aggform->aggminvtransfn))
2805  use_ma_code = false; /* sine qua non */
2806  else if (aggform->aggmfinalmodify == AGGMODIFY_READ_ONLY &&
2807  aggform->aggfinalmodify != AGGMODIFY_READ_ONLY)
2808  use_ma_code = true; /* decision forced by safety */
2810  use_ma_code = false; /* non-moving frame head */
2811  else if (contain_volatile_functions((Node *) wfunc))
2812  use_ma_code = false; /* avoid possible behavioral change */
2813  else if (contain_subplans((Node *) wfunc))
2814  use_ma_code = false; /* subplans might contain volatile functions */
2815  else
2816  use_ma_code = true; /* yes, let's use it */
2817  if (use_ma_code)
2818  {
2819  peraggstate->transfn_oid = transfn_oid = aggform->aggmtransfn;
2820  peraggstate->invtransfn_oid = invtransfn_oid = aggform->aggminvtransfn;
2821  peraggstate->finalfn_oid = finalfn_oid = aggform->aggmfinalfn;
2822  finalextra = aggform->aggmfinalextra;
2823  finalmodify = aggform->aggmfinalmodify;
2824  aggtranstype = aggform->aggmtranstype;
2825  initvalAttNo = Anum_pg_aggregate_aggminitval;
2826  }
2827  else
2828  {
2829  peraggstate->transfn_oid = transfn_oid = aggform->aggtransfn;
2830  peraggstate->invtransfn_oid = invtransfn_oid = InvalidOid;
2831  peraggstate->finalfn_oid = finalfn_oid = aggform->aggfinalfn;
2832  finalextra = aggform->aggfinalextra;
2833  finalmodify = aggform->aggfinalmodify;
2834  aggtranstype = aggform->aggtranstype;
2835  initvalAttNo = Anum_pg_aggregate_agginitval;
2836  }
2837 
2838  /*
2839  * ExecInitWindowAgg already checked permission to call aggregate function
2840  * ... but we still need to check the component functions
2841  */
2842 
2843  /* Check that aggregate owner has permission to call component fns */
2844  {
2845  HeapTuple procTuple;
2846  Oid aggOwner;
2847 
2848  procTuple = SearchSysCache1(PROCOID,
2849  ObjectIdGetDatum(wfunc->winfnoid));
2850  if (!HeapTupleIsValid(procTuple))
2851  elog(ERROR, "cache lookup failed for function %u",
2852  wfunc->winfnoid);
2853  aggOwner = ((Form_pg_proc) GETSTRUCT(procTuple))->proowner;
2854  ReleaseSysCache(procTuple);
2855 
2856  aclresult = object_aclcheck(ProcedureRelationId, transfn_oid, aggOwner,
2857  ACL_EXECUTE);
2858  if (aclresult != ACLCHECK_OK)
2859  aclcheck_error(aclresult, OBJECT_FUNCTION,
2860  get_func_name(transfn_oid));
2861  InvokeFunctionExecuteHook(transfn_oid);
2862 
2863  if (OidIsValid(invtransfn_oid))
2864  {
2865  aclresult = object_aclcheck(ProcedureRelationId, invtransfn_oid, aggOwner,
2866  ACL_EXECUTE);
2867  if (aclresult != ACLCHECK_OK)
2868  aclcheck_error(aclresult, OBJECT_FUNCTION,
2869  get_func_name(invtransfn_oid));
2870  InvokeFunctionExecuteHook(invtransfn_oid);
2871  }
2872 
2873  if (OidIsValid(finalfn_oid))
2874  {
2875  aclresult = object_aclcheck(ProcedureRelationId, finalfn_oid, aggOwner,
2876  ACL_EXECUTE);
2877  if (aclresult != ACLCHECK_OK)
2878  aclcheck_error(aclresult, OBJECT_FUNCTION,
2879  get_func_name(finalfn_oid));
2880  InvokeFunctionExecuteHook(finalfn_oid);
2881  }
2882  }
2883 
2884  /*
2885  * If the selected finalfn isn't read-only, we can't run this aggregate as
2886  * a window function. This is a user-facing error, so we take a bit more
2887  * care with the error message than elsewhere in this function.
2888  */
2889  if (finalmodify != AGGMODIFY_READ_ONLY)
2890  ereport(ERROR,
2891  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2892  errmsg("aggregate function %s does not support use as a window function",
2893  format_procedure(wfunc->winfnoid))));
2894 
2895  /* Detect how many arguments to pass to the finalfn */
2896  if (finalextra)
2897  peraggstate->numFinalArgs = numArguments + 1;
2898  else
2899  peraggstate->numFinalArgs = 1;
2900 
2901  /* resolve actual type of transition state, if polymorphic */
2902  aggtranstype = resolve_aggregate_transtype(wfunc->winfnoid,
2903  aggtranstype,
2904  inputTypes,
2905  numArguments);
2906 
2907  /* build expression trees using actual argument & result types */
2908  build_aggregate_transfn_expr(inputTypes,
2909  numArguments,
2910  0, /* no ordered-set window functions yet */
2911  false, /* no variadic window functions yet */
2912  aggtranstype,
2913  wfunc->inputcollid,
2914  transfn_oid,
2915  invtransfn_oid,
2916  &transfnexpr,
2917  &invtransfnexpr);
2918 
2919  /* set up infrastructure for calling the transfn(s) and finalfn */
2920  fmgr_info(transfn_oid, &peraggstate->transfn);
2921  fmgr_info_set_expr((Node *) transfnexpr, &peraggstate->transfn);
2922 
2923  if (OidIsValid(invtransfn_oid))
2924  {
2925  fmgr_info(invtransfn_oid, &peraggstate->invtransfn);
2926  fmgr_info_set_expr((Node *) invtransfnexpr, &peraggstate->invtransfn);
2927  }
2928 
2929  if (OidIsValid(finalfn_oid))
2930  {
2931  build_aggregate_finalfn_expr(inputTypes,
2932  peraggstate->numFinalArgs,
2933  aggtranstype,
2934  wfunc->wintype,
2935  wfunc->inputcollid,
2936  finalfn_oid,
2937  &finalfnexpr);
2938  fmgr_info(finalfn_oid, &peraggstate->finalfn);
2939  fmgr_info_set_expr((Node *) finalfnexpr, &peraggstate->finalfn);
2940  }
2941 
2942  /* get info about relevant datatypes */
2943  get_typlenbyval(wfunc->wintype,
2944  &peraggstate->resulttypeLen,
2945  &peraggstate->resulttypeByVal);
2946  get_typlenbyval(aggtranstype,
2947  &peraggstate->transtypeLen,
2948  &peraggstate->transtypeByVal);
2949 
2950  /*
2951  * initval is potentially null, so don't try to access it as a struct
2952  * field. Must do it the hard way with SysCacheGetAttr.
2953  */
2954  textInitVal = SysCacheGetAttr(AGGFNOID, aggTuple, initvalAttNo,
2955  &peraggstate->initValueIsNull);
2956 
2957  if (peraggstate->initValueIsNull)
2958  peraggstate->initValue = (Datum) 0;
2959  else
2960  peraggstate->initValue = GetAggInitVal(textInitVal,
2961  aggtranstype);
2962 
2963  /*
2964  * If the transfn is strict and the initval is NULL, make sure input type
2965  * and transtype are the same (or at least binary-compatible), so that
2966  * it's OK to use the first input value as the initial transValue. This
2967  * should have been checked at agg definition time, but we must check
2968  * again in case the transfn's strictness property has been changed.
2969  */
2970  if (peraggstate->transfn.fn_strict && peraggstate->initValueIsNull)
2971  {
2972  if (numArguments < 1 ||
2973  !IsBinaryCoercible(inputTypes[0], aggtranstype))
2974  ereport(ERROR,
2975  (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
2976  errmsg("aggregate %u needs to have compatible input type and transition type",
2977  wfunc->winfnoid)));
2978  }
2979 
2980  /*
2981  * Insist that forward and inverse transition functions have the same
2982  * strictness setting. Allowing them to differ would require handling
2983  * more special cases in advance_windowaggregate and
2984  * advance_windowaggregate_base, for no discernible benefit. This should
2985  * have been checked at agg definition time, but we must check again in
2986  * case either function's strictness property has been changed.
2987  */
2988  if (OidIsValid(invtransfn_oid) &&
2989  peraggstate->transfn.fn_strict != peraggstate->invtransfn.fn_strict)
2990  ereport(ERROR,
2991  (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
2992  errmsg("strictness of aggregate's forward and inverse transition functions must match")));
2993 
2994  /*
2995  * Moving aggregates use their own aggcontext.
2996  *
2997  * This is necessary because they might restart at different times, so we
2998  * might never be able to reset the shared context otherwise. We can't
2999  * make it the aggregates' responsibility to clean up after themselves,
3000  * because strict aggregates must be restarted whenever we remove their
3001  * last non-NULL input, which the aggregate won't be aware is happening.
3002  * Also, just pfree()ing the transValue upon restarting wouldn't help,
3003  * since we'd miss any indirectly referenced data. We could, in theory,
3004  * make the memory allocation rules for moving aggregates different than
3005  * they have historically been for plain aggregates, but that seems grotty
3006  * and likely to lead to memory leaks.
3007  */
3008  if (OidIsValid(invtransfn_oid))
3009  peraggstate->aggcontext =
3011  "WindowAgg Per Aggregate",
3013  else
3014  peraggstate->aggcontext = winstate->aggcontext;
3015 
3016  ReleaseSysCache(aggTuple);
3017 
3018  return peraggstate;
3019 }
3020 
3021 static Datum
3022 GetAggInitVal(Datum textInitVal, Oid transtype)
3023 {
3024  Oid typinput,
3025  typioparam;
3026  char *strInitVal;
3027  Datum initVal;
3028 
3029  getTypeInputInfo(transtype, &typinput, &typioparam);
3030  strInitVal = TextDatumGetCString(textInitVal);
3031  initVal = OidInputFunctionCall(typinput, strInitVal,
3032  typioparam, -1);
3033  pfree(strInitVal);
3034  return initVal;
3035 }
3036 
3037 /*
3038  * are_peers
3039  * compare two rows to see if they are equal according to the ORDER BY clause
3040  *
3041  * NB: this does not consider the window frame mode.
3042  */
3043 static bool
3045  TupleTableSlot *slot2)
3046 {
3047  WindowAgg *node = (WindowAgg *) winstate->ss.ps.plan;
3048  ExprContext *econtext = winstate->tmpcontext;
3049 
3050  /* If no ORDER BY, all rows are peers with each other */
3051  if (node->ordNumCols == 0)
3052  return true;
3053 
3054  econtext->ecxt_outertuple = slot1;
3055  econtext->ecxt_innertuple = slot2;
3056  return ExecQualAndReset(winstate->ordEqfunction, econtext);
3057 }
3058 
3059 /*
3060  * window_gettupleslot
3061  * Fetch the pos'th tuple of the current partition into the slot,
3062  * using the winobj's read pointer
3063  *
3064  * Returns true if successful, false if no such row
3065  */
3066 static bool
3068 {
3069  WindowAggState *winstate = winobj->winstate;
3070  MemoryContext oldcontext;
3071 
3072  /* often called repeatedly in a row */
3074 
3075  /* Don't allow passing -1 to spool_tuples here */
3076  if (pos < 0)
3077  return false;
3078 
3079  /* If necessary, fetch the tuple into the spool */
3080  spool_tuples(winstate, pos);
3081 
3082  if (pos >= winstate->spooled_rows)
3083  return false;
3084 
3085  if (pos < winobj->markpos)
3086  elog(ERROR, "cannot fetch row before WindowObject's mark position");
3087 
3089 
3090  tuplestore_select_read_pointer(winstate->buffer, winobj->readptr);
3091 
3092  /*
3093  * Advance or rewind until we are within one tuple of the one we want.
3094  */
3095  if (winobj->seekpos < pos - 1)
3096  {
3097  if (!tuplestore_skiptuples(winstate->buffer,
3098  pos - 1 - winobj->seekpos,
3099  true))
3100  elog(ERROR, "unexpected end of tuplestore");
3101  winobj->seekpos = pos - 1;
3102  }
3103  else if (winobj->seekpos > pos + 1)
3104  {
3105  if (!tuplestore_skiptuples(winstate->buffer,
3106  winobj->seekpos - (pos + 1),
3107  false))
3108  elog(ERROR, "unexpected end of tuplestore");
3109  winobj->seekpos = pos + 1;
3110  }
3111  else if (winobj->seekpos == pos)
3112  {
3113  /*
3114  * There's no API to refetch the tuple at the current position. We
3115  * have to move one tuple forward, and then one backward. (We don't
3116  * do it the other way because we might try to fetch the row before
3117  * our mark, which isn't allowed.) XXX this case could stand to be
3118  * optimized.
3119  */
3120  tuplestore_advance(winstate->buffer, true);
3121  winobj->seekpos++;
3122  }
3123 
3124  /*
3125  * Now we should be on the tuple immediately before or after the one we
3126  * want, so just fetch forwards or backwards as appropriate.
3127  *
3128  * Notice that we tell tuplestore_gettupleslot to make a physical copy of
3129  * the fetched tuple. This ensures that the slot's contents remain valid
3130  * through manipulations of the tuplestore, which some callers depend on.
3131  */
3132  if (winobj->seekpos > pos)
3133  {
3134  if (!tuplestore_gettupleslot(winstate->buffer, false, true, slot))
3135  elog(ERROR, "unexpected end of tuplestore");
3136  winobj->seekpos--;
3137  }
3138  else
3139  {
3140  if (!tuplestore_gettupleslot(winstate->buffer, true, true, slot))
3141  elog(ERROR, "unexpected end of tuplestore");
3142  winobj->seekpos++;
3143  }
3144 
3145  Assert(winobj->seekpos == pos);
3146 
3147  MemoryContextSwitchTo(oldcontext);
3148 
3149  return true;
3150 }
3151 
3152 
3153 /***********************************************************************
3154  * API exposed to window functions
3155  ***********************************************************************/
3156 
3157 
3158 /*
3159  * WinGetPartitionLocalMemory
3160  * Get working memory that lives till end of partition processing
3161  *
3162  * On first call within a given partition, this allocates and zeroes the
3163  * requested amount of space. Subsequent calls just return the same chunk.
3164  *
3165  * Memory obtained this way is normally used to hold state that should be
3166  * automatically reset for each new partition. If a window function wants
3167  * to hold state across the whole query, fcinfo->fn_extra can be used in the
3168  * usual way for that.
3169  */
3170 void *
3172 {
3173  Assert(WindowObjectIsValid(winobj));
3174  if (winobj->localmem == NULL)
3175  winobj->localmem =
3177  return winobj->localmem;
3178 }
3179 
3180 /*
3181  * WinGetCurrentPosition
3182  * Return the current row's position (counting from 0) within the current
3183  * partition.
3184  */
3185 int64
3187 {
3188  Assert(WindowObjectIsValid(winobj));
3189  return winobj->winstate->currentpos;
3190 }
3191 
3192 /*
3193  * WinGetPartitionRowCount
3194  * Return total number of rows contained in the current partition.
3195  *
3196  * Note: this is a relatively expensive operation because it forces the
3197  * whole partition to be "spooled" into the tuplestore at once. Once
3198  * executed, however, additional calls within the same partition are cheap.
3199  */
3200 int64
3202 {
3203  Assert(WindowObjectIsValid(winobj));
3204  spool_tuples(winobj->winstate, -1);
3205  return winobj->winstate->spooled_rows;
3206 }
3207 
3208 /*
3209  * WinSetMarkPosition
3210  * Set the "mark" position for the window object, which is the oldest row
3211  * number (counting from 0) it is allowed to fetch during all subsequent
3212  * operations within the current partition.
3213  *
3214  * Window functions do not have to call this, but are encouraged to move the
3215  * mark forward when possible to keep the tuplestore size down and prevent
3216  * having to spill rows to disk.
3217  */
3218 void
3219 WinSetMarkPosition(WindowObject winobj, int64 markpos)
3220 {
3221  WindowAggState *winstate;
3222 
3223  Assert(WindowObjectIsValid(winobj));
3224  winstate = winobj->winstate;
3225 
3226  if (markpos < winobj->markpos)
3227  elog(ERROR, "cannot move WindowObject's mark position backward");
3228  tuplestore_select_read_pointer(winstate->buffer, winobj->markptr);
3229  if (markpos > winobj->markpos)
3230  {
3231  tuplestore_skiptuples(winstate->buffer,
3232  markpos - winobj->markpos,
3233  true);
3234  winobj->markpos = markpos;
3235  }
3236  tuplestore_select_read_pointer(winstate->buffer, winobj->readptr);
3237  if (markpos > winobj->seekpos)
3238  {
3239  tuplestore_skiptuples(winstate->buffer,
3240  markpos - winobj->seekpos,
3241  true);
3242  winobj->seekpos = markpos;
3243  }
3244 }
3245 
3246 /*
3247  * WinRowsArePeers
3248  * Compare two rows (specified by absolute position in partition) to see
3249  * if they are equal according to the ORDER BY clause.
3250  *
3251  * NB: this does not consider the window frame mode.
3252  */
3253 bool
3254 WinRowsArePeers(WindowObject winobj, int64 pos1, int64 pos2)
3255 {
3256  WindowAggState *winstate;
3257  WindowAgg *node;
3258  TupleTableSlot *slot1;
3259  TupleTableSlot *slot2;
3260  bool res;
3261 
3262  Assert(WindowObjectIsValid(winobj));
3263  winstate = winobj->winstate;
3264  node = (WindowAgg *) winstate->ss.ps.plan;
3265 
3266  /* If no ORDER BY, all rows are peers; don't bother to fetch them */
3267  if (node->ordNumCols == 0)
3268  return true;
3269 
3270  /*
3271  * Note: OK to use temp_slot_2 here because we aren't calling any
3272  * frame-related functions (those tend to clobber temp_slot_2).
3273  */
3274  slot1 = winstate->temp_slot_1;
3275  slot2 = winstate->temp_slot_2;
3276 
3277  if (!window_gettupleslot(winobj, pos1, slot1))
3278  elog(ERROR, "specified position is out of window: " INT64_FORMAT,
3279  pos1);
3280  if (!window_gettupleslot(winobj, pos2, slot2))
3281  elog(ERROR, "specified position is out of window: " INT64_FORMAT,
3282  pos2);
3283 
3284  res = are_peers(winstate, slot1, slot2);
3285 
3286  ExecClearTuple(slot1);
3287  ExecClearTuple(slot2);
3288 
3289  return res;
3290 }
3291 
3292 /*
3293  * WinGetFuncArgInPartition
3294  * Evaluate a window function's argument expression on a specified
3295  * row of the partition. The row is identified in lseek(2) style,
3296  * i.e. relative to the current, first, or last row.
3297  *
3298  * argno: argument number to evaluate (counted from 0)
3299  * relpos: signed rowcount offset from the seek position
3300  * seektype: WINDOW_SEEK_CURRENT, WINDOW_SEEK_HEAD, or WINDOW_SEEK_TAIL
3301  * set_mark: If the row is found and set_mark is true, the mark is moved to
3302  * the row as a side-effect.
3303  * isnull: output argument, receives isnull status of result
3304  * isout: output argument, set to indicate whether target row position
3305  * is out of partition (can pass NULL if caller doesn't care about this)
3306  *
3307  * Specifying a nonexistent row is not an error, it just causes a null result
3308  * (plus setting *isout true, if isout isn't NULL).
3309  */
3310 Datum
3312  int relpos, int seektype, bool set_mark,
3313  bool *isnull, bool *isout)
3314 {
3315  WindowAggState *winstate;
3316  ExprContext *econtext;
3317  TupleTableSlot *slot;
3318  bool gottuple;
3319  int64 abs_pos;
3320 
3321  Assert(WindowObjectIsValid(winobj));
3322  winstate = winobj->winstate;
3323  econtext = winstate->ss.ps.ps_ExprContext;
3324  slot = winstate->temp_slot_1;
3325 
3326  switch (seektype)
3327  {
3328  case WINDOW_SEEK_CURRENT:
3329  abs_pos = winstate->currentpos + relpos;
3330  break;
3331  case WINDOW_SEEK_HEAD:
3332  abs_pos = relpos;
3333  break;
3334  case WINDOW_SEEK_TAIL:
3335  spool_tuples(winstate, -1);
3336  abs_pos = winstate->spooled_rows - 1 + relpos;
3337  break;
3338  default:
3339  elog(ERROR, "unrecognized window seek type: %d", seektype);
3340  abs_pos = 0; /* keep compiler quiet */
3341  break;
3342  }
3343 
3344  gottuple = window_gettupleslot(winobj, abs_pos, slot);
3345 
3346  if (!gottuple)
3347  {
3348  if (isout)
3349  *isout = true;
3350  *isnull = true;
3351  return (Datum) 0;
3352  }
3353  else
3354  {
3355  if (isout)
3356  *isout = false;
3357  if (set_mark)
3358  WinSetMarkPosition(winobj, abs_pos);
3359  econtext->ecxt_outertuple = slot;
3360  return ExecEvalExpr((ExprState *) list_nth(winobj->argstates, argno),
3361  econtext, isnull);
3362  }
3363 }
3364 
3365 /*
3366  * WinGetFuncArgInFrame
3367  * Evaluate a window function's argument expression on a specified
3368  * row of the window frame. The row is identified in lseek(2) style,
3369  * i.e. relative to the first or last row of the frame. (We do not
3370  * support WINDOW_SEEK_CURRENT here, because it's not very clear what
3371  * that should mean if the current row isn't part of the frame.)
3372  *
3373  * argno: argument number to evaluate (counted from 0)
3374  * relpos: signed rowcount offset from the seek position
3375  * seektype: WINDOW_SEEK_HEAD or WINDOW_SEEK_TAIL
3376  * set_mark: If the row is found/in frame and set_mark is true, the mark is
3377  * moved to the row as a side-effect.
3378  * isnull: output argument, receives isnull status of result
3379  * isout: output argument, set to indicate whether target row position
3380  * is out of frame (can pass NULL if caller doesn't care about this)
3381  *
3382  * Specifying a nonexistent or not-in-frame row is not an error, it just
3383  * causes a null result (plus setting *isout true, if isout isn't NULL).
3384  *
3385  * Note that some exclusion-clause options lead to situations where the
3386  * rows that are in-frame are not consecutive in the partition. But we
3387  * count only in-frame rows when measuring relpos.
3388  *
3389  * The set_mark flag is interpreted as meaning that the caller will specify
3390  * a constant (or, perhaps, monotonically increasing) relpos in successive
3391  * calls, so that *if there is no exclusion clause* there will be no need
3392  * to fetch a row before the previously fetched row. But we do not expect
3393  * the caller to know how to account for exclusion clauses. Therefore,
3394  * if there is an exclusion clause we take responsibility for adjusting the
3395  * mark request to something that will be safe given the above assumption
3396  * about relpos.
3397  */
3398 Datum
3400  int relpos, int seektype, bool set_mark,
3401  bool *isnull, bool *isout)
3402 {
3403  WindowAggState *winstate;
3404  ExprContext *econtext;
3405  TupleTableSlot *slot;
3406  int64 abs_pos;
3407  int64 mark_pos;
3408 
3409  Assert(WindowObjectIsValid(winobj));
3410  winstate = winobj->winstate;
3411  econtext = winstate->ss.ps.ps_ExprContext;
3412  slot = winstate->temp_slot_1;
3413 
3414  switch (seektype)
3415  {
3416  case WINDOW_SEEK_CURRENT:
3417  elog(ERROR, "WINDOW_SEEK_CURRENT is not supported for WinGetFuncArgInFrame");
3418  abs_pos = mark_pos = 0; /* keep compiler quiet */
3419  break;
3420  case WINDOW_SEEK_HEAD:
3421  /* rejecting relpos < 0 is easy and simplifies code below */
3422  if (relpos < 0)
3423  goto out_of_frame;
3424  update_frameheadpos(winstate);
3425  abs_pos = winstate->frameheadpos + relpos;
3426  mark_pos = abs_pos;
3427 
3428  /*
3429  * Account for exclusion option if one is active, but advance only
3430  * abs_pos not mark_pos. This prevents changes of the current
3431  * row's peer group from resulting in trying to fetch a row before
3432  * some previous mark position.
3433  *
3434  * Note that in some corner cases such as current row being
3435  * outside frame, these calculations are theoretically too simple,
3436  * but it doesn't matter because we'll end up deciding the row is
3437  * out of frame. We do not attempt to avoid fetching rows past
3438  * end of frame; that would happen in some cases anyway.
3439  */
3440  switch (winstate->frameOptions & FRAMEOPTION_EXCLUSION)
3441  {
3442  case 0:
3443  /* no adjustment needed */
3444  break;
3446  if (abs_pos >= winstate->currentpos &&
3447  winstate->currentpos >= winstate->frameheadpos)
3448  abs_pos++;
3449  break;
3451  update_grouptailpos(winstate);
3452  if (abs_pos >= winstate->groupheadpos &&
3453  winstate->grouptailpos > winstate->frameheadpos)
3454  {
3455  int64 overlapstart = Max(winstate->groupheadpos,
3456  winstate->frameheadpos);
3457 
3458  abs_pos += winstate->grouptailpos - overlapstart;
3459  }
3460  break;
3462  update_grouptailpos(winstate);
3463  if (abs_pos >= winstate->groupheadpos &&
3464  winstate->grouptailpos > winstate->frameheadpos)
3465  {
3466  int64 overlapstart = Max(winstate->groupheadpos,
3467  winstate->frameheadpos);
3468 
3469  if (abs_pos == overlapstart)
3470  abs_pos = winstate->currentpos;
3471  else
3472  abs_pos += winstate->grouptailpos - overlapstart - 1;
3473  }
3474  break;
3475  default:
3476  elog(ERROR, "unrecognized frame option state: 0x%x",
3477  winstate->frameOptions);
3478  break;
3479  }
3480  break;
3481  case WINDOW_SEEK_TAIL:
3482  /* rejecting relpos > 0 is easy and simplifies code below */
3483  if (relpos > 0)
3484  goto out_of_frame;
3485  update_frametailpos(winstate);
3486  abs_pos = winstate->frametailpos - 1 + relpos;
3487 
3488  /*
3489  * Account for exclusion option if one is active. If there is no
3490  * exclusion, we can safely set the mark at the accessed row. But
3491  * if there is, we can only mark the frame start, because we can't
3492  * be sure how far back in the frame the exclusion might cause us
3493  * to fetch in future. Furthermore, we have to actually check
3494  * against frameheadpos here, since it's unsafe to try to fetch a
3495  * row before frame start if the mark might be there already.
3496  */
3497  switch (winstate->frameOptions & FRAMEOPTION_EXCLUSION)
3498  {
3499  case 0:
3500  /* no adjustment needed */
3501  mark_pos = abs_pos;
3502  break;
3504  if (abs_pos <= winstate->currentpos &&
3505  winstate->currentpos < winstate->frametailpos)
3506  abs_pos--;
3507  update_frameheadpos(winstate);
3508  if (abs_pos < winstate->frameheadpos)
3509  goto out_of_frame;
3510  mark_pos = winstate->frameheadpos;
3511  break;
3513  update_grouptailpos(winstate);
3514  if (abs_pos < winstate->grouptailpos &&
3515  winstate->groupheadpos < winstate->frametailpos)
3516  {
3517  int64 overlapend = Min(winstate->grouptailpos,
3518  winstate->frametailpos);
3519 
3520  abs_pos -= overlapend - winstate->groupheadpos;
3521  }
3522  update_frameheadpos(winstate);
3523  if (abs_pos < winstate->frameheadpos)
3524  goto out_of_frame;
3525  mark_pos = winstate->frameheadpos;
3526  break;
3528  update_grouptailpos(winstate);
3529  if (abs_pos < winstate->grouptailpos &&
3530  winstate->groupheadpos < winstate->frametailpos)
3531  {
3532  int64 overlapend = Min(winstate->grouptailpos,
3533  winstate->frametailpos);
3534 
3535  if (abs_pos == overlapend - 1)
3536  abs_pos = winstate->currentpos;
3537  else
3538  abs_pos -= overlapend - 1 - winstate->groupheadpos;
3539  }
3540  update_frameheadpos(winstate);
3541  if (abs_pos < winstate->frameheadpos)
3542  goto out_of_frame;
3543  mark_pos = winstate->frameheadpos;
3544  break;
3545  default:
3546  elog(ERROR, "unrecognized frame option state: 0x%x",
3547  winstate->frameOptions);
3548  mark_pos = 0; /* keep compiler quiet */
3549  break;
3550  }
3551  break;
3552  default:
3553  elog(ERROR, "unrecognized window seek type: %d", seektype);
3554  abs_pos = mark_pos = 0; /* keep compiler quiet */
3555  break;
3556  }
3557 
3558  if (!window_gettupleslot(winobj, abs_pos, slot))
3559  goto out_of_frame;
3560 
3561  /* The code above does not detect all out-of-frame cases, so check */
3562  if (row_is_in_frame(winstate, abs_pos, slot) <= 0)
3563  goto out_of_frame;
3564 
3565  if (isout)
3566  *isout = false;
3567  if (set_mark)
3568  WinSetMarkPosition(winobj, mark_pos);
3569  econtext->ecxt_outertuple = slot;
3570  return ExecEvalExpr((ExprState *) list_nth(winobj->argstates, argno),
3571  econtext, isnull);
3572 
3573 out_of_frame:
3574  if (isout)
3575  *isout = true;
3576  *isnull = true;
3577  return (Datum) 0;
3578 }
3579 
3580 /*
3581  * WinGetFuncArgCurrent
3582  * Evaluate a window function's argument expression on the current row.
3583  *
3584  * argno: argument number to evaluate (counted from 0)
3585  * isnull: output argument, receives isnull status of result
3586  *
3587  * Note: this isn't quite equivalent to WinGetFuncArgInPartition or
3588  * WinGetFuncArgInFrame targeting the current row, because it will succeed
3589  * even if the WindowObject's mark has been set beyond the current row.
3590  * This should generally be used for "ordinary" arguments of a window
3591  * function, such as the offset argument of lead() or lag().
3592  */
3593 Datum
3594 WinGetFuncArgCurrent(WindowObject winobj, int argno, bool *isnull)
3595 {
3596  WindowAggState *winstate;
3597  ExprContext *econtext;
3598 
3599  Assert(WindowObjectIsValid(winobj));
3600  winstate = winobj->winstate;
3601 
3602  econtext = winstate->ss.ps.ps_ExprContext;
3603 
3604  econtext->ecxt_outertuple = winstate->ss.ss_ScanTupleSlot;
3605  return ExecEvalExpr((ExprState *) list_nth(winobj->argstates, argno),
3606  econtext, isnull);
3607 }
AclResult
Definition: acl.h:182
@ ACLCHECK_OK
Definition: acl.h:183
void aclcheck_error(AclResult aclerr, ObjectType objtype, const char *objectname)
Definition: aclchk.c:2702
AclResult object_aclcheck(Oid classid, Oid objectid, Oid roleid, AclMode mode)
Definition: aclchk.c:3890
int16 AttrNumber
Definition: attnum.h:21
#define TextDatumGetCString(d)
Definition: builtins.h:98
#define Min(x, y)
Definition: c.h:1004
signed short int16
Definition: c.h:493
#define Max(x, y)
Definition: c.h:998
#define INT64_FORMAT
Definition: c.h:548
#define Assert(condition)
Definition: c.h:858
#define MemSet(start, val, len)
Definition: c.h:1020
#define OidIsValid(objectId)
Definition: c.h:775
size_t Size
Definition: c.h:605
bool contain_subplans(Node *clause)
Definition: clauses.c:330
bool contain_volatile_functions(Node *clause)
Definition: clauses.c:538
Datum datumCopy(Datum value, bool typByVal, int typLen)
Definition: datum.c:132
int errcode(int sqlerrcode)
Definition: elog.c:857
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:224
#define ereport(elevel,...)
Definition: elog.h:149
bool equal(const void *a, const void *b)
Definition: equalfuncs.c:223
void ExecReScan(PlanState *node)
Definition: execAmi.c:76
ExprState * ExecInitQual(List *qual, PlanState *parent)
Definition: execExpr.c:220
ExprState * ExecInitExpr(Expr *node, PlanState *parent)
Definition: execExpr.c:134
ExprState * execTuplesMatchPrepare(TupleDesc desc, int numCols, const AttrNumber *keyColIdx, const Oid *eqOperators, const Oid *collations, PlanState *parent)
Definition: execGrouping.c:58
void ExecEndNode(PlanState *node)
Definition: execProcnode.c:557
PlanState * ExecInitNode(Plan *node, EState *estate, int eflags)
Definition: execProcnode.c:142
const TupleTableSlotOps TTSOpsVirtual
Definition: execTuples.c:84
TupleTableSlot * ExecInitExtraTupleSlot(EState *estate, TupleDesc tupledesc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1918
void ExecInitResultTupleSlotTL(PlanState *planstate, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1886
const TupleTableSlotOps TTSOpsMinimalTuple
Definition: execTuples.c:86
void ExecCreateScanSlotFromOuterPlan(EState *estate, ScanState *scanstate, const TupleTableSlotOps *tts_ops)
Definition: execUtils.c:659
void ExecAssignExprContext(EState *estate, PlanState *planstate)
Definition: execUtils.c:483
void ExecAssignProjectionInfo(PlanState *planstate, TupleDesc inputDesc)
Definition: execUtils.c:538
struct WindowStatePerAggData * WindowStatePerAgg
Definition: execnodes.h:2543
#define InstrCountFiltered1(node, delta)
Definition: execnodes.h:1221
#define outerPlanState(node)
Definition: execnodes.h:1213
@ WINDOWAGG_PASSTHROUGH
Definition: execnodes.h:2552
@ WINDOWAGG_RUN
Definition: execnodes.h:2551
@ WINDOWAGG_DONE
Definition: execnodes.h:2550
@ WINDOWAGG_PASSTHROUGH_STRICT
Definition: execnodes.h:2553
struct WindowStatePerFuncData * WindowStatePerFunc
Definition: execnodes.h:2542
#define EXEC_FLAG_BACKWARD
Definition: executor.h:68
static TupleTableSlot * ExecProject(ProjectionInfo *projInfo)
Definition: executor.h:376
#define ResetExprContext(econtext)
Definition: executor.h:544
static bool ExecQual(ExprState *state, ExprContext *econtext)
Definition: executor.h:413
static bool ExecQualAndReset(ExprState *state, ExprContext *econtext)
Definition: executor.h:440
static Datum ExecEvalExpr(ExprState *state, ExprContext *econtext, bool *isNull)
Definition: executor.h:333
static Datum ExecEvalExprSwitchContext(ExprState *state, ExprContext *econtext, bool *isNull)
Definition: executor.h:348
#define EXEC_FLAG_MARK
Definition: executor.h:69
static TupleTableSlot * ExecProcNode(PlanState *node)
Definition: executor.h:269
ExpandedObjectHeader * DatumGetEOHP(Datum d)
Definition: expandeddatum.c:29
void DeleteExpandedObject(Datum d)
#define MakeExpandedObjectReadOnly(d, isnull, typlen)
#define DatumIsReadWriteExpandedObject(d, isnull, typlen)
void fmgr_info(Oid functionId, FmgrInfo *finfo)
Definition: fmgr.c:127
Datum OidInputFunctionCall(Oid functionId, char *str, Oid typioparam, int32 typmod)
Definition: fmgr.c:1754
Datum FunctionCall5Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, Datum arg3, Datum arg4, Datum arg5)
Definition: fmgr.c:1223
void fmgr_info_cxt(Oid functionId, FmgrInfo *finfo, MemoryContext mcxt)
Definition: fmgr.c:137
#define InitFunctionCallInfoData(Fcinfo, Flinfo, Nargs, Collation, Context, Resultinfo)
Definition: fmgr.h:150
#define LOCAL_FCINFO(name, nargs)
Definition: fmgr.h:110
#define FunctionCallInvoke(fcinfo)
Definition: fmgr.h:172
#define fmgr_info_set_expr(expr, finfo)
Definition: fmgr.h:135
int work_mem
Definition: globals.c:128
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define GETSTRUCT(TUP)
Definition: htup_details.h:653
static struct @155 value
int i
Definition: isn.c:73
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:77
void get_typlenbyval(Oid typid, int16 *typlen, bool *typbyval)
Definition: lsyscache.c:2251
void getTypeInputInfo(Oid type, Oid *typInput, Oid *typIOParam)
Definition: lsyscache.c:2874
char * get_func_name(Oid funcid)
Definition: lsyscache.c:1608
void MemoryContextReset(MemoryContext context)
Definition: mcxt.c:383
void pfree(void *pointer)
Definition: mcxt.c:1520
void * palloc0(Size size)
Definition: mcxt.c:1346
void * MemoryContextAllocZero(MemoryContext context, Size size)
Definition: mcxt.c:1214
MemoryContext CurrentMemoryContext
Definition: mcxt.c:143
MemoryContext MemoryContextGetParent(MemoryContext context)
Definition: mcxt.c:731
void MemoryContextDelete(MemoryContext context)
Definition: mcxt.c:454
#define AllocSetContextCreate
Definition: memutils.h:129
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:160
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:122
Oid GetUserId(void)
Definition: miscinit.c:514
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:42
Datum WinGetFuncArgInPartition(WindowObject winobj, int argno, int relpos, int seektype, bool set_mark, bool *isnull, bool *isout)
static void begin_partition(WindowAggState *winstate)
struct WindowObjectData WindowObjectData
static void update_grouptailpos(WindowAggState *winstate)
Datum WinGetFuncArgInFrame(WindowObject winobj, int argno, int relpos, int seektype, bool set_mark, bool *isnull, bool *isout)
WindowAggState * ExecInitWindowAgg(WindowAgg *node, EState *estate, int eflags)
struct WindowStatePerAggData WindowStatePerAggData
static Datum GetAggInitVal(Datum textInitVal, Oid transtype)
static void spool_tuples(WindowAggState *winstate, int64 pos)
static void advance_windowaggregate(WindowAggState *winstate, WindowStatePerFunc perfuncstate, WindowStatePerAgg peraggstate)
static int row_is_in_frame(WindowAggState *winstate, int64 pos, TupleTableSlot *slot)
void ExecEndWindowAgg(WindowAggState *node)
static void eval_windowfunction(WindowAggState *winstate, WindowStatePerFunc perfuncstate, Datum *result, bool *isnull)
struct WindowStatePerFuncData WindowStatePerFuncData
static WindowStatePerAggData * initialize_peragg(WindowAggState *winstate, WindowFunc *wfunc, WindowStatePerAgg peraggstate)
static void finalize_windowaggregate(WindowAggState *winstate, WindowStatePerFunc perfuncstate, WindowStatePerAgg peraggstate, Datum *result, bool *isnull)
static bool advance_windowaggregate_base(WindowAggState *winstate, WindowStatePerFunc perfuncstate, WindowStatePerAgg peraggstate)
static bool window_gettupleslot(WindowObject winobj, int64 pos, TupleTableSlot *slot)
void ExecReScanWindowAgg(WindowAggState *node)
int64 WinGetCurrentPosition(WindowObject winobj)
bool WinRowsArePeers(WindowObject winobj, int64 pos1, int64 pos2)
static TupleTableSlot * ExecWindowAgg(PlanState *pstate)
void WinSetMarkPosition(WindowObject winobj, int64 markpos)
static void eval_windowaggregates(WindowAggState *winstate)
static void release_partition(WindowAggState *winstate)
void * WinGetPartitionLocalMemory(WindowObject winobj, Size sz)
static void update_frametailpos(WindowAggState *winstate)
static void update_frameheadpos(WindowAggState *winstate)
static void initialize_windowaggregate(WindowAggState *winstate, WindowStatePerFunc perfuncstate, WindowStatePerAgg peraggstate)
static bool are_peers(WindowAggState *winstate, TupleTableSlot *slot1, TupleTableSlot *slot2)
Datum WinGetFuncArgCurrent(WindowObject winobj, int argno, bool *isnull)
int64 WinGetPartitionRowCount(WindowObject winobj)
NodeTag
Definition: nodes.h:27
#define makeNode(_type_)
Definition: nodes.h:155
#define castNode(_type_, nodeptr)
Definition: nodes.h:176
#define InvokeFunctionExecuteHook(objectId)
Definition: objectaccess.h:213
void build_aggregate_finalfn_expr(Oid *agg_input_types, int num_finalfn_inputs, Oid agg_state_type, Oid agg_result_type, Oid agg_input_collation, Oid finalfn_oid, Expr **finalfnexpr)
Definition: parse_agg.c:2136
Oid resolve_aggregate_transtype(Oid aggfuncid, Oid aggtranstype, Oid *inputTypes, int numArguments)
Definition: parse_agg.c:1934
void build_aggregate_transfn_expr(Oid *agg_input_types, int agg_num_inputs, int agg_num_direct_inputs, bool agg_variadic, Oid agg_state_type, Oid agg_input_collation, Oid transfn_oid, Oid invtransfn_oid, Expr **transfnexpr, Expr **invtransfnexpr)
Definition: parse_agg.c:2028
bool IsBinaryCoercible(Oid srctype, Oid targettype)
#define FRAMEOPTION_END_CURRENT_ROW
Definition: parsenodes.h:591
#define FRAMEOPTION_END_OFFSET
Definition: parsenodes.h:602
#define FRAMEOPTION_EXCLUDE_CURRENT_ROW
Definition: parsenodes.h:596
#define FRAMEOPTION_END_OFFSET_PRECEDING
Definition: parsenodes.h:593
#define FRAMEOPTION_START_UNBOUNDED_PRECEDING
Definition: parsenodes.h:586
#define FRAMEOPTION_START_CURRENT_ROW
Definition: parsenodes.h:590
#define FRAMEOPTION_START_OFFSET
Definition: parsenodes.h:600
@ OBJECT_FUNCTION
Definition: parsenodes.h:2280
#define FRAMEOPTION_EXCLUDE_TIES
Definition: parsenodes.h:598
#define FRAMEOPTION_RANGE
Definition: parsenodes.h:582
#define FRAMEOPTION_EXCLUDE_GROUP
Definition: parsenodes.h:597
#define FRAMEOPTION_GROUPS
Definition: parsenodes.h:584
#define ACL_EXECUTE
Definition: parsenodes.h:83
#define FRAMEOPTION_END_UNBOUNDED_FOLLOWING
Definition: parsenodes.h:589
#define FRAMEOPTION_START_OFFSET_PRECEDING
Definition: parsenodes.h:592
#define FRAMEOPTION_EXCLUSION
Definition: parsenodes.h:604
#define FRAMEOPTION_ROWS
Definition: parsenodes.h:583
FormData_pg_aggregate * Form_pg_aggregate
Definition: pg_aggregate.h:109
void * arg
#define FUNC_MAX_ARGS
const void size_t len
#define lfirst(lc)
Definition: pg_list.h:172
static int list_length(const List *l)
Definition: pg_list.h:152
#define NIL
Definition: pg_list.h:68
static void * list_nth(const List *list, int n)
Definition: pg_list.h:299
FormData_pg_proc * Form_pg_proc
Definition: pg_proc.h:136
#define outerPlan(node)
Definition: plannodes.h:182
static bool DatumGetBool(Datum X)
Definition: postgres.h:90
static int64 DatumGetInt64(Datum X)
Definition: postgres.h:385
uintptr_t Datum
Definition: postgres.h:64
static Datum BoolGetDatum(bool X)
Definition: postgres.h:102
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
static Pointer DatumGetPointer(Datum X)
Definition: postgres.h:312
#define InvalidOid
Definition: postgres_ext.h:36
unsigned int Oid
Definition: postgres_ext.h:31
MemoryContextSwitchTo(old_ctx)
char * format_procedure(Oid procedure_oid)
Definition: regproc.c:299
MemoryContext ecxt_per_tuple_memory
Definition: execnodes.h:263
TupleTableSlot * ecxt_innertuple
Definition: execnodes.h:257
Datum * ecxt_aggvalues
Definition: execnodes.h:274
TupleTableSlot * ecxt_scantuple
Definition: execnodes.h:255
bool * ecxt_aggnulls
Definition: execnodes.h:276
MemoryContext ecxt_per_query_memory
Definition: execnodes.h:262
TupleTableSlot * ecxt_outertuple
Definition: execnodes.h:259
Expr * expr
Definition: execnodes.h:111
Definition: fmgr.h:57
bool fn_strict
Definition: fmgr.h:61
Definition: pg_list.h:54
Definition: nodes.h:129
bool outeropsset
Definition: execnodes.h:1200
const TupleTableSlotOps * outerops
Definition: execnodes.h:1192
ExprState * qual
Definition: execnodes.h:1138
Plan * plan
Definition: execnodes.h:1117
bool outeropsfixed
Definition: execnodes.h:1196
EState * state
Definition: execnodes.h:1119
ExprContext * ps_ExprContext
Definition: execnodes.h:1156
ProjectionInfo * ps_ProjInfo
Definition: execnodes.h:1157
ExecProcNodeMtd ExecProcNode
Definition: execnodes.h:1123
List * qual
Definition: plannodes.h:153
TupleTableSlot * ss_ScanTupleSlot
Definition: execnodes.h:1567
PlanState ps
Definition: execnodes.h:1564
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:123
ExprState * endOffset
Definition: execnodes.h:2587
MemoryContext aggcontext
Definition: execnodes.h:2606
ScanState ss
Definition: execnodes.h:2559
int64 aggregatedbase
Definition: execnodes.h:2581
int64 frametailgroup
Definition: execnodes.h:2601
int64 frameheadgroup
Definition: execnodes.h:2600
WindowStatePerAgg peragg
Definition: execnodes.h:2567
MemoryContext partcontext
Definition: execnodes.h:2605
FmgrInfo endInRangeFunc
Definition: execnodes.h:2593
TupleTableSlot * framehead_slot
Definition: execnodes.h:2634
bool frametail_valid
Definition: execnodes.h:2627
bool partition_spooled
Definition: execnodes.h:2621
FmgrInfo startInRangeFunc
Definition: execnodes.h:2592
int64 spooled_rows
Definition: execnodes.h:2575
int64 frameheadpos
Definition: execnodes.h:2577
bool more_partitions
Definition: execnodes.h:2623
Datum startOffsetValue
Definition: execnodes.h:2588
int64 grouptailpos
Definition: execnodes.h:2603
int64 currentgroup
Definition: execnodes.h:2599
TupleTableSlot * frametail_slot
Definition: execnodes.h:2635
ExprState * ordEqfunction
Definition: execnodes.h:2569
ExprState * runcondition
Definition: execnodes.h:2610
TupleTableSlot * temp_slot_2
Definition: execnodes.h:2640
Tuplestorestate * buffer
Definition: execnodes.h:2570
WindowAggStatus status
Definition: execnodes.h:2583
TupleTableSlot * agg_row_slot
Definition: execnodes.h:2638
struct WindowObjectData * agg_winobj
Definition: execnodes.h:2580
WindowStatePerFunc perfunc
Definition: execnodes.h:2566
bool framehead_valid
Definition: execnodes.h:2625
int64 groupheadpos
Definition: execnodes.h:2602
MemoryContext curaggcontext
Definition: execnodes.h:2607
bool inRangeNullsFirst
Definition: execnodes.h:2596
bool grouptail_valid
Definition: execnodes.h:2629
Datum endOffsetValue
Definition: execnodes.h:2589
int64 currentpos
Definition: execnodes.h:2576
ExprState * partEqfunction
Definition: execnodes.h:2568
int64 frametailpos
Definition: execnodes.h:2578
ExprState * startOffset
Definition: execnodes.h:2586
TupleTableSlot * first_part_slot
Definition: execnodes.h:2632
int64 aggregatedupto
Definition: execnodes.h:2582
ExprContext * tmpcontext
Definition: execnodes.h:2608
TupleTableSlot * temp_slot_1
Definition: execnodes.h:2639
bool use_pass_through
Definition: execnodes.h:2615
int partNumCols
Definition: plannodes.h:1046
Oid endInRangeFunc
Definition: plannodes.h:1090
Node * endOffset
Definition: plannodes.h:1076
bool topWindow
Definition: plannodes.h:1105
Plan plan
Definition: plannodes.h:1040
Oid inRangeColl
Definition: plannodes.h:1093
Node * startOffset
Definition: plannodes.h:1073
List * runCondition
Definition: plannodes.h:1079
Oid startInRangeFunc
Definition: plannodes.h:1087
bool inRangeAsc
Definition: plannodes.h:1096
Index winref
Definition: plannodes.h:1043
bool inRangeNullsFirst
Definition: plannodes.h:1099
int ordNumCols
Definition: plannodes.h:1058
int frameOptions
Definition: plannodes.h:1070
WindowFunc * wfunc
Definition: execnodes.h:871
ExprState * aggfilter
Definition: execnodes.h:873
List * args
Definition: primnodes.h:575
Index winref
Definition: primnodes.h:581
Oid winfnoid
Definition: primnodes.h:567
WindowAggState * winstate
Definition: nodeWindowAgg.c:65
MemoryContext aggcontext
WindowFuncExprState * wfuncstate
Definition: nodeWindowAgg.c:81
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:266
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:218
Datum SysCacheGetAttr(int cacheId, HeapTuple tup, AttrNumber attributeNumber, bool *isNull)
Definition: syscache.c:479
bool tuplestore_gettupleslot(Tuplestorestate *state, bool forward, bool copy, TupleTableSlot *slot)
Definition: tuplestore.c:1078
void tuplestore_puttupleslot(Tuplestorestate *state, TupleTableSlot *slot)
Definition: tuplestore.c:708
void tuplestore_select_read_pointer(Tuplestorestate *state, int ptr)
Definition: tuplestore.c:473
Tuplestorestate * tuplestore_begin_heap(bool randomAccess, bool interXact, int maxKBytes)
Definition: tuplestore.c:318
int tuplestore_alloc_read_pointer(Tuplestorestate *state, int eflags)
Definition: tuplestore.c:383
void tuplestore_trim(Tuplestorestate *state)
Definition: tuplestore.c:1360
bool tuplestore_advance(Tuplestorestate *state, bool forward)
Definition: tuplestore.c:1110
bool tuplestore_in_memory(Tuplestorestate *state)
Definition: tuplestore.c:1455
void tuplestore_end(Tuplestorestate *state)
Definition: tuplestore.c:453
void tuplestore_set_eflags(Tuplestorestate *state, int eflags)
Definition: tuplestore.c:359
bool tuplestore_skiptuples(Tuplestorestate *state, int64 ntuples, bool forward)
Definition: tuplestore.c:1135
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:454
static TupleTableSlot * ExecCopySlot(TupleTableSlot *dstslot, TupleTableSlot *srcslot)
Definition: tuptable.h:509
static Datum slot_getattr(TupleTableSlot *slot, int attnum, bool *isnull)
Definition: tuptable.h:395
#define TupIsNull(slot)
Definition: tuptable.h:306
#define WINDOW_SEEK_TAIL
Definition: windowapi.h:34
#define WINDOW_SEEK_HEAD
Definition: windowapi.h:33
#define WindowObjectIsValid(winobj)
Definition: windowapi.h:41
#define WINDOW_SEEK_CURRENT
Definition: windowapi.h:32