SQLite

  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 ephemeral
** table before processing any rows.
*/
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;
}

typedef struct WindowCodeArg WindowCodeArg;
struct WindowCodeArg {
  Parse *pParse;
  Window *pMWin;
  Vdbe *pVdbe;
  int regGosub;
  int addrGosub;
  int regArg;
};

#define WINDOW_RETURN_ROW 1
#define WINDOW_AGGINVERSE 2
#define WINDOW_AGGSTEP    3

static int windowCodeOp(
 WindowCodeArg *p,
 int op,
 int csr,
 int regCountdown,
 int jumpOnEof
){
  int ret = 0;
  Vdbe *v = p->pVdbe;
  int addrIf = 0; 

  if( regCountdown>0 ){
    addrIf = sqlite3VdbeAddOp3(v, OP_IfPos, regCountdown, 0, 1);
  }

  if( jumpOnEof ){
    sqlite3VdbeAddOp2(v, OP_Next, csr, sqlite3VdbeCurrentAddr(v)+2);
    ret = sqlite3VdbeAddOp0(v, OP_Goto);
  }else{
    sqlite3VdbeAddOp2(v, OP_Next, csr, sqlite3VdbeCurrentAddr(v)+1);
  }

  switch( op ){
    case WINDOW_RETURN_ROW:
      windowAggFinal(p->pParse, p->pMWin, 0);
      windowReturnOneRow(p->pParse, p->pMWin, p->regGosub, p->addrGosub);
      break;

    case WINDOW_AGGINVERSE:
      windowAggStep(p->pParse, p->pMWin, csr, 1, p->regArg, p->pMWin->regSize);
      break;

    case WINDOW_AGGSTEP:
      windowAggStep(p->pParse, p->pMWin, csr, 0, p->regArg, p->pMWin->regSize);
      break;
  }

  if( ret ){
    sqlite3VdbeJumpHere(v, ret);
  }
  if( regCountdown>0 ){
    sqlite3VdbeJumpHere(v, addrIf);
  }
  return ret;
}



