#include "nodes/execnodes.h"

Include dependency graph for nodeWindowAgg.h:

This graph shows which files directly or indirectly include this file:

Functions
WindowAggState *	ExecInitWindowAgg (WindowAgg node, EState estate, int eflags)

void	ExecEndWindowAgg (WindowAggState *node)

void	ExecReScanWindowAgg (WindowAggState *node)

Function Documentation

void ExecEndWindowAgg ( WindowAggState * node )

Definition at line 2013 of file nodeWindowAgg.c.

References WindowAggState::agg_row_slot, WindowStatePerAggData::aggcontext, WindowAggState::aggcontext, ExecClearTuple(), ExecEndNode(), ExecFreeExprContext(), WindowAggState::first_part_slot, i, MemoryContextDelete(), WindowAggState::numaggs, outerPlan, outerPlanState, WindowAggState::partcontext, WindowAggState::peragg, WindowAggState::perfunc, pfree(), ScanState::ps, PlanState::ps_ExprContext, release_partition(), WindowAggState::ss, ScanState::ss_ScanTupleSlot, WindowAggState::temp_slot_1, WindowAggState::temp_slot_2, and WindowAggState::tmpcontext.

Referenced by ExecEndNode().

 {
     PlanState  *outerPlan;
     int         i;
 
     release_partition(node);
 
     ExecClearTuple(node->ss.ss_ScanTupleSlot);
     ExecClearTuple(node->first_part_slot);
     ExecClearTuple(node->agg_row_slot);
     ExecClearTuple(node->temp_slot_1);
     ExecClearTuple(node->temp_slot_2);
 
     /*
      * Free both the expr contexts.
      */
     ExecFreeExprContext(&node->ss.ps);
     node->ss.ps.ps_ExprContext = node->tmpcontext;
     ExecFreeExprContext(&node->ss.ps);
 
     for (i = 0; i < node->numaggs; i++)
     {
         if (node->peragg[i].aggcontext != node->aggcontext)
             MemoryContextDelete(node->peragg[i].aggcontext);
     }
     MemoryContextDelete(node->partcontext);
     MemoryContextDelete(node->aggcontext);
 
     pfree(node->perfunc);
     pfree(node->peragg);
 
     outerPlan = outerPlanState(node);
     ExecEndNode(outerPlan);
 }

WindowAggState* ExecInitWindowAgg	(	WindowAgg *	node,
		EState *	estate,
		int	eflags
	)

Definition at line 1771 of file nodeWindowAgg.c.

