windowapi.h File Reference

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

Go to the source code of this file.

Macros
#define	WINDOW_SEEK_CURRENT   0
#define	WINDOW_SEEK_HEAD   1
#define	WINDOW_SEEK_TAIL   2
#define	PG_WINDOW_OBJECT()   ((WindowObject) fcinfo->context)
#define	WindowObjectIsValid(winobj)    ((winobj) != NULL && IsA(winobj, WindowObjectData))

Typedefs
typedef struct WindowObjectData *	WindowObject

Functions
void *	WinGetPartitionLocalMemory (WindowObject winobj, Size sz)
int64	WinGetCurrentPosition (WindowObject winobj)
int64	WinGetPartitionRowCount (WindowObject winobj)
void	WinSetMarkPosition (WindowObject winobj, int64 markpos)
bool	WinRowsArePeers (WindowObject winobj, int64 pos1, int64 pos2)
Datum	WinGetFuncArgInPartition (WindowObject winobj, int argno, int relpos, int seektype, bool set_mark, bool *isnull, bool *isout)
Datum	WinGetFuncArgInFrame (WindowObject winobj, int argno, int relpos, int seektype, bool set_mark, bool *isnull, bool *isout)
Datum	WinGetFuncArgCurrent (WindowObject winobj, int argno, bool *isnull)

Macro Definition Documentation

PG_WINDOW_OBJECT

#define PG_WINDOW_OBJECT

(

)

((WindowObject) fcinfo->context)

Definition at line 39 of file windowapi.h.

WINDOW_SEEK_CURRENT

#define WINDOW_SEEK_CURRENT   0

Definition at line 32 of file windowapi.h.

WINDOW_SEEK_HEAD

#define WINDOW_SEEK_HEAD   1

Definition at line 33 of file windowapi.h.

WINDOW_SEEK_TAIL

#define WINDOW_SEEK_TAIL   2

Definition at line 34 of file windowapi.h.

WindowObjectIsValid

#define WindowObjectIsValid

(

winobj

)

((winobj) != NULL && IsA(winobj, WindowObjectData))

Definition at line 41 of file windowapi.h.

Typedef Documentation

WindowObject

typedef struct WindowObjectData* WindowObject

Definition at line 37 of file windowapi.h.

Function Documentation

WinGetCurrentPosition()

int64 WinGetCurrentPosition

(

WindowObject

winobj

)

Definition at line 3196 of file nodeWindowAgg.c.

{
    Assert(WindowObjectIsValid(winobj));
    return winobj->winstate->currentpos;
}

References Assert(), WindowAggState::currentpos, WindowObjectIsValid, and WindowObjectData::winstate.

Referenced by rank_up(), window_cume_dist(), window_percent_rank(), window_rank(), and window_row_number().

WinGetFuncArgCurrent()

Datum WinGetFuncArgCurrent	(	WindowObject	winobj,
		int	argno,
		bool *	isnull
	)

Definition at line 3604 of file nodeWindowAgg.c.

{
    WindowAggState *winstate;
    ExprContext *econtext;
 
    Assert(WindowObjectIsValid(winobj));
    winstate = winobj->winstate;
 
    econtext = winstate->ss.ps.ps_ExprContext;
 
    econtext->ecxt_outertuple = winstate->ss.ss_ScanTupleSlot;
    return ExecEvalExpr((ExprState *) list_nth(winobj->argstates, argno),
                        econtext, isnull);
}

References WindowObjectData::argstates, Assert(), ExprContext::ecxt_outertuple, ExecEvalExpr(), list_nth(), ScanState::ps, PlanState::ps_ExprContext, WindowAggState::ss, ScanState::ss_ScanTupleSlot, WindowObjectIsValid, and WindowObjectData::winstate.

Referenced by leadlag_common(), window_nth_value(), and window_ntile().

WinGetFuncArgInFrame()

Datum WinGetFuncArgInFrame	(	WindowObject	winobj,
		int	argno,
		int	relpos,
		int	seektype,
		bool	set_mark,
		bool *	isnull,
		bool *	isout
	)

Definition at line 3409 of file nodeWindowAgg.c.