/*
** This function - windowCodeStep() - generates the VM code that reads data
** from the sub-select and returns rows to the consumer. For the simplest
** case:
**
**     ROWS BETWEEN <expr1> PRECEDING AND <expr2> FOLLOWING
**
** The VM code generated is equivalent in spirit to the following:
**
**     while( !eof ){
**       if( new partition ){
**         Gosub flush
**       }    
**       Insert new row into eph table.
**     
**       if( first row of partition ){
**         Rewind(csrEnd, skipNext=1)
**         Rewind(csrStart, skipNext=1)
**         Rewind(csrCurrent, skipNext=1)
**     
**         regEnd = <expr2>          // FOLLOWING expression
**         regStart = <expr1>        // PRECEDING expression
**       }else{
**         if( (regEnd--)<=0 ){
**           Next(csrCurrent)
**           Return one row.
**           if( (regStart--)<0 ){
**             Next(csrStart)
**             AggInverse(csrStart)
**           }
**         }
**       }    
**     
**       Next(csrEnd)
**       AggStep(csrEnd)
**     }    
**     flush:
**       while( 1 ){ 
**         Next(csrCurrent)
**         if( eof ) break
**         Return one row.
**         if( (regStart--)<0 ){
**           Next(csrStart)
**           AggInverse(csrStart)
**         }
**       }    
**       Empty eph table.
**
** More generally, the pattern used for all window types is:
**
**     while( !eof ){
**       if( new partition ){
**         Gosub flush
**       }    
**       Insert new row into eph table.
**       if( first row of partition ){
**         FIRST_ROW_CODE
**       }else{
**         SECOND_ROW_CODE
**       }    
**       ALL_ROW_CODE
**     }    
**     flush:
**       FLUSH_CODE
**       Empty eph table.
**
*/
static void windowCodeStep(
  Parse *pParse, 
  Select *p,
  WhereInfo *pWInfo,
  int regGosub, 
  int addrGosub
){
  Window *pMWin = p->pWin;
  Vdbe *v = sqlite3GetVdbe(pParse);
  int regFlushPart;               /* Register for "Gosub flush_partition" */

  int regArg;
  int csrCurrent = pMWin->iEphCsr;
  int csrWrite = csrCurrent+1;
  int csrStart = csrCurrent+2;
  int csrEnd = csrCurrent+3;

  int regStart;                    /* Value of <expr> PRECEDING */
  int regEnd;                      /* Value of <expr> FOLLOWING */

  int iSubCsr = p->pSrc->a[0].iCursor;      /* Cursor of sub-select */
  int nSub = p->pSrc->a[0].pTab->nCol;      /* Number of cols returned by sub */
  int iCol;                                 /* To iterate through sub cols */

  int addrGoto;
  int addrIf;


  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;
  WindowCodeArg s;

  memset(&s, 0, sizeof(WindowCodeArg));
  s.pParse = pParse;
  s.pMWin = pMWin;
  s.pVdbe = v;
  s.regGosub = regGosub;
  s.addrGosub = addrGosub;

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

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

  assert( pMWin->eStart==TK_PRECEDING 
       || pMWin->eStart==TK_CURRENT 
       || pMWin->eStart==TK_FOLLOWING 
       || pMWin->eStart==TK_UNBOUNDED 
  );
  assert( pMWin->eEnd==TK_FOLLOWING 
       || pMWin->eEnd==TK_CURRENT 
       || pMWin->eEnd==TK_UNBOUNDED 
       || pMWin->eEnd==TK_PRECEDING 
  );


  /* Load the column values for the row returned by the sub-select
  ** into an array of registers starting at reg. Assemble them into
  ** a record in register regRecord. TODO: An optimization here? */
  for(iCol=0; iCol<nSub; iCol++){
    sqlite3VdbeAddOp3(v, OP_Column, iSubCsr, iCol, reg+iCol);
  }
  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

    }
    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 */
  s.regArg = 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==pMWin->eEnd 
   && pMWin->eStart!=TK_CURRENT && pMWin->eStart!=TK_UNBOUNDED 
  ){
    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_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);

  /* Begin generating SECOND_ROW_CODE */
  VdbeModuleComment((pParse->pVdbe, "Begin windowCodeStep.SECOND_ROW_CODE"));
  if( bCache ){
    addrCacheNext = sqlite3VdbeCurrentAddr(v);
  }else{
    sqlite3VdbeJumpHere(v, addrIf);
  }

  if( pMWin->eStart==TK_FOLLOWING ){


    windowCodeOp(&s, WINDOW_RETURN_ROW, csrCurrent, regEnd, 0);


    windowCodeOp(&s, WINDOW_AGGINVERSE, csrStart, regStart, 0);




  }else
  if( pMWin->eEnd==TK_PRECEDING ){




    windowCodeOp(&s, WINDOW_AGGSTEP, csrEnd, regEnd, 0);

    windowCodeOp(&s, WINDOW_RETURN_ROW, csrCurrent, 0, 0);

    windowCodeOp(&s, WINDOW_AGGINVERSE, csrStart, regStart, 0);




  }else{
    int addr = sqlite3VdbeAddOp3(v, OP_IfPos, regEnd, 0, 1);

    windowCodeOp(&s, WINDOW_RETURN_ROW, csrCurrent, 0, 0);


    windowCodeOp(&s, WINDOW_AGGINVERSE, csrStart, regStart, 0);

    sqlite3VdbeJumpHere(v, addr);

  }
  VdbeModuleComment((pParse->pVdbe, "End windowCodeStep.SECOND_ROW_CODE"));

  VdbeModuleComment((pParse->pVdbe, "Begin windowCodeStep.ALL_ROW_CODE"));
  sqlite3VdbeJumpHere(v, addrGoto);
  if( pMWin->eEnd!=TK_PRECEDING ){

    windowCodeOp(&s, WINDOW_AGGSTEP, csrEnd, 0, 0);
  }
  VdbeModuleComment((pParse->pVdbe, "End windowCodeStep.ALL_ROW_CODE"));

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

  VdbeModuleComment((pParse->pVdbe, "Begin windowCodeStep.FLUSH_CODE"));
  if( pMWin->pPartition && bCache==0 ){
    addrInteger = sqlite3VdbeAddOp2(v, OP_Integer, 0, regFlushPart);
    sqlite3VdbeJumpHere(v, addrGosubFlush);
  }

  if( pMWin->eEnd==TK_PRECEDING ){







    windowCodeOp(&s, WINDOW_AGGSTEP, csrEnd, regEnd, 1);






    windowCodeOp(&s, WINDOW_RETURN_ROW, csrCurrent, 0, 1);


  }else{
    int addrBreak;
    int addrStart = sqlite3VdbeCurrentAddr(v);

    if( pMWin->eStart==TK_FOLLOWING ){




      addrBreak = windowCodeOp(&s, WINDOW_RETURN_ROW, csrCurrent, regEnd, 1);
      windowCodeOp(&s, WINDOW_AGGINVERSE, csrStart, regStart, 1);
    }else{


      addrBreak = windowCodeOp(&s, WINDOW_RETURN_ROW, csrCurrent, 0, 1);
      windowCodeOp(&s, WINDOW_AGGINVERSE, csrStart, regStart, 0);



    }
    sqlite3VdbeAddOp2(v, OP_Goto, 0, addrStart);
    sqlite3VdbeJumpHere(v, addrBreak);
  }


  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);
  VdbeModuleComment((pParse->pVdbe, "End windowCodeStep.FLUSH_CODE"));
  if( pMWin->pPartition ){
    sqlite3VdbeChangeP1(v, addrInteger, sqlite3VdbeCurrentAddr(v));
    sqlite3VdbeAddOp1(v, OP_Return, regFlushPart);
  }
}

/*