SQLite

    }
    rc = 1;
    goto multi_select_end;
  }

#ifndef SQLITE_OMIT_CTE
  if( p->selFlags & SF_Recursive ){
    SrcList *pSrc = p->pSrc;      /* The FROM clause of the recursive query */
    int nCol = p->pEList->nExpr;  /* Number of columns in the CTE */
    int addrTop;                  /* Top of the loop */
    int addrCont, addrBreak;      /* CONTINUE and BREAK addresses */
    int iCurrent;                 /* The Current table */
    int regCurrent;               /* Register holding Current table */
    int iQueue;                   /* The Queue table */
    int iDistinct;                /* To ensure unique results if UNION */
    int eDest;                    /* How to write to Queue */
    SelectDest destQueue;         /* SelectDest targetting the Queue table */
    int i;                        /* Loop counter */

    /* Check that there is no ORDER BY or LIMIT clause. Neither of these 
    ** are currently supported on recursive queries.
    */
    assert( p->pOffset==0 || p->pLimit );
    if( p->pOrderBy || p->pLimit ){
      sqlite3ErrorMsg(pParse, "%s in a recursive query",
          p->pOrderBy ? "ORDER BY" : "LIMIT"
      );
      goto multi_select_end;
    }

    if( sqlite3AuthCheck(pParse, SQLITE_RECURSIVE, 0, 0, 0) ){
      goto multi_select_end;
    }
    addrBreak = sqlite3VdbeMakeLabel(v);
    addrCont = sqlite3VdbeMakeLabel(v);

    /* Locate the cursor number of the Current table */
    for(i=0; ALWAYS(i<pSrc->nSrc); i++){
      if( pSrc->a[i].isRecursive ){
        iCurrent = pSrc->a[i].iCursor;
        break;
      }
    }

    /* Allocate cursors for Queue and Distinct.  The cursor number for
    ** the Distinct table must be exactly one greater than Queue in order
    ** for the SRT_DistTable destination to work. */
    iQueue = pParse->nTab++;
    if( p->op==TK_UNION ){
      eDest = SRT_DistTable;
      iDistinct = pParse->nTab++;
    }else{
      eDest = SRT_Table;
      iDistinct = 0;
    }
    sqlite3SelectDestInit(&destQueue, eDest, iQueue);

    /* Allocate cursors for Current, Queue, and iDistinct. */
    regCurrent = ++pParse->nMem;
    sqlite3VdbeAddOp3(v, OP_OpenPseudo, iCurrent, regCurrent, nCol);
    sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iQueue, nCol);
    if( iDistinct ){
      p->addrOpenEphm[0] = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iDistinct, 0);
      p->selFlags |= SF_UsesEphemeral;
    }

    /* Store the results of the initial SELECT in Queue. */
    rc = sqlite3Select(pParse, pPrior, &destQueue);
    if( rc ) goto multi_select_end;

    /* Find the next row in the Queue and output that row */



    addrTop = sqlite3VdbeAddOp2(v, OP_Rewind, iQueue, addrBreak);

    selectInnerLoop(pParse, p, p->pEList, iQueue, p->pEList->nExpr,
        0, 0, &dest, addrCont, addrBreak);
    sqlite3VdbeResolveLabel(v, addrCont);

    /* Transfer the next row in Queue over to Current */
    sqlite3VdbeAddOp1(v, OP_NullRow, iCurrent); /* To reset column cache */
    sqlite3VdbeAddOp2(v, OP_RowData, iQueue, regCurrent);
    sqlite3VdbeAddOp1(v, OP_Delete, iQueue);

    /* Execute the recursive SELECT taking the single row in Current as
    ** the value for the CTE. Store the results in the Queue.
    */
    p->pPrior = 0;
    rc = sqlite3Select(pParse, p, &destQueue);
    assert( p->pPrior==0 );
    p->pPrior = pPrior;
    if( rc ) goto multi_select_end;

    /* Keep running the loop until the Queue is empty */
    sqlite3VdbeAddOp2(v, OP_Goto, 0, addrTop);
    sqlite3VdbeResolveLabel(v, addrBreak);
  }else