{
    WindowAggState *winstate;
    ExprContext *econtext;
    TupleTableSlot *slot;
    int64       abs_pos;
    int64       mark_pos;
 
    Assert(WindowObjectIsValid(winobj));
    winstate = winobj->winstate;
    econtext = winstate->ss.ps.ps_ExprContext;
    slot = winstate->temp_slot_1;
 
    switch (seektype)
    {
        case WINDOW_SEEK_CURRENT:
            elog(ERROR, "WINDOW_SEEK_CURRENT is not supported for WinGetFuncArgInFrame");
            abs_pos = mark_pos = 0; /* keep compiler quiet */
            break;
        case WINDOW_SEEK_HEAD:
            /* rejecting relpos < 0 is easy and simplifies code below */
            if (relpos < 0)
                goto out_of_frame;
            update_frameheadpos(winstate);
            abs_pos = winstate->frameheadpos + relpos;
            mark_pos = abs_pos;
 
            /*
             * Account for exclusion option if one is active, but advance only
             * abs_pos not mark_pos.  This prevents changes of the current
             * row's peer group from resulting in trying to fetch a row before
             * some previous mark position.
             *
             * Note that in some corner cases such as current row being
             * outside frame, these calculations are theoretically too simple,
             * but it doesn't matter because we'll end up deciding the row is
             * out of frame.  We do not attempt to avoid fetching rows past
             * end of frame; that would happen in some cases anyway.
             */
            switch (winstate->frameOptions & FRAMEOPTION_EXCLUSION)
            {
                case 0:
                    /* no adjustment needed */
                    break;
                case FRAMEOPTION_EXCLUDE_CURRENT_ROW:
                    if (abs_pos >= winstate->currentpos &&
                        winstate->currentpos >= winstate->frameheadpos)
                        abs_pos++;
                    break;
                case FRAMEOPTION_EXCLUDE_GROUP:
                    update_grouptailpos(winstate);
                    if (abs_pos >= winstate->groupheadpos &&
                        winstate->grouptailpos > winstate->frameheadpos)
                    {
                        int64       overlapstart = Max(winstate->groupheadpos,
                                                       winstate->frameheadpos);
 
                        abs_pos += winstate->grouptailpos - overlapstart;
                    }
                    break;
                case FRAMEOPTION_EXCLUDE_TIES:
                    update_grouptailpos(winstate);
                    if (abs_pos >= winstate->groupheadpos &&
                        winstate->grouptailpos > winstate->frameheadpos)
                    {
                        int64       overlapstart = Max(winstate->groupheadpos,
                                                       winstate->frameheadpos);
 
                        if (abs_pos == overlapstart)
                            abs_pos = winstate->currentpos;
                        else
                            abs_pos += winstate->grouptailpos - overlapstart - 1;
                    }
                    break;
                default:
                    elog(ERROR, "unrecognized frame option state: 0x%x",
                         winstate->frameOptions);
                    break;
            }
            break;
        case WINDOW_SEEK_TAIL:
            /* rejecting relpos > 0 is easy and simplifies code below */
            if (relpos > 0)
                goto out_of_frame;
            update_frametailpos(winstate);
            abs_pos = winstate->frametailpos - 1 + relpos;
 
            /*
             * Account for exclusion option if one is active.  If there is no
             * exclusion, we can safely set the mark at the accessed row.  But
             * if there is, we can only mark the frame start, because we can't
             * be sure how far back in the frame the exclusion might cause us
             * to fetch in future.  Furthermore, we have to actually check
             * against frameheadpos here, since it's unsafe to try to fetch a
             * row before frame start if the mark might be there already.
             */
            switch (winstate->frameOptions & FRAMEOPTION_EXCLUSION)
            {
                case 0:
                    /* no adjustment needed */
                    mark_pos = abs_pos;
                    break;
                case FRAMEOPTION_EXCLUDE_CURRENT_ROW:
                    if (abs_pos <= winstate->currentpos &&
                        winstate->currentpos < winstate->frametailpos)
                        abs_pos--;
                    update_frameheadpos(winstate);
                    if (abs_pos < winstate->frameheadpos)
                        goto out_of_frame;
                    mark_pos = winstate->frameheadpos;
                    break;
                case FRAMEOPTION_EXCLUDE_GROUP:
                    update_grouptailpos(winstate);
                    if (abs_pos < winstate->grouptailpos &&
                        winstate->groupheadpos < winstate->frametailpos)
                    {
                        int64       overlapend = Min(winstate->grouptailpos,
                                                     winstate->frametailpos);
 
                        abs_pos -= overlapend - winstate->groupheadpos;
                    }
                    update_frameheadpos(winstate);
                    if (abs_pos < winstate->frameheadpos)
                        goto out_of_frame;
                    mark_pos = winstate->frameheadpos;
                    break;
                case FRAMEOPTION_EXCLUDE_TIES:
                    update_grouptailpos(winstate);
                    if (abs_pos < winstate->grouptailpos &&
                        winstate->groupheadpos < winstate->frametailpos)
                    {
                        int64       overlapend = Min(winstate->grouptailpos,
                                                     winstate->frametailpos);
 
                        if (abs_pos == overlapend - 1)
                            abs_pos = winstate->currentpos;
                        else
                            abs_pos -= overlapend - 1 - winstate->groupheadpos;
                    }
                    update_frameheadpos(winstate);
                    if (abs_pos < winstate->frameheadpos)
                        goto out_of_frame;
                    mark_pos = winstate->frameheadpos;
                    break;
                default:
                    elog(ERROR, "unrecognized frame option state: 0x%x",
                         winstate->frameOptions);
                    mark_pos = 0;   /* keep compiler quiet */
                    break;
            }
            break;
        default:
            elog(ERROR, "unrecognized window seek type: %d", seektype);
            abs_pos = mark_pos = 0; /* keep compiler quiet */
            break;
    }
 
    if (!window_gettupleslot(winobj, abs_pos, slot))
        goto out_of_frame;
 
    /* The code above does not detect all out-of-frame cases, so check */
    if (row_is_in_frame(winstate, abs_pos, slot) <= 0)
        goto out_of_frame;
 
    if (isout)
        *isout = false;
    if (set_mark)
        WinSetMarkPosition(winobj, mark_pos);
    econtext->ecxt_outertuple = slot;
    return ExecEvalExpr((ExprState *) list_nth(winobj->argstates, argno),
                        econtext, isnull);
 
out_of_frame:
    if (isout)
        *isout = true;
    *isnull = true;
    return (Datum) 0;
}