Referenced by ExecInitNode().

 {
     WindowAggState *winstate;
     Plan       *outerPlan;
     ExprContext *econtext;
     ExprContext *tmpcontext;
     WindowStatePerFunc perfunc;
     WindowStatePerAgg peragg;
     int         numfuncs,
                 wfuncno,
                 numaggs,
                 aggno;
     ListCell   *l;
 
     /* check for unsupported flags */
     Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
 
     /*
      * create state structure
      */
     winstate = makeNode(WindowAggState);
     winstate->ss.ps.plan = (Plan *) node;
     winstate->ss.ps.state = estate;
     winstate->ss.ps.ExecProcNode = ExecWindowAgg;
 
     /*
      * Create expression contexts.  We need two, one for per-input-tuple
      * processing and one for per-output-tuple processing.  We cheat a little
      * by using ExecAssignExprContext() to build both.
      */
     ExecAssignExprContext(estate, &winstate->ss.ps);
     tmpcontext = winstate->ss.ps.ps_ExprContext;
     winstate->tmpcontext = tmpcontext;
     ExecAssignExprContext(estate, &winstate->ss.ps);
 
     /* Create long-lived context for storage of partition-local memory etc */
     winstate->partcontext =
         AllocSetContextCreate(CurrentMemoryContext,
                               "WindowAgg Partition",
                               ALLOCSET_DEFAULT_SIZES);
 
     /*
      * Create mid-lived context for aggregate trans values etc.
      *
      * Note that moving aggregates each use their own private context, not
      * this one.
      */
     winstate->aggcontext =
         AllocSetContextCreate(CurrentMemoryContext,
                               "WindowAgg Aggregates",
                               ALLOCSET_DEFAULT_SIZES);
 
     /*
      * tuple table initialization
      */
     ExecInitScanTupleSlot(estate, &winstate->ss);
     ExecInitResultTupleSlot(estate, &winstate->ss.ps);
     winstate->first_part_slot = ExecInitExtraTupleSlot(estate);
     winstate->agg_row_slot = ExecInitExtraTupleSlot(estate);
     winstate->temp_slot_1 = ExecInitExtraTupleSlot(estate);
     winstate->temp_slot_2 = ExecInitExtraTupleSlot(estate);
 
     /*
      * WindowAgg nodes never have quals, since they can only occur at the
      * logical top level of a query (ie, after any WHERE or HAVING filters)
      */
     Assert(node->plan.qual == NIL);
     winstate->ss.ps.qual = NULL;
 
     /*
      * initialize child nodes
      */
     outerPlan = outerPlan(node);
     outerPlanState(winstate) = ExecInitNode(outerPlan, estate, eflags);
 
     /*
      * initialize source tuple type (which is also the tuple type that we'll
      * store in the tuplestore and use in all our working slots).
      */
     ExecAssignScanTypeFromOuterPlan(&winstate->ss);
 
     ExecSetSlotDescriptor(winstate->first_part_slot,
                           winstate->ss.ss_ScanTupleSlot->tts_tupleDescriptor);
     ExecSetSlotDescriptor(winstate->agg_row_slot,
                           winstate->ss.ss_ScanTupleSlot->tts_tupleDescriptor);
     ExecSetSlotDescriptor(winstate->temp_slot_1,
                           winstate->ss.ss_ScanTupleSlot->tts_tupleDescriptor);
     ExecSetSlotDescriptor(winstate->temp_slot_2,
                           winstate->ss.ss_ScanTupleSlot->tts_tupleDescriptor);
 
     /*
      * Initialize result tuple type and projection info.
      */
     ExecAssignResultTypeFromTL(&winstate->ss.ps);
     ExecAssignProjectionInfo(&winstate->ss.ps, NULL);
 
     /* Set up data for comparing tuples */
     if (node->partNumCols > 0)
         winstate->partEqfunctions = execTuplesMatchPrepare(node->partNumCols,
                                                            node->partOperators);
     if (node->ordNumCols > 0)
         winstate->ordEqfunctions = execTuplesMatchPrepare(node->ordNumCols,
                                                           node->ordOperators);
 
     /*
      * WindowAgg nodes use aggvalues and aggnulls as well as Agg nodes.
      */
     numfuncs = winstate->numfuncs;
     numaggs = winstate->numaggs;
     econtext = winstate->ss.ps.ps_ExprContext;
     econtext->ecxt_aggvalues = (Datum *) palloc0(sizeof(Datum) * numfuncs);
     econtext->ecxt_aggnulls = (bool *) palloc0(sizeof(bool) * numfuncs);
 
     /*
      * allocate per-wfunc/per-agg state information.
      */
     perfunc = (WindowStatePerFunc) palloc0(sizeof(WindowStatePerFuncData) * numfuncs);
     peragg = (WindowStatePerAgg) palloc0(sizeof(WindowStatePerAggData) * numaggs);
     winstate->perfunc = perfunc;
     winstate->peragg = peragg;
 
     wfuncno = -1;
     aggno = -1;
     foreach(l, winstate->funcs)
     {
         WindowFuncExprState *wfuncstate = (WindowFuncExprState *) lfirst(l);
         WindowFunc *wfunc = wfuncstate->wfunc;
         WindowStatePerFunc perfuncstate;
         AclResult   aclresult;
         int         i;
 
         if (wfunc->winref != node->winref)  /* planner screwed up? */
             elog(ERROR, "WindowFunc with winref %u assigned to WindowAgg with winref %u",
                  wfunc->winref, node->winref);
 
         /* Look for a previous duplicate window function */
         for (i = 0; i <= wfuncno; i++)
         {
             if (equal(wfunc, perfunc[i].wfunc) &&
                 !contain_volatile_functions((Node *) wfunc))
                 break;
         }
         if (i <= wfuncno)
         {
             /* Found a match to an existing entry, so just mark it */
             wfuncstate->wfuncno = i;
             continue;
         }
 
         /* Nope, so assign a new PerAgg record */
         perfuncstate = &perfunc[++wfuncno];
 
         /* Mark WindowFunc state node with assigned index in the result array */
         wfuncstate->wfuncno = wfuncno;
 
         /* Check permission to call window function */
         aclresult = pg_proc_aclcheck(wfunc->winfnoid, GetUserId(),
                                      ACL_EXECUTE);
         if (aclresult != ACLCHECK_OK)
             aclcheck_error(aclresult, ACL_KIND_PROC,
                            get_func_name(wfunc->winfnoid));
         InvokeFunctionExecuteHook(wfunc->winfnoid);
 
         /* Fill in the perfuncstate data */
         perfuncstate->wfuncstate = wfuncstate;
         perfuncstate->wfunc = wfunc;
         perfuncstate->numArguments = list_length(wfuncstate->args);
 
         fmgr_info_cxt(wfunc->winfnoid, &perfuncstate->flinfo,
                       econtext->ecxt_per_query_memory);
         fmgr_info_set_expr((Node *) wfunc, &perfuncstate->flinfo);
 
         perfuncstate->winCollation = wfunc->inputcollid;
 
         get_typlenbyval(wfunc->wintype,
                         &perfuncstate->resulttypeLen,
                         &perfuncstate->resulttypeByVal);
 
         /*
          * If it's really just a plain aggregate function, we'll emulate the
          * Agg environment for it.
          */
         perfuncstate->plain_agg = wfunc->winagg;
         if (wfunc->winagg)
         {
             WindowStatePerAgg peraggstate;
 
             perfuncstate->aggno = ++aggno;
             peraggstate = &winstate->peragg[aggno];
             initialize_peragg(winstate, wfunc, peraggstate);
             peraggstate->wfuncno = wfuncno;
         }
         else
         {
             WindowObject winobj = makeNode(WindowObjectData);
 
             winobj->winstate = winstate;
             winobj->argstates = wfuncstate->args;
             winobj->localmem = NULL;
             perfuncstate->winobj = winobj;
         }
     }
 
     /* Update numfuncs, numaggs to match number of unique functions found */
     winstate->numfuncs = wfuncno + 1;
     winstate->numaggs = aggno + 1;
 
     /* Set up WindowObject for aggregates, if needed */
     if (winstate->numaggs > 0)
     {
         WindowObject agg_winobj = makeNode(WindowObjectData);
 
         agg_winobj->winstate = winstate;
         agg_winobj->argstates = NIL;
         agg_winobj->localmem = NULL;
         /* make sure markptr = -1 to invalidate. It may not get used */
         agg_winobj->markptr = -1;
         agg_winobj->readptr = -1;
         winstate->agg_winobj = agg_winobj;
     }
 
     /* copy frame options to state node for easy access */
     winstate->frameOptions = node->frameOptions;
 
     /* initialize frame bound offset expressions */
     winstate->startOffset = ExecInitExpr((Expr *) node->startOffset,
                                          (PlanState *) winstate);
     winstate->endOffset = ExecInitExpr((Expr *) node->endOffset,
                                        (PlanState *) winstate);
 
     winstate->all_first = true;
     winstate->partition_spooled = false;
     winstate->more_partitions = false;
 
     return winstate;
 }