#endif

  /* Compound SELECTs that have an ORDER BY clause are handled separately.
  */
  if( p->pOrderBy ){
    return multiSelectOrderBy(pParse, p, pDest);

**
**     * For each "Next", "Prev", "VNext" or "VPrev" instruction, indent
**       all opcodes that occur between the p2 jump destination and the opcode
**       itself by 2 spaces.
**
**     * For each "Goto", if the jump destination is earlier in the program
**       and ends on one of:
**          Yield  SeekGt  SeekLt  RowSetRead  Rewind
**       then indent all opcodes between the earlier instruction
**       and "Goto" by 2 spaces.
*/
static void explain_data_prepare(struct callback_data *p, sqlite3_stmt *pSql){
  const char *zSql;               /* The text of the SQL statement */
  const char *z;                  /* Used to check if this is an EXPLAIN */
  int *abYield = 0;               /* True if op is an OP_Yield */
  int nAlloc = 0;                 /* Allocated size of p->aiIndent[], abYield */
  int iOp;                        /* Index of operation in p->aiIndent[] */

  const char *azNext[] = { "Next", "Prev", "VPrev", "VNext", "SorterNext", 0 };
  const char *azYield[] = { "Yield", "SeekLt", "SeekGt", "RowSetRead", "Rewind", 0 };
  const char *azGoto[] = { "Goto", 0 };

  /* Try to figure out if this is really an EXPLAIN statement. If this
  ** cannot be verified, return early.  */
  zSql = sqlite3_sql(pSql);
  if( zSql==0 ) return;
  for(z=zSql; *z==' ' || *z=='\t' || *z=='\n' || *z=='\f' || *z=='\r'; z++);

    p->aiIndent[iOp] = 0;
    p->nIndent = iOp+1;

    if( str_in_array(zOp, azNext) ){
      for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2;
    }
    if( str_in_array(zOp, azGoto) && p2op<p->nIndent && abYield[p2op] ){
      for(i=p2op+1; i<iOp; i++) p->aiIndent[i] += 2;
    }
  }

  p->iIndent = 0;
  sqlite3_free(abYield);
  sqlite3_reset(pSql);
}

      pCx->isTable = 1;
    }
  }
  pCx->isOrdered = (pOp->p5!=BTREE_UNORDERED);
  break;
}




























/* Opcode: SorterOpen P1 * * P4 *
**
** This opcode works like OP_OpenEphemeral except that it opens
** a transient index that is specifically designed to sort large
** tables using an external merge-sort algorithm.
*/
case OP_SorterOpen: {

  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  pC = p->apCsr[pOp->p1];
  assert( pC!=0 );
  pC->nullRow = 1;
  pC->rowidIsValid = 0;
  pC->cacheStatus = CACHE_STALE;

  if( pC->pCursor ){
    sqlite3BtreeClearCursor(pC->pCursor);
  }
  break;
}

/* Opcode: Last P1 P2 * * *

  {
    /* Case 6:  There is no usable index.  We must do a complete
    **          scan of the entire table.
    */
    static const u8 aStep[] = { OP_Next, OP_Prev };
    static const u8 aStart[] = { OP_Rewind, OP_Last };
    assert( bRev==0 || bRev==1 );
    if( pTabItem->isRecursive ){
      pLevel->op = OP_Noop;
    }else{
      pLevel->op = aStep[bRev];
      pLevel->p1 = iCur;
      pLevel->p2 = 1 + sqlite3VdbeAddOp2(v, aStart[bRev], iCur, addrBrk);
      pLevel->p5 = SQLITE_STMTSTATUS_FULLSCAN_STEP;
    }
  }

  /* Insert code to test every subexpression that can be completely
  ** computed using the current set of tables.
  */
  for(pTerm=pWC->a, j=pWC->nTerm; j>0; j--, pTerm++){
    Expr *pE;