References WindowObjectData::argstates, Assert(), WindowAggState::currentpos, ExprContext::ecxt_outertuple, elog(), ERROR, ExecEvalExpr(), WindowAggState::frameheadpos, FRAMEOPTION_EXCLUDE_CURRENT_ROW, FRAMEOPTION_EXCLUDE_GROUP, FRAMEOPTION_EXCLUDE_TIES, FRAMEOPTION_EXCLUSION, WindowAggState::frameOptions, WindowAggState::frametailpos, WindowAggState::groupheadpos, WindowAggState::grouptailpos, list_nth(), Max, Min, ScanState::ps, PlanState::ps_ExprContext, row_is_in_frame(), WindowAggState::ss, WindowAggState::temp_slot_1, update_frameheadpos(), update_frametailpos(), update_grouptailpos(), window_gettupleslot(), WINDOW_SEEK_CURRENT, WINDOW_SEEK_HEAD, WINDOW_SEEK_TAIL, WindowObjectIsValid, WinSetMarkPosition(), and WindowObjectData::winstate.

Referenced by window_first_value(), window_last_value(), and window_nth_value().

WinGetFuncArgInPartition()

Datum WinGetFuncArgInPartition	(	WindowObject	winobj,
		int	argno,
		int	relpos,
		int	seektype,
		bool	set_mark,
		bool *	isnull,
		bool *	isout
	)

Definition at line 3321 of file nodeWindowAgg.c.

{
    WindowAggState *winstate;
    ExprContext *econtext;
    TupleTableSlot *slot;
    bool        gottuple;
    int64       abs_pos;
 
    Assert(WindowObjectIsValid(winobj));
    winstate = winobj->winstate;
    econtext = winstate->ss.ps.ps_ExprContext;
    slot = winstate->temp_slot_1;
 
    switch (seektype)
    {
        case WINDOW_SEEK_CURRENT:
            abs_pos = winstate->currentpos + relpos;
            break;
        case WINDOW_SEEK_HEAD:
            abs_pos = relpos;
            break;
        case WINDOW_SEEK_TAIL:
            spool_tuples(winstate, -1);
            abs_pos = winstate->spooled_rows - 1 + relpos;
            break;
        default:
            elog(ERROR, "unrecognized window seek type: %d", seektype);
            abs_pos = 0;        /* keep compiler quiet */
            break;
    }
 
    gottuple = window_gettupleslot(winobj, abs_pos, slot);
 
    if (!gottuple)
    {
        if (isout)
            *isout = true;
        *isnull = true;
        return (Datum) 0;
    }
    else
    {
        if (isout)
            *isout = false;
        if (set_mark)
            WinSetMarkPosition(winobj, abs_pos);
        econtext->ecxt_outertuple = slot;
        return ExecEvalExpr((ExprState *) list_nth(winobj->argstates, argno),
                            econtext, isnull);
    }
}

References WindowObjectData::argstates, Assert(), WindowAggState::currentpos, ExprContext::ecxt_outertuple, elog(), ERROR, ExecEvalExpr(), list_nth(), ScanState::ps, PlanState::ps_ExprContext, spool_tuples(), WindowAggState::spooled_rows, WindowAggState::ss, WindowAggState::temp_slot_1, window_gettupleslot(), WINDOW_SEEK_CURRENT, WINDOW_SEEK_HEAD, WINDOW_SEEK_TAIL, WindowObjectIsValid, WinSetMarkPosition(), and WindowObjectData::winstate.

