nodeWindowAgg.h File Reference

#include "nodes/execnodes.h"

Include dependency graph for nodeWindowAgg.h:

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

Go to the source code of this file.

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

Function Documentation

ExecEndWindowAgg()

void ExecEndWindowAgg

(

WindowAggState *

node

)

Definition at line 2682 of file nodeWindowAgg.c.

{
    PlanState  *outerPlan;
    int         i;
 
    release_partition(node);
 
    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);
}

References WindowStatePerAggData::aggcontext, WindowAggState::aggcontext, ExecEndNode(), i, MemoryContextDelete(), WindowAggState::numaggs, outerPlan, outerPlanState, WindowAggState::partcontext, WindowAggState::peragg, WindowAggState::perfunc, pfree(), and release_partition().

Referenced by ExecEndNode().

ExecInitWindowAgg()

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

Definition at line 2375 of file nodeWindowAgg.c.

{
    WindowAggState *winstate;
    Plan       *outerPlan;
    ExprContext *econtext;
    ExprContext *tmpcontext;
    WindowStatePerFunc perfunc;
    WindowStatePerAgg peragg;
    int         frameOptions = node->frameOptions;
    int         numfuncs,
                wfuncno,
                numaggs,
                aggno;
    TupleDesc   scanDesc;
    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);
 
    /* Only the top-level WindowAgg may have a qual */
    Assert(node->plan.qual == NIL || node->topWindow);
 
    /* Initialize the qual */
    winstate->ss.ps.qual = ExecInitQual(node->plan.qual,
                                        (PlanState *) winstate);
 
    /*
     * Setup the run condition, if we received one from the query planner.
     * When set, this may allow us to move into pass-through mode so that we
     * don't have to perform any further evaluation of WindowFuncs in the
     * current partition or possibly stop returning tuples altogether when all
     * tuples are in the same partition.
     */
    winstate->runcondition = ExecInitQual(node->runCondition,
                                          (PlanState *) winstate);
 
    /*
     * When we're not the top-level WindowAgg node or we are but have a
     * PARTITION BY clause we must move into one of the WINDOWAGG_PASSTHROUGH*
     * modes when the runCondition becomes false.
     */
    winstate->use_pass_through = !node->topWindow || node->partNumCols > 0;
 
    /* remember if we're the top-window or we are below the top-window */
    winstate->top_window = node->topWindow;
 
    /*
     * 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).
     */
    ExecCreateScanSlotFromOuterPlan(estate, &winstate->ss, &TTSOpsMinimalTuple);
    scanDesc = winstate->ss.ss_ScanTupleSlot->tts_tupleDescriptor;
 
    /* the outer tuple isn't the child's tuple, but always a minimal tuple */
    winstate->ss.ps.outeropsset = true;
    winstate->ss.ps.outerops = &TTSOpsMinimalTuple;
    winstate->ss.ps.outeropsfixed = true;
 
    /*
     * tuple table initialization
     */
    winstate->first_part_slot = ExecInitExtraTupleSlot(estate, scanDesc,
                                                       &TTSOpsMinimalTuple);
    winstate->agg_row_slot = ExecInitExtraTupleSlot(estate, scanDesc,
                                                    &TTSOpsMinimalTuple);
    winstate->temp_slot_1 = ExecInitExtraTupleSlot(estate, scanDesc,
                                                   &TTSOpsMinimalTuple);
    winstate->temp_slot_2 = ExecInitExtraTupleSlot(estate, scanDesc,
                                                   &TTSOpsMinimalTuple);
 
    /*
     * create frame head and tail slots only if needed (must create slots in
     * exactly the same cases that update_frameheadpos and update_frametailpos
     * need them)
     */
    winstate->framehead_slot = winstate->frametail_slot = NULL;
 
    if (frameOptions & (FRAMEOPTION_RANGE | FRAMEOPTION_GROUPS))
    {
        if (((frameOptions & FRAMEOPTION_START_CURRENT_ROW) &&
             node->ordNumCols != 0) ||
            (frameOptions & FRAMEOPTION_START_OFFSET))
            winstate->framehead_slot = ExecInitExtraTupleSlot(estate, scanDesc,
                                                              &TTSOpsMinimalTuple);
        if (((frameOptions & FRAMEOPTION_END_CURRENT_ROW) &&
             node->ordNumCols != 0) ||
            (frameOptions & FRAMEOPTION_END_OFFSET))
            winstate->frametail_slot = ExecInitExtraTupleSlot(estate, scanDesc,
                                                              &TTSOpsMinimalTuple);
    }
 
    /*
     * Initialize result slot, type and projection.
     */
    ExecInitResultTupleSlotTL(&winstate->ss.ps, &TTSOpsVirtual);
    ExecAssignProjectionInfo(&winstate->ss.ps, NULL);
 
    /* Set up data for comparing tuples */
    if (node->partNumCols > 0)
        winstate->partEqfunction =
            execTuplesMatchPrepare(scanDesc,
                                   node->partNumCols,
                                   node->partColIdx,
                                   node->partOperators,
                                   node->partCollations,
                                   &winstate->ss.ps);
 
    if (node->ordNumCols > 0)
        winstate->ordEqfunction =
            execTuplesMatchPrepare(scanDesc,
                                   node->ordNumCols,
                                   node->ordColIdx,
                                   node->ordOperators,
                                   node->ordCollations,
                                   &winstate->ss.ps);
 
    /*
     * 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 = object_aclcheck(ProcedureRelationId, wfunc->winfnoid, GetUserId(),
                                    ACL_EXECUTE);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error(aclresult, OBJECT_FUNCTION,
                           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);
        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;
 
            /* It's a real window function, so set up to call it. */
            fmgr_info_cxt(wfunc->winfnoid, &perfuncstate->flinfo,
                          econtext->ecxt_per_query_memory);
            fmgr_info_set_expr((Node *) wfunc, &perfuncstate->flinfo);
        }
    }
 
    /* 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;
    }
 
    /* Set the status to running */
    winstate->status = WINDOWAGG_RUN;
 
    /* copy frame options to state node for easy access */
    winstate->frameOptions = frameOptions;
 
    /* initialize frame bound offset expressions */
    winstate->startOffset = ExecInitExpr((Expr *) node->startOffset,
                                         (PlanState *) winstate);
    winstate->endOffset = ExecInitExpr((Expr *) node->endOffset,
                                       (PlanState *) winstate);
 
    /* Lookup in_range support functions if needed */
    if (OidIsValid(node->startInRangeFunc))
        fmgr_info(node->startInRangeFunc, &winstate->startInRangeFunc);
    if (OidIsValid(node->endInRangeFunc))
        fmgr_info(node->endInRangeFunc, &winstate->endInRangeFunc);
    winstate->inRangeColl = node->inRangeColl;
    winstate->inRangeAsc = node->inRangeAsc;
    winstate->inRangeNullsFirst = node->inRangeNullsFirst;
 
    winstate->all_first = true;
    winstate->partition_spooled = false;
    winstate->more_partitions = false;
 
    return winstate;
}

