windowapi.h File Reference

#include "fmgr.h"

Include dependency graph for windowapi.h:

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	WinCheckAndInitializeNullTreatment (WindowObject winobj, bool allowNullTreatment, FunctionCallInfo fcinfo)
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 41 of file windowapi.h.

WINDOW_SEEK_CURRENT

#define WINDOW_SEEK_CURRENT   0

Definition at line 34 of file windowapi.h.

WINDOW_SEEK_HEAD

#define WINDOW_SEEK_HEAD   1

Definition at line 35 of file windowapi.h.

WINDOW_SEEK_TAIL

#define WINDOW_SEEK_TAIL   2

Definition at line 36 of file windowapi.h.

WindowObjectIsValid

#define WindowObjectIsValid

(

winobj

)

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

Definition at line 43 of file windowapi.h.

Typedef Documentation

WindowObject

typedef struct WindowObjectData* WindowObject

Definition at line 39 of file windowapi.h.

Function Documentation

WinCheckAndInitializeNullTreatment()

void WinCheckAndInitializeNullTreatment ( WindowObject  winobj, bool  allowNullTreatment, FunctionCallInfo  fcinfo  )

extern

Definition at line 3651 of file nodeWindowAgg.c.

{
    Assert(WindowObjectIsValid(winobj));
    if (winobj->ignore_nulls != NO_NULLTREATMENT && !allowNullTreatment)
    {
        const char *funcname = get_func_name(fcinfo->flinfo->fn_oid);
 
        if (!funcname)
            elog(ERROR, "could not get function name");
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("function %s does not allow RESPECT/IGNORE NULLS",
                        funcname)));
    }
    else if (winobj->ignore_nulls == PARSER_IGNORE_NULLS)
        winobj->ignore_nulls = IGNORE_NULLS;
}

References Assert, elog, ereport, errcode(), errmsg, ERROR, fb(), FunctionCallInfoBaseData::flinfo, FmgrInfo::fn_oid, funcname, get_func_name(), WindowObjectData::ignore_nulls, IGNORE_NULLS, NO_NULLTREATMENT, PARSER_IGNORE_NULLS, and WindowObjectIsValid.

Referenced by leadlag_common(), window_cume_dist(), window_dense_rank(), window_first_value(), window_last_value(), window_nth_value(), window_ntile(), window_percent_rank(), window_rank(), and window_row_number().

WinGetCurrentPosition()

int64 WinGetCurrentPosition ( WindowObject  winobj )

extern

Definition at line 3699 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  )

extern

Definition at line 4196 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(), fb(), 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  )

extern

Definition at line 3997 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;
 
    if (winobj->ignore_nulls == IGNORE_NULLS)
        return ignorenulls_getfuncarginframe(winobj, argno, relpos, seektype,
                                             set_mark, isnull, isout);
 
    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(winobj, abs_pos, slot, false) <= 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(), fb(), WindowAggState::frameheadpos, FRAMEOPTION_EXCLUDE_CURRENT_ROW, FRAMEOPTION_EXCLUDE_GROUP, FRAMEOPTION_EXCLUDE_TIES, FRAMEOPTION_EXCLUSION, WindowAggState::frameOptions, WindowAggState::frametailpos, WindowAggState::groupheadpos, WindowAggState::grouptailpos, WindowObjectData::ignore_nulls, IGNORE_NULLS, ignorenulls_getfuncarginframe(), 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  )

extern

Definition at line 3824 of file nodeWindowAgg.c.