Referenced by leadlag_common().

WinGetPartitionLocalMemory()

void* WinGetPartitionLocalMemory	(	WindowObject	winobj,
		Size	sz
	)

Definition at line 3181 of file nodeWindowAgg.c.

{
    Assert(WindowObjectIsValid(winobj));
    if (winobj->localmem == NULL)
        winobj->localmem =
            MemoryContextAllocZero(winobj->winstate->partcontext, sz);
    return winobj->localmem;
}

References Assert(), WindowObjectData::localmem, MemoryContextAllocZero(), WindowAggState::partcontext, WindowObjectIsValid, and WindowObjectData::winstate.

Referenced by rank_up(), window_cume_dist(), window_dense_rank(), window_ntile(), window_percent_rank(), and window_rank().

WinGetPartitionRowCount()

int64 WinGetPartitionRowCount

(

WindowObject

winobj

)

Definition at line 3211 of file nodeWindowAgg.c.

{
    Assert(WindowObjectIsValid(winobj));
    spool_tuples(winobj->winstate, -1);
    return winobj->winstate->spooled_rows;
}

References Assert(), spool_tuples(), WindowAggState::spooled_rows, WindowObjectIsValid, and WindowObjectData::winstate.

Referenced by window_cume_dist(), window_ntile(), and window_percent_rank().

WinRowsArePeers()

bool WinRowsArePeers	(	WindowObject	winobj,
		int64	pos1,
		int64	pos2
	)

Definition at line 3264 of file nodeWindowAgg.c.

{
    WindowAggState *winstate;
    WindowAgg  *node;
    TupleTableSlot *slot1;
    TupleTableSlot *slot2;
    bool        res;
 
    Assert(WindowObjectIsValid(winobj));
    winstate = winobj->winstate;
    node = (WindowAgg *) winstate->ss.ps.plan;
 
    /* If no ORDER BY, all rows are peers; don't bother to fetch them */
    if (node->ordNumCols == 0)
        return true;
 
    /*
     * Note: OK to use temp_slot_2 here because we aren't calling any
     * frame-related functions (those tend to clobber temp_slot_2).
     */
    slot1 = winstate->temp_slot_1;
    slot2 = winstate->temp_slot_2;
 
    if (!window_gettupleslot(winobj, pos1, slot1))
        elog(ERROR, "specified position is out of window: " INT64_FORMAT,
             pos1);
    if (!window_gettupleslot(winobj, pos2, slot2))
        elog(ERROR, "specified position is out of window: " INT64_FORMAT,
             pos2);
 
    res = are_peers(winstate, slot1, slot2);
 
    ExecClearTuple(slot1);
    ExecClearTuple(slot2);
 
    return res;
}

References are_peers(), Assert(), elog(), ERROR, ExecClearTuple(), if(), INT64_FORMAT, WindowAgg::ordNumCols, PlanState::plan, ScanState::ps, res, WindowAggState::ss, WindowAggState::temp_slot_1, WindowAggState::temp_slot_2, window_gettupleslot(), WindowObjectIsValid, and WindowObjectData::winstate.

Referenced by rank_up(), and window_cume_dist().

WinSetMarkPosition()

void WinSetMarkPosition	(	WindowObject	winobj,
		int64	markpos
	)

Definition at line 3229 of file nodeWindowAgg.c.

{
    WindowAggState *winstate;
 
    Assert(WindowObjectIsValid(winobj));
    winstate = winobj->winstate;
 
    if (markpos < winobj->markpos)
        elog(ERROR, "cannot move WindowObject's mark position backward");
    tuplestore_select_read_pointer(winstate->buffer, winobj->markptr);
    if (markpos > winobj->markpos)
    {
        tuplestore_skiptuples(winstate->buffer,
                              markpos - winobj->markpos,
                              true);
        winobj->markpos = markpos;
    }
    tuplestore_select_read_pointer(winstate->buffer, winobj->readptr);
    if (markpos > winobj->seekpos)
    {
        tuplestore_skiptuples(winstate->buffer,
                              markpos - winobj->seekpos,
                              true);
        winobj->seekpos = markpos;
    }
}

References Assert(), WindowAggState::buffer, elog(), ERROR, WindowObjectData::markpos, WindowObjectData::markptr, WindowObjectData::readptr, WindowObjectData::seekpos, tuplestore_select_read_pointer(), tuplestore_skiptuples(), WindowObjectIsValid, and WindowObjectData::winstate.

Referenced by eval_windowaggregates(), rank_up(), window_row_number(), WinGetFuncArgInFrame(), and WinGetFuncArgInPartition().