References ACL_EXECUTE, aclcheck_error(), ACLCHECK_OK, WindowAggState::agg_row_slot, WindowAggState::agg_winobj, WindowAggState::aggcontext, WindowStatePerFuncData::aggno, WindowAggState::all_first, ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, WindowFuncExprState::args, WindowObjectData::argstates, Assert(), contain_volatile_functions(), CurrentMemoryContext, ExprContext::ecxt_aggnulls, ExprContext::ecxt_aggvalues, ExprContext::ecxt_per_query_memory, elog(), WindowAggState::endInRangeFunc, WindowAgg::endInRangeFunc, WindowAggState::endOffset, WindowAgg::endOffset, equal(), ERROR, EXEC_FLAG_BACKWARD, EXEC_FLAG_MARK, ExecAssignExprContext(), ExecAssignProjectionInfo(), ExecCreateScanSlotFromOuterPlan(), ExecInitExpr(), ExecInitExtraTupleSlot(), ExecInitNode(), ExecInitQual(), ExecInitResultTupleSlotTL(), PlanState::ExecProcNode, execTuplesMatchPrepare(), ExecWindowAgg(), WindowAggState::first_part_slot, WindowStatePerFuncData::flinfo, fmgr_info(), fmgr_info_cxt(), fmgr_info_set_expr, WindowAggState::framehead_slot, FRAMEOPTION_END_CURRENT_ROW, FRAMEOPTION_END_OFFSET, FRAMEOPTION_GROUPS, FRAMEOPTION_RANGE, FRAMEOPTION_START_CURRENT_ROW, FRAMEOPTION_START_OFFSET, WindowAggState::frameOptions, WindowAgg::frameOptions, WindowAggState::frametail_slot, WindowAggState::funcs, get_func_name(), get_typlenbyval(), GetUserId(), i, initialize_peragg(), WindowAggState::inRangeAsc, WindowAgg::inRangeAsc, WindowAggState::inRangeColl, WindowAgg::inRangeColl, WindowAggState::inRangeNullsFirst, WindowAgg::inRangeNullsFirst, InvokeFunctionExecuteHook, lfirst, list_length(), WindowObjectData::localmem, makeNode, WindowObjectData::markptr, WindowAggState::more_partitions, NIL, WindowAggState::numaggs, WindowStatePerFuncData::numArguments, WindowAggState::numfuncs, object_aclcheck(), OBJECT_FUNCTION, OidIsValid, WindowAggState::ordEqfunction, WindowAgg::ordNumCols, PlanState::outerops, PlanState::outeropsfixed, PlanState::outeropsset, outerPlan, outerPlanState, palloc0(), WindowAggState::partcontext, WindowAggState::partEqfunction, WindowAggState::partition_spooled, WindowAgg::partNumCols, WindowAggState::peragg, WindowAggState::perfunc, WindowStatePerFuncData::plain_agg, PlanState::plan, WindowAgg::plan, ScanState::ps, PlanState::ps_ExprContext, PlanState::qual, Plan::qual, WindowObjectData::readptr, WindowStatePerFuncData::resulttypeByVal, WindowStatePerFuncData::resulttypeLen, WindowAggState::runcondition, WindowAgg::runCondition, WindowAggState::ss, ScanState::ss_ScanTupleSlot, WindowAggState::startInRangeFunc, WindowAgg::startInRangeFunc, WindowAggState::startOffset, WindowAgg::startOffset, PlanState::state, WindowAggState::status, WindowAggState::temp_slot_1, WindowAggState::temp_slot_2, WindowAggState::tmpcontext, WindowAggState::top_window, WindowAgg::topWindow, TupleTableSlot::tts_tupleDescriptor, TTSOpsMinimalTuple, TTSOpsVirtual, WindowAggState::use_pass_through, WindowStatePerFuncData::wfunc, WindowFuncExprState::wfunc, WindowStatePerAggData::wfuncno, WindowFuncExprState::wfuncno, WindowStatePerFuncData::wfuncstate, WindowStatePerFuncData::winCollation, WINDOWAGG_RUN, WindowFunc::winfnoid, WindowStatePerFuncData::winobj, WindowAgg::winref, WindowFunc::winref, and WindowObjectData::winstate.

Referenced by ExecInitNode().

ExecReScanWindowAgg()

void ExecReScanWindowAgg

(

WindowAggState *

node

)

Definition at line 2709 of file nodeWindowAgg.c.

{
    PlanState  *outerPlan = outerPlanState(node);
    ExprContext *econtext = node->ss.ps.ps_ExprContext;
 
    node->status = WINDOWAGG_RUN;
    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);
    if (node->framehead_slot)
        ExecClearTuple(node->framehead_slot);
    if (node->frametail_slot)
        ExecClearTuple(node->frametail_slot);
 
    /* 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);
}

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

Referenced by ExecReScan().