{
    WindowAggState *winstate;
    int64       abs_pos;
    int64       mark_pos;
    Datum       datum;
    bool        null_treatment;
    int         notnull_offset;
    int         notnull_relpos;
    int         forward;
    bool        myisout;
    bool        got_datum;
 
    Assert(WindowObjectIsValid(winobj));
    winstate = winobj->winstate;
 
    null_treatment = (winobj->ignore_nulls == IGNORE_NULLS && relpos != 0);
 
    switch (seektype)
    {
        case WINDOW_SEEK_CURRENT:
            if (null_treatment)
                abs_pos = winstate->currentpos;
            else
                abs_pos = winstate->currentpos + relpos;
            break;
        case WINDOW_SEEK_HEAD:
            if (null_treatment)
                abs_pos = 0;
            else
                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;
    }
 
    /* Easy case if IGNORE NULLS is not specified */
    if (!null_treatment)
    {
        /* get tuple and evaluate in partition */
        datum = gettuple_eval_partition(winobj, argno,
                                        abs_pos, isnull, &myisout);
        if (!myisout && set_mark)
            WinSetMarkPosition(winobj, abs_pos);
        if (isout)
            *isout = myisout;
        return datum;
    }
 
    /* Prepare for loop */
    notnull_offset = 0;
    notnull_relpos = abs(relpos);
    forward = relpos > 0 ? 1 : -1;
    myisout = false;
    got_datum = false;
    datum = 0;
 
    /*
     * IGNORE NULLS + WINDOW_SEEK_CURRENT + relpos > 0 case, we would fetch
     * beyond the current row + relpos to find out the target row. If we mark
     * at abs_pos, next call to WinGetFuncArgInPartition or
     * WinGetFuncArgInFrame (in case when a window function have multiple
     * args) could fail with "cannot fetch row before WindowObject's mark
     * position". So keep the mark position at currentpos.
     */
    if (seektype == WINDOW_SEEK_CURRENT && relpos > 0)
        mark_pos = winstate->currentpos;
    else
    {
        /*
         * For other cases we have no idea what position of row callers would
         * fetch next time. Also for relpos < 0 case (we go backward), we
         * cannot set mark either. For those cases we always set mark at 0.
         */
        mark_pos = 0;
    }
 
    /*
     * Get the next nonnull value in the partition, moving forward or backward
     * until we find a value or reach the partition's end.  We cache the
     * nullness status because we may repeat this process many times.
     */
    do
    {
        int         nn_info;    /* NOT NULL status */
 
        abs_pos += forward;
        if (abs_pos < 0)        /* clearly out of partition */
            break;
 
        /* check NOT NULL cached info */
        nn_info = get_notnull_info(winobj, abs_pos, argno);
        if (nn_info == NN_NOTNULL)  /* this row is known to be NOT NULL */
            notnull_offset++;
        else if (nn_info == NN_NULL)    /* this row is known to be NULL */
            continue;           /* keep on moving forward or backward */
        else                    /* need to check NULL or not */
        {
            /*
             * NOT NULL info does not exist yet.  Get tuple and evaluate func
             * arg in partition. Keep the return value in case this row is the
             * target; re-evaluating a volatile argument could give a
             * different nullness status.
             */
            datum = gettuple_eval_partition(winobj, argno,
                                            abs_pos, isnull, &myisout);
            if (myisout)        /* out of partition? */
                break;
            if (!*isnull)
            {
                notnull_offset++;
                if (notnull_offset >= notnull_relpos)
                    got_datum = true;
            }
            /* record the row status */
            put_notnull_info(winobj, abs_pos, argno, *isnull);
        }
    } while (notnull_offset < notnull_relpos);
 
    /* get tuple and evaluate func arg in partition */
    if (!got_datum)
        datum = gettuple_eval_partition(winobj, argno,
                                        abs_pos, isnull, &myisout);
    if (!myisout && set_mark)
        WinSetMarkPosition(winobj, mark_pos);
    if (isout)
        *isout = myisout;
 
    return datum;
}

References Assert, WindowAggState::currentpos, elog, ERROR, fb(), get_notnull_info(), gettuple_eval_partition(), WindowObjectData::ignore_nulls, IGNORE_NULLS, NN_NOTNULL, NN_NULL, put_notnull_info(), spool_tuples(), WindowAggState::spooled_rows, 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  )

extern

Definition at line 3684 of file nodeWindowAgg.c.

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

References Assert, fb(), 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 )

extern

Definition at line 3714 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  )

extern

Definition at line 3767 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(), fb(), INT64_FORMAT, WindowAgg::ordNumCols, PlanState::plan, ScanState::ps, 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  )

extern

Definition at line 3732 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, fb(), WindowObjectData::markpos, WindowObjectData::markptr, WindowObjectData::readptr, WindowObjectData::seekpos, tuplestore_select_read_pointer(), tuplestore_skiptuples(), WindowObjectIsValid, and WindowObjectData::winstate.

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