select.c.svn-base
上传用户:sunhongbo
上传日期:2022-01-25
资源大小:3010k
文件大小:125k
源码类别:

数据库系统

开发平台:

C/C++

  1. /*
  2. ** 2001 September 15
  3. **
  4. ** The author disclaims copyright to this source code.  In place of
  5. ** a legal notice, here is a blessing:
  6. **
  7. **    May you do good and not evil.
  8. **    May you find forgiveness for yourself and forgive others.
  9. **    May you share freely, never taking more than you give.
  10. **
  11. *************************************************************************
  12. ** This file contains C code routines that are called by the parser
  13. ** to handle SELECT statements in SQLite.
  14. **
  15. ** $Id: select.c,v 1.427 2008/04/15 12:14:22 drh Exp $
  16. */
  17. #include "sqliteInt.h"
  18. /*
  19. ** Delete all the content of a Select structure but do not deallocate
  20. ** the select structure itself.
  21. */
  22. static void clearSelect(Select *p){
  23.   sqlite3ExprListDelete(p->pEList);
  24.   sqlite3SrcListDelete(p->pSrc);
  25.   sqlite3ExprDelete(p->pWhere);
  26.   sqlite3ExprListDelete(p->pGroupBy);
  27.   sqlite3ExprDelete(p->pHaving);
  28.   sqlite3ExprListDelete(p->pOrderBy);
  29.   sqlite3SelectDelete(p->pPrior);
  30.   sqlite3ExprDelete(p->pLimit);
  31.   sqlite3ExprDelete(p->pOffset);
  32. }
  33. /*
  34. ** Initialize a SelectDest structure.
  35. */
  36. void sqlite3SelectDestInit(SelectDest *pDest, int eDest, int iParm){
  37.   pDest->eDest = eDest;
  38.   pDest->iParm = iParm;
  39.   pDest->affinity = 0;
  40.   pDest->iMem = 0;
  41.   pDest->nMem = 0;
  42. }
  43. /*
  44. ** Allocate a new Select structure and return a pointer to that
  45. ** structure.
  46. */
  47. Select *sqlite3SelectNew(
  48.   Parse *pParse,        /* Parsing context */
  49.   ExprList *pEList,     /* which columns to include in the result */
  50.   SrcList *pSrc,        /* the FROM clause -- which tables to scan */
  51.   Expr *pWhere,         /* the WHERE clause */
  52.   ExprList *pGroupBy,   /* the GROUP BY clause */
  53.   Expr *pHaving,        /* the HAVING clause */
  54.   ExprList *pOrderBy,   /* the ORDER BY clause */
  55.   int isDistinct,       /* true if the DISTINCT keyword is present */
  56.   Expr *pLimit,         /* LIMIT value.  NULL means not used */
  57.   Expr *pOffset         /* OFFSET value.  NULL means no offset */
  58. ){
  59.   Select *pNew;
  60.   Select standin;
  61.   sqlite3 *db = pParse->db;
  62.   pNew = sqlite3DbMallocZero(db, sizeof(*pNew) );
  63.   assert( !pOffset || pLimit );   /* Can't have OFFSET without LIMIT. */
  64.   if( pNew==0 ){
  65.     pNew = &standin;
  66.     memset(pNew, 0, sizeof(*pNew));
  67.   }
  68.   if( pEList==0 ){
  69.     pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db,TK_ALL,0,0,0), 0);
  70.   }
  71.   pNew->pEList = pEList;
  72.   pNew->pSrc = pSrc;
  73.   pNew->pWhere = pWhere;
  74.   pNew->pGroupBy = pGroupBy;
  75.   pNew->pHaving = pHaving;
  76.   pNew->pOrderBy = pOrderBy;
  77.   pNew->isDistinct = isDistinct;
  78.   pNew->op = TK_SELECT;
  79.   assert( pOffset==0 || pLimit!=0 );
  80.   pNew->pLimit = pLimit;
  81.   pNew->pOffset = pOffset;
  82.   pNew->iLimit = -1;
  83.   pNew->iOffset = -1;
  84.   pNew->addrOpenEphm[0] = -1;
  85.   pNew->addrOpenEphm[1] = -1;
  86.   pNew->addrOpenEphm[2] = -1;
  87.   if( pNew==&standin) {
  88.     clearSelect(pNew);
  89.     pNew = 0;
  90.   }
  91.   return pNew;
  92. }
  93. /*
  94. ** Delete the given Select structure and all of its substructures.
  95. */
  96. void sqlite3SelectDelete(Select *p){
  97.   if( p ){
  98.     clearSelect(p);
  99.     sqlite3_free(p);
  100.   }
  101. }
  102. /*
  103. ** Given 1 to 3 identifiers preceeding the JOIN keyword, determine the
  104. ** type of join.  Return an integer constant that expresses that type
  105. ** in terms of the following bit values:
  106. **
  107. **     JT_INNER
  108. **     JT_CROSS
  109. **     JT_OUTER
  110. **     JT_NATURAL
  111. **     JT_LEFT
  112. **     JT_RIGHT
  113. **
  114. ** A full outer join is the combination of JT_LEFT and JT_RIGHT.
  115. **
  116. ** If an illegal or unsupported join type is seen, then still return
  117. ** a join type, but put an error in the pParse structure.
  118. */
  119. int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){
  120.   int jointype = 0;
  121.   Token *apAll[3];
  122.   Token *p;
  123.   static const struct {
  124.     const char zKeyword[8];
  125.     u8 nChar;
  126.     u8 code;
  127.   } keywords[] = {
  128.     { "natural", 7, JT_NATURAL },
  129.     { "left",    4, JT_LEFT|JT_OUTER },
  130.     { "right",   5, JT_RIGHT|JT_OUTER },
  131.     { "full",    4, JT_LEFT|JT_RIGHT|JT_OUTER },
  132.     { "outer",   5, JT_OUTER },
  133.     { "inner",   5, JT_INNER },
  134.     { "cross",   5, JT_INNER|JT_CROSS },
  135.   };
  136.   int i, j;
  137.   apAll[0] = pA;
  138.   apAll[1] = pB;
  139.   apAll[2] = pC;
  140.   for(i=0; i<3 && apAll[i]; i++){
  141.     p = apAll[i];
  142.     for(j=0; j<sizeof(keywords)/sizeof(keywords[0]); j++){
  143.       if( p->n==keywords[j].nChar 
  144.           && sqlite3StrNICmp((char*)p->z, keywords[j].zKeyword, p->n)==0 ){
  145.         jointype |= keywords[j].code;
  146.         break;
  147.       }
  148.     }
  149.     if( j>=sizeof(keywords)/sizeof(keywords[0]) ){
  150.       jointype |= JT_ERROR;
  151.       break;
  152.     }
  153.   }
  154.   if(
  155.      (jointype & (JT_INNER|JT_OUTER))==(JT_INNER|JT_OUTER) ||
  156.      (jointype & JT_ERROR)!=0
  157.   ){
  158.     const char *zSp1 = " ";
  159.     const char *zSp2 = " ";
  160.     if( pB==0 ){ zSp1++; }
  161.     if( pC==0 ){ zSp2++; }
  162.     sqlite3ErrorMsg(pParse, "unknown or unsupported join type: "
  163.        "%T%s%T%s%T", pA, zSp1, pB, zSp2, pC);
  164.     jointype = JT_INNER;
  165.   }else if( jointype & JT_RIGHT ){
  166.     sqlite3ErrorMsg(pParse, 
  167.       "RIGHT and FULL OUTER JOINs are not currently supported");
  168.     jointype = JT_INNER;
  169.   }
  170.   return jointype;
  171. }
  172. /*
  173. ** Return the index of a column in a table.  Return -1 if the column
  174. ** is not contained in the table.
  175. */
  176. static int columnIndex(Table *pTab, const char *zCol){
  177.   int i;
  178.   for(i=0; i<pTab->nCol; i++){
  179.     if( sqlite3StrICmp(pTab->aCol[i].zName, zCol)==0 ) return i;
  180.   }
  181.   return -1;
  182. }
  183. /*
  184. ** Set the value of a token to a '00'-terminated string.
  185. */
  186. static void setToken(Token *p, const char *z){
  187.   p->z = (u8*)z;
  188.   p->n = z ? strlen(z) : 0;
  189.   p->dyn = 0;
  190. }
  191. /*
  192. ** Set the token to the double-quoted and escaped version of the string pointed
  193. ** to by z. For example;
  194. **
  195. **    {a"bc}  ->  {"a""bc"}
  196. */
  197. static void setQuotedToken(Parse *pParse, Token *p, const char *z){
  198.   /* Check if the string contains any " characters. If it does, then
  199.   ** this function will malloc space to create a quoted version of
  200.   ** the string in. Otherwise, save a call to sqlite3MPrintf() by
  201.   ** just copying the pointer to the string.
  202.   */
  203.   const char *z2 = z;
  204.   while( *z2 ){
  205.     if( *z2=='"' ) break;
  206.     z2++;
  207.   }
  208.   if( *z2 ){
  209.     /* String contains " characters - copy and quote the string. */
  210.     p->z = (u8 *)sqlite3MPrintf(pParse->db, ""%w"", z);
  211.     if( p->z ){
  212.       p->n = strlen((char *)p->z);
  213.       p->dyn = 1;
  214.     }
  215.   }else{
  216.     /* String contains no " characters - copy the pointer. */
  217.     p->z = (u8*)z;
  218.     p->n = (z2 - z);
  219.     p->dyn = 0;
  220.   }
  221. }
  222. /*
  223. ** Create an expression node for an identifier with the name of zName
  224. */
  225. Expr *sqlite3CreateIdExpr(Parse *pParse, const char *zName){
  226.   Token dummy;
  227.   setToken(&dummy, zName);
  228.   return sqlite3PExpr(pParse, TK_ID, 0, 0, &dummy);
  229. }
  230. /*
  231. ** Add a term to the WHERE expression in *ppExpr that requires the
  232. ** zCol column to be equal in the two tables pTab1 and pTab2.
  233. */
  234. static void addWhereTerm(
  235.   Parse *pParse,           /* Parsing context */
  236.   const char *zCol,        /* Name of the column */
  237.   const Table *pTab1,      /* First table */
  238.   const char *zAlias1,     /* Alias for first table.  May be NULL */
  239.   const Table *pTab2,      /* Second table */
  240.   const char *zAlias2,     /* Alias for second table.  May be NULL */
  241.   int iRightJoinTable,     /* VDBE cursor for the right table */
  242.   Expr **ppExpr,           /* Add the equality term to this expression */
  243.   int isOuterJoin          /* True if dealing with an OUTER join */
  244. ){
  245.   Expr *pE1a, *pE1b, *pE1c;
  246.   Expr *pE2a, *pE2b, *pE2c;
  247.   Expr *pE;
  248.   pE1a = sqlite3CreateIdExpr(pParse, zCol);
  249.   pE2a = sqlite3CreateIdExpr(pParse, zCol);
  250.   if( zAlias1==0 ){
  251.     zAlias1 = pTab1->zName;
  252.   }
  253.   pE1b = sqlite3CreateIdExpr(pParse, zAlias1);
  254.   if( zAlias2==0 ){
  255.     zAlias2 = pTab2->zName;
  256.   }
  257.   pE2b = sqlite3CreateIdExpr(pParse, zAlias2);
  258.   pE1c = sqlite3PExpr(pParse, TK_DOT, pE1b, pE1a, 0);
  259.   pE2c = sqlite3PExpr(pParse, TK_DOT, pE2b, pE2a, 0);
  260.   pE = sqlite3PExpr(pParse, TK_EQ, pE1c, pE2c, 0);
  261.   if( pE && isOuterJoin ){
  262.     ExprSetProperty(pE, EP_FromJoin);
  263.     pE->iRightJoinTable = iRightJoinTable;
  264.   }
  265.   *ppExpr = sqlite3ExprAnd(pParse->db,*ppExpr, pE);
  266. }
  267. /*
  268. ** Set the EP_FromJoin property on all terms of the given expression.
  269. ** And set the Expr.iRightJoinTable to iTable for every term in the
  270. ** expression.
  271. **
  272. ** The EP_FromJoin property is used on terms of an expression to tell
  273. ** the LEFT OUTER JOIN processing logic that this term is part of the
  274. ** join restriction specified in the ON or USING clause and not a part
  275. ** of the more general WHERE clause.  These terms are moved over to the
  276. ** WHERE clause during join processing but we need to remember that they
  277. ** originated in the ON or USING clause.
  278. **
  279. ** The Expr.iRightJoinTable tells the WHERE clause processing that the
  280. ** expression depends on table iRightJoinTable even if that table is not
  281. ** explicitly mentioned in the expression.  That information is needed
  282. ** for cases like this:
  283. **
  284. **    SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.b AND t1.x=5
  285. **
  286. ** The where clause needs to defer the handling of the t1.x=5
  287. ** term until after the t2 loop of the join.  In that way, a
  288. ** NULL t2 row will be inserted whenever t1.x!=5.  If we do not
  289. ** defer the handling of t1.x=5, it will be processed immediately
  290. ** after the t1 loop and rows with t1.x!=5 will never appear in
  291. ** the output, which is incorrect.
  292. */
  293. static void setJoinExpr(Expr *p, int iTable){
  294.   while( p ){
  295.     ExprSetProperty(p, EP_FromJoin);
  296.     p->iRightJoinTable = iTable;
  297.     setJoinExpr(p->pLeft, iTable);
  298.     p = p->pRight;
  299.   } 
  300. }
  301. /*
  302. ** This routine processes the join information for a SELECT statement.
  303. ** ON and USING clauses are converted into extra terms of the WHERE clause.
  304. ** NATURAL joins also create extra WHERE clause terms.
  305. **
  306. ** The terms of a FROM clause are contained in the Select.pSrc structure.
  307. ** The left most table is the first entry in Select.pSrc.  The right-most
  308. ** table is the last entry.  The join operator is held in the entry to
  309. ** the left.  Thus entry 0 contains the join operator for the join between
  310. ** entries 0 and 1.  Any ON or USING clauses associated with the join are
  311. ** also attached to the left entry.
  312. **
  313. ** This routine returns the number of errors encountered.
  314. */
  315. static int sqliteProcessJoin(Parse *pParse, Select *p){
  316.   SrcList *pSrc;                  /* All tables in the FROM clause */
  317.   int i, j;                       /* Loop counters */
  318.   struct SrcList_item *pLeft;     /* Left table being joined */
  319.   struct SrcList_item *pRight;    /* Right table being joined */
  320.   pSrc = p->pSrc;
  321.   pLeft = &pSrc->a[0];
  322.   pRight = &pLeft[1];
  323.   for(i=0; i<pSrc->nSrc-1; i++, pRight++, pLeft++){
  324.     Table *pLeftTab = pLeft->pTab;
  325.     Table *pRightTab = pRight->pTab;
  326.     int isOuter;
  327.     if( pLeftTab==0 || pRightTab==0 ) continue;
  328.     isOuter = (pRight->jointype & JT_OUTER)!=0;
  329.     /* When the NATURAL keyword is present, add WHERE clause terms for
  330.     ** every column that the two tables have in common.
  331.     */
  332.     if( pRight->jointype & JT_NATURAL ){
  333.       if( pRight->pOn || pRight->pUsing ){
  334.         sqlite3ErrorMsg(pParse, "a NATURAL join may not have "
  335.            "an ON or USING clause", 0);
  336.         return 1;
  337.       }
  338.       for(j=0; j<pLeftTab->nCol; j++){
  339.         char *zName = pLeftTab->aCol[j].zName;
  340.         if( columnIndex(pRightTab, zName)>=0 ){
  341.           addWhereTerm(pParse, zName, pLeftTab, pLeft->zAlias, 
  342.                               pRightTab, pRight->zAlias,
  343.                               pRight->iCursor, &p->pWhere, isOuter);
  344.           
  345.         }
  346.       }
  347.     }
  348.     /* Disallow both ON and USING clauses in the same join
  349.     */
  350.     if( pRight->pOn && pRight->pUsing ){
  351.       sqlite3ErrorMsg(pParse, "cannot have both ON and USING "
  352.         "clauses in the same join");
  353.       return 1;
  354.     }
  355.     /* Add the ON clause to the end of the WHERE clause, connected by
  356.     ** an AND operator.
  357.     */
  358.     if( pRight->pOn ){
  359.       if( isOuter ) setJoinExpr(pRight->pOn, pRight->iCursor);
  360.       p->pWhere = sqlite3ExprAnd(pParse->db, p->pWhere, pRight->pOn);
  361.       pRight->pOn = 0;
  362.     }
  363.     /* Create extra terms on the WHERE clause for each column named
  364.     ** in the USING clause.  Example: If the two tables to be joined are 
  365.     ** A and B and the USING clause names X, Y, and Z, then add this
  366.     ** to the WHERE clause:    A.X=B.X AND A.Y=B.Y AND A.Z=B.Z
  367.     ** Report an error if any column mentioned in the USING clause is
  368.     ** not contained in both tables to be joined.
  369.     */
  370.     if( pRight->pUsing ){
  371.       IdList *pList = pRight->pUsing;
  372.       for(j=0; j<pList->nId; j++){
  373.         char *zName = pList->a[j].zName;
  374.         if( columnIndex(pLeftTab, zName)<0 || columnIndex(pRightTab, zName)<0 ){
  375.           sqlite3ErrorMsg(pParse, "cannot join using column %s - column "
  376.             "not present in both tables", zName);
  377.           return 1;
  378.         }
  379.         addWhereTerm(pParse, zName, pLeftTab, pLeft->zAlias, 
  380.                             pRightTab, pRight->zAlias,
  381.                             pRight->iCursor, &p->pWhere, isOuter);
  382.       }
  383.     }
  384.   }
  385.   return 0;
  386. }
  387. /*
  388. ** Insert code into "v" that will push the record on the top of the
  389. ** stack into the sorter.
  390. */
  391. static void pushOntoSorter(
  392.   Parse *pParse,         /* Parser context */
  393.   ExprList *pOrderBy,    /* The ORDER BY clause */
  394.   Select *pSelect,       /* The whole SELECT statement */
  395.   int regData            /* Register holding data to be sorted */
  396. ){
  397.   Vdbe *v = pParse->pVdbe;
  398.   int nExpr = pOrderBy->nExpr;
  399.   int regBase = sqlite3GetTempRange(pParse, nExpr+2);
  400.   int regRecord = sqlite3GetTempReg(pParse);
  401.   sqlite3ExprCodeExprList(pParse, pOrderBy, regBase, 0);
  402.   sqlite3VdbeAddOp2(v, OP_Sequence, pOrderBy->iECursor, regBase+nExpr);
  403.   sqlite3ExprCodeMove(pParse, regData, regBase+nExpr+1);
  404.   sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nExpr + 2, regRecord);
  405.   sqlite3VdbeAddOp2(v, OP_IdxInsert, pOrderBy->iECursor, regRecord);
  406.   sqlite3ReleaseTempReg(pParse, regRecord);
  407.   sqlite3ReleaseTempRange(pParse, regBase, nExpr+2);
  408.   if( pSelect->iLimit>=0 ){
  409.     int addr1, addr2;
  410.     int iLimit;
  411.     if( pSelect->pOffset ){
  412.       iLimit = pSelect->iOffset+1;
  413.     }else{
  414.       iLimit = pSelect->iLimit;
  415.     }
  416.     addr1 = sqlite3VdbeAddOp1(v, OP_IfZero, iLimit);
  417.     sqlite3VdbeAddOp2(v, OP_AddImm, iLimit, -1);
  418.     addr2 = sqlite3VdbeAddOp0(v, OP_Goto);
  419.     sqlite3VdbeJumpHere(v, addr1);
  420.     sqlite3VdbeAddOp1(v, OP_Last, pOrderBy->iECursor);
  421.     sqlite3VdbeAddOp1(v, OP_Delete, pOrderBy->iECursor);
  422.     sqlite3VdbeJumpHere(v, addr2);
  423.     pSelect->iLimit = -1;
  424.   }
  425. }
  426. /*
  427. ** Add code to implement the OFFSET
  428. */
  429. static void codeOffset(
  430.   Vdbe *v,          /* Generate code into this VM */
  431.   Select *p,        /* The SELECT statement being coded */
  432.   int iContinue     /* Jump here to skip the current record */
  433. ){
  434.   if( p->iOffset>=0 && iContinue!=0 ){
  435.     int addr;
  436.     sqlite3VdbeAddOp2(v, OP_AddImm, p->iOffset, -1);
  437.     addr = sqlite3VdbeAddOp1(v, OP_IfNeg, p->iOffset);
  438.     sqlite3VdbeAddOp2(v, OP_Goto, 0, iContinue);
  439.     VdbeComment((v, "skip OFFSET records"));
  440.     sqlite3VdbeJumpHere(v, addr);
  441.   }
  442. }
  443. /*
  444. ** Add code that will check to make sure the N registers starting at iMem
  445. ** form a distinct entry.  iTab is a sorting index that holds previously
  446. ** seen combinations of the N values.  A new entry is made in iTab
  447. ** if the current N values are new.
  448. **
  449. ** A jump to addrRepeat is made and the N+1 values are popped from the
  450. ** stack if the top N elements are not distinct.
  451. */
  452. static void codeDistinct(
  453.   Parse *pParse,     /* Parsing and code generating context */
  454.   int iTab,          /* A sorting index used to test for distinctness */
  455.   int addrRepeat,    /* Jump to here if not distinct */
  456.   int N,             /* Number of elements */
  457.   int iMem           /* First element */
  458. ){
  459.   Vdbe *v;
  460.   int r1;
  461.   v = pParse->pVdbe;
  462.   r1 = sqlite3GetTempReg(pParse);
  463.   sqlite3VdbeAddOp3(v, OP_MakeRecord, iMem, N, r1);
  464.   sqlite3VdbeAddOp3(v, OP_Found, iTab, addrRepeat, r1);
  465.   sqlite3VdbeAddOp2(v, OP_IdxInsert, iTab, r1);
  466.   sqlite3ReleaseTempReg(pParse, r1);
  467. }
  468. /*
  469. ** Generate an error message when a SELECT is used within a subexpression
  470. ** (example:  "a IN (SELECT * FROM table)") but it has more than 1 result
  471. ** column.  We do this in a subroutine because the error occurs in multiple
  472. ** places.
  473. */
  474. static int checkForMultiColumnSelectError(
  475.   Parse *pParse,       /* Parse context. */
  476.   SelectDest *pDest,   /* Destination of SELECT results */
  477.   int nExpr            /* Number of result columns returned by SELECT */
  478. ){
  479.   int eDest = pDest->eDest;
  480.   if( nExpr>1 && (eDest==SRT_Mem || eDest==SRT_Set) ){
  481.     sqlite3ErrorMsg(pParse, "only a single result allowed for "
  482.        "a SELECT that is part of an expression");
  483.     return 1;
  484.   }else{
  485.     return 0;
  486.   }
  487. }
  488. /*
  489. ** This routine generates the code for the inside of the inner loop
  490. ** of a SELECT.
  491. **
  492. ** If srcTab and nColumn are both zero, then the pEList expressions
  493. ** are evaluated in order to get the data for this row.  If nColumn>0
  494. ** then data is pulled from srcTab and pEList is used only to get the
  495. ** datatypes for each column.
  496. */
  497. static void selectInnerLoop(
  498.   Parse *pParse,          /* The parser context */
  499.   Select *p,              /* The complete select statement being coded */
  500.   ExprList *pEList,       /* List of values being extracted */
  501.   int srcTab,             /* Pull data from this table */
  502.   int nColumn,            /* Number of columns in the source table */
  503.   ExprList *pOrderBy,     /* If not NULL, sort results using this key */
  504.   int distinct,           /* If >=0, make sure results are distinct */
  505.   SelectDest *pDest,      /* How to dispose of the results */
  506.   int iContinue,          /* Jump here to continue with next row */
  507.   int iBreak,             /* Jump here to break out of the inner loop */
  508.   char *aff               /* affinity string if eDest is SRT_Union */
  509. ){
  510.   Vdbe *v = pParse->pVdbe;
  511.   int i;
  512.   int hasDistinct;        /* True if the DISTINCT keyword is present */
  513.   int regResult;              /* Start of memory holding result set */
  514.   int eDest = pDest->eDest;   /* How to dispose of results */
  515.   int iParm = pDest->iParm;   /* First argument to disposal method */
  516.   int nResultCol;             /* Number of result columns */
  517.   if( v==0 ) return;
  518.   assert( pEList!=0 );
  519.   /* If there was a LIMIT clause on the SELECT statement, then do the check
  520.   ** to see if this row should be output.
  521.   */
  522.   hasDistinct = distinct>=0 && pEList->nExpr>0;
  523.   if( pOrderBy==0 && !hasDistinct ){
  524.     codeOffset(v, p, iContinue);
  525.   }
  526.   /* Pull the requested columns.
  527.   */
  528.   if( nColumn>0 ){
  529.     nResultCol = nColumn;
  530.   }else{
  531.     nResultCol = pEList->nExpr;
  532.   }
  533.   if( pDest->iMem==0 ){
  534.     pDest->iMem = sqlite3GetTempRange(pParse, nResultCol);
  535.     pDest->nMem = nResultCol;
  536.   }else if( pDest->nMem!=nResultCol ){
  537.     /* This happens when two SELECTs of a compound SELECT have differing
  538.     ** numbers of result columns.  The error message will be generated by
  539.     ** a higher-level routine. */
  540.     return;
  541.   }
  542.   regResult = pDest->iMem;
  543.   if( nColumn>0 ){
  544.     for(i=0; i<nColumn; i++){
  545.       sqlite3VdbeAddOp3(v, OP_Column, srcTab, i, regResult+i);
  546.     }
  547.   }else if( eDest!=SRT_Exists ){
  548.     /* If the destination is an EXISTS(...) expression, the actual
  549.     ** values returned by the SELECT are not required.
  550.     */
  551.     sqlite3ExprCodeExprList(pParse, pEList, regResult, eDest==SRT_Callback);
  552.   }
  553.   nColumn = nResultCol;
  554.   /* If the DISTINCT keyword was present on the SELECT statement
  555.   ** and this row has been seen before, then do not make this row
  556.   ** part of the result.
  557.   */
  558.   if( hasDistinct ){
  559.     assert( pEList!=0 );
  560.     assert( pEList->nExpr==nColumn );
  561.     codeDistinct(pParse, distinct, iContinue, nColumn, regResult);
  562.     if( pOrderBy==0 ){
  563.       codeOffset(v, p, iContinue);
  564.     }
  565.   }
  566.   if( checkForMultiColumnSelectError(pParse, pDest, pEList->nExpr) ){
  567.     return;
  568.   }
  569.   switch( eDest ){
  570.     /* In this mode, write each query result to the key of the temporary
  571.     ** table iParm.
  572.     */
  573. #ifndef SQLITE_OMIT_COMPOUND_SELECT
  574.     case SRT_Union: {
  575.       int r1;
  576.       r1 = sqlite3GetTempReg(pParse);
  577.       sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nColumn, r1);
  578.       if( aff ){
  579.         sqlite3VdbeChangeP4(v, -1, aff, P4_STATIC);
  580.       }
  581.       sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, r1);
  582.       sqlite3ReleaseTempReg(pParse, r1);
  583.       break;
  584.     }
  585.     /* Construct a record from the query result, but instead of
  586.     ** saving that record, use it as a key to delete elements from
  587.     ** the temporary table iParm.
  588.     */
  589.     case SRT_Except: {
  590.       sqlite3VdbeAddOp3(v, OP_IdxDelete, iParm, regResult, nColumn);
  591.       break;
  592.     }
  593. #endif
  594.     /* Store the result as data using a unique key.
  595.     */
  596.     case SRT_Table:
  597.     case SRT_EphemTab: {
  598.       int r1 = sqlite3GetTempReg(pParse);
  599.       sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nColumn, r1);
  600.       if( pOrderBy ){
  601.         pushOntoSorter(pParse, pOrderBy, p, r1);
  602.       }else{
  603.         int r2 = sqlite3GetTempReg(pParse);
  604.         sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, r2);
  605.         sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, r2);
  606.         sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
  607.         sqlite3ReleaseTempReg(pParse, r2);
  608.       }
  609.       sqlite3ReleaseTempReg(pParse, r1);
  610.       break;
  611.     }
  612. #ifndef SQLITE_OMIT_SUBQUERY
  613.     /* If we are creating a set for an "expr IN (SELECT ...)" construct,
  614.     ** then there should be a single item on the stack.  Write this
  615.     ** item into the set table with bogus data.
  616.     */
  617.     case SRT_Set: {
  618.       int addr2;
  619.       assert( nColumn==1 );
  620.       addr2 = sqlite3VdbeAddOp1(v, OP_IsNull, regResult);
  621.       p->affinity = sqlite3CompareAffinity(pEList->a[0].pExpr, pDest->affinity);
  622.       if( pOrderBy ){
  623.         /* At first glance you would think we could optimize out the
  624.         ** ORDER BY in this case since the order of entries in the set
  625.         ** does not matter.  But there might be a LIMIT clause, in which
  626.         ** case the order does matter */
  627.         pushOntoSorter(pParse, pOrderBy, p, regResult);
  628.       }else{
  629.         int r1 = sqlite3GetTempReg(pParse);
  630.         sqlite3VdbeAddOp4(v, OP_MakeRecord, regResult, 1, r1, &p->affinity, 1);
  631.         sqlite3ExprCacheAffinityChange(pParse, regResult, 1);
  632.         sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, r1);
  633.         sqlite3ReleaseTempReg(pParse, r1);
  634.       }
  635.       sqlite3VdbeJumpHere(v, addr2);
  636.       break;
  637.     }
  638.     /* If any row exist in the result set, record that fact and abort.
  639.     */
  640.     case SRT_Exists: {
  641.       sqlite3VdbeAddOp2(v, OP_Integer, 1, iParm);
  642.       /* The LIMIT clause will terminate the loop for us */
  643.       break;
  644.     }
  645.     /* If this is a scalar select that is part of an expression, then
  646.     ** store the results in the appropriate memory cell and break out
  647.     ** of the scan loop.
  648.     */
  649.     case SRT_Mem: {
  650.       assert( nColumn==1 );
  651.       if( pOrderBy ){
  652.         pushOntoSorter(pParse, pOrderBy, p, regResult);
  653.       }else{
  654.         sqlite3ExprCodeMove(pParse, regResult, iParm);
  655.         /* The LIMIT clause will jump out of the loop for us */
  656.       }
  657.       break;
  658.     }
  659. #endif /* #ifndef SQLITE_OMIT_SUBQUERY */
  660.     /* Send the data to the callback function or to a subroutine.  In the
  661.     ** case of a subroutine, the subroutine itself is responsible for
  662.     ** popping the data from the stack.
  663.     */
  664.     case SRT_Subroutine:
  665.     case SRT_Callback: {
  666.       if( pOrderBy ){
  667.         int r1 = sqlite3GetTempReg(pParse);
  668.         sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nColumn, r1);
  669.         pushOntoSorter(pParse, pOrderBy, p, r1);
  670.         sqlite3ReleaseTempReg(pParse, r1);
  671.       }else if( eDest==SRT_Subroutine ){
  672.         sqlite3VdbeAddOp2(v, OP_Gosub, 0, iParm);
  673.       }else{
  674.         sqlite3VdbeAddOp2(v, OP_ResultRow, regResult, nColumn);
  675.         sqlite3ExprCacheAffinityChange(pParse, regResult, nColumn);
  676.       }
  677.       break;
  678.     }
  679. #if !defined(SQLITE_OMIT_TRIGGER)
  680.     /* Discard the results.  This is used for SELECT statements inside
  681.     ** the body of a TRIGGER.  The purpose of such selects is to call
  682.     ** user-defined functions that have side effects.  We do not care
  683.     ** about the actual results of the select.
  684.     */
  685.     default: {
  686.       assert( eDest==SRT_Discard );
  687.       break;
  688.     }
  689. #endif
  690.   }
  691.   /* Jump to the end of the loop if the LIMIT is reached.
  692.   */
  693.   if( p->iLimit>=0 && pOrderBy==0 ){
  694.     sqlite3VdbeAddOp2(v, OP_AddImm, p->iLimit, -1);
  695.     sqlite3VdbeAddOp2(v, OP_IfZero, p->iLimit, iBreak);
  696.   }
  697. }
  698. /*
  699. ** Given an expression list, generate a KeyInfo structure that records
  700. ** the collating sequence for each expression in that expression list.
  701. **
  702. ** If the ExprList is an ORDER BY or GROUP BY clause then the resulting
  703. ** KeyInfo structure is appropriate for initializing a virtual index to
  704. ** implement that clause.  If the ExprList is the result set of a SELECT
  705. ** then the KeyInfo structure is appropriate for initializing a virtual
  706. ** index to implement a DISTINCT test.
  707. **
  708. ** Space to hold the KeyInfo structure is obtain from malloc.  The calling
  709. ** function is responsible for seeing that this structure is eventually
  710. ** freed.  Add the KeyInfo structure to the P4 field of an opcode using
  711. ** P4_KEYINFO_HANDOFF is the usual way of dealing with this.
  712. */
  713. static KeyInfo *keyInfoFromExprList(Parse *pParse, ExprList *pList){
  714.   sqlite3 *db = pParse->db;
  715.   int nExpr;
  716.   KeyInfo *pInfo;
  717.   struct ExprList_item *pItem;
  718.   int i;
  719.   nExpr = pList->nExpr;
  720.   pInfo = sqlite3DbMallocZero(db, sizeof(*pInfo) + nExpr*(sizeof(CollSeq*)+1) );
  721.   if( pInfo ){
  722.     pInfo->aSortOrder = (u8*)&pInfo->aColl[nExpr];
  723.     pInfo->nField = nExpr;
  724.     pInfo->enc = ENC(db);
  725.     for(i=0, pItem=pList->a; i<nExpr; i++, pItem++){
  726.       CollSeq *pColl;
  727.       pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
  728.       if( !pColl ){
  729.         pColl = db->pDfltColl;
  730.       }
  731.       pInfo->aColl[i] = pColl;
  732.       pInfo->aSortOrder[i] = pItem->sortOrder;
  733.     }
  734.   }
  735.   return pInfo;
  736. }
  737. /*
  738. ** If the inner loop was generated using a non-null pOrderBy argument,
  739. ** then the results were placed in a sorter.  After the loop is terminated
  740. ** we need to run the sorter and output the results.  The following
  741. ** routine generates the code needed to do that.
  742. */
  743. static void generateSortTail(
  744.   Parse *pParse,    /* Parsing context */
  745.   Select *p,        /* The SELECT statement */
  746.   Vdbe *v,          /* Generate code into this VDBE */
  747.   int nColumn,      /* Number of columns of data */
  748.   SelectDest *pDest /* Write the sorted results here */
  749. ){
  750.   int brk = sqlite3VdbeMakeLabel(v);
  751.   int cont = sqlite3VdbeMakeLabel(v);
  752.   int addr;
  753.   int iTab;
  754.   int pseudoTab = 0;
  755.   ExprList *pOrderBy = p->pOrderBy;
  756.   int eDest = pDest->eDest;
  757.   int iParm = pDest->iParm;
  758.   int regRow;
  759.   int regRowid;
  760.   iTab = pOrderBy->iECursor;
  761.   if( eDest==SRT_Callback || eDest==SRT_Subroutine ){
  762.     pseudoTab = pParse->nTab++;
  763.     sqlite3VdbeAddOp2(v, OP_SetNumColumns, 0, nColumn);
  764.     sqlite3VdbeAddOp2(v, OP_OpenPseudo, pseudoTab, eDest==SRT_Callback);
  765.   }
  766.   addr = 1 + sqlite3VdbeAddOp2(v, OP_Sort, iTab, brk);
  767.   codeOffset(v, p, cont);
  768.   regRow = sqlite3GetTempReg(pParse);
  769.   regRowid = sqlite3GetTempReg(pParse);
  770.   sqlite3VdbeAddOp3(v, OP_Column, iTab, pOrderBy->nExpr + 1, regRow);
  771.   switch( eDest ){
  772.     case SRT_Table:
  773.     case SRT_EphemTab: {
  774.       sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, regRowid);
  775.       sqlite3VdbeAddOp3(v, OP_Insert, iParm, regRow, regRowid);
  776.       sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
  777.       break;
  778.     }
  779. #ifndef SQLITE_OMIT_SUBQUERY
  780.     case SRT_Set: {
  781.       int j1;
  782.       assert( nColumn==1 );
  783.       j1 = sqlite3VdbeAddOp1(v, OP_IsNull, regRow);
  784.       sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, 1, regRowid, &p->affinity, 1);
  785.       sqlite3ExprCacheAffinityChange(pParse, regRow, 1);
  786.       sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, regRowid);
  787.       sqlite3VdbeJumpHere(v, j1);
  788.       break;
  789.     }
  790.     case SRT_Mem: {
  791.       assert( nColumn==1 );
  792.       sqlite3ExprCodeMove(pParse, regRow, iParm);
  793.       /* The LIMIT clause will terminate the loop for us */
  794.       break;
  795.     }
  796. #endif
  797.     case SRT_Callback:
  798.     case SRT_Subroutine: {
  799.       int i;
  800.       sqlite3VdbeAddOp2(v, OP_Integer, 1, regRowid);
  801.       sqlite3VdbeAddOp3(v, OP_Insert, pseudoTab, regRow, regRowid);
  802.       for(i=0; i<nColumn; i++){
  803.         assert( regRow!=pDest->iMem+i );
  804.         sqlite3VdbeAddOp3(v, OP_Column, pseudoTab, i, pDest->iMem+i);
  805.       }
  806.       if( eDest==SRT_Callback ){
  807.         sqlite3VdbeAddOp2(v, OP_ResultRow, pDest->iMem, nColumn);
  808.         sqlite3ExprCacheAffinityChange(pParse, pDest->iMem, nColumn);
  809.       }else{
  810.         sqlite3VdbeAddOp2(v, OP_Gosub, 0, iParm);
  811.       }
  812.       break;
  813.     }
  814.     default: {
  815.       /* Do nothing */
  816.       break;
  817.     }
  818.   }
  819.   sqlite3ReleaseTempReg(pParse, regRow);
  820.   sqlite3ReleaseTempReg(pParse, regRowid);
  821.   /* Jump to the end of the loop when the LIMIT is reached
  822.   */
  823.   if( p->iLimit>=0 ){
  824.     sqlite3VdbeAddOp2(v, OP_AddImm, p->iLimit, -1);
  825.     sqlite3VdbeAddOp2(v, OP_IfZero, p->iLimit, brk);
  826.   }
  827.   /* The bottom of the loop
  828.   */
  829.   sqlite3VdbeResolveLabel(v, cont);
  830.   sqlite3VdbeAddOp2(v, OP_Next, iTab, addr);
  831.   sqlite3VdbeResolveLabel(v, brk);
  832.   if( eDest==SRT_Callback || eDest==SRT_Subroutine ){
  833.     sqlite3VdbeAddOp2(v, OP_Close, pseudoTab, 0);
  834.   }
  835. }
  836. /*
  837. ** Return a pointer to a string containing the 'declaration type' of the
  838. ** expression pExpr. The string may be treated as static by the caller.
  839. **
  840. ** The declaration type is the exact datatype definition extracted from the
  841. ** original CREATE TABLE statement if the expression is a column. The
  842. ** declaration type for a ROWID field is INTEGER. Exactly when an expression
  843. ** is considered a column can be complex in the presence of subqueries. The
  844. ** result-set expression in all of the following SELECT statements is 
  845. ** considered a column by this function.
  846. **
  847. **   SELECT col FROM tbl;
  848. **   SELECT (SELECT col FROM tbl;
  849. **   SELECT (SELECT col FROM tbl);
  850. **   SELECT abc FROM (SELECT col AS abc FROM tbl);
  851. ** 
  852. ** The declaration type for any expression other than a column is NULL.
  853. */
  854. static const char *columnType(
  855.   NameContext *pNC, 
  856.   Expr *pExpr,
  857.   const char **pzOriginDb,
  858.   const char **pzOriginTab,
  859.   const char **pzOriginCol
  860. ){
  861.   char const *zType = 0;
  862.   char const *zOriginDb = 0;
  863.   char const *zOriginTab = 0;
  864.   char const *zOriginCol = 0;
  865.   int j;
  866.   if( pExpr==0 || pNC->pSrcList==0 ) return 0;
  867.   switch( pExpr->op ){
  868.     case TK_AGG_COLUMN:
  869.     case TK_COLUMN: {
  870.       /* The expression is a column. Locate the table the column is being
  871.       ** extracted from in NameContext.pSrcList. This table may be real
  872.       ** database table or a subquery.
  873.       */
  874.       Table *pTab = 0;            /* Table structure column is extracted from */
  875.       Select *pS = 0;             /* Select the column is extracted from */
  876.       int iCol = pExpr->iColumn;  /* Index of column in pTab */
  877.       while( pNC && !pTab ){
  878.         SrcList *pTabList = pNC->pSrcList;
  879.         for(j=0;j<pTabList->nSrc && pTabList->a[j].iCursor!=pExpr->iTable;j++);
  880.         if( j<pTabList->nSrc ){
  881.           pTab = pTabList->a[j].pTab;
  882.           pS = pTabList->a[j].pSelect;
  883.         }else{
  884.           pNC = pNC->pNext;
  885.         }
  886.       }
  887.       if( pTab==0 ){
  888.         /* FIX ME:
  889.         ** This can occurs if you have something like "SELECT new.x;" inside
  890.         ** a trigger.  In other words, if you reference the special "new"
  891.         ** table in the result set of a select.  We do not have a good way
  892.         ** to find the actual table type, so call it "TEXT".  This is really
  893.         ** something of a bug, but I do not know how to fix it.
  894.         **
  895.         ** This code does not produce the correct answer - it just prevents
  896.         ** a segfault.  See ticket #1229.
  897.         */
  898.         zType = "TEXT";
  899.         break;
  900.       }
  901.       assert( pTab );
  902.       if( pS ){
  903.         /* The "table" is actually a sub-select or a view in the FROM clause
  904.         ** of the SELECT statement. Return the declaration type and origin
  905.         ** data for the result-set column of the sub-select.
  906.         */
  907.         if( iCol>=0 && iCol<pS->pEList->nExpr ){
  908.           /* If iCol is less than zero, then the expression requests the
  909.           ** rowid of the sub-select or view. This expression is legal (see 
  910.           ** test case misc2.2.2) - it always evaluates to NULL.
  911.           */
  912.           NameContext sNC;
  913.           Expr *p = pS->pEList->a[iCol].pExpr;
  914.           sNC.pSrcList = pS->pSrc;
  915.           sNC.pNext = 0;
  916.           sNC.pParse = pNC->pParse;
  917.           zType = columnType(&sNC, p, &zOriginDb, &zOriginTab, &zOriginCol); 
  918.         }
  919.       }else if( pTab->pSchema ){
  920.         /* A real table */
  921.         assert( !pS );
  922.         if( iCol<0 ) iCol = pTab->iPKey;
  923.         assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
  924.         if( iCol<0 ){
  925.           zType = "INTEGER";
  926.           zOriginCol = "rowid";
  927.         }else{
  928.           zType = pTab->aCol[iCol].zType;
  929.           zOriginCol = pTab->aCol[iCol].zName;
  930.         }
  931.         zOriginTab = pTab->zName;
  932.         if( pNC->pParse ){
  933.           int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema);
  934.           zOriginDb = pNC->pParse->db->aDb[iDb].zName;
  935.         }
  936.       }
  937.       break;
  938.     }
  939. #ifndef SQLITE_OMIT_SUBQUERY
  940.     case TK_SELECT: {
  941.       /* The expression is a sub-select. Return the declaration type and
  942.       ** origin info for the single column in the result set of the SELECT
  943.       ** statement.
  944.       */
  945.       NameContext sNC;
  946.       Select *pS = pExpr->pSelect;
  947.       Expr *p = pS->pEList->a[0].pExpr;
  948.       sNC.pSrcList = pS->pSrc;
  949.       sNC.pNext = pNC;
  950.       sNC.pParse = pNC->pParse;
  951.       zType = columnType(&sNC, p, &zOriginDb, &zOriginTab, &zOriginCol); 
  952.       break;
  953.     }
  954. #endif
  955.   }
  956.   
  957.   if( pzOriginDb ){
  958.     assert( pzOriginTab && pzOriginCol );
  959.     *pzOriginDb = zOriginDb;
  960.     *pzOriginTab = zOriginTab;
  961.     *pzOriginCol = zOriginCol;
  962.   }
  963.   return zType;
  964. }
  965. /*
  966. ** Generate code that will tell the VDBE the declaration types of columns
  967. ** in the result set.
  968. */
  969. static void generateColumnTypes(
  970.   Parse *pParse,      /* Parser context */
  971.   SrcList *pTabList,  /* List of tables */
  972.   ExprList *pEList    /* Expressions defining the result set */
  973. ){
  974. #ifndef SQLITE_OMIT_DECLTYPE
  975.   Vdbe *v = pParse->pVdbe;
  976.   int i;
  977.   NameContext sNC;
  978.   sNC.pSrcList = pTabList;
  979.   sNC.pParse = pParse;
  980.   for(i=0; i<pEList->nExpr; i++){
  981.     Expr *p = pEList->a[i].pExpr;
  982.     const char *zType;
  983. #ifdef SQLITE_ENABLE_COLUMN_METADATA
  984.     const char *zOrigDb = 0;
  985.     const char *zOrigTab = 0;
  986.     const char *zOrigCol = 0;
  987.     zType = columnType(&sNC, p, &zOrigDb, &zOrigTab, &zOrigCol);
  988.     /* The vdbe must make its own copy of the column-type and other 
  989.     ** column specific strings, in case the schema is reset before this
  990.     ** virtual machine is deleted.
  991.     */
  992.     sqlite3VdbeSetColName(v, i, COLNAME_DATABASE, zOrigDb, P4_TRANSIENT);
  993.     sqlite3VdbeSetColName(v, i, COLNAME_TABLE, zOrigTab, P4_TRANSIENT);
  994.     sqlite3VdbeSetColName(v, i, COLNAME_COLUMN, zOrigCol, P4_TRANSIENT);
  995. #else
  996.     zType = columnType(&sNC, p, 0, 0, 0);
  997. #endif
  998.     sqlite3VdbeSetColName(v, i, COLNAME_DECLTYPE, zType, P4_TRANSIENT);
  999.   }
  1000. #endif /* SQLITE_OMIT_DECLTYPE */
  1001. }
  1002. /*
  1003. ** Generate code that will tell the VDBE the names of columns
  1004. ** in the result set.  This information is used to provide the
  1005. ** azCol[] values in the callback.
  1006. */
  1007. static void generateColumnNames(
  1008.   Parse *pParse,      /* Parser context */
  1009.   SrcList *pTabList,  /* List of tables */
  1010.   ExprList *pEList    /* Expressions defining the result set */
  1011. ){
  1012.   Vdbe *v = pParse->pVdbe;
  1013.   int i, j;
  1014.   sqlite3 *db = pParse->db;
  1015.   int fullNames, shortNames;
  1016. #ifndef SQLITE_OMIT_EXPLAIN
  1017.   /* If this is an EXPLAIN, skip this step */
  1018.   if( pParse->explain ){
  1019.     return;
  1020.   }
  1021. #endif
  1022.   assert( v!=0 );
  1023.   if( pParse->colNamesSet || v==0 || db->mallocFailed ) return;
  1024.   pParse->colNamesSet = 1;
  1025.   fullNames = (db->flags & SQLITE_FullColNames)!=0;
  1026.   shortNames = (db->flags & SQLITE_ShortColNames)!=0;
  1027.   sqlite3VdbeSetNumCols(v, pEList->nExpr);
  1028.   for(i=0; i<pEList->nExpr; i++){
  1029.     Expr *p;
  1030.     p = pEList->a[i].pExpr;
  1031.     if( p==0 ) continue;
  1032.     if( pEList->a[i].zName ){
  1033.       char *zName = pEList->a[i].zName;
  1034.       sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, strlen(zName));
  1035.       continue;
  1036.     }
  1037.     if( p->op==TK_COLUMN && pTabList ){
  1038.       Table *pTab;
  1039.       char *zCol;
  1040.       int iCol = p->iColumn;
  1041.       for(j=0; j<pTabList->nSrc && pTabList->a[j].iCursor!=p->iTable; j++){}
  1042.       assert( j<pTabList->nSrc );
  1043.       pTab = pTabList->a[j].pTab;
  1044.       if( iCol<0 ) iCol = pTab->iPKey;
  1045.       assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
  1046.       if( iCol<0 ){
  1047.         zCol = "rowid";
  1048.       }else{
  1049.         zCol = pTab->aCol[iCol].zName;
  1050.       }
  1051.       if( !shortNames && !fullNames && p->span.z && p->span.z[0] ){
  1052.         sqlite3VdbeSetColName(v, i, COLNAME_NAME, (char*)p->span.z, p->span.n);
  1053.       }else if( fullNames || (!shortNames && pTabList->nSrc>1) ){
  1054.         char *zName = 0;
  1055.         char *zTab;
  1056.  
  1057.         zTab = pTabList->a[j].zAlias;
  1058.         if( fullNames || zTab==0 ) zTab = pTab->zName;
  1059.         sqlite3SetString(&zName, zTab, ".", zCol, (char*)0);
  1060.         sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, P4_DYNAMIC);
  1061.       }else{
  1062.         sqlite3VdbeSetColName(v, i, COLNAME_NAME, zCol, strlen(zCol));
  1063.       }
  1064.     }else if( p->span.z && p->span.z[0] ){
  1065.       sqlite3VdbeSetColName(v, i, COLNAME_NAME, (char*)p->span.z, p->span.n);
  1066.       /* sqlite3VdbeCompressSpace(v, addr); */
  1067.     }else{
  1068.       char zName[30];
  1069.       assert( p->op!=TK_COLUMN || pTabList==0 );
  1070.       sqlite3_snprintf(sizeof(zName), zName, "column%d", i+1);
  1071.       sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, 0);
  1072.     }
  1073.   }
  1074.   generateColumnTypes(pParse, pTabList, pEList);
  1075. }
  1076. #ifndef SQLITE_OMIT_COMPOUND_SELECT
  1077. /*
  1078. ** Name of the connection operator, used for error messages.
  1079. */
  1080. static const char *selectOpName(int id){
  1081.   char *z;
  1082.   switch( id ){
  1083.     case TK_ALL:       z = "UNION ALL";   break;
  1084.     case TK_INTERSECT: z = "INTERSECT";   break;
  1085.     case TK_EXCEPT:    z = "EXCEPT";      break;
  1086.     default:           z = "UNION";       break;
  1087.   }
  1088.   return z;
  1089. }
  1090. #endif /* SQLITE_OMIT_COMPOUND_SELECT */
  1091. /*
  1092. ** Forward declaration
  1093. */
  1094. static int prepSelectStmt(Parse*, Select*);
  1095. /*
  1096. ** Given a SELECT statement, generate a Table structure that describes
  1097. ** the result set of that SELECT.
  1098. */
  1099. Table *sqlite3ResultSetOfSelect(Parse *pParse, char *zTabName, Select *pSelect){
  1100.   Table *pTab;
  1101.   int i, j;
  1102.   ExprList *pEList;
  1103.   Column *aCol, *pCol;
  1104.   sqlite3 *db = pParse->db;
  1105.   while( pSelect->pPrior ) pSelect = pSelect->pPrior;
  1106.   if( prepSelectStmt(pParse, pSelect) ){
  1107.     return 0;
  1108.   }
  1109.   if( sqlite3SelectResolve(pParse, pSelect, 0) ){
  1110.     return 0;
  1111.   }
  1112.   pTab = sqlite3DbMallocZero(db, sizeof(Table) );
  1113.   if( pTab==0 ){
  1114.     return 0;
  1115.   }
  1116.   pTab->nRef = 1;
  1117.   pTab->zName = zTabName ? sqlite3DbStrDup(db, zTabName) : 0;
  1118.   pEList = pSelect->pEList;
  1119.   pTab->nCol = pEList->nExpr;
  1120.   assert( pTab->nCol>0 );
  1121.   pTab->aCol = aCol = sqlite3DbMallocZero(db, sizeof(pTab->aCol[0])*pTab->nCol);
  1122.   for(i=0, pCol=aCol; i<pTab->nCol; i++, pCol++){
  1123.     Expr *p, *pR;
  1124.     char *zType;
  1125.     char *zName;
  1126.     int nName;
  1127.     CollSeq *pColl;
  1128.     int cnt;
  1129.     NameContext sNC;
  1130.     
  1131.     /* Get an appropriate name for the column
  1132.     */
  1133.     p = pEList->a[i].pExpr;
  1134.     assert( p->pRight==0 || p->pRight->token.z==0 || p->pRight->token.z[0]!=0 );
  1135.     if( (zName = pEList->a[i].zName)!=0 ){
  1136.       /* If the column contains an "AS <name>" phrase, use <name> as the name */
  1137.       zName = sqlite3DbStrDup(db, zName);
  1138.     }else if( p->op==TK_DOT 
  1139.               && (pR=p->pRight)!=0 && pR->token.z && pR->token.z[0] ){
  1140.       /* For columns of the from A.B use B as the name */
  1141.       zName = sqlite3MPrintf(db, "%T", &pR->token);
  1142.     }else if( p->span.z && p->span.z[0] ){
  1143.       /* Use the original text of the column expression as its name */
  1144.       zName = sqlite3MPrintf(db, "%T", &p->span);
  1145.     }else{
  1146.       /* If all else fails, make up a name */
  1147.       zName = sqlite3MPrintf(db, "column%d", i+1);
  1148.     }
  1149.     if( !zName || db->mallocFailed ){
  1150.       db->mallocFailed = 1;
  1151.       sqlite3_free(zName);
  1152.       sqlite3DeleteTable(pTab);
  1153.       return 0;
  1154.     }
  1155.     sqlite3Dequote(zName);
  1156.     /* Make sure the column name is unique.  If the name is not unique,
  1157.     ** append a integer to the name so that it becomes unique.
  1158.     */
  1159.     nName = strlen(zName);
  1160.     for(j=cnt=0; j<i; j++){
  1161.       if( sqlite3StrICmp(aCol[j].zName, zName)==0 ){
  1162.         zName[nName] = 0;
  1163.         zName = sqlite3MPrintf(db, "%z:%d", zName, ++cnt);
  1164.         j = -1;
  1165.         if( zName==0 ) break;
  1166.       }
  1167.     }
  1168.     pCol->zName = zName;
  1169.     /* Get the typename, type affinity, and collating sequence for the
  1170.     ** column.
  1171.     */
  1172.     memset(&sNC, 0, sizeof(sNC));
  1173.     sNC.pSrcList = pSelect->pSrc;
  1174.     zType = sqlite3DbStrDup(db, columnType(&sNC, p, 0, 0, 0));
  1175.     pCol->zType = zType;
  1176.     pCol->affinity = sqlite3ExprAffinity(p);
  1177.     pColl = sqlite3ExprCollSeq(pParse, p);
  1178.     if( pColl ){
  1179.       pCol->zColl = sqlite3DbStrDup(db, pColl->zName);
  1180.     }
  1181.   }
  1182.   pTab->iPKey = -1;
  1183.   return pTab;
  1184. }
  1185. /*
  1186. ** Prepare a SELECT statement for processing by doing the following
  1187. ** things:
  1188. **
  1189. **    (1)  Make sure VDBE cursor numbers have been assigned to every
  1190. **         element of the FROM clause.
  1191. **
  1192. **    (2)  Fill in the pTabList->a[].pTab fields in the SrcList that 
  1193. **         defines FROM clause.  When views appear in the FROM clause,
  1194. **         fill pTabList->a[].pSelect with a copy of the SELECT statement
  1195. **         that implements the view.  A copy is made of the view's SELECT
  1196. **         statement so that we can freely modify or delete that statement
  1197. **         without worrying about messing up the presistent representation
  1198. **         of the view.
  1199. **
  1200. **    (3)  Add terms to the WHERE clause to accomodate the NATURAL keyword
  1201. **         on joins and the ON and USING clause of joins.
  1202. **
  1203. **    (4)  Scan the list of columns in the result set (pEList) looking
  1204. **         for instances of the "*" operator or the TABLE.* operator.
  1205. **         If found, expand each "*" to be every column in every table
  1206. **         and TABLE.* to be every column in TABLE.
  1207. **
  1208. ** Return 0 on success.  If there are problems, leave an error message
  1209. ** in pParse and return non-zero.
  1210. */
  1211. static int prepSelectStmt(Parse *pParse, Select *p){
  1212.   int i, j, k, rc;
  1213.   SrcList *pTabList;
  1214.   ExprList *pEList;
  1215.   struct SrcList_item *pFrom;
  1216.   sqlite3 *db = pParse->db;
  1217.   if( p==0 || p->pSrc==0 || db->mallocFailed ){
  1218.     return 1;
  1219.   }
  1220.   pTabList = p->pSrc;
  1221.   pEList = p->pEList;
  1222.   /* Make sure cursor numbers have been assigned to all entries in
  1223.   ** the FROM clause of the SELECT statement.
  1224.   */
  1225.   sqlite3SrcListAssignCursors(pParse, p->pSrc);
  1226.   /* Look up every table named in the FROM clause of the select.  If
  1227.   ** an entry of the FROM clause is a subquery instead of a table or view,
  1228.   ** then create a transient table structure to describe the subquery.
  1229.   */
  1230.   for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
  1231.     Table *pTab;
  1232.     if( pFrom->pTab!=0 ){
  1233.       /* This statement has already been prepared.  There is no need
  1234.       ** to go further. */
  1235.       assert( i==0 );
  1236.       return 0;
  1237.     }
  1238.     if( pFrom->zName==0 ){
  1239. #ifndef SQLITE_OMIT_SUBQUERY
  1240.       /* A sub-query in the FROM clause of a SELECT */
  1241.       assert( pFrom->pSelect!=0 );
  1242.       if( pFrom->zAlias==0 ){
  1243.         pFrom->zAlias =
  1244.           sqlite3MPrintf(db, "sqlite_subquery_%p_", (void*)pFrom->pSelect);
  1245.       }
  1246.       assert( pFrom->pTab==0 );
  1247.       pFrom->pTab = pTab = 
  1248.         sqlite3ResultSetOfSelect(pParse, pFrom->zAlias, pFrom->pSelect);
  1249.       if( pTab==0 ){
  1250.         return 1;
  1251.       }
  1252.       /* The isEphem flag indicates that the Table structure has been
  1253.       ** dynamically allocated and may be freed at any time.  In other words,
  1254.       ** pTab is not pointing to a persistent table structure that defines
  1255.       ** part of the schema. */
  1256.       pTab->isEphem = 1;
  1257. #endif
  1258.     }else{
  1259.       /* An ordinary table or view name in the FROM clause */
  1260.       assert( pFrom->pTab==0 );
  1261.       pFrom->pTab = pTab = 
  1262.         sqlite3LocateTable(pParse,0,pFrom->zName,pFrom->zDatabase);
  1263.       if( pTab==0 ){
  1264.         return 1;
  1265.       }
  1266.       pTab->nRef++;
  1267. #if !defined(SQLITE_OMIT_VIEW) || !defined (SQLITE_OMIT_VIRTUALTABLE)
  1268.       if( pTab->pSelect || IsVirtual(pTab) ){
  1269.         /* We reach here if the named table is a really a view */
  1270.         if( sqlite3ViewGetColumnNames(pParse, pTab) ){
  1271.           return 1;
  1272.         }
  1273.         /* If pFrom->pSelect!=0 it means we are dealing with a
  1274.         ** view within a view.  The SELECT structure has already been
  1275.         ** copied by the outer view so we can skip the copy step here
  1276.         ** in the inner view.
  1277.         */
  1278.         if( pFrom->pSelect==0 ){
  1279.           pFrom->pSelect = sqlite3SelectDup(db, pTab->pSelect);
  1280.         }
  1281.       }
  1282. #endif
  1283.     }
  1284.   }
  1285.   /* Process NATURAL keywords, and ON and USING clauses of joins.
  1286.   */
  1287.   if( sqliteProcessJoin(pParse, p) ) return 1;
  1288.   /* For every "*" that occurs in the column list, insert the names of
  1289.   ** all columns in all tables.  And for every TABLE.* insert the names
  1290.   ** of all columns in TABLE.  The parser inserted a special expression
  1291.   ** with the TK_ALL operator for each "*" that it found in the column list.
  1292.   ** The following code just has to locate the TK_ALL expressions and expand
  1293.   ** each one to the list of all columns in all tables.
  1294.   **
  1295.   ** The first loop just checks to see if there are any "*" operators
  1296.   ** that need expanding.
  1297.   */
  1298.   for(k=0; k<pEList->nExpr; k++){
  1299.     Expr *pE = pEList->a[k].pExpr;
  1300.     if( pE->op==TK_ALL ) break;
  1301.     if( pE->op==TK_DOT && pE->pRight && pE->pRight->op==TK_ALL
  1302.          && pE->pLeft && pE->pLeft->op==TK_ID ) break;
  1303.   }
  1304.   rc = 0;
  1305.   if( k<pEList->nExpr ){
  1306.     /*
  1307.     ** If we get here it means the result set contains one or more "*"
  1308.     ** operators that need to be expanded.  Loop through each expression
  1309.     ** in the result set and expand them one by one.
  1310.     */
  1311.     struct ExprList_item *a = pEList->a;
  1312.     ExprList *pNew = 0;
  1313.     int flags = pParse->db->flags;
  1314.     int longNames = (flags & SQLITE_FullColNames)!=0 &&
  1315.                       (flags & SQLITE_ShortColNames)==0;
  1316.     for(k=0; k<pEList->nExpr; k++){
  1317.       Expr *pE = a[k].pExpr;
  1318.       if( pE->op!=TK_ALL &&
  1319.            (pE->op!=TK_DOT || pE->pRight==0 || pE->pRight->op!=TK_ALL) ){
  1320.         /* This particular expression does not need to be expanded.
  1321.         */
  1322.         pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr, 0);
  1323.         if( pNew ){
  1324.           pNew->a[pNew->nExpr-1].zName = a[k].zName;
  1325.         }else{
  1326.           rc = 1;
  1327.         }
  1328.         a[k].pExpr = 0;
  1329.         a[k].zName = 0;
  1330.       }else{
  1331.         /* This expression is a "*" or a "TABLE.*" and needs to be
  1332.         ** expanded. */
  1333.         int tableSeen = 0;      /* Set to 1 when TABLE matches */
  1334.         char *zTName;            /* text of name of TABLE */
  1335.         if( pE->op==TK_DOT && pE->pLeft ){
  1336.           zTName = sqlite3NameFromToken(db, &pE->pLeft->token);
  1337.         }else{
  1338.           zTName = 0;
  1339.         }
  1340.         for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
  1341.           Table *pTab = pFrom->pTab;
  1342.           char *zTabName = pFrom->zAlias;
  1343.           if( zTabName==0 || zTabName[0]==0 ){ 
  1344.             zTabName = pTab->zName;
  1345.           }
  1346.           if( zTName && (zTabName==0 || zTabName[0]==0 || 
  1347.                  sqlite3StrICmp(zTName, zTabName)!=0) ){
  1348.             continue;
  1349.           }
  1350.           tableSeen = 1;
  1351.           for(j=0; j<pTab->nCol; j++){
  1352.             Expr *pExpr, *pRight;
  1353.             char *zName = pTab->aCol[j].zName;
  1354.             /* If a column is marked as 'hidden' (currently only possible
  1355.             ** for virtual tables), do not include it in the expanded
  1356.             ** result-set list.
  1357.             */
  1358.             if( IsHiddenColumn(&pTab->aCol[j]) ){
  1359.               assert(IsVirtual(pTab));
  1360.               continue;
  1361.             }
  1362.             if( i>0 ){
  1363.               struct SrcList_item *pLeft = &pTabList->a[i-1];
  1364.               if( (pLeft[1].jointype & JT_NATURAL)!=0 &&
  1365.                         columnIndex(pLeft->pTab, zName)>=0 ){
  1366.                 /* In a NATURAL join, omit the join columns from the 
  1367.                 ** table on the right */
  1368.                 continue;
  1369.               }
  1370.               if( sqlite3IdListIndex(pLeft[1].pUsing, zName)>=0 ){
  1371.                 /* In a join with a USING clause, omit columns in the
  1372.                 ** using clause from the table on the right. */
  1373.                 continue;
  1374.               }
  1375.             }
  1376.             pRight = sqlite3PExpr(pParse, TK_ID, 0, 0, 0);
  1377.             if( pRight==0 ) break;
  1378.             setQuotedToken(pParse, &pRight->token, zName);
  1379.             if( zTabName && (longNames || pTabList->nSrc>1) ){
  1380.               Expr *pLeft = sqlite3PExpr(pParse, TK_ID, 0, 0, 0);
  1381.               pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight, 0);
  1382.               if( pExpr==0 ) break;
  1383.               setQuotedToken(pParse, &pLeft->token, zTabName);
  1384.               setToken(&pExpr->span, 
  1385.                   sqlite3MPrintf(db, "%s.%s", zTabName, zName));
  1386.               pExpr->span.dyn = 1;
  1387.               pExpr->token.z = 0;
  1388.               pExpr->token.n = 0;
  1389.               pExpr->token.dyn = 0;
  1390.             }else{
  1391.               pExpr = pRight;
  1392.               pExpr->span = pExpr->token;
  1393.               pExpr->span.dyn = 0;
  1394.             }
  1395.             if( longNames ){
  1396.               pNew = sqlite3ExprListAppend(pParse, pNew, pExpr, &pExpr->span);
  1397.             }else{
  1398.               pNew = sqlite3ExprListAppend(pParse, pNew, pExpr, &pRight->token);
  1399.             }
  1400.           }
  1401.         }
  1402.         if( !tableSeen ){
  1403.           if( zTName ){
  1404.             sqlite3ErrorMsg(pParse, "no such table: %s", zTName);
  1405.           }else{
  1406.             sqlite3ErrorMsg(pParse, "no tables specified");
  1407.           }
  1408.           rc = 1;
  1409.         }
  1410.         sqlite3_free(zTName);
  1411.       }
  1412.     }
  1413.     sqlite3ExprListDelete(pEList);
  1414.     p->pEList = pNew;
  1415.   }
  1416. #if SQLITE_MAX_COLUMN
  1417.   if( p->pEList && p->pEList->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
  1418.     sqlite3ErrorMsg(pParse, "too many columns in result set");
  1419.     rc = SQLITE_ERROR;
  1420.   }
  1421. #endif
  1422.   if( db->mallocFailed ){
  1423.     rc = SQLITE_NOMEM;
  1424.   }
  1425.   return rc;
  1426. }
  1427. /*
  1428. ** pE is a pointer to an expression which is a single term in
  1429. ** ORDER BY or GROUP BY clause.
  1430. **
  1431. ** If pE evaluates to an integer constant i, then return i.
  1432. ** This is an indication to the caller that it should sort
  1433. ** by the i-th column of the result set.
  1434. **
  1435. ** If pE is a well-formed expression and the SELECT statement
  1436. ** is not compound, then return 0.  This indicates to the
  1437. ** caller that it should sort by the value of the ORDER BY
  1438. ** expression.
  1439. **
  1440. ** If the SELECT is compound, then attempt to match pE against
  1441. ** result set columns in the left-most SELECT statement.  Return
  1442. ** the index i of the matching column, as an indication to the 
  1443. ** caller that it should sort by the i-th column.  If there is
  1444. ** no match, return -1 and leave an error message in pParse.
  1445. */
  1446. static int matchOrderByTermToExprList(
  1447.   Parse *pParse,     /* Parsing context for error messages */
  1448.   Select *pSelect,   /* The SELECT statement with the ORDER BY clause */
  1449.   Expr *pE,          /* The specific ORDER BY term */
  1450.   int idx,           /* When ORDER BY term is this */
  1451.   int isCompound,    /* True if this is a compound SELECT */
  1452.   u8 *pHasAgg        /* True if expression contains aggregate functions */
  1453. ){
  1454.   int i;             /* Loop counter */
  1455.   ExprList *pEList;  /* The columns of the result set */
  1456.   NameContext nc;    /* Name context for resolving pE */
  1457.   /* If the term is an integer constant, return the value of that
  1458.   ** constant */
  1459.   pEList = pSelect->pEList;
  1460.   if( sqlite3ExprIsInteger(pE, &i) ){
  1461.     if( i<=0 ){
  1462.       /* If i is too small, make it too big.  That way the calling
  1463.       ** function still sees a value that is out of range, but does
  1464.       ** not confuse the column number with 0 or -1 result code.
  1465.       */
  1466.       i = pEList->nExpr+1;
  1467.     }
  1468.     return i;
  1469.   }
  1470.   /* If the term is a simple identifier that try to match that identifier
  1471.   ** against a column name in the result set.
  1472.   */
  1473.   if( pE->op==TK_ID || (pE->op==TK_STRING && pE->token.z[0]!=''') ){
  1474.     sqlite3 *db = pParse->db;
  1475.     char *zCol = sqlite3NameFromToken(db, &pE->token);
  1476.     if( zCol==0 ){
  1477.       return -1;
  1478.     }
  1479.     for(i=0; i<pEList->nExpr; i++){
  1480.       char *zAs = pEList->a[i].zName;
  1481.       if( zAs!=0 && sqlite3StrICmp(zAs, zCol)==0 ){
  1482.         sqlite3_free(zCol);
  1483.         return i+1;
  1484.       }
  1485.     }
  1486.     sqlite3_free(zCol);
  1487.   }
  1488.   /* Resolve all names in the ORDER BY term expression
  1489.   */
  1490.   memset(&nc, 0, sizeof(nc));
  1491.   nc.pParse = pParse;
  1492.   nc.pSrcList = pSelect->pSrc;
  1493.   nc.pEList = pEList;
  1494.   nc.allowAgg = 1;
  1495.   nc.nErr = 0;
  1496.   if( sqlite3ExprResolveNames(&nc, pE) ){
  1497.     if( isCompound ){
  1498.       sqlite3ErrorClear(pParse);
  1499.       return 0;
  1500.     }else{
  1501.       return -1;
  1502.     }
  1503.   }
  1504.   if( nc.hasAgg && pHasAgg ){
  1505.     *pHasAgg = 1;
  1506.   }
  1507.   /* For a compound SELECT, we need to try to match the ORDER BY
  1508.   ** expression against an expression in the result set
  1509.   */
  1510.   if( isCompound ){
  1511.     for(i=0; i<pEList->nExpr; i++){
  1512.       if( sqlite3ExprCompare(pEList->a[i].pExpr, pE) ){
  1513.         return i+1;
  1514.       }
  1515.     }
  1516.   }
  1517.   return 0;
  1518. }
  1519. /*
  1520. ** Analyze and ORDER BY or GROUP BY clause in a simple SELECT statement.
  1521. ** Return the number of errors seen.
  1522. **
  1523. ** Every term of the ORDER BY or GROUP BY clause needs to be an
  1524. ** expression.  If any expression is an integer constant, then
  1525. ** that expression is replaced by the corresponding 
  1526. ** expression from the result set.
  1527. */
  1528. static int processOrderGroupBy(
  1529.   Parse *pParse,        /* Parsing context.  Leave error messages here */
  1530.   Select *pSelect,      /* The SELECT statement containing the clause */
  1531.   ExprList *pOrderBy,   /* The ORDER BY or GROUP BY clause to be processed */
  1532.   int isOrder,          /* 1 for ORDER BY.  0 for GROUP BY */
  1533.   u8 *pHasAgg           /* Set to TRUE if any term contains an aggregate */
  1534. ){
  1535.   int i;
  1536.   sqlite3 *db = pParse->db;
  1537.   ExprList *pEList;
  1538.   if( pOrderBy==0 || pParse->db->mallocFailed ) return 0;
  1539. #if SQLITE_MAX_COLUMN
  1540.   if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
  1541.     const char *zType = isOrder ? "ORDER" : "GROUP";
  1542.     sqlite3ErrorMsg(pParse, "too many terms in %s BY clause", zType);
  1543.     return 1;
  1544.   }
  1545. #endif
  1546.   pEList = pSelect->pEList;
  1547.   if( pEList==0 ){
  1548.     return 0;
  1549.   }
  1550.   for(i=0; i<pOrderBy->nExpr; i++){
  1551.     int iCol;
  1552.     Expr *pE = pOrderBy->a[i].pExpr;
  1553.     iCol = matchOrderByTermToExprList(pParse, pSelect, pE, i+1, 0, pHasAgg);
  1554.     if( iCol<0 ){
  1555.       return 1;
  1556.     }
  1557.     if( iCol>pEList->nExpr ){
  1558.       const char *zType = isOrder ? "ORDER" : "GROUP";
  1559.       sqlite3ErrorMsg(pParse, 
  1560.          "%r %s BY term out of range - should be "
  1561.          "between 1 and %d", i+1, zType, pEList->nExpr);
  1562.       return 1;
  1563.     }
  1564.     if( iCol>0 ){
  1565.       CollSeq *pColl = pE->pColl;
  1566.       int flags = pE->flags & EP_ExpCollate;
  1567.       sqlite3ExprDelete(pE);
  1568.       pE = sqlite3ExprDup(db, pEList->a[iCol-1].pExpr);
  1569.       pOrderBy->a[i].pExpr = pE;
  1570.       if( pE && pColl && flags ){
  1571.         pE->pColl = pColl;
  1572.         pE->flags |= flags;
  1573.       }
  1574.     }
  1575.   }
  1576.   return 0;
  1577. }
  1578. /*
  1579. ** Analyze and ORDER BY or GROUP BY clause in a SELECT statement.  Return
  1580. ** the number of errors seen.
  1581. **
  1582. ** The processing depends on whether the SELECT is simple or compound.
  1583. ** For a simple SELECT statement, evry term of the ORDER BY or GROUP BY
  1584. ** clause needs to be an expression.  If any expression is an integer
  1585. ** constant, then that expression is replaced by the corresponding 
  1586. ** expression from the result set.
  1587. **
  1588. ** For compound SELECT statements, every expression needs to be of
  1589. ** type TK_COLUMN with a iTable value as given in the 4th parameter.
  1590. ** If any expression is an integer, that becomes the column number.
  1591. ** Otherwise, match the expression against result set columns from
  1592. ** the left-most SELECT.
  1593. */
  1594. static int processCompoundOrderBy(
  1595.   Parse *pParse,        /* Parsing context.  Leave error messages here */
  1596.   Select *pSelect,      /* The SELECT statement containing the ORDER BY */
  1597.   int iTable            /* Output table for compound SELECT statements */
  1598. ){
  1599.   int i;
  1600.   ExprList *pOrderBy;
  1601.   ExprList *pEList;
  1602.   sqlite3 *db;
  1603.   int moreToDo = 1;
  1604.   pOrderBy = pSelect->pOrderBy;
  1605.   if( pOrderBy==0 ) return 0;
  1606.   db = pParse->db;
  1607. #if SQLITE_MAX_COLUMN
  1608.   if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
  1609.     sqlite3ErrorMsg(pParse, "too many terms in ORDER BY clause");
  1610.     return 1;
  1611.   }
  1612. #endif
  1613.   for(i=0; i<pOrderBy->nExpr; i++){
  1614.     pOrderBy->a[i].done = 0;
  1615.   }
  1616.   while( pSelect->pPrior ){
  1617.     pSelect = pSelect->pPrior;
  1618.   }
  1619.   while( pSelect && moreToDo ){
  1620.     moreToDo = 0;
  1621.     for(i=0; i<pOrderBy->nExpr; i++){
  1622.       int iCol = -1;
  1623.       Expr *pE, *pDup;
  1624.       if( pOrderBy->a[i].done ) continue;
  1625.       pE = pOrderBy->a[i].pExpr;
  1626.       pDup = sqlite3ExprDup(db, pE);
  1627.       if( !db->mallocFailed ){
  1628.         assert(pDup);
  1629.         iCol = matchOrderByTermToExprList(pParse, pSelect, pDup, i+1, 1, 0);
  1630.       }
  1631.       sqlite3ExprDelete(pDup);
  1632.       if( iCol<0 ){
  1633.         return 1;
  1634.       }
  1635.       pEList = pSelect->pEList;
  1636.       if( pEList==0 ){
  1637.         return 1;
  1638.       }
  1639.       if( iCol>pEList->nExpr ){
  1640.         sqlite3ErrorMsg(pParse, 
  1641.            "%r ORDER BY term out of range - should be "
  1642.            "between 1 and %d", i+1, pEList->nExpr);
  1643.         return 1;
  1644.       }
  1645.       if( iCol>0 ){
  1646.         pE->op = TK_COLUMN;
  1647.         pE->iTable = iTable;
  1648.         pE->iAgg = -1;
  1649.         pE->iColumn = iCol-1;
  1650.         pE->pTab = 0;
  1651.         pOrderBy->a[i].done = 1;
  1652.       }else{
  1653.         moreToDo = 1;
  1654.       }
  1655.     }
  1656.     pSelect = pSelect->pNext;
  1657.   }
  1658.   for(i=0; i<pOrderBy->nExpr; i++){
  1659.     if( pOrderBy->a[i].done==0 ){
  1660.       sqlite3ErrorMsg(pParse, "%r ORDER BY term does not match any "
  1661.             "column in the result set", i+1);
  1662.       return 1;
  1663.     }
  1664.   }
  1665.   return 0;
  1666. }
  1667. /*
  1668. ** Get a VDBE for the given parser context.  Create a new one if necessary.
  1669. ** If an error occurs, return NULL and leave a message in pParse.
  1670. */
  1671. Vdbe *sqlite3GetVdbe(Parse *pParse){
  1672.   Vdbe *v = pParse->pVdbe;
  1673.   if( v==0 ){
  1674.     v = pParse->pVdbe = sqlite3VdbeCreate(pParse->db);
  1675. #ifndef SQLITE_OMIT_TRACE
  1676.     if( v ){
  1677.       sqlite3VdbeAddOp0(v, OP_Trace);
  1678.     }
  1679. #endif
  1680.   }
  1681.   return v;
  1682. }
  1683. /*
  1684. ** Compute the iLimit and iOffset fields of the SELECT based on the
  1685. ** pLimit and pOffset expressions.  pLimit and pOffset hold the expressions
  1686. ** that appear in the original SQL statement after the LIMIT and OFFSET
  1687. ** keywords.  Or NULL if those keywords are omitted. iLimit and iOffset 
  1688. ** are the integer memory register numbers for counters used to compute 
  1689. ** the limit and offset.  If there is no limit and/or offset, then 
  1690. ** iLimit and iOffset are negative.
  1691. **
  1692. ** This routine changes the values of iLimit and iOffset only if
  1693. ** a limit or offset is defined by pLimit and pOffset.  iLimit and
  1694. ** iOffset should have been preset to appropriate default values
  1695. ** (usually but not always -1) prior to calling this routine.
  1696. ** Only if pLimit!=0 or pOffset!=0 do the limit registers get
  1697. ** redefined.  The UNION ALL operator uses this property to force
  1698. ** the reuse of the same limit and offset registers across multiple
  1699. ** SELECT statements.
  1700. */
  1701. static void computeLimitRegisters(Parse *pParse, Select *p, int iBreak){
  1702.   Vdbe *v = 0;
  1703.   int iLimit = 0;
  1704.   int iOffset;
  1705.   int addr1;
  1706.   /* 
  1707.   ** "LIMIT -1" always shows all rows.  There is some
  1708.   ** contraversy about what the correct behavior should be.
  1709.   ** The current implementation interprets "LIMIT 0" to mean
  1710.   ** no rows.
  1711.   */
  1712.   if( p->pLimit ){
  1713.     p->iLimit = iLimit = ++pParse->nMem;
  1714.     v = sqlite3GetVdbe(pParse);
  1715.     if( v==0 ) return;
  1716.     sqlite3ExprCode(pParse, p->pLimit, iLimit);
  1717.     sqlite3VdbeAddOp1(v, OP_MustBeInt, iLimit);
  1718.     VdbeComment((v, "LIMIT counter"));
  1719.     sqlite3VdbeAddOp2(v, OP_IfZero, iLimit, iBreak);
  1720.   }
  1721.   if( p->pOffset ){
  1722.     p->iOffset = iOffset = ++pParse->nMem;
  1723.     if( p->pLimit ){
  1724.       pParse->nMem++;   /* Allocate an extra register for limit+offset */
  1725.     }
  1726.     v = sqlite3GetVdbe(pParse);
  1727.     if( v==0 ) return;
  1728.     sqlite3ExprCode(pParse, p->pOffset, iOffset);
  1729.     sqlite3VdbeAddOp1(v, OP_MustBeInt, iOffset);
  1730.     VdbeComment((v, "OFFSET counter"));
  1731.     addr1 = sqlite3VdbeAddOp1(v, OP_IfPos, iOffset);
  1732.     sqlite3VdbeAddOp2(v, OP_Integer, 0, iOffset);
  1733.     sqlite3VdbeJumpHere(v, addr1);
  1734.     if( p->pLimit ){
  1735.       sqlite3VdbeAddOp3(v, OP_Add, iLimit, iOffset, iOffset+1);
  1736.       VdbeComment((v, "LIMIT+OFFSET"));
  1737.       addr1 = sqlite3VdbeAddOp1(v, OP_IfPos, iLimit);
  1738.       sqlite3VdbeAddOp2(v, OP_Integer, -1, iOffset+1);
  1739.       sqlite3VdbeJumpHere(v, addr1);
  1740.     }
  1741.   }
  1742. }
  1743. /*
  1744. ** Allocate a virtual index to use for sorting.
  1745. */
  1746. static void createSortingIndex(Parse *pParse, Select *p, ExprList *pOrderBy){
  1747.   if( pOrderBy ){
  1748.     int addr;
  1749.     assert( pOrderBy->iECursor==0 );
  1750.     pOrderBy->iECursor = pParse->nTab++;
  1751.     addr = sqlite3VdbeAddOp2(pParse->pVdbe, OP_OpenEphemeral,
  1752.                             pOrderBy->iECursor, pOrderBy->nExpr+1);
  1753.     assert( p->addrOpenEphm[2] == -1 );
  1754.     p->addrOpenEphm[2] = addr;
  1755.   }
  1756. }
  1757. #ifndef SQLITE_OMIT_COMPOUND_SELECT
  1758. /*
  1759. ** Return the appropriate collating sequence for the iCol-th column of
  1760. ** the result set for the compound-select statement "p".  Return NULL if
  1761. ** the column has no default collating sequence.
  1762. **
  1763. ** The collating sequence for the compound select is taken from the
  1764. ** left-most term of the select that has a collating sequence.
  1765. */
  1766. static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){
  1767.   CollSeq *pRet;
  1768.   if( p->pPrior ){
  1769.     pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
  1770.   }else{
  1771.     pRet = 0;
  1772.   }
  1773.   if( pRet==0 ){
  1774.     pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
  1775.   }
  1776.   return pRet;
  1777. }
  1778. #endif /* SQLITE_OMIT_COMPOUND_SELECT */
  1779. #ifndef SQLITE_OMIT_COMPOUND_SELECT
  1780. /*
  1781. ** This routine is called to process a query that is really the union
  1782. ** or intersection of two or more separate queries.
  1783. **
  1784. ** "p" points to the right-most of the two queries.  the query on the
  1785. ** left is p->pPrior.  The left query could also be a compound query
  1786. ** in which case this routine will be called recursively. 
  1787. **
  1788. ** The results of the total query are to be written into a destination
  1789. ** of type eDest with parameter iParm.
  1790. **
  1791. ** Example 1:  Consider a three-way compound SQL statement.
  1792. **
  1793. **     SELECT a FROM t1 UNION SELECT b FROM t2 UNION SELECT c FROM t3
  1794. **
  1795. ** This statement is parsed up as follows:
  1796. **
  1797. **     SELECT c FROM t3
  1798. **      |
  1799. **      `----->  SELECT b FROM t2
  1800. **                |
  1801. **                `------>  SELECT a FROM t1
  1802. **
  1803. ** The arrows in the diagram above represent the Select.pPrior pointer.
  1804. ** So if this routine is called with p equal to the t3 query, then
  1805. ** pPrior will be the t2 query.  p->op will be TK_UNION in this case.
  1806. **
  1807. ** Notice that because of the way SQLite parses compound SELECTs, the
  1808. ** individual selects always group from left to right.
  1809. */
  1810. static int multiSelect(
  1811.   Parse *pParse,        /* Parsing context */
  1812.   Select *p,            /* The right-most of SELECTs to be coded */
  1813.   SelectDest *pDest,    /* What to do with query results */
  1814.   char *aff             /* If eDest is SRT_Union, the affinity string */
  1815. ){
  1816.   int rc = SQLITE_OK;   /* Success code from a subroutine */
  1817.   Select *pPrior;       /* Another SELECT immediately to our left */
  1818.   Vdbe *v;              /* Generate code to this VDBE */
  1819.   int nCol;             /* Number of columns in the result set */
  1820.   ExprList *pOrderBy;   /* The ORDER BY clause on p */
  1821.   int aSetP2[2];        /* Set P2 value of these op to number of columns */
  1822.   int nSetP2 = 0;       /* Number of slots in aSetP2[] used */
  1823.   SelectDest dest;      /* Alternative data destination */
  1824.   dest = *pDest;
  1825.   /* Make sure there is no ORDER BY or LIMIT clause on prior SELECTs.  Only
  1826.   ** the last (right-most) SELECT in the series may have an ORDER BY or LIMIT.
  1827.   */
  1828.   if( p==0 || p->pPrior==0 ){
  1829.     rc = 1;
  1830.     goto multi_select_end;
  1831.   }
  1832.   pPrior = p->pPrior;
  1833.   assert( pPrior->pRightmost!=pPrior );
  1834.   assert( pPrior->pRightmost==p->pRightmost );
  1835.   if( pPrior->pOrderBy ){
  1836.     sqlite3ErrorMsg(pParse,"ORDER BY clause should come after %s not before",
  1837.       selectOpName(p->op));
  1838.     rc = 1;
  1839.     goto multi_select_end;
  1840.   }
  1841.   if( pPrior->pLimit ){
  1842.     sqlite3ErrorMsg(pParse,"LIMIT clause should come after %s not before",
  1843.       selectOpName(p->op));
  1844.     rc = 1;
  1845.     goto multi_select_end;
  1846.   }
  1847.   /* Make sure we have a valid query engine.  If not, create a new one.
  1848.   */
  1849.   v = sqlite3GetVdbe(pParse);
  1850.   if( v==0 ){
  1851.     rc = 1;
  1852.     goto multi_select_end;
  1853.   }
  1854.   /* Create the destination temporary table if necessary
  1855.   */
  1856.   if( dest.eDest==SRT_EphemTab ){
  1857.     assert( p->pEList );
  1858.     assert( nSetP2<sizeof(aSetP2)/sizeof(aSetP2[0]) );
  1859.     aSetP2[nSetP2++] = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, dest.iParm, 0);
  1860.     dest.eDest = SRT_Table;
  1861.   }
  1862.   /* Generate code for the left and right SELECT statements.
  1863.   */
  1864.   pOrderBy = p->pOrderBy;
  1865.   switch( p->op ){
  1866.     case TK_ALL: {
  1867.       if( pOrderBy==0 ){
  1868.         int addr = 0;
  1869.         assert( !pPrior->pLimit );
  1870.         pPrior->pLimit = p->pLimit;
  1871.         pPrior->pOffset = p->pOffset;
  1872.         rc = sqlite3Select(pParse, pPrior, &dest, 0, 0, 0, aff);
  1873.         p->pLimit = 0;
  1874.         p->pOffset = 0;
  1875.         if( rc ){
  1876.           goto multi_select_end;
  1877.         }
  1878.         p->pPrior = 0;
  1879.         p->iLimit = pPrior->iLimit;
  1880.         p->iOffset = pPrior->iOffset;
  1881.         if( p->iLimit>=0 ){
  1882.           addr = sqlite3VdbeAddOp1(v, OP_IfZero, p->iLimit);
  1883.           VdbeComment((v, "Jump ahead if LIMIT reached"));
  1884.         }
  1885.         rc = sqlite3Select(pParse, p, &dest, 0, 0, 0, aff);
  1886.         p->pPrior = pPrior;
  1887.         if( rc ){
  1888.           goto multi_select_end;
  1889.         }
  1890.         if( addr ){
  1891.           sqlite3VdbeJumpHere(v, addr);
  1892.         }
  1893.         break;
  1894.       }
  1895.       /* For UNION ALL ... ORDER BY fall through to the next case */
  1896.     }
  1897.     case TK_EXCEPT:
  1898.     case TK_UNION: {
  1899.       int unionTab;    /* Cursor number of the temporary table holding result */
  1900.       int op = 0;      /* One of the SRT_ operations to apply to self */
  1901.       int priorOp;     /* The SRT_ operation to apply to prior selects */
  1902.       Expr *pLimit, *pOffset; /* Saved values of p->nLimit and p->nOffset */
  1903.       int addr;
  1904.       SelectDest uniondest;
  1905.       priorOp = p->op==TK_ALL ? SRT_Table : SRT_Union;
  1906.       if( dest.eDest==priorOp && pOrderBy==0 && !p->pLimit && !p->pOffset ){
  1907.         /* We can reuse a temporary table generated by a SELECT to our
  1908.         ** right.
  1909.         */
  1910.         unionTab = dest.iParm;
  1911.       }else{
  1912.         /* We will need to create our own temporary table to hold the
  1913.         ** intermediate results.
  1914.         */
  1915.         unionTab = pParse->nTab++;
  1916.         if( processCompoundOrderBy(pParse, p, unionTab) ){
  1917.           rc = 1;
  1918.           goto multi_select_end;
  1919.         }
  1920.         addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, unionTab, 0);
  1921.         if( priorOp==SRT_Table ){
  1922.           assert( nSetP2<sizeof(aSetP2)/sizeof(aSetP2[0]) );
  1923.           aSetP2[nSetP2++] = addr;
  1924.         }else{
  1925.           assert( p->addrOpenEphm[0] == -1 );
  1926.           p->addrOpenEphm[0] = addr;
  1927.           p->pRightmost->usesEphm = 1;
  1928.         }
  1929.         createSortingIndex(pParse, p, pOrderBy);
  1930.         assert( p->pEList );
  1931.       }
  1932.       /* Code the SELECT statements to our left
  1933.       */
  1934.       assert( !pPrior->pOrderBy );
  1935.       sqlite3SelectDestInit(&uniondest, priorOp, unionTab);
  1936.       rc = sqlite3Select(pParse, pPrior, &uniondest, 0, 0, 0, aff);
  1937.       if( rc ){
  1938.         goto multi_select_end;
  1939.       }
  1940.       /* Code the current SELECT statement
  1941.       */
  1942.       switch( p->op ){
  1943.          case TK_EXCEPT:  op = SRT_Except;   break;
  1944.          case TK_UNION:   op = SRT_Union;    break;
  1945.          case TK_ALL:     op = SRT_Table;    break;
  1946.       }
  1947.       p->pPrior = 0;
  1948.       p->pOrderBy = 0;
  1949.       p->disallowOrderBy = pOrderBy!=0;
  1950.       pLimit = p->pLimit;
  1951.       p->pLimit = 0;
  1952.       pOffset = p->pOffset;
  1953.       p->pOffset = 0;
  1954.       uniondest.eDest = op;
  1955.       rc = sqlite3Select(pParse, p, &uniondest, 0, 0, 0, aff);
  1956.       /* Query flattening in sqlite3Select() might refill p->pOrderBy.
  1957.       ** Be sure to delete p->pOrderBy, therefore, to avoid a memory leak. */
  1958.       sqlite3ExprListDelete(p->pOrderBy);
  1959.       p->pPrior = pPrior;
  1960.       p->pOrderBy = pOrderBy;
  1961.       sqlite3ExprDelete(p->pLimit);
  1962.       p->pLimit = pLimit;
  1963.       p->pOffset = pOffset;
  1964.       p->iLimit = -1;
  1965.       p->iOffset = -1;
  1966.       if( rc ){
  1967.         goto multi_select_end;
  1968.       }
  1969.       /* Convert the data in the temporary table into whatever form
  1970.       ** it is that we currently need.
  1971.       */      
  1972.       if( dest.eDest!=priorOp || unionTab!=dest.iParm ){
  1973.         int iCont, iBreak, iStart;
  1974.         assert( p->pEList );
  1975.         if( dest.eDest==SRT_Callback ){
  1976.           Select *pFirst = p;
  1977.           while( pFirst->pPrior ) pFirst = pFirst->pPrior;
  1978.           generateColumnNames(pParse, 0, pFirst->pEList);
  1979.         }
  1980.         iBreak = sqlite3VdbeMakeLabel(v);
  1981.         iCont = sqlite3VdbeMakeLabel(v);
  1982.         computeLimitRegisters(pParse, p, iBreak);
  1983.         sqlite3VdbeAddOp2(v, OP_Rewind, unionTab, iBreak);
  1984.         iStart = sqlite3VdbeCurrentAddr(v);
  1985.         selectInnerLoop(pParse, p, p->pEList, unionTab, p->pEList->nExpr,
  1986.                         pOrderBy, -1, &dest, iCont, iBreak, 0);
  1987.         sqlite3VdbeResolveLabel(v, iCont);
  1988.         sqlite3VdbeAddOp2(v, OP_Next, unionTab, iStart);
  1989.         sqlite3VdbeResolveLabel(v, iBreak);
  1990.         sqlite3VdbeAddOp2(v, OP_Close, unionTab, 0);
  1991.       }
  1992.       break;
  1993.     }
  1994.     case TK_INTERSECT: {
  1995.       int tab1, tab2;
  1996.       int iCont, iBreak, iStart;
  1997.       Expr *pLimit, *pOffset;
  1998.       int addr;
  1999.       SelectDest intersectdest;
  2000.       int r1;
  2001.       /* INTERSECT is different from the others since it requires
  2002.       ** two temporary tables.  Hence it has its own case.  Begin
  2003.       ** by allocating the tables we will need.
  2004.       */
  2005.       tab1 = pParse->nTab++;
  2006.       tab2 = pParse->nTab++;
  2007.       if( processCompoundOrderBy(pParse, p, tab1) ){
  2008.         rc = 1;
  2009.         goto multi_select_end;
  2010.       }
  2011.       createSortingIndex(pParse, p, pOrderBy);
  2012.       addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab1, 0);
  2013.       assert( p->addrOpenEphm[0] == -1 );
  2014.       p->addrOpenEphm[0] = addr;
  2015.       p->pRightmost->usesEphm = 1;
  2016.       assert( p->pEList );
  2017.       /* Code the SELECTs to our left into temporary table "tab1".
  2018.       */
  2019.       sqlite3SelectDestInit(&intersectdest, SRT_Union, tab1);
  2020.       rc = sqlite3Select(pParse, pPrior, &intersectdest, 0, 0, 0, aff);
  2021.       if( rc ){
  2022.         goto multi_select_end;
  2023.       }
  2024.       /* Code the current SELECT into temporary table "tab2"
  2025.       */
  2026.       addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab2, 0);
  2027.       assert( p->addrOpenEphm[1] == -1 );
  2028.       p->addrOpenEphm[1] = addr;
  2029.       p->pPrior = 0;
  2030.       pLimit = p->pLimit;
  2031.       p->pLimit = 0;
  2032.       pOffset = p->pOffset;
  2033.       p->pOffset = 0;
  2034.       intersectdest.iParm = tab2;
  2035.       rc = sqlite3Select(pParse, p, &intersectdest, 0, 0, 0, aff);
  2036.       p->pPrior = pPrior;
  2037.       sqlite3ExprDelete(p->pLimit);
  2038.       p->pLimit = pLimit;
  2039.       p->pOffset = pOffset;
  2040.       if( rc ){
  2041.         goto multi_select_end;
  2042.       }
  2043.       /* Generate code to take the intersection of the two temporary
  2044.       ** tables.
  2045.       */
  2046.       assert( p->pEList );
  2047.       if( dest.eDest==SRT_Callback ){
  2048.         Select *pFirst = p;
  2049.         while( pFirst->pPrior ) pFirst = pFirst->pPrior;
  2050.         generateColumnNames(pParse, 0, pFirst->pEList);
  2051.       }
  2052.       iBreak = sqlite3VdbeMakeLabel(v);
  2053.       iCont = sqlite3VdbeMakeLabel(v);
  2054.       computeLimitRegisters(pParse, p, iBreak);
  2055.       sqlite3VdbeAddOp2(v, OP_Rewind, tab1, iBreak);
  2056.       r1 = sqlite3GetTempReg(pParse);
  2057.       iStart = sqlite3VdbeAddOp2(v, OP_RowKey, tab1, r1);
  2058.       sqlite3VdbeAddOp3(v, OP_NotFound, tab2, iCont, r1);
  2059.       sqlite3ReleaseTempReg(pParse, r1);
  2060.       selectInnerLoop(pParse, p, p->pEList, tab1, p->pEList->nExpr,
  2061.                       pOrderBy, -1, &dest, iCont, iBreak, 0);
  2062.       sqlite3VdbeResolveLabel(v, iCont);
  2063.       sqlite3VdbeAddOp2(v, OP_Next, tab1, iStart);
  2064.       sqlite3VdbeResolveLabel(v, iBreak);
  2065.       sqlite3VdbeAddOp2(v, OP_Close, tab2, 0);
  2066.       sqlite3VdbeAddOp2(v, OP_Close, tab1, 0);
  2067.       break;
  2068.     }
  2069.   }
  2070.   /* Make sure all SELECTs in the statement have the same number of elements
  2071.   ** in their result sets.
  2072.   */
  2073.   assert( p->pEList && pPrior->pEList );
  2074.   if( p->pEList->nExpr!=pPrior->pEList->nExpr ){
  2075.     sqlite3ErrorMsg(pParse, "SELECTs to the left and right of %s"
  2076.       " do not have the same number of result columns", selectOpName(p->op));
  2077.     rc = 1;
  2078.     goto multi_select_end;
  2079.   }
  2080.   /* Set the number of columns in temporary tables
  2081.   */
  2082.   nCol = p->pEList->nExpr;
  2083.   while( nSetP2 ){
  2084.     sqlite3VdbeChangeP2(v, aSetP2[--nSetP2], nCol);
  2085.   }
  2086.   /* Compute collating sequences used by either the ORDER BY clause or
  2087.   ** by any temporary tables needed to implement the compound select.
  2088.   ** Attach the KeyInfo structure to all temporary tables.  Invoke the
  2089.   ** ORDER BY processing if there is an ORDER BY clause.
  2090.   **
  2091.   ** This section is run by the right-most SELECT statement only.
  2092.   ** SELECT statements to the left always skip this part.  The right-most
  2093.   ** SELECT might also skip this part if it has no ORDER BY clause and
  2094.   ** no temp tables are required.
  2095.   */
  2096.   if( pOrderBy || p->usesEphm ){
  2097.     int i;                        /* Loop counter */
  2098.     KeyInfo *pKeyInfo;            /* Collating sequence for the result set */
  2099.     Select *pLoop;                /* For looping through SELECT statements */
  2100.     int nKeyCol;                  /* Number of entries in pKeyInfo->aCol[] */
  2101.     CollSeq **apColl;             /* For looping through pKeyInfo->aColl[] */
  2102.     CollSeq **aCopy;              /* A copy of pKeyInfo->aColl[] */
  2103.     assert( p->pRightmost==p );
  2104.     nKeyCol = nCol + (pOrderBy ? pOrderBy->nExpr : 0);
  2105.     pKeyInfo = sqlite3DbMallocZero(pParse->db,
  2106.                        sizeof(*pKeyInfo)+nKeyCol*(sizeof(CollSeq*) + 1));
  2107.     if( !pKeyInfo ){
  2108.       rc = SQLITE_NOMEM;
  2109.       goto multi_select_end;
  2110.     }
  2111.     pKeyInfo->enc = ENC(pParse->db);
  2112.     pKeyInfo->nField = nCol;
  2113.     for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
  2114.       *apColl = multiSelectCollSeq(pParse, p, i);
  2115.       if( 0==*apColl ){
  2116.         *apColl = pParse->db->pDfltColl;
  2117.       }
  2118.     }
  2119.     for(pLoop=p; pLoop; pLoop=pLoop->pPrior){
  2120.       for(i=0; i<2; i++){
  2121.         int addr = pLoop->addrOpenEphm[i];
  2122.         if( addr<0 ){
  2123.           /* If [0] is unused then [1] is also unused.  So we can
  2124.           ** always safely abort as soon as the first unused slot is found */
  2125.           assert( pLoop->addrOpenEphm[1]<0 );
  2126.           break;
  2127.         }
  2128.         sqlite3VdbeChangeP2(v, addr, nCol);
  2129.         sqlite3VdbeChangeP4(v, addr, (char*)pKeyInfo, P4_KEYINFO);
  2130.         pLoop->addrOpenEphm[i] = -1;
  2131.       }
  2132.     }
  2133.     if( pOrderBy ){
  2134.       struct ExprList_item *pOTerm = pOrderBy->a;
  2135.       int nOrderByExpr = pOrderBy->nExpr;
  2136.       int addr;
  2137.       u8 *pSortOrder;
  2138.       /* Reuse the same pKeyInfo for the ORDER BY as was used above for
  2139.       ** the compound select statements.  Except we have to change out the
  2140.       ** pKeyInfo->aColl[] values.  Some of the aColl[] values will be
  2141.       ** reused when constructing the pKeyInfo for the ORDER BY, so make
  2142.       ** a copy.  Sufficient space to hold both the nCol entries for
  2143.       ** the compound select and the nOrderbyExpr entries for the ORDER BY
  2144.       ** was allocated above.  But we need to move the compound select
  2145.       ** entries out of the way before constructing the ORDER BY entries.
  2146.       ** Move the compound select entries into aCopy[] where they can be
  2147.       ** accessed and reused when constructing the ORDER BY entries.
  2148.       ** Because nCol might be greater than or less than nOrderByExpr
  2149.       ** we have to use memmove() when doing the copy.
  2150.       */
  2151.       aCopy = &pKeyInfo->aColl[nOrderByExpr];
  2152.       pSortOrder = pKeyInfo->aSortOrder = (u8*)&aCopy[nCol];
  2153.       memmove(aCopy, pKeyInfo->aColl, nCol*sizeof(CollSeq*));
  2154.       apColl = pKeyInfo->aColl;
  2155.       for(i=0; i<nOrderByExpr; i++, pOTerm++, apColl++, pSortOrder++){
  2156.         Expr *pExpr = pOTerm->pExpr;
  2157.         if( (pExpr->flags & EP_ExpCollate) ){
  2158.           assert( pExpr->pColl!=0 );
  2159.           *apColl = pExpr->pColl;
  2160.         }else{
  2161.           *apColl = aCopy[pExpr->iColumn];
  2162.         }
  2163.         *pSortOrder = pOTerm->sortOrder;
  2164.       }
  2165.       assert( p->pRightmost==p );
  2166.       assert( p->addrOpenEphm[2]>=0 );
  2167.       addr = p->addrOpenEphm[2];
  2168.       sqlite3VdbeChangeP2(v, addr, p->pOrderBy->nExpr+2);
  2169.       pKeyInfo->nField = nOrderByExpr;
  2170.       sqlite3VdbeChangeP4(v, addr, (char*)pKeyInfo, P4_KEYINFO_HANDOFF);
  2171.       pKeyInfo = 0;
  2172.       generateSortTail(pParse, p, v, p->pEList->nExpr, &dest);
  2173.     }
  2174.     sqlite3_free(pKeyInfo);
  2175.   }
  2176. multi_select_end:
  2177.   pDest->iMem = dest.iMem;
  2178.   pDest->nMem = dest.nMem;
  2179.   return rc;
  2180. }
  2181. #endif /* SQLITE_OMIT_COMPOUND_SELECT */
  2182. #ifndef SQLITE_OMIT_VIEW
  2183. /* Forward Declarations */
  2184. static void substExprList(sqlite3*, ExprList*, int, ExprList*);
  2185. static void substSelect(sqlite3*, Select *, int, ExprList *);
  2186. /*
  2187. ** Scan through the expression pExpr.  Replace every reference to
  2188. ** a column in table number iTable with a copy of the iColumn-th
  2189. ** entry in pEList.  (But leave references to the ROWID column 
  2190. ** unchanged.)
  2191. **
  2192. ** This routine is part of the flattening procedure.  A subquery
  2193. ** whose result set is defined by pEList appears as entry in the
  2194. ** FROM clause of a SELECT such that the VDBE cursor assigned to that
  2195. ** FORM clause entry is iTable.  This routine make the necessary 
  2196. ** changes to pExpr so that it refers directly to the source table
  2197. ** of the subquery rather the result set of the subquery.
  2198. */
  2199. static void substExpr(
  2200.   sqlite3 *db,        /* Report malloc errors to this connection */
  2201.   Expr *pExpr,        /* Expr in which substitution occurs */
  2202.   int iTable,         /* Table to be substituted */
  2203.   ExprList *pEList    /* Substitute expressions */
  2204. ){
  2205.   if( pExpr==0 ) return;
  2206.   if( pExpr->op==TK_COLUMN && pExpr->iTable==iTable ){
  2207.     if( pExpr->iColumn<0 ){
  2208.       pExpr->op = TK_NULL;
  2209.     }else{
  2210.       Expr *pNew;
  2211.       assert( pEList!=0 && pExpr->iColumn<pEList->nExpr );
  2212.       assert( pExpr->pLeft==0 && pExpr->pRight==0 && pExpr->pList==0 );
  2213.       pNew = pEList->a[pExpr->iColumn].pExpr;
  2214.       assert( pNew!=0 );
  2215.       pExpr->op = pNew->op;
  2216.       assert( pExpr->pLeft==0 );
  2217.       pExpr->pLeft = sqlite3ExprDup(db, pNew->pLeft);
  2218.       assert( pExpr->pRight==0 );
  2219.       pExpr->pRight = sqlite3ExprDup(db, pNew->pRight);
  2220.       assert( pExpr->pList==0 );
  2221.       pExpr->pList = sqlite3ExprListDup(db, pNew->pList);
  2222.       pExpr->iTable = pNew->iTable;
  2223.       pExpr->pTab = pNew->pTab;
  2224.       pExpr->iColumn = pNew->iColumn;
  2225.       pExpr->iAgg = pNew->iAgg;
  2226.       sqlite3TokenCopy(db, &pExpr->token, &pNew->token);
  2227.       sqlite3TokenCopy(db, &pExpr->span, &pNew->span);
  2228.       pExpr->pSelect = sqlite3SelectDup(db, pNew->pSelect);
  2229.       pExpr->flags = pNew->flags;
  2230.     }
  2231.   }else{
  2232.     substExpr(db, pExpr->pLeft, iTable, pEList);
  2233.     substExpr(db, pExpr->pRight, iTable, pEList);
  2234.     substSelect(db, pExpr->pSelect, iTable, pEList);
  2235.     substExprList(db, pExpr->pList, iTable, pEList);
  2236.   }
  2237. }
  2238. static void substExprList(
  2239.   sqlite3 *db,         /* Report malloc errors here */
  2240.   ExprList *pList,     /* List to scan and in which to make substitutes */
  2241.   int iTable,          /* Table to be substituted */
  2242.   ExprList *pEList     /* Substitute values */
  2243. ){
  2244.   int i;
  2245.   if( pList==0 ) return;
  2246.   for(i=0; i<pList->nExpr; i++){
  2247.     substExpr(db, pList->a[i].pExpr, iTable, pEList);
  2248.   }
  2249. }
  2250. static void substSelect(
  2251.   sqlite3 *db,         /* Report malloc errors here */
  2252.   Select *p,           /* SELECT statement in which to make substitutions */
  2253.   int iTable,          /* Table to be replaced */
  2254.   ExprList *pEList     /* Substitute values */
  2255. ){
  2256.   if( !p ) return;
  2257.   substExprList(db, p->pEList, iTable, pEList);
  2258.   substExprList(db, p->pGroupBy, iTable, pEList);
  2259.   substExprList(db, p->pOrderBy, iTable, pEList);
  2260.   substExpr(db, p->pHaving, iTable, pEList);
  2261.   substExpr(db, p->pWhere, iTable, pEList);
  2262.   substSelect(db, p->pPrior, iTable, pEList);
  2263. }
  2264. #endif /* !defined(SQLITE_OMIT_VIEW) */
  2265. #ifndef SQLITE_OMIT_VIEW
  2266. /*
  2267. ** This routine attempts to flatten subqueries in order to speed
  2268. ** execution.  It returns 1 if it makes changes and 0 if no flattening
  2269. ** occurs.
  2270. **
  2271. ** To understand the concept of flattening, consider the following
  2272. ** query:
  2273. **
  2274. **     SELECT a FROM (SELECT x+y AS a FROM t1 WHERE z<100) WHERE a>5
  2275. **
  2276. ** The default way of implementing this query is to execute the
  2277. ** subquery first and store the results in a temporary table, then
  2278. ** run the outer query on that temporary table.  This requires two
  2279. ** passes over the data.  Furthermore, because the temporary table
  2280. ** has no indices, the WHERE clause on the outer query cannot be
  2281. ** optimized.
  2282. **
  2283. ** This routine attempts to rewrite queries such as the above into
  2284. ** a single flat select, like this:
  2285. **
  2286. **     SELECT x+y AS a FROM t1 WHERE z<100 AND a>5
  2287. **
  2288. ** The code generated for this simpification gives the same result
  2289. ** but only has to scan the data once.  And because indices might 
  2290. ** exist on the table t1, a complete scan of the data might be
  2291. ** avoided.
  2292. **
  2293. ** Flattening is only attempted if all of the following are true:
  2294. **
  2295. **   (1)  The subquery and the outer query do not both use aggregates.
  2296. **
  2297. **   (2)  The subquery is not an aggregate or the outer query is not a join.
  2298. **
  2299. **   (3)  The subquery is not the right operand of a left outer join, or
  2300. **        the subquery is not itself a join.  (Ticket #306)
  2301. **
  2302. **   (4)  The subquery is not DISTINCT or the outer query is not a join.
  2303. **
  2304. **   (5)  The subquery is not DISTINCT or the outer query does not use
  2305. **        aggregates.
  2306. **
  2307. **   (6)  The subquery does not use aggregates or the outer query is not
  2308. **        DISTINCT.
  2309. **
  2310. **   (7)  The subquery has a FROM clause.
  2311. **
  2312. **   (8)  The subquery does not use LIMIT or the outer query is not a join.
  2313. **
  2314. **   (9)  The subquery does not use LIMIT or the outer query does not use
  2315. **        aggregates.
  2316. **
  2317. **  (10)  The subquery does not use aggregates or the outer query does not
  2318. **        use LIMIT.
  2319. **
  2320. **  (11)  The subquery and the outer query do not both have ORDER BY clauses.
  2321. **
  2322. **  (12)  The subquery is not the right term of a LEFT OUTER JOIN or the
  2323. **        subquery has no WHERE clause.  (added by ticket #350)
  2324. **
  2325. **  (13)  The subquery and outer query do not both use LIMIT
  2326. **
  2327. **  (14)  The subquery does not use OFFSET
  2328. **
  2329. **  (15)  The outer query is not part of a compound select or the
  2330. **        subquery does not have both an ORDER BY and a LIMIT clause.
  2331. **        (See ticket #2339)
  2332. **
  2333. **  (16)  The outer query is not an aggregate or the subquery does
  2334. **        not contain ORDER BY.  (Ticket #2942)  This used to not matter
  2335. **        until we introduced the group_concat() function.  
  2336. **
  2337. ** In this routine, the "p" parameter is a pointer to the outer query.
  2338. ** The subquery is p->pSrc->a[iFrom].  isAgg is true if the outer query
  2339. ** uses aggregates and subqueryIsAgg is true if the subquery uses aggregates.
  2340. **
  2341. ** If flattening is not attempted, this routine is a no-op and returns 0.
  2342. ** If flattening is attempted this routine returns 1.
  2343. **
  2344. ** All of the expression analysis must occur on both the outer query and
  2345. ** the subquery before this routine runs.
  2346. */
  2347. static int flattenSubquery(
  2348.   sqlite3 *db,         /* Database connection */
  2349.   Select *p,           /* The parent or outer SELECT statement */
  2350.   int iFrom,           /* Index in p->pSrc->a[] of the inner subquery */
  2351.   int isAgg,           /* True if outer SELECT uses aggregate functions */
  2352.   int subqueryIsAgg    /* True if the subquery uses aggregate functions */
  2353. ){
  2354.   Select *pSub;       /* The inner query or "subquery" */
  2355.   SrcList *pSrc;      /* The FROM clause of the outer query */
  2356.   SrcList *pSubSrc;   /* The FROM clause of the subquery */
  2357.   ExprList *pList;    /* The result set of the outer query */
  2358.   int iParent;        /* VDBE cursor number of the pSub result set temp table */
  2359.   int i;              /* Loop counter */
  2360.   Expr *pWhere;                    /* The WHERE clause */
  2361.   struct SrcList_item *pSubitem;   /* The subquery */
  2362.   /* Check to see if flattening is permitted.  Return 0 if not.
  2363.   */
  2364.   if( p==0 ) return 0;
  2365.   pSrc = p->pSrc;
  2366.   assert( pSrc && iFrom>=0 && iFrom<pSrc->nSrc );
  2367.   pSubitem = &pSrc->a[iFrom];
  2368.   pSub = pSubitem->pSelect;
  2369.   assert( pSub!=0 );
  2370.   if( isAgg && subqueryIsAgg ) return 0;                 /* Restriction (1)  */
  2371.   if( subqueryIsAgg && pSrc->nSrc>1 ) return 0;          /* Restriction (2)  */
  2372.   pSubSrc = pSub->pSrc;
  2373.   assert( pSubSrc );
  2374.   /* Prior to version 3.1.2, when LIMIT and OFFSET had to be simple constants,
  2375.   ** not arbitrary expresssions, we allowed some combining of LIMIT and OFFSET
  2376.   ** because they could be computed at compile-time.  But when LIMIT and OFFSET
  2377.   ** became arbitrary expressions, we were forced to add restrictions (13)
  2378.   ** and (14). */
  2379.   if( pSub->pLimit && p->pLimit ) return 0;              /* Restriction (13) */
  2380.   if( pSub->pOffset ) return 0;                          /* Restriction (14) */
  2381.   if( p->pRightmost && pSub->pLimit && pSub->pOrderBy ){
  2382.     return 0;                                            /* Restriction (15) */
  2383.   }
  2384.   if( pSubSrc->nSrc==0 ) return 0;                       /* Restriction (7)  */
  2385.   if( (pSub->isDistinct || pSub->pLimit) 
  2386.          && (pSrc->nSrc>1 || isAgg) ){          /* Restrictions (4)(5)(8)(9) */
  2387.      return 0;       
  2388.   }
  2389.   if( p->isDistinct && subqueryIsAgg ) return 0;         /* Restriction (6)  */
  2390.   if( (p->disallowOrderBy || p->pOrderBy) && pSub->pOrderBy ){
  2391.      return 0;                                           /* Restriction (11) */
  2392.   }
  2393.   if( isAgg && pSub->pOrderBy ) return 0;                /* Restriction (16) */
  2394.   /* Restriction 3:  If the subquery is a join, make sure the subquery is 
  2395.   ** not used as the right operand of an outer join.  Examples of why this
  2396.   ** is not allowed:
  2397.   **
  2398.   **         t1 LEFT OUTER JOIN (t2 JOIN t3)
  2399.   **
  2400.   ** If we flatten the above, we would get
  2401.   **
  2402.   **         (t1 LEFT OUTER JOIN t2) JOIN t3
  2403.   **
  2404.   ** which is not at all the same thing.
  2405.   */
  2406.   if( pSubSrc->nSrc>1 && (pSubitem->jointype & JT_OUTER)!=0 ){
  2407.     return 0;
  2408.   }
  2409.   /* Restriction 12:  If the subquery is the right operand of a left outer
  2410.   ** join, make sure the subquery has no WHERE clause.
  2411.   ** An examples of why this is not allowed:
  2412.   **
  2413.   **         t1 LEFT OUTER JOIN (SELECT * FROM t2 WHERE t2.x>0)
  2414.   **
  2415.   ** If we flatten the above, we would get
  2416.   **
  2417.   **         (t1 LEFT OUTER JOIN t2) WHERE t2.x>0
  2418.   **
  2419.   ** But the t2.x>0 test will always fail on a NULL row of t2, which
  2420.   ** effectively converts the OUTER JOIN into an INNER JOIN.
  2421.   */
  2422.   if( (pSubitem->jointype & JT_OUTER)!=0 && pSub->pWhere!=0 ){
  2423.     return 0;
  2424.   }
  2425.   /* If we reach this point, it means flattening is permitted for the
  2426.   ** iFrom-th entry of the FROM clause in the outer query.
  2427.   */
  2428.   /* Move all of the FROM elements of the subquery into the
  2429.   ** the FROM clause of the outer query.  Before doing this, remember
  2430.   ** the cursor number for the original outer query FROM element in
  2431.   ** iParent.  The iParent cursor will never be used.  Subsequent code
  2432.   ** will scan expressions looking for iParent references and replace
  2433.   ** those references with expressions that resolve to the subquery FROM
  2434.   ** elements we are now copying in.
  2435.   */
  2436.   iParent = pSubitem->iCursor;
  2437.   {
  2438.     int nSubSrc = pSubSrc->nSrc;
  2439.     int jointype = pSubitem->jointype;
  2440.     sqlite3DeleteTable(pSubitem->pTab);
  2441.     sqlite3_free(pSubitem->zDatabase);
  2442.     sqlite3_free(pSubitem->zName);
  2443.     sqlite3_free(pSubitem->zAlias);
  2444.     pSubitem->pTab = 0;
  2445.     pSubitem->zDatabase = 0;
  2446.     pSubitem->zName = 0;
  2447.     pSubitem->zAlias = 0;
  2448.     if( nSubSrc>1 ){
  2449.       int extra = nSubSrc - 1;
  2450.       for(i=1; i<nSubSrc; i++){
  2451.         pSrc = sqlite3SrcListAppend(db, pSrc, 0, 0);
  2452.         if( pSrc==0 ){
  2453.           p->pSrc = 0;
  2454.           return 1;
  2455.         }
  2456.       }
  2457.       p->pSrc = pSrc;
  2458.       for(i=pSrc->nSrc-1; i-extra>=iFrom; i--){
  2459.         pSrc->a[i] = pSrc->a[i-extra];
  2460.       }
  2461.     }
  2462.     for(i=0; i<nSubSrc; i++){
  2463.       pSrc->a[i+iFrom] = pSubSrc->a[i];
  2464.       memset(&pSubSrc->a[i], 0, sizeof(pSubSrc->a[i]));
  2465.     }
  2466.     pSrc->a[iFrom].jointype = jointype;
  2467.   }
  2468.   /* Now begin substituting subquery result set expressions for 
  2469.   ** references to the iParent in the outer query.
  2470.   ** 
  2471.   ** Example:
  2472.   **
  2473.   **   SELECT a+5, b*10 FROM (SELECT x*3 AS a, y+10 AS b FROM t1) WHERE a>b;
  2474.   **                        _____________ subquery __________/          /
  2475.   **    _____________________ outer query ______________________________/
  2476.   **
  2477.   ** We look at every expression in the outer query and every place we see
  2478.   ** "a" we substitute "x*3" and every place we see "b" we substitute "y+10".
  2479.   */
  2480.   pList = p->pEList;
  2481.   for(i=0; i<pList->nExpr; i++){
  2482.     Expr *pExpr;
  2483.     if( pList->a[i].zName==0 && (pExpr = pList->a[i].pExpr)->span.z!=0 ){
  2484.       pList->a[i].zName = 
  2485.              sqlite3DbStrNDup(db, (char*)pExpr->span.z, pExpr->span.n);
  2486.     }
  2487.   }
  2488.   substExprList(db, p->pEList, iParent, pSub->pEList);
  2489.   if( isAgg ){
  2490.     substExprList(db, p->pGroupBy, iParent, pSub->pEList);
  2491.     substExpr(db, p->pHaving, iParent, pSub->pEList);
  2492.   }
  2493.   if( pSub->pOrderBy ){
  2494.     assert( p->pOrderBy==0 );
  2495.     p->pOrderBy = pSub->pOrderBy;
  2496.     pSub->pOrderBy = 0;
  2497.   }else if( p->pOrderBy ){
  2498.     substExprList(db, p->pOrderBy, iParent, pSub->pEList);
  2499.   }
  2500.   if( pSub->pWhere ){
  2501.     pWhere = sqlite3ExprDup(db, pSub->pWhere);
  2502.   }else{
  2503.     pWhere = 0;
  2504.   }
  2505.   if( subqueryIsAgg ){
  2506.     assert( p->pHaving==0 );
  2507.     p->pHaving = p->pWhere;
  2508.     p->pWhere = pWhere;
  2509.     substExpr(db, p->pHaving, iParent, pSub->pEList);
  2510.     p->pHaving = sqlite3ExprAnd(db, p->pHaving, 
  2511.                                 sqlite3ExprDup(db, pSub->pHaving));
  2512.     assert( p->pGroupBy==0 );
  2513.     p->pGroupBy = sqlite3ExprListDup(db, pSub->pGroupBy);
  2514.   }else{
  2515.     substExpr(db, p->pWhere, iParent, pSub->pEList);
  2516.     p->pWhere = sqlite3ExprAnd(db, p->pWhere, pWhere);
  2517.   }
  2518.   /* The flattened query is distinct if either the inner or the
  2519.   ** outer query is distinct. 
  2520.   */
  2521.   p->isDistinct = p->isDistinct || pSub->isDistinct;
  2522.   /*
  2523.   ** SELECT ... FROM (SELECT ... LIMIT a OFFSET b) LIMIT x OFFSET y;
  2524.   **
  2525.   ** One is tempted to try to add a and b to combine the limits.  But this
  2526.   ** does not work if either limit is negative.
  2527.   */
  2528.   if( pSub->pLimit ){
  2529.     p->pLimit = pSub->pLimit;
  2530.     pSub->pLimit = 0;
  2531.   }
  2532.   /* Finially, delete what is left of the subquery and return
  2533.   ** success.
  2534.   */
  2535.   sqlite3SelectDelete(pSub);
  2536.   return 1;
  2537. }
  2538. #endif /* SQLITE_OMIT_VIEW */
  2539. /*
  2540. ** Analyze the SELECT statement passed as an argument to see if it
  2541. ** is a min() or max() query. Return WHERE_ORDERBY_MIN or WHERE_ORDERBY_MAX if 
  2542. ** it is, or 0 otherwise. At present, a query is considered to be
  2543. ** a min()/max() query if:
  2544. **
  2545. **   1. There is a single object in the FROM clause.
  2546. **
  2547. **   2. There is a single expression in the result set, and it is
  2548. **      either min(x) or max(x), where x is a column reference.
  2549. */
  2550. static int minMaxQuery(Parse *pParse, Select *p){
  2551.   Expr *pExpr;
  2552.   ExprList *pEList = p->pEList;
  2553.   if( pEList->nExpr!=1 ) return WHERE_ORDERBY_NORMAL;
  2554.   pExpr = pEList->a[0].pExpr;
  2555.   pEList = pExpr->pList;
  2556.   if( pExpr->op!=TK_AGG_FUNCTION || pEList==0 || pEList->nExpr!=1 ) return 0;
  2557.   if( pEList->a[0].pExpr->op!=TK_AGG_COLUMN ) return WHERE_ORDERBY_NORMAL;
  2558.   if( pExpr->token.n!=3 ) return WHERE_ORDERBY_NORMAL;
  2559.   if( sqlite3StrNICmp((char*)pExpr->token.z,"min",3)==0 ){
  2560.     return WHERE_ORDERBY_MIN;
  2561.   }else if( sqlite3StrNICmp((char*)pExpr->token.z,"max",3)==0 ){
  2562.     return WHERE_ORDERBY_MAX;
  2563.   }
  2564.   return WHERE_ORDERBY_NORMAL;
  2565. }
  2566. /*
  2567. ** This routine resolves any names used in the result set of the
  2568. ** supplied SELECT statement. If the SELECT statement being resolved
  2569. ** is a sub-select, then pOuterNC is a pointer to the NameContext 
  2570. ** of the parent SELECT.
  2571. */
  2572. int sqlite3SelectResolve(
  2573.   Parse *pParse,         /* The parser context */
  2574.   Select *p,             /* The SELECT statement being coded. */
  2575.   NameContext *pOuterNC  /* The outer name context. May be NULL. */
  2576. ){
  2577.   ExprList *pEList;          /* Result set. */
  2578.   int i;                     /* For-loop variable used in multiple places */
  2579.   NameContext sNC;           /* Local name-context */
  2580.   ExprList *pGroupBy;        /* The group by clause */
  2581.   /* If this routine has run before, return immediately. */
  2582.   if( p->isResolved ){
  2583.     assert( !pOuterNC );
  2584.     return SQLITE_OK;
  2585.   }
  2586.   p->isResolved = 1;
  2587.   /* If there have already been errors, do nothing. */
  2588.   if( pParse->nErr>0 ){
  2589.     return SQLITE_ERROR;
  2590.   }
  2591.   /* Prepare the select statement. This call will allocate all cursors
  2592.   ** required to handle the tables and subqueries in the FROM clause.
  2593.   */
  2594.   if( prepSelectStmt(pParse, p) ){
  2595.     return SQLITE_ERROR;
  2596.   }
  2597.   /* Resolve the expressions in the LIMIT and OFFSET clauses. These
  2598.   ** are not allowed to refer to any names, so pass an empty NameContext.
  2599.   */
  2600.   memset(&sNC, 0, sizeof(sNC));
  2601.   sNC.pParse = pParse;
  2602.   if( sqlite3ExprResolveNames(&sNC, p->pLimit) ||
  2603.       sqlite3ExprResolveNames(&sNC, p->pOffset) ){
  2604.     return SQLITE_ERROR;
  2605.   }
  2606.   /* Set up the local name-context to pass to ExprResolveNames() to
  2607.   ** resolve the expression-list.
  2608.   */
  2609.   sNC.allowAgg = 1;
  2610.   sNC.pSrcList = p->pSrc;
  2611.   sNC.pNext = pOuterNC;
  2612.   /* Resolve names in the result set. */
  2613.   pEList = p->pEList;
  2614.   if( !pEList ) return SQLITE_ERROR;
  2615.   for(i=0; i<pEList->nExpr; i++){
  2616.     Expr *pX = pEList->a[i].pExpr;
  2617.     if( sqlite3ExprResolveNames(&sNC, pX) ){
  2618.       return SQLITE_ERROR;
  2619.     }
  2620.   }
  2621.   /* If there are no aggregate functions in the result-set, and no GROUP BY 
  2622.   ** expression, do not allow aggregates in any of the other expressions.
  2623.   */
  2624.   assert( !p->isAgg );
  2625.   pGroupBy = p->pGroupBy;
  2626.   if( pGroupBy || sNC.hasAgg ){
  2627.     p->isAgg = 1;
  2628.   }else{
  2629.     sNC.allowAgg = 0;
  2630.   }
  2631.   /* If a HAVING clause is present, then there must be a GROUP BY clause.
  2632.   */
  2633.   if( p->pHaving && !pGroupBy ){
  2634.     sqlite3ErrorMsg(pParse, "a GROUP BY clause is required before HAVING");
  2635.     return SQLITE_ERROR;
  2636.   }
  2637.   /* Add the expression list to the name-context before parsing the
  2638.   ** other expressions in the SELECT statement. This is so that
  2639.   ** expressions in the WHERE clause (etc.) can refer to expressions by
  2640.   ** aliases in the result set.
  2641.   **
  2642.   ** Minor point: If this is the case, then the expression will be
  2643.   ** re-evaluated for each reference to it.
  2644.   */
  2645.   sNC.pEList = p->pEList;
  2646.   if( sqlite3ExprResolveNames(&sNC, p->pWhere) ||
  2647.      sqlite3ExprResolveNames(&sNC, p->pHaving) ){
  2648.     return SQLITE_ERROR;
  2649.   }
  2650.   if( p->pPrior==0 ){
  2651.     if( processOrderGroupBy(pParse, p, p->pOrderBy, 1, &sNC.hasAgg) ){
  2652.       return SQLITE_ERROR;
  2653.     }
  2654.   }
  2655.   if( processOrderGroupBy(pParse, p, pGroupBy, 0, &sNC.hasAgg) ){
  2656.     return SQLITE_ERROR;
  2657.   }
  2658.   if( pParse->db->mallocFailed ){
  2659.     return SQLITE_NOMEM;
  2660.   }
  2661.   /* Make sure the GROUP BY clause does not contain aggregate functions.
  2662.   */
  2663.   if( pGroupBy ){
  2664.     struct ExprList_item *pItem;
  2665.   
  2666.     for(i=0, pItem=pGroupBy->a; i<pGroupBy->nExpr; i++, pItem++){
  2667.       if( ExprHasProperty(pItem->pExpr, EP_Agg) ){
  2668.         sqlite3ErrorMsg(pParse, "aggregate functions are not allowed in "
  2669.             "the GROUP BY clause");
  2670.         return SQLITE_ERROR;
  2671.       }
  2672.     }
  2673.   }
  2674.   /* If this is one SELECT of a compound, be sure to resolve names
  2675.   ** in the other SELECTs.
  2676.   */
  2677.   if( p->pPrior ){
  2678.     return sqlite3SelectResolve(pParse, p->pPrior, pOuterNC);
  2679.   }else{
  2680.     return SQLITE_OK;
  2681.   }
  2682. }
  2683. /*
  2684. ** Reset the aggregate accumulator.
  2685. **
  2686. ** The aggregate accumulator is a set of memory cells that hold
  2687. ** intermediate results while calculating an aggregate.  This
  2688. ** routine simply stores NULLs in all of those memory cells.
  2689. */
  2690. static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){
  2691.   Vdbe *v = pParse->pVdbe;
  2692.   int i;
  2693.   struct AggInfo_func *pFunc;
  2694.   if( pAggInfo->nFunc+pAggInfo->nColumn==0 ){
  2695.     return;
  2696.   }
  2697.   for(i=0; i<pAggInfo->nColumn; i++){
  2698.     sqlite3VdbeAddOp2(v, OP_Null, 0, pAggInfo->aCol[i].iMem);
  2699.   }
  2700.   for(pFunc=pAggInfo->aFunc, i=0; i<pAggInfo->nFunc; i++, pFunc++){
  2701.     sqlite3VdbeAddOp2(v, OP_Null, 0, pFunc->iMem);
  2702.     if( pFunc->iDistinct>=0 ){
  2703.       Expr *pE = pFunc->pExpr;
  2704.       if( pE->pList==0 || pE->pList->nExpr!=1 ){
  2705.         sqlite3ErrorMsg(pParse, "DISTINCT in aggregate must be followed "
  2706.            "by an expression");
  2707.         pFunc->iDistinct = -1;
  2708.       }else{
  2709.         KeyInfo *pKeyInfo = keyInfoFromExprList(pParse, pE->pList);
  2710.         sqlite3VdbeAddOp4(v, OP_OpenEphemeral, pFunc->iDistinct, 0, 0,
  2711.                           (char*)pKeyInfo, P4_KEYINFO_HANDOFF);
  2712.       }
  2713.     }
  2714.   }
  2715. }
  2716. /*
  2717. ** Invoke the OP_AggFinalize opcode for every aggregate function
  2718. ** in the AggInfo structure.
  2719. */
  2720. static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){
  2721.   Vdbe *v = pParse->pVdbe;
  2722.   int i;
  2723.   struct AggInfo_func *pF;
  2724.   for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
  2725.     ExprList *pList = pF->pExpr->pList;
  2726.     sqlite3VdbeAddOp4(v, OP_AggFinal, pF->iMem, pList ? pList->nExpr : 0, 0,
  2727.                       (void*)pF->pFunc, P4_FUNCDEF);
  2728.   }
  2729. }
  2730. /*
  2731. ** Update the accumulator memory cells for an aggregate based on
  2732. ** the current cursor position.
  2733. */
  2734. static void updateAccumulator(Parse *pParse, AggInfo *pAggInfo){
  2735.   Vdbe *v = pParse->pVdbe;
  2736.   int i;
  2737.   struct AggInfo_func *pF;
  2738.   struct AggInfo_col *pC;
  2739.   pAggInfo->directMode = 1;
  2740.   for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
  2741.     int nArg;
  2742.     int addrNext = 0;
  2743.     int regAgg;
  2744.     ExprList *pList = pF->pExpr->pList;
  2745.     if( pList ){
  2746.       nArg = pList->nExpr;
  2747.       regAgg = sqlite3GetTempRange(pParse, nArg);
  2748.       sqlite3ExprCodeExprList(pParse, pList, regAgg, 0);
  2749.     }else{
  2750.       nArg = 0;
  2751.       regAgg = 0;
  2752.     }
  2753.     if( pF->iDistinct>=0 ){
  2754.       addrNext = sqlite3VdbeMakeLabel(v);
  2755.       assert( nArg==1 );
  2756.       codeDistinct(pParse, pF->iDistinct, addrNext, 1, regAgg);
  2757.     }
  2758.     if( pF->pFunc->needCollSeq ){
  2759.       CollSeq *pColl = 0;
  2760.       struct ExprList_item *pItem;
  2761.       int j;
  2762.       assert( pList!=0 );  /* pList!=0 if pF->pFunc->needCollSeq is true */
  2763.       for(j=0, pItem=pList->a; !pColl && j<nArg; j++, pItem++){
  2764.         pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
  2765.       }
  2766.       if( !pColl ){
  2767.         pColl = pParse->db->pDfltColl;
  2768.       }
  2769.       sqlite3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ);
  2770.     }
  2771.     sqlite3VdbeAddOp4(v, OP_AggStep, 0, regAgg, pF->iMem,
  2772.                       (void*)pF->pFunc, P4_FUNCDEF);
  2773.     sqlite3VdbeChangeP5(v, nArg);
  2774.     sqlite3ReleaseTempRange(pParse, regAgg, nArg);
  2775.     sqlite3ExprCacheAffinityChange(pParse, regAgg, nArg);
  2776.     if( addrNext ){
  2777.       sqlite3VdbeResolveLabel(v, addrNext);
  2778.     }
  2779.   }
  2780.   for(i=0, pC=pAggInfo->aCol; i<pAggInfo->nAccumulator; i++, pC++){
  2781.     sqlite3ExprCode(pParse, pC->pExpr, pC->iMem);
  2782.   }
  2783.   pAggInfo->directMode = 0;
  2784. }
  2785. #ifndef SQLITE_OMIT_TRIGGER
  2786. /*
  2787. ** This function is used when a SELECT statement is used to create a
  2788. ** temporary table for iterating through when running an INSTEAD OF
  2789. ** UPDATE or INSTEAD OF DELETE trigger. 
  2790. **
  2791. ** If possible, the SELECT statement is modified so that NULL values
  2792. ** are stored in the temporary table for all columns for which the 
  2793. ** corresponding bit in argument mask is not set. If mask takes the
  2794. ** special value 0xffffffff, then all columns are populated.
  2795. */
  2796. void sqlite3SelectMask(Parse *pParse, Select *p, u32 mask){
  2797.   if( p && !p->pPrior && !p->isDistinct && mask!=0xffffffff ){
  2798.     ExprList *pEList;
  2799.     int i;
  2800.     sqlite3SelectResolve(pParse, p, 0);
  2801.     pEList = p->pEList;
  2802.     for(i=0; pEList && i<pEList->nExpr && i<32; i++){
  2803.       if( !(mask&((u32)1<<i)) ){
  2804.         sqlite3ExprDelete(pEList->a[i].pExpr);
  2805.         pEList->a[i].pExpr = sqlite3Expr(pParse->db, TK_NULL, 0, 0, 0);
  2806.       }
  2807.     }
  2808.   }
  2809. }
  2810. #endif
  2811. /*
  2812. ** Generate code for the given SELECT statement.
  2813. **
  2814. ** The results are distributed in various ways depending on the
  2815. ** contents of the SelectDest structure pointed to by argument pDest
  2816. ** as follows:
  2817. **
  2818. **     pDest->eDest    Result
  2819. **     ------------    -------------------------------------------
  2820. **     SRT_Callback    Invoke the callback for each row of the result.
  2821. **
  2822. **     SRT_Mem         Store first result in memory cell pDest->iParm
  2823. **
  2824. **     SRT_Set         Store non-null results as keys of table pDest->iParm. 
  2825. **                     Apply the affinity pDest->affinity before storing them.
  2826. **
  2827. **     SRT_Union       Store results as a key in a temporary table pDest->iParm.
  2828. **
  2829. **     SRT_Except      Remove results from the temporary table pDest->iParm.
  2830. **
  2831. **     SRT_Table       Store results in temporary table pDest->iParm
  2832. **
  2833. **     SRT_EphemTab    Create an temporary table pDest->iParm and store
  2834. **                     the result there. The cursor is left open after
  2835. **                     returning.
  2836. **
  2837. **     SRT_Subroutine  For each row returned, push the results onto the
  2838. **                     vdbe stack and call the subroutine (via OP_Gosub)
  2839. **                     at address pDest->iParm.
  2840. **
  2841. **     SRT_Exists      Store a 1 in memory cell pDest->iParm if the result
  2842. **                     set is not empty.
  2843. **
  2844. **     SRT_Discard     Throw the results away.
  2845. **
  2846. ** See the selectInnerLoop() function for a canonical listing of the 
  2847. ** allowed values of eDest and their meanings.
  2848. **
  2849. ** This routine returns the number of errors.  If any errors are
  2850. ** encountered, then an appropriate error message is left in
  2851. ** pParse->zErrMsg.
  2852. **
  2853. ** This routine does NOT free the Select structure passed in.  The
  2854. ** calling function needs to do that.
  2855. **
  2856. ** The pParent, parentTab, and *pParentAgg fields are filled in if this
  2857. ** SELECT is a subquery.  This routine may try to combine this SELECT
  2858. ** with its parent to form a single flat query.  In so doing, it might
  2859. ** change the parent query from a non-aggregate to an aggregate query.
  2860. ** For that reason, the pParentAgg flag is passed as a pointer, so it
  2861. ** can be changed.
  2862. **
  2863. ** Example 1:   The meaning of the pParent parameter.
  2864. **
  2865. **    SELECT * FROM t1 JOIN (SELECT x, count(*) FROM t2) JOIN t3;
  2866. **                          _______ subquery _______/        /
  2867. **                                                           /
  2868. **      ____________________ outer query ___________________/
  2869. **
  2870. ** This routine is called for the outer query first.   For that call,
  2871. ** pParent will be NULL.  During the processing of the outer query, this 
  2872. ** routine is called recursively to handle the subquery.  For the recursive
  2873. ** call, pParent will point to the outer query.  Because the subquery is
  2874. ** the second element in a three-way join, the parentTab parameter will
  2875. ** be 1 (the 2nd value of a 0-indexed array.)
  2876. */
  2877. int sqlite3Select(
  2878.   Parse *pParse,         /* The parser context */
  2879.   Select *p,             /* The SELECT statement being coded. */
  2880.   SelectDest *pDest,     /* What to do with the query results */
  2881.   Select *pParent,       /* Another SELECT for which this is a sub-query */
  2882.   int parentTab,         /* Index in pParent->pSrc of this query */
  2883.   int *pParentAgg,       /* True if pParent uses aggregate functions */
  2884.   char *aff              /* If eDest is SRT_Union, the affinity string */
  2885. ){
  2886.   int i, j;              /* Loop counters */
  2887.   WhereInfo *pWInfo;     /* Return from sqlite3WhereBegin() */
  2888.   Vdbe *v;               /* The virtual machine under construction */
  2889.   int isAgg;             /* True for select lists like "count(*)" */
  2890.   ExprList *pEList;      /* List of columns to extract. */
  2891.   SrcList *pTabList;     /* List of tables to select from */
  2892.   Expr *pWhere;          /* The WHERE clause.  May be NULL */
  2893.   ExprList *pOrderBy;    /* The ORDER BY clause.  May be NULL */
  2894.   ExprList *pGroupBy;    /* The GROUP BY clause.  May be NULL */
  2895.   Expr *pHaving;         /* The HAVING clause.  May be NULL */
  2896.   int isDistinct;        /* True if the DISTINCT keyword is present */
  2897.   int distinct;          /* Table to use for the distinct set */
  2898.   int rc = 1;            /* Value to return from this function */
  2899.   int addrSortIndex;     /* Address of an OP_OpenEphemeral instruction */
  2900.   AggInfo sAggInfo;      /* Information used by aggregate queries */
  2901.   int iEnd;              /* Address of the end of the query */
  2902.   sqlite3 *db;           /* The database connection */
  2903.   db = pParse->db;
  2904.   if( p==0 || db->mallocFailed || pParse->nErr ){
  2905.     return 1;
  2906.   }
  2907.   if( sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1;
  2908.   memset(&sAggInfo, 0, sizeof(sAggInfo));
  2909.   pOrderBy = p->pOrderBy;
  2910.   if( IgnorableOrderby(pDest) ){
  2911.     p->pOrderBy = 0;
  2912.     /* In these cases the DISTINCT operator makes no difference to the
  2913.     ** results, so remove it if it were specified.
  2914.     */
  2915.     assert(pDest->eDest==SRT_Exists || pDest->eDest==SRT_Union || 
  2916.            pDest->eDest==SRT_Except || pDest->eDest==SRT_Discard);
  2917.     p->isDistinct = 0;
  2918.   }
  2919.   if( sqlite3SelectResolve(pParse, p, 0) ){
  2920.     goto select_end;
  2921.   }
  2922.   p->pOrderBy = pOrderBy;
  2923. #ifndef SQLITE_OMIT_COMPOUND_SELECT
  2924.   /* If there is are a sequence of queries, do the earlier ones first.
  2925.   */
  2926.   if( p->pPrior ){
  2927.     if( p->pRightmost==0 ){
  2928.       Select *pLoop, *pRight = 0;
  2929.       int cnt = 0;
  2930.       int mxSelect;
  2931.       for(pLoop=p; pLoop; pLoop=pLoop->pPrior, cnt++){
  2932.         pLoop->pRightmost = p;
  2933.         pLoop->pNext = pRight;
  2934.         pRight = pLoop;
  2935.       }
  2936.       mxSelect = db->aLimit[SQLITE_LIMIT_COMPOUND_SELECT];
  2937.       if( mxSelect && cnt>mxSelect ){
  2938.         sqlite3ErrorMsg(pParse, "too many terms in compound SELECT");
  2939.         return 1;
  2940.       }
  2941.     }
  2942.     return multiSelect(pParse, p, pDest, aff);
  2943.   }
  2944. #endif
  2945.   /* Make local copies of the parameters for this query.
  2946.   */
  2947.   pTabList = p->pSrc;
  2948.   pWhere = p->pWhere;
  2949.   pGroupBy = p->pGroupBy;
  2950.   pHaving = p->pHaving;
  2951.   isAgg = p->isAgg;
  2952.   isDistinct = p->isDistinct;
  2953.   pEList = p->pEList;
  2954.   if( pEList==0 ) goto select_end;
  2955.   /* 
  2956.   ** Do not even attempt to generate any code if we have already seen
  2957.   ** errors before this routine starts.
  2958.   */
  2959.   if( pParse->nErr>0 ) goto select_end;
  2960.   /* If writing to memory or generating a set
  2961.   ** only a single column may be output.
  2962.   */
  2963. #ifndef SQLITE_OMIT_SUBQUERY
  2964.   if( checkForMultiColumnSelectError(pParse, pDest, pEList->nExpr) ){
  2965.     goto select_end;
  2966.   }
  2967. #endif
  2968.   /* ORDER BY is ignored for some destinations.
  2969.   */
  2970.   if( IgnorableOrderby(pDest) ){
  2971.     pOrderBy = 0;
  2972.   }
  2973.   /* Begin generating code.
  2974.   */
  2975.   v = sqlite3GetVdbe(pParse);
  2976.   if( v==0 ) goto select_end;
  2977.   /* Generate code for all sub-queries in the FROM clause
  2978.   */
  2979. #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
  2980.   for(i=0; i<pTabList->nSrc; i++){
  2981.     const char *zSavedAuthContext = 0;
  2982.     int needRestoreContext;
  2983.     struct SrcList_item *pItem = &pTabList->a[i];
  2984.     SelectDest dest;
  2985.     if( pItem->pSelect==0 || pItem->isPopulated ) continue;
  2986.     if( pItem->zName!=0 ){
  2987.       zSavedAuthContext = pParse->zAuthContext;
  2988.       pParse->zAuthContext = pItem->zName;
  2989.       needRestoreContext = 1;
  2990.     }else{
  2991.       needRestoreContext = 0;
  2992.     }
  2993.     /* Increment Parse.nHeight by the height of the largest expression
  2994.     ** tree refered to by this, the parent select. The child select
  2995.     ** may contain expression trees of at most
  2996.     ** (SQLITE_MAX_EXPR_DEPTH-Parse.nHeight) height. This is a bit
  2997.     ** more conservative than necessary, but much easier than enforcing
  2998.     ** an exact limit.
  2999.     */
  3000.     pParse->nHeight += sqlite3SelectExprHeight(p);
  3001.     sqlite3SelectDestInit(&dest, SRT_EphemTab, pItem->iCursor);
  3002.     sqlite3Select(pParse, pItem->pSelect, &dest, p, i, &isAgg, 0);
  3003.     if( db->mallocFailed ){
  3004.       goto select_end;
  3005.     }
  3006.     pParse->nHeight -= sqlite3SelectExprHeight(p);
  3007.     if( needRestoreContext ){
  3008.       pParse->zAuthContext = zSavedAuthContext;
  3009.     }
  3010.     pTabList = p->pSrc;
  3011.     pWhere = p->pWhere;
  3012.     if( !IgnorableOrderby(pDest) ){
  3013.       pOrderBy = p->pOrderBy;
  3014.     }
  3015.     pGroupBy = p->pGroupBy;
  3016.     pHaving = p->pHaving;
  3017.     isDistinct = p->isDistinct;
  3018.   }
  3019. #endif
  3020.   /* Check to see if this is a subquery that can be "flattened" into its parent.
  3021.   ** If flattening is a possiblity, do so and return immediately.  
  3022.   */
  3023. #ifndef SQLITE_OMIT_VIEW
  3024.   if( pParent && pParentAgg &&
  3025.       flattenSubquery(db, pParent, parentTab, *pParentAgg, isAgg) ){
  3026.     if( isAgg ) *pParentAgg = 1;
  3027.     goto select_end;
  3028.   }
  3029. #endif
  3030.   /* If possible, rewrite the query to use GROUP BY instead of DISTINCT.
  3031.   ** GROUP BY may use an index, DISTINCT never does.
  3032.   */
  3033.   if( p->isDistinct && !p->isAgg && !p->pGroupBy ){
  3034.     p->pGroupBy = sqlite3ExprListDup(db, p->pEList);
  3035.     pGroupBy = p->pGroupBy;
  3036.     p->isDistinct = 0;
  3037.     isDistinct = 0;
  3038.   }
  3039.   /* If there is an ORDER BY clause, then this sorting
  3040.   ** index might end up being unused if the data can be 
  3041.   ** extracted in pre-sorted order.  If that is the case, then the
  3042.   ** OP_OpenEphemeral instruction will be changed to an OP_Noop once
  3043.   ** we figure out that the sorting index is not needed.  The addrSortIndex
  3044.   ** variable is used to facilitate that change.
  3045.   */
  3046.   if( pOrderBy ){
  3047.     KeyInfo *pKeyInfo;
  3048.     pKeyInfo = keyInfoFromExprList(pParse, pOrderBy);
  3049.     pOrderBy->iECursor = pParse->nTab++;
  3050.     p->addrOpenEphm[2] = addrSortIndex =
  3051.       sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
  3052.                            pOrderBy->iECursor, pOrderBy->nExpr+2, 0,
  3053.                            (char*)pKeyInfo, P4_KEYINFO_HANDOFF);
  3054.   }else{
  3055.     addrSortIndex = -1;
  3056.   }
  3057.   /* If the output is destined for a temporary table, open that table.
  3058.   */
  3059.   if( pDest->eDest==SRT_EphemTab ){
  3060.     sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pDest->iParm, pEList->nExpr);
  3061.   }
  3062.   /* Set the limiter.
  3063.   */
  3064.   iEnd = sqlite3VdbeMakeLabel(v);
  3065.   computeLimitRegisters(pParse, p, iEnd);
  3066.   /* Open a virtual index to use for the distinct set.
  3067.   */
  3068.   if( isDistinct ){
  3069.     KeyInfo *pKeyInfo;
  3070.     assert( isAgg || pGroupBy );
  3071.     distinct = pParse->nTab++;
  3072.     pKeyInfo = keyInfoFromExprList(pParse, p->pEList);
  3073.     sqlite3VdbeAddOp4(v, OP_OpenEphemeral, distinct, 0, 0,
  3074.                         (char*)pKeyInfo, P4_KEYINFO_HANDOFF);
  3075.   }else{
  3076.     distinct = -1;
  3077.   }
  3078.   /* Aggregate and non-aggregate queries are handled differently */
  3079.   if( !isAgg && pGroupBy==0 ){
  3080.     /* This case is for non-aggregate queries
  3081.     ** Begin the database scan
  3082.     */
  3083.     pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, &pOrderBy, 0);
  3084.     if( pWInfo==0 ) goto select_end;
  3085.     /* If sorting index that was created by a prior OP_OpenEphemeral 
  3086.     ** instruction ended up not being needed, then change the OP_OpenEphemeral
  3087.     ** into an OP_Noop.
  3088.     */
  3089.     if( addrSortIndex>=0 && pOrderBy==0 ){
  3090.       sqlite3VdbeChangeToNoop(v, addrSortIndex, 1);
  3091.       p->addrOpenEphm[2] = -1;
  3092.     }
  3093.     /* Use the standard inner loop
  3094.     */
  3095.     assert(!isDistinct);
  3096.     selectInnerLoop(pParse, p, pEList, 0, 0, pOrderBy, -1, pDest,
  3097.                     pWInfo->iContinue, pWInfo->iBreak, aff);
  3098.     /* End the database scan loop.
  3099.     */
  3100.     sqlite3WhereEnd(pWInfo);
  3101.   }else{
  3102.     /* This is the processing for aggregate queries */
  3103.     NameContext sNC;    /* Name context for processing aggregate information */
  3104.     int iAMem;          /* First Mem address for storing current GROUP BY */
  3105.     int iBMem;          /* First Mem address for previous GROUP BY */
  3106.     int iUseFlag;       /* Mem address holding flag indicating that at least
  3107.                         ** one row of the input to the aggregator has been
  3108.                         ** processed */
  3109.     int iAbortFlag;     /* Mem address which causes query abort if positive */
  3110.     int groupBySort;    /* Rows come from source in GROUP BY order */
  3111.     /* The following variables hold addresses or labels for parts of the
  3112.     ** virtual machine program we are putting together */
  3113.     int addrOutputRow;      /* Start of subroutine that outputs a result row */
  3114.     int addrSetAbort;       /* Set the abort flag and return */
  3115.     int addrInitializeLoop; /* Start of code that initializes the input loop */
  3116.     int addrTopOfLoop;      /* Top of the input loop */
  3117.     int addrGroupByChange;  /* Code that runs when any GROUP BY term changes */
  3118.     int addrProcessRow;     /* Code to process a single input row */
  3119.     int addrEnd;            /* End of all processing */
  3120.     int addrSortingIdx;     /* The OP_OpenEphemeral for the sorting index */
  3121.     int addrReset;          /* Subroutine for resetting the accumulator */
  3122.     addrEnd = sqlite3VdbeMakeLabel(v);
  3123.     /* Convert TK_COLUMN nodes into TK_AGG_COLUMN and make entries in
  3124.     ** sAggInfo for all TK_AGG_FUNCTION nodes in expressions of the
  3125.     ** SELECT statement.
  3126.     */
  3127.     memset(&sNC, 0, sizeof(sNC));
  3128.     sNC.pParse = pParse;
  3129.     sNC.pSrcList = pTabList;
  3130.     sNC.pAggInfo = &sAggInfo;
  3131.     sAggInfo.nSortingColumn = pGroupBy ? pGroupBy->nExpr+1 : 0;
  3132.     sAggInfo.pGroupBy = pGroupBy;
  3133.     sqlite3ExprAnalyzeAggList(&sNC, pEList);
  3134.     sqlite3ExprAnalyzeAggList(&sNC, pOrderBy);
  3135.     if( pHaving ){
  3136.       sqlite3ExprAnalyzeAggregates(&sNC, pHaving);
  3137.     }
  3138.     sAggInfo.nAccumulator = sAggInfo.nColumn;
  3139.     for(i=0; i<sAggInfo.nFunc; i++){
  3140.       sqlite3ExprAnalyzeAggList(&sNC, sAggInfo.aFunc[i].pExpr->pList);
  3141.     }
  3142.     if( db->mallocFailed ) goto select_end;
  3143.     /* Processing for aggregates with GROUP BY is very different and
  3144.     ** much more complex than aggregates without a GROUP BY.
  3145.     */
  3146.     if( pGroupBy ){
  3147.       KeyInfo *pKeyInfo;  /* Keying information for the group by clause */
  3148.       /* Create labels that we will be needing
  3149.       */
  3150.      
  3151.       addrInitializeLoop = sqlite3VdbeMakeLabel(v);
  3152.       addrGroupByChange = sqlite3VdbeMakeLabel(v);
  3153.       addrProcessRow = sqlite3VdbeMakeLabel(v);
  3154.       /* If there is a GROUP BY clause we might need a sorting index to
  3155.       ** implement it.  Allocate that sorting index now.  If it turns out
  3156.       ** that we do not need it after all, the OpenEphemeral instruction
  3157.       ** will be converted into a Noop.  
  3158.       */
  3159.       sAggInfo.sortingIdx = pParse->nTab++;
  3160.       pKeyInfo = keyInfoFromExprList(pParse, pGroupBy);
  3161.       addrSortingIdx = sqlite3VdbeAddOp4(v, OP_OpenEphemeral, 
  3162.           sAggInfo.sortingIdx, sAggInfo.nSortingColumn, 
  3163.           0, (char*)pKeyInfo, P4_KEYINFO_HANDOFF);
  3164.       /* Initialize memory locations used by GROUP BY aggregate processing
  3165.       */
  3166.       iUseFlag = ++pParse->nMem;
  3167.       iAbortFlag = ++pParse->nMem;
  3168.       iAMem = pParse->nMem + 1;
  3169.       pParse->nMem += pGroupBy->nExpr;
  3170.       iBMem = pParse->nMem + 1;
  3171.       pParse->nMem += pGroupBy->nExpr;
  3172.       sqlite3VdbeAddOp2(v, OP_Integer, 0, iAbortFlag);
  3173.       VdbeComment((v, "clear abort flag"));
  3174.       sqlite3VdbeAddOp2(v, OP_Integer, 0, iUseFlag);
  3175.       VdbeComment((v, "indicate accumulator empty"));
  3176.       sqlite3VdbeAddOp2(v, OP_Goto, 0, addrInitializeLoop);
  3177.       /* Generate a subroutine that outputs a single row of the result
  3178.       ** set.  This subroutine first looks at the iUseFlag.  If iUseFlag
  3179.       ** is less than or equal to zero, the subroutine is a no-op.  If
  3180.       ** the processing calls for the query to abort, this subroutine
  3181.       ** increments the iAbortFlag memory location before returning in
  3182.       ** order to signal the caller to abort.
  3183.       */
  3184.       addrSetAbort = sqlite3VdbeCurrentAddr(v);
  3185.       sqlite3VdbeAddOp2(v, OP_Integer, 1, iAbortFlag);
  3186.       VdbeComment((v, "set abort flag"));
  3187.       sqlite3VdbeAddOp2(v, OP_Return, 0, 0);
  3188.       addrOutputRow = sqlite3VdbeCurrentAddr(v);
  3189.       sqlite3VdbeAddOp2(v, OP_IfPos, iUseFlag, addrOutputRow+2);
  3190.       VdbeComment((v, "Groupby result generator entry point"));
  3191.       sqlite3VdbeAddOp2(v, OP_Return, 0, 0);
  3192.       finalizeAggFunctions(pParse, &sAggInfo);
  3193.       if( pHaving ){
  3194.         sqlite3ExprIfFalse(pParse, pHaving, addrOutputRow+1, SQLITE_JUMPIFNULL);
  3195.       }
  3196.       selectInnerLoop(pParse, p, p->pEList, 0, 0, pOrderBy,
  3197.                       distinct, pDest,
  3198.                       addrOutputRow+1, addrSetAbort, aff);
  3199.       sqlite3VdbeAddOp2(v, OP_Return, 0, 0);
  3200.       VdbeComment((v, "end groupby result generator"));
  3201.       /* Generate a subroutine that will reset the group-by accumulator
  3202.       */
  3203.       addrReset = sqlite3VdbeCurrentAddr(v);
  3204.       resetAccumulator(pParse, &sAggInfo);
  3205.       sqlite3VdbeAddOp2(v, OP_Return, 0, 0);
  3206.       /* Begin a loop that will extract all source rows in GROUP BY order.
  3207.       ** This might involve two separate loops with an OP_Sort in between, or
  3208.       ** it might be a single loop that uses an index to extract information
  3209.       ** in the right order to begin with.
  3210.       */
  3211.       sqlite3VdbeResolveLabel(v, addrInitializeLoop);
  3212.       sqlite3VdbeAddOp2(v, OP_Gosub, 0, addrReset);
  3213.       pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, &pGroupBy, 0);
  3214.       if( pWInfo==0 ) goto select_end;
  3215.       if( pGroupBy==0 ){
  3216.         /* The optimizer is able to deliver rows in group by order so
  3217.         ** we do not have to sort.  The OP_OpenEphemeral table will be
  3218.         ** cancelled later because we still need to use the pKeyInfo
  3219.         */
  3220.         pGroupBy = p->pGroupBy;
  3221.         groupBySort = 0;
  3222.       }else{
  3223.         /* Rows are coming out in undetermined order.  We have to push
  3224.         ** each row into a sorting index, terminate the first loop,
  3225.         ** then loop over the sorting index in order to get the output
  3226.         ** in sorted order
  3227.         */
  3228.         int regBase;
  3229.         int regRecord;
  3230.         int nCol;
  3231.         int nGroupBy;
  3232.         groupBySort = 1;
  3233.         nGroupBy = pGroupBy->nExpr;
  3234.         nCol = nGroupBy + 1;
  3235.         j = nGroupBy+1;
  3236.         for(i=0; i<sAggInfo.nColumn; i++){
  3237.           if( sAggInfo.aCol[i].iSorterColumn>=j ){
  3238.             nCol++;
  3239.             j++;
  3240.           }
  3241.         }
  3242.         regBase = sqlite3GetTempRange(pParse, nCol);
  3243.         sqlite3ExprCodeExprList(pParse, pGroupBy, regBase, 0);
  3244.         sqlite3VdbeAddOp2(v, OP_Sequence, sAggInfo.sortingIdx,regBase+nGroupBy);
  3245.         j = nGroupBy+1;
  3246.         for(i=0; i<sAggInfo.nColumn; i++){
  3247.           struct AggInfo_col *pCol = &sAggInfo.aCol[i];
  3248.           if( pCol->iSorterColumn>=j ){
  3249.             int r1 = j + regBase;
  3250.             int r2 = sqlite3ExprCodeGetColumn(pParse, 
  3251.                                pCol->pTab, pCol->iColumn, pCol->iTable, r1, 0);
  3252.             if( r1!=r2 ){
  3253.               sqlite3VdbeAddOp2(v, OP_SCopy, r2, r1);
  3254.             }
  3255.             j++;
  3256.           }
  3257.         }
  3258.         regRecord = sqlite3GetTempReg(pParse);
  3259.         sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord);
  3260.         sqlite3VdbeAddOp2(v, OP_IdxInsert, sAggInfo.sortingIdx, regRecord);
  3261.         sqlite3ReleaseTempReg(pParse, regRecord);
  3262.         sqlite3ReleaseTempRange(pParse, regBase, nCol);
  3263.         sqlite3WhereEnd(pWInfo);
  3264.         sqlite3VdbeAddOp2(v, OP_Sort, sAggInfo.sortingIdx, addrEnd);
  3265.         VdbeComment((v, "GROUP BY sort"));
  3266.         sAggInfo.useSortingIdx = 1;
  3267.       }
  3268.       /* Evaluate the current GROUP BY terms and store in b0, b1, b2...
  3269.       ** (b0 is memory location iBMem+0, b1 is iBMem+1, and so forth)
  3270.       ** Then compare the current GROUP BY terms against the GROUP BY terms
  3271.       ** from the previous row currently stored in a0, a1, a2...
  3272.       */
  3273.       addrTopOfLoop = sqlite3VdbeCurrentAddr(v);
  3274.       for(j=0; j<pGroupBy->nExpr; j++){
  3275.         if( groupBySort ){
  3276.           sqlite3VdbeAddOp3(v, OP_Column, sAggInfo.sortingIdx, j, iBMem+j);
  3277.         }else{
  3278.           sAggInfo.directMode = 1;
  3279.           sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr, iBMem+j);
  3280.         }
  3281.       }
  3282.       for(j=pGroupBy->nExpr-1; j>=0; j--){
  3283.         if( j==0 ){
  3284.           sqlite3VdbeAddOp3(v, OP_Eq, iAMem+j, addrProcessRow, iBMem+j);
  3285.         }else{
  3286.           sqlite3VdbeAddOp3(v, OP_Ne, iAMem+j, addrGroupByChange, iBMem+j);
  3287.         }
  3288.         sqlite3VdbeChangeP4(v, -1, (void*)pKeyInfo->aColl[j], P4_COLLSEQ);
  3289.         sqlite3VdbeChangeP5(v, SQLITE_NULLEQUAL);
  3290.       }
  3291.       /* Generate code that runs whenever the GROUP BY changes.
  3292.       ** Change in the GROUP BY are detected by the previous code
  3293.       ** block.  If there were no changes, this block is skipped.
  3294.       **
  3295.       ** This code copies current group by terms in b0,b1,b2,...
  3296.       ** over to a0,a1,a2.  It then calls the output subroutine
  3297.       ** and resets the aggregate accumulator registers in preparation
  3298.       ** for the next GROUP BY batch.
  3299.       */
  3300.       sqlite3VdbeResolveLabel(v, addrGroupByChange);
  3301.       for(j=0; j<pGroupBy->nExpr; j++){
  3302.         sqlite3ExprCodeMove(pParse, iBMem+j, iAMem+j);
  3303.       }
  3304.       sqlite3VdbeAddOp2(v, OP_Gosub, 0, addrOutputRow);
  3305.       VdbeComment((v, "output one row"));
  3306.       sqlite3VdbeAddOp2(v, OP_IfPos, iAbortFlag, addrEnd);
  3307.       VdbeComment((v, "check abort flag"));
  3308.       sqlite3VdbeAddOp2(v, OP_Gosub, 0, addrReset);
  3309.       VdbeComment((v, "reset accumulator"));
  3310.       /* Update the aggregate accumulators based on the content of
  3311.       ** the current row
  3312.       */
  3313.       sqlite3VdbeResolveLabel(v, addrProcessRow);
  3314.       updateAccumulator(pParse, &sAggInfo);
  3315.       sqlite3VdbeAddOp2(v, OP_Integer, 1, iUseFlag);
  3316.       VdbeComment((v, "indicate data in accumulator"));
  3317.       /* End of the loop
  3318.       */
  3319.       if( groupBySort ){
  3320.         sqlite3VdbeAddOp2(v, OP_Next, sAggInfo.sortingIdx, addrTopOfLoop);
  3321.       }else{
  3322.         sqlite3WhereEnd(pWInfo);
  3323.         sqlite3VdbeChangeToNoop(v, addrSortingIdx, 1);
  3324.       }
  3325.       /* Output the final row of result
  3326.       */
  3327.       sqlite3VdbeAddOp2(v, OP_Gosub, 0, addrOutputRow);
  3328.       VdbeComment((v, "output final row"));
  3329.       
  3330.     } /* endif pGroupBy */
  3331.     else {
  3332.       ExprList *pMinMax = 0;
  3333.       ExprList *pDel = 0;
  3334.       u8 flag;
  3335.       /* Check if the query is of one of the following forms:
  3336.       **
  3337.       **   SELECT min(x) FROM ...
  3338.       **   SELECT max(x) FROM ...
  3339.       **
  3340.       ** If it is, then ask the code in where.c to attempt to sort results
  3341.       ** as if there was an "ORDER ON x" or "ORDER ON x DESC" clause. 
  3342.       ** If where.c is able to produce results sorted in this order, then
  3343.       ** add vdbe code to break out of the processing loop after the 
  3344.       ** first iteration (since the first iteration of the loop is 
  3345.       ** guaranteed to operate on the row with the minimum or maximum 
  3346.       ** value of x, the only row required).
  3347.       **
  3348.       ** A special flag must be passed to sqlite3WhereBegin() to slightly
  3349.       ** modify behaviour as follows:
  3350.       **
  3351.       **   + If the query is a "SELECT min(x)", then the loop coded by
  3352.       **     where.c should not iterate over any values with a NULL value
  3353.       **     for x.
  3354.       **
  3355.       **   + The optimizer code in where.c (the thing that decides which
  3356.       **     index or indices to use) should place a different priority on 
  3357.       **     satisfying the 'ORDER BY' clause than it does in other cases.
  3358.       **     Refer to code and comments in where.c for details.
  3359.       */
  3360.       flag = minMaxQuery(pParse, p);
  3361.       if( flag ){
  3362.         pDel = pMinMax = sqlite3ExprListDup(db, p->pEList->a[0].pExpr->pList);
  3363.         if( pMinMax && !db->mallocFailed ){
  3364.           pMinMax->a[0].sortOrder = ((flag==WHERE_ORDERBY_MIN)?0:1);
  3365.           pMinMax->a[0].pExpr->op = TK_COLUMN;
  3366.         }
  3367.       }
  3368.       /* This case runs if the aggregate has no GROUP BY clause.  The
  3369.       ** processing is much simpler since there is only a single row
  3370.       ** of output.
  3371.       */
  3372.       resetAccumulator(pParse, &sAggInfo);
  3373.       pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, &pMinMax, flag);
  3374.       if( pWInfo==0 ){
  3375.         sqlite3ExprListDelete(pDel);
  3376.         goto select_end;
  3377.       }
  3378.       updateAccumulator(pParse, &sAggInfo);
  3379.       if( !pMinMax && flag ){
  3380.         sqlite3VdbeAddOp2(v, OP_Goto, 0, pWInfo->iBreak);
  3381.         VdbeComment((v, "%s() by index", (flag==WHERE_ORDERBY_MIN?"min":"max")));
  3382.       }
  3383.       sqlite3WhereEnd(pWInfo);
  3384.       finalizeAggFunctions(pParse, &sAggInfo);
  3385.       pOrderBy = 0;
  3386.       if( pHaving ){
  3387.         sqlite3ExprIfFalse(pParse, pHaving, addrEnd, SQLITE_JUMPIFNULL);
  3388.       }
  3389.       selectInnerLoop(pParse, p, p->pEList, 0, 0, 0, -1, 
  3390.                       pDest, addrEnd, addrEnd, aff);
  3391.       sqlite3ExprListDelete(pDel);
  3392.     }
  3393.     sqlite3VdbeResolveLabel(v, addrEnd);
  3394.     
  3395.   } /* endif aggregate query */
  3396.   /* If there is an ORDER BY clause, then we need to sort the results
  3397.   ** and send them to the callback one by one.
  3398.   */
  3399.   if( pOrderBy ){
  3400.     generateSortTail(pParse, p, v, pEList->nExpr, pDest);
  3401.   }
  3402. #ifndef SQLITE_OMIT_SUBQUERY
  3403.   /* If this was a subquery, we have now converted the subquery into a
  3404.   ** temporary table.  So set the SrcList_item.isPopulated flag to prevent
  3405.   ** this subquery from being evaluated again and to force the use of
  3406.   ** the temporary table.
  3407.   */
  3408.   if( pParent ){
  3409.     assert( pParent->pSrc->nSrc>parentTab );
  3410.     assert( pParent->pSrc->a[parentTab].pSelect==p );
  3411.     pParent->pSrc->a[parentTab].isPopulated = 1;
  3412.   }
  3413. #endif
  3414.   /* Jump here to skip this query
  3415.   */
  3416.   sqlite3VdbeResolveLabel(v, iEnd);
  3417.   /* The SELECT was successfully coded.   Set the return code to 0
  3418.   ** to indicate no errors.
  3419.   */
  3420.   rc = 0;
  3421.   /* Control jumps to here if an error is encountered above, or upon
  3422.   ** successful coding of the SELECT.
  3423.   */
  3424. select_end:
  3425.   /* Identify column names if we will be using them in a callback.  This
  3426.   ** step is skipped if the output is going to some other destination.
  3427.   */
  3428.   if( rc==SQLITE_OK && pDest->eDest==SRT_Callback ){
  3429.     generateColumnNames(pParse, pTabList, pEList);
  3430.   }
  3431.   sqlite3_free(sAggInfo.aCol);
  3432.   sqlite3_free(sAggInfo.aFunc);
  3433.   return rc;
  3434. }
  3435. #if defined(SQLITE_DEBUG)
  3436. /*
  3437. *******************************************************************************
  3438. ** The following code is used for testing and debugging only.  The code
  3439. ** that follows does not appear in normal builds.
  3440. **
  3441. ** These routines are used to print out the content of all or part of a 
  3442. ** parse structures such as Select or Expr.  Such printouts are useful
  3443. ** for helping to understand what is happening inside the code generator
  3444. ** during the execution of complex SELECT statements.
  3445. **
  3446. ** These routine are not called anywhere from within the normal
  3447. ** code base.  Then are intended to be called from within the debugger
  3448. ** or from temporary "printf" statements inserted for debugging.
  3449. */
  3450. static void sqlite3PrintExpr(Expr *p){
  3451.   if( p->token.z && p->token.n>0 ){
  3452.     sqlite3DebugPrintf("(%.*s", p->token.n, p->token.z);
  3453.   }else{
  3454.     sqlite3DebugPrintf("(%d", p->op);
  3455.   }
  3456.   if( p->pLeft ){
  3457.     sqlite3DebugPrintf(" ");
  3458.     sqlite3PrintExpr(p->pLeft);
  3459.   }
  3460.   if( p->pRight ){
  3461.     sqlite3DebugPrintf(" ");
  3462.     sqlite3PrintExpr(p->pRight);
  3463.   }
  3464.   sqlite3DebugPrintf(")");
  3465. }
  3466. static void sqlite3PrintExprList(ExprList *pList){
  3467.   int i;
  3468.   for(i=0; i<pList->nExpr; i++){
  3469.     sqlite3PrintExpr(pList->a[i].pExpr);
  3470.     if( i<pList->nExpr-1 ){
  3471.       sqlite3DebugPrintf(", ");
  3472.     }
  3473.   }
  3474. }
  3475. static void sqlite3PrintSelect(Select *p, int indent){
  3476.   sqlite3DebugPrintf("%*sSELECT(%p) ", indent, "", p);
  3477.   sqlite3PrintExprList(p->pEList);
  3478.   sqlite3DebugPrintf("n");
  3479.   if( p->pSrc ){
  3480.     char *zPrefix;
  3481.     int i;
  3482.     zPrefix = "FROM";
  3483.     for(i=0; i<p->pSrc->nSrc; i++){
  3484.       struct SrcList_item *pItem = &p->pSrc->a[i];
  3485.       sqlite3DebugPrintf("%*s ", indent+6, zPrefix);
  3486.       zPrefix = "";
  3487.       if( pItem->pSelect ){
  3488.         sqlite3DebugPrintf("(n");
  3489.         sqlite3PrintSelect(pItem->pSelect, indent+10);
  3490.         sqlite3DebugPrintf("%*s)", indent+8, "");
  3491.       }else if( pItem->zName ){
  3492.         sqlite3DebugPrintf("%s", pItem->zName);
  3493.       }
  3494.       if( pItem->pTab ){
  3495.         sqlite3DebugPrintf("(table: %s)", pItem->pTab->zName);
  3496.       }
  3497.       if( pItem->zAlias ){
  3498.         sqlite3DebugPrintf(" AS %s", pItem->zAlias);
  3499.       }
  3500.       if( i<p->pSrc->nSrc-1 ){
  3501.         sqlite3DebugPrintf(",");
  3502.       }
  3503.       sqlite3DebugPrintf("n");
  3504.     }
  3505.   }
  3506.   if( p->pWhere ){
  3507.     sqlite3DebugPrintf("%*s WHERE ", indent, "");
  3508.     sqlite3PrintExpr(p->pWhere);
  3509.     sqlite3DebugPrintf("n");
  3510.   }
  3511.   if( p->pGroupBy ){
  3512.     sqlite3DebugPrintf("%*s GROUP BY ", indent, "");
  3513.     sqlite3PrintExprList(p->pGroupBy);
  3514.     sqlite3DebugPrintf("n");
  3515.   }
  3516.   if( p->pHaving ){
  3517.     sqlite3DebugPrintf("%*s HAVING ", indent, "");
  3518.     sqlite3PrintExpr(p->pHaving);
  3519.     sqlite3DebugPrintf("n");
  3520.   }
  3521.   if( p->pOrderBy ){
  3522.     sqlite3DebugPrintf("%*s ORDER BY ", indent, "");
  3523.     sqlite3PrintExprList(p->pOrderBy);
  3524.     sqlite3DebugPrintf("n");
  3525.   }
  3526. }
  3527. /* End of the structure debug printing code
  3528. *****************************************************************************/
  3529. #endif /* defined(SQLITE_TEST) || defined(SQLITE_DEBUG) */