SQLite

  int regPart;            /* First in a set of registers holding PARTITION BY
                          ** and ORDER BY values for the window */
  Expr *pOwner;           /* Expression object this window is attached to */
  int nBufferCol;         /* Number of columns in buffer table */
  int iArgCol;            /* Offset of first argument for this function */

  int regFirst;
  int regSize;
};

#ifndef SQLITE_OMIT_WINDOWFUNC
void sqlite3WindowDelete(sqlite3*, Window*);
void sqlite3WindowListDelete(sqlite3 *db, Window *p);
Window *sqlite3WindowAlloc(Parse*, int, int, Expr*, int , Expr*);
void sqlite3WindowAttach(Parse*, Expr*, Window*);

    pMWin->regPart = pParse->nMem+1;
    pParse->nMem += nPart;
    sqlite3VdbeAddOp3(v, OP_Null, 0, pMWin->regPart, pMWin->regPart+nPart-1);
  }

  pMWin->regFirst = ++pParse->nMem;
  sqlite3VdbeAddOp2(v, OP_Integer, 1, pMWin->regFirst);
  pMWin->regSize = ++pParse->nMem;
  sqlite3VdbeAddOp2(v, OP_Integer, 0, pMWin->regSize);

  for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
    FuncDef *p = pWin->pFunc;
    if( (p->funcFlags & SQLITE_FUNC_MINMAX) && pWin->eStart!=TK_UNBOUNDED ){
      /* The inline versions of min() and max() require a single ephemeral
      ** table and 3 registers. The registers are used as follows:
      **

  sqlite3VdbeAddOp1(v, OP_ResetSorter, pMWin->iEphCsr);
  sqlite3VdbeAddOp1(v, OP_Return, regFlushPart);
  VdbeComment((v, "end flush_partition subroutine"));

  /* Jump to here to skip over flush_partition */
  sqlite3VdbeJumpHere(v, addrGoto);
}

/* 
** Return true if the entire partition should be cached in the temp
** table before processing.
*/
static int windowCachePartition(Window *pMWin){
  Window *pWin;
  for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
    FuncDef *pFunc = pWin->pFunc;
    if( (pFunc->funcFlags & SQLITE_FUNC_WINDOW_SIZE)
     || (pFunc->zName==nth_valueName)
     || (pFunc->zName==first_valueName)
     || (pFunc->zName==leadName)
     || (pFunc->zName==lagName)
    ){
      return 1;
    }
  }
  return 0;
}