void ExecReScanWindowAgg ( WindowAggState * node )

Definition at line 2053 of file nodeWindowAgg.c.

References WindowAggState::agg_row_slot, WindowAggState::all_done, WindowAggState::all_first, PlanState::chgParam, ExprContext::ecxt_aggnulls, ExprContext::ecxt_aggvalues, ExecClearTuple(), ExecReScan(), WindowAggState::first_part_slot, MemSet, NULL, WindowAggState::numfuncs, outerPlan, outerPlanState, ScanState::ps, PlanState::ps_ExprContext, release_partition(), WindowAggState::ss, ScanState::ss_ScanTupleSlot, WindowAggState::temp_slot_1, and WindowAggState::temp_slot_2.

Referenced by ExecReScan().

 {
     PlanState  *outerPlan = outerPlanState(node);
     ExprContext *econtext = node->ss.ps.ps_ExprContext;
 
     node->all_done = false;
     node->all_first = true;
 
     /* release tuplestore et al */
     release_partition(node);
 
     /* release all temp tuples, but especially first_part_slot */
     ExecClearTuple(node->ss.ss_ScanTupleSlot);
     ExecClearTuple(node->first_part_slot);
     ExecClearTuple(node->agg_row_slot);
     ExecClearTuple(node->temp_slot_1);
     ExecClearTuple(node->temp_slot_2);
 
     /* Forget current wfunc values */
     MemSet(econtext->ecxt_aggvalues, 0, sizeof(Datum) * node->numfuncs);
     MemSet(econtext->ecxt_aggnulls, 0, sizeof(bool) * node->numfuncs);
 
     /*
      * if chgParam of subnode is not null then plan will be re-scanned by
      * first ExecProcNode.
      */
     if (outerPlan->chgParam == NULL)
         ExecReScan(outerPlan);
 }

Functions

Function Documentation