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 2533 of file nodeWindowAgg.c.

References WindowAggState::agg_row_slot, WindowStatePerAggData::aggcontext, WindowAggState::aggcontext, ExecClearTuple(), ExecEndNode(), ExecFreeExprContext(), WindowAggState::first_part_slot, WindowAggState::framehead_slot, WindowAggState::frametail_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);
    if (node->framehead_slot)
        ExecClearTuple(node->framehead_slot);
    if (node->frametail_slot)
        ExecClearTuple(node->frametail_slot);

    /*
     * 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);
}

ExecInitWindowAgg()

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

Definition at line 2249 of file nodeWindowAgg.c.

References ACL_EXECUTE, aclcheck_error(), ACLCHECK_OK, WindowAggState::agg_row_slot, WindowAggState::agg_winobj, WindowAggState::aggcontext, WindowStatePerFuncData::aggno, 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, WindowAgg::endInRangeFunc, WindowAgg::endOffset, equal(), ERROR, EXEC_FLAG_BACKWARD, EXEC_FLAG_MARK, ExecAssignExprContext(), ExecAssignProjectionInfo(), ExecCreateScanSlotFromOuterPlan(), ExecInitExpr(), ExecInitExtraTupleSlot(), ExecInitNode(), 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, WindowAgg::frameOptions, WindowAggState::frameOptions, WindowAggState::frametail_slot, WindowAggState::funcs, get_func_name(), get_typlenbyval(), GetUserId(), i, initialize_peragg(), WindowFunc::inputcollid, WindowAgg::inRangeAsc, WindowAgg::inRangeColl, WindowAgg::inRangeNullsFirst, InvokeFunctionExecuteHook, lfirst, list_length(), WindowObjectData::localmem, makeNode, WindowObjectData::markptr, NIL, WindowAggState::numaggs, WindowStatePerFuncData::numArguments, WindowAggState::numfuncs, OBJECT_FUNCTION, OidIsValid, WindowAgg::ordColIdx, WindowAgg::ordCollations, WindowAggState::ordEqfunction, WindowAgg::ordNumCols, WindowAgg::ordOperators, PlanState::outerops, PlanState::outeropsfixed, PlanState::outeropsset, outerPlan, outerPlanState, palloc0(), WindowAgg::partColIdx, WindowAgg::partCollations, WindowAggState::partcontext, WindowAggState::partEqfunction, WindowAgg::partNumCols, WindowAgg::partOperators, WindowAggState::peragg, WindowAggState::perfunc, pg_proc_aclcheck(), WindowStatePerFuncData::plain_agg, WindowAgg::plan, PlanState::plan, ScanState::ps, PlanState::ps_ExprContext, Plan::qual, PlanState::qual, WindowObjectData::readptr, WindowStatePerFuncData::resulttypeByVal, WindowStatePerFuncData::resulttypeLen, WindowAggState::ss, ScanState::ss_ScanTupleSlot, WindowAgg::startInRangeFunc, WindowAgg::startOffset, WindowAggState::startOffset, PlanState::state, WindowAggState::temp_slot_1, WindowAggState::temp_slot_2, WindowAggState::tmpcontext, TupleTableSlot::tts_tupleDescriptor, TTSOpsMinimalTuple, TTSOpsVirtual, WindowStatePerFuncData::wfunc, WindowFuncExprState::wfunc, WindowStatePerAggData::wfuncno, WindowFuncExprState::wfuncno, WindowStatePerFuncData::wfuncstate, WindowFunc::winagg, WindowStatePerFuncData::winCollation, WindowFunc::winfnoid, WindowStatePerFuncData::winobj, WindowFunc::winref, WindowAgg::winref, WindowObjectData::winstate, and WindowFunc::wintype.

Referenced by ExecInitNode().

{
    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);

    /*
     * 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).
     */
    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 = pg_proc_aclcheck(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;
    }

    /* 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;
}

ExecReScanWindowAgg()

void ExecReScanWindowAgg

(

WindowAggState *

node

)

Definition at line 2577 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, WindowAggState::framehead_slot, WindowAggState::frametail_slot, MemSet, 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);
    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);
}