static void windowCodeStep(
  Parse *pParse, 
  Select *p,
  WhereInfo *pWInfo,
  int regGosub, 
  int addrGosub

  int addrGoto;
  int addrIf;
  int addrIfEnd;
  int addrIfStart;
  int addrGosubFlush;
  int addrInteger;
  int addrCacheRewind;
  int addrCacheNext;

  int addrShortcut = 0;

  int bCache = windowCachePartition(pMWin);

  int reg = pParse->nMem+1;
  int regRecord = reg+nSub;
  int regRowid = regRecord+1;

  bCache = 1;

  pParse->nMem += 1 + nSub + 1;

  regFlushPart = ++pParse->nMem;
  regStart = ++pParse->nMem;
  regEnd = ++pParse->nMem;

  ** into an array of registers starting at reg. Assemble them into
  ** a record in register regRecord. TODO: An optimization here? */
  for(k=0; k<nSub; k++){
    sqlite3VdbeAddOp3(v, OP_Column, iSubCsr, k, reg+k);
  }
  sqlite3VdbeAddOp3(v, OP_MakeRecord, reg, nSub, regRecord);

  /* An input row has just been read into an array of registers starting
  ** at reg. If the window has a PARTITION clause, this block generates 
  ** VM code to check if the input row is the start of a new partition.
  ** If so, it does an OP_Gosub to an address to be filled in later. The
  ** address of the OP_Gosub is stored in local variable addrGosubFlush.
  */
  if( pMWin->pPartition ){
    int addr;
    ExprList *pPart = pMWin->pPartition;
    int nPart = pPart->nExpr;
    int regNewPart = reg + pMWin->nBufferCol;
    KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pPart, 0, 0);

    addrIf = sqlite3VdbeAddOp1(v, OP_If, pMWin->regFirst);
    addr = sqlite3VdbeAddOp3(v, OP_Compare, regNewPart, pMWin->regPart, nPart);
    sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO);
    sqlite3VdbeAddOp3(v, OP_Jump, addr+2, addr+4, addr+2);
    VdbeCoverageEqNe(v);
    addrGosubFlush = sqlite3VdbeAddOp1(v, OP_Gosub, regFlushPart);
    VdbeComment((v, "call flush_partition"));
    sqlite3VdbeJumpHere(v, addrIf);
    sqlite3VdbeAddOp3(v, OP_Copy, regNewPart, pMWin->regPart, nPart-1);
  }

  /* Insert the new row into the ephemeral table */
  sqlite3VdbeAddOp2(v, OP_NewRowid, csrWrite, regRowid);
  sqlite3VdbeAddOp3(v, OP_Insert, csrWrite, regRecord, regRowid);
  sqlite3VdbeAddOp2(v, OP_AddImm, pMWin->regSize, 1);


  if( bCache ){
    sqlite3VdbeAddOp2(v, OP_Integer, 0, pMWin->regFirst);
    sqlite3WhereEnd(pWInfo);
    addrInteger = sqlite3VdbeAddOp2(v, OP_Integer, 0, regFlushPart);
    if( pMWin->pPartition ){
      sqlite3VdbeJumpHere(v, addrGosubFlush);
    }
    addrCacheRewind = sqlite3VdbeAddOp1(v, OP_Rewind, csrWrite);
  }else{
    addrIf = sqlite3VdbeAddOp1(v, OP_IfNot, pMWin->regFirst);

  }

  /* This block is run for the first row of each partition */
  regArg = windowInitAccum(pParse, pMWin);

  sqlite3ExprCode(pParse, pMWin->pStart, regStart);
  windowCheckIntValue(pParse, regStart, 0);
  sqlite3ExprCode(pParse, pMWin->pEnd, regEnd);
  windowCheckIntValue(pParse, regEnd, 1);

  if( pMWin->eStart==TK_FOLLOWING || pMWin->eEnd==TK_PRECEDING ){
    int op = ((pMWin->eStart==TK_FOLLOWING) ? OP_Ge : OP_Le);
    int addrGe = sqlite3VdbeAddOp3(v, op, regStart, 0, regEnd);
    windowAggFinal(pParse, pMWin, 0);
    if( bCache ){
      sqlite3VdbeAddOp2(v, OP_Rowid, csrWrite, regRowid);
      sqlite3VdbeAddOp3(v, OP_NotExists, csrCurrent, 0, regRowid);
      windowReturnOneRow(pParse, pMWin, regGosub, addrGosub);
      sqlite3VdbeAddOp2(v, OP_Next, csrWrite, addrCacheRewind+1);
    }else{
      sqlite3VdbeAddOp2(v, OP_Rewind, csrCurrent, 1);
      windowReturnOneRow(pParse, pMWin, regGosub, addrGosub);
      sqlite3VdbeAddOp1(v, OP_ResetSorter, csrCurrent);
    }
    addrShortcut = sqlite3VdbeAddOp0(v, OP_Goto);
    sqlite3VdbeJumpHere(v, addrGe);
  }
  if( pMWin->eStart==TK_FOLLOWING ){
    sqlite3VdbeAddOp3(v, OP_Subtract, regStart, regEnd, regStart);
  }

  sqlite3VdbeAddOp2(v, OP_Rewind, csrStart, 1);   sqlite3VdbeChangeP5(v, 1);
  sqlite3VdbeAddOp2(v, OP_Rewind, csrCurrent, 1); sqlite3VdbeChangeP5(v, 1);
  sqlite3VdbeAddOp2(v, OP_Rewind, csrEnd, 1); sqlite3VdbeChangeP5(v, 1);

  sqlite3VdbeAddOp2(v, OP_Integer, 0, pMWin->regFirst);
  addrGoto = sqlite3VdbeAddOp0(v, OP_Goto);

  /* This block is run for the second and subsequent rows of each partition */
  if( bCache ){
    addrCacheNext = sqlite3VdbeCurrentAddr(v);
  }else{
    sqlite3VdbeJumpHere(v, addrIf);
  }

  if( pMWin->eStart==TK_FOLLOWING ){
    addrIfEnd = sqlite3VdbeAddOp3(v, OP_IfPos, regEnd, 0, 1);
    windowAggFinal(pParse, pMWin, 0);
    sqlite3VdbeAddOp2(v, OP_Next, csrCurrent, sqlite3VdbeCurrentAddr(v)+1);
    windowReturnOneRow(pParse, pMWin, regGosub, addrGosub);
    sqlite3VdbeJumpHere(v, addrIfEnd);

    addrIfStart = sqlite3VdbeAddOp3(v, OP_IfPos, regStart, 0, 1);
    sqlite3VdbeAddOp2(v, OP_Next, csrStart, sqlite3VdbeCurrentAddr(v)+1);
    windowAggStep(pParse, pMWin, csrStart, 1, regArg, pMWin->regSize);
    sqlite3VdbeJumpHere(v, addrIfStart);
  }else
  if( pMWin->eEnd==TK_PRECEDING ){
    addrIfEnd = sqlite3VdbeAddOp3(v, OP_IfPos, regEnd, 0, 1);
    sqlite3VdbeAddOp2(v, OP_Next, csrEnd, sqlite3VdbeCurrentAddr(v)+1);
    windowAggStep(pParse, pMWin, csrEnd, 0, regArg, pMWin->regSize);
    sqlite3VdbeJumpHere(v, addrIfEnd);

    windowAggFinal(pParse, pMWin, 0);
    sqlite3VdbeAddOp2(v, OP_Next, csrCurrent, sqlite3VdbeCurrentAddr(v)+1);
    windowReturnOneRow(pParse, pMWin, regGosub, addrGosub);

    addrIfStart = sqlite3VdbeAddOp3(v, OP_IfPos, regStart, 0, 1);
    sqlite3VdbeAddOp2(v, OP_Next, csrStart, sqlite3VdbeCurrentAddr(v)+1);
    windowAggStep(pParse, pMWin, csrStart, 1, regArg, pMWin->regSize);
    sqlite3VdbeJumpHere(v, addrIfStart);
  }else{
    addrIfEnd = sqlite3VdbeAddOp3(v, OP_IfPos, regEnd, 0, 1);
    windowAggFinal(pParse, pMWin, 0);
    sqlite3VdbeAddOp2(v, OP_Next, csrCurrent, sqlite3VdbeCurrentAddr(v)+1);
    windowReturnOneRow(pParse, pMWin, regGosub, addrGosub);
    addrIfStart = sqlite3VdbeAddOp3(v, OP_IfPos, regStart, 0, 1);
    sqlite3VdbeAddOp2(v, OP_Next, csrStart, sqlite3VdbeCurrentAddr(v)+1);
    windowAggStep(pParse, pMWin, csrStart, 1, regArg, pMWin->regSize);
    sqlite3VdbeJumpHere(v, addrIfStart);
    sqlite3VdbeJumpHere(v, addrIfEnd);
  }

  sqlite3VdbeJumpHere(v, addrGoto);
  if( pMWin->eEnd!=TK_PRECEDING ){
    sqlite3VdbeAddOp2(v, OP_Next, csrEnd, sqlite3VdbeCurrentAddr(v)+1);
    windowAggStep(pParse, pMWin, csrEnd, 0, regArg, pMWin->regSize);
  }

  /* End of the main input loop */
  if( bCache ){
    sqlite3VdbeAddOp2(v, OP_Next, csrWrite, addrCacheNext);
    sqlite3VdbeJumpHere(v, addrCacheRewind); 
  }else{
    if( addrShortcut>0 ) sqlite3VdbeJumpHere(v, addrShortcut);
    sqlite3WhereEnd(pWInfo);
  }

  /* Fall through */

  if( pMWin->pPartition && bCache==0 ){
    addrInteger = sqlite3VdbeAddOp2(v, OP_Integer, 0, regFlushPart);
    sqlite3VdbeJumpHere(v, addrGosubFlush);
  }

  if( pMWin->eStart==TK_FOLLOWING ){
    int addrBreak;
    addrIfEnd = sqlite3VdbeAddOp3(v, OP_IfPos, regEnd, 0, 1);
    sqlite3VdbeAddOp2(v, OP_Next, csrCurrent, sqlite3VdbeCurrentAddr(v)+2);
    addrBreak = sqlite3VdbeAddOp0(v, OP_Goto);
    windowAggFinal(pParse, pMWin, 0);
    windowReturnOneRow(pParse, pMWin, regGosub, addrGosub);
    sqlite3VdbeJumpHere(v, addrIfEnd);

    addrIfStart = sqlite3VdbeAddOp3(v, OP_IfPos, regStart, 0, 1);
    sqlite3VdbeAddOp2(v, OP_Next, csrStart, sqlite3VdbeCurrentAddr(v)+2);
    sqlite3VdbeAddOp0(v, OP_Goto);
    windowAggStep(pParse, pMWin, csrStart, 1, regArg, pMWin->regSize);
    sqlite3VdbeJumpHere(v, addrIfStart);
    sqlite3VdbeJumpHere(v, addrIfStart+2);

    sqlite3VdbeAddOp2(v, OP_Goto, 0, addrIfEnd);
    sqlite3VdbeJumpHere(v, addrBreak);
  }else{
    sqlite3VdbeAddOp2(v, OP_Next, csrCurrent, sqlite3VdbeCurrentAddr(v)+2);
    addrGoto = sqlite3VdbeAddOp0(v, OP_Goto);
    if( pMWin->eEnd==TK_PRECEDING ){
      addrIfEnd = sqlite3VdbeAddOp3(v, OP_IfPos, regEnd, 0, 1);
      sqlite3VdbeAddOp2(v, OP_Next, csrEnd, sqlite3VdbeCurrentAddr(v)+1);
      windowAggStep(pParse, pMWin, csrEnd, 0, regArg, pMWin->regSize);
      sqlite3VdbeJumpHere(v, addrIfEnd);
      windowAggFinal(pParse, pMWin, 0);
      windowReturnOneRow(pParse, pMWin, regGosub, addrGosub);
    }else{
      windowAggFinal(pParse, pMWin, 0);
      windowReturnOneRow(pParse, pMWin, regGosub, addrGosub);
      addrIfStart = sqlite3VdbeAddOp3(v, OP_IfPos, regStart, 0, 1);
      sqlite3VdbeAddOp2(v, OP_Next, csrStart, sqlite3VdbeCurrentAddr(v)+1);
      windowAggStep(pParse, pMWin, csrStart, 1, regArg, pMWin->regSize);
      sqlite3VdbeJumpHere(v, addrIfStart);
      sqlite3VdbeAddOp2(v, OP_Goto, 0, addrGoto-1);
    }
    sqlite3VdbeJumpHere(v, addrGoto);
  }


  if( bCache && addrShortcut>0 ) sqlite3VdbeJumpHere(v, addrShortcut);
  sqlite3VdbeAddOp1(v, OP_ResetSorter, csrCurrent);
  sqlite3VdbeAddOp2(v, OP_Integer, 0, pMWin->regSize);
  if( bCache==0 ) sqlite3VdbeAddOp2(v, OP_Integer, 1, pMWin->regFirst);
  if( pMWin->pPartition ){
    sqlite3VdbeChangeP1(v, addrInteger, sqlite3VdbeCurrentAddr(v));
    sqlite3VdbeAddOp1(v, OP_Return, regFlushPart);
  }
}

/*

  ** windowCodeDefaultStep() is the only one of the three functions that
  ** does not cache each partition in a temp table before beginning to
  ** return rows.
  */
  if( pMWin->eType==TK_ROWS 
   && (pMWin->eStart!=TK_UNBOUNDED||pMWin->eEnd!=TK_CURRENT||!pMWin->pOrderBy)
  ){















    if( (pMWin->eStart!=TK_PRECEDING && pMWin->eStart!=TK_FOLLOWING)
     || (pMWin->eEnd!=TK_FOLLOWING && pMWin->eEnd!=TK_PRECEDING) 
    ){
      VdbeModuleComment((pParse->pVdbe, "Begin RowExprStep()"));
      windowCodeRowExprStep(pParse, p, pWInfo, regGosub, addrGosub);
      VdbeModuleComment((pParse->pVdbe, "End RowExprStep()"));
    }else{
      VdbeModuleComment((pParse->pVdbe, "Begin windowCodeStep()"));
      windowCodeStep(pParse, p, pWInfo, regGosub, addrGosub);

## 2018 May 19
#
# The author disclaims copyright to this source code.  In place of
# a legal notice, here is a blessing:
#
#    May you do good and not evil.
#    May you find forgiveness for yourself and forgive others.
#    May you share freely, never taking more than you give.