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

数据库系统

开发平台:

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 routines used for analyzing expressions and
  13. ** for generating VDBE code that evaluates expressions in SQLite.
  14. **
  15. ** $Id: expr.c,v 1.367 2008/04/15 12:14:22 drh Exp $
  16. */
  17. #include "sqliteInt.h"
  18. #include <ctype.h>
  19. /*
  20. ** Return the 'affinity' of the expression pExpr if any.
  21. **
  22. ** If pExpr is a column, a reference to a column via an 'AS' alias,
  23. ** or a sub-select with a column as the return value, then the 
  24. ** affinity of that column is returned. Otherwise, 0x00 is returned,
  25. ** indicating no affinity for the expression.
  26. **
  27. ** i.e. the WHERE clause expresssions in the following statements all
  28. ** have an affinity:
  29. **
  30. ** CREATE TABLE t1(a);
  31. ** SELECT * FROM t1 WHERE a;
  32. ** SELECT a AS b FROM t1 WHERE b;
  33. ** SELECT * FROM t1 WHERE (select a from t1);
  34. */
  35. char sqlite3ExprAffinity(Expr *pExpr){
  36.   int op = pExpr->op;
  37.   if( op==TK_SELECT ){
  38.     return sqlite3ExprAffinity(pExpr->pSelect->pEList->a[0].pExpr);
  39.   }
  40. #ifndef SQLITE_OMIT_CAST
  41.   if( op==TK_CAST ){
  42.     return sqlite3AffinityType(&pExpr->token);
  43.   }
  44. #endif
  45.   return pExpr->affinity;
  46. }
  47. /*
  48. ** Set the collating sequence for expression pExpr to be the collating
  49. ** sequence named by pToken.   Return a pointer to the revised expression.
  50. ** The collating sequence is marked as "explicit" using the EP_ExpCollate
  51. ** flag.  An explicit collating sequence will override implicit
  52. ** collating sequences.
  53. */
  54. Expr *sqlite3ExprSetColl(Parse *pParse, Expr *pExpr, Token *pName){
  55.   char *zColl = 0;            /* Dequoted name of collation sequence */
  56.   CollSeq *pColl;
  57.   zColl = sqlite3NameFromToken(pParse->db, pName);
  58.   if( pExpr && zColl ){
  59.     pColl = sqlite3LocateCollSeq(pParse, zColl, -1);
  60.     if( pColl ){
  61.       pExpr->pColl = pColl;
  62.       pExpr->flags |= EP_ExpCollate;
  63.     }
  64.   }
  65.   sqlite3_free(zColl);
  66.   return pExpr;
  67. }
  68. /*
  69. ** Return the default collation sequence for the expression pExpr. If
  70. ** there is no default collation type, return 0.
  71. */
  72. CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr){
  73.   CollSeq *pColl = 0;
  74.   if( pExpr ){
  75.     int op;
  76.     pColl = pExpr->pColl;
  77.     op = pExpr->op;
  78.     if( (op==TK_CAST || op==TK_UPLUS) && !pColl ){
  79.       return sqlite3ExprCollSeq(pParse, pExpr->pLeft);
  80.     }
  81.   }
  82.   if( sqlite3CheckCollSeq(pParse, pColl) ){ 
  83.     pColl = 0;
  84.   }
  85.   return pColl;
  86. }
  87. /*
  88. ** pExpr is an operand of a comparison operator.  aff2 is the
  89. ** type affinity of the other operand.  This routine returns the
  90. ** type affinity that should be used for the comparison operator.
  91. */
  92. char sqlite3CompareAffinity(Expr *pExpr, char aff2){
  93.   char aff1 = sqlite3ExprAffinity(pExpr);
  94.   if( aff1 && aff2 ){
  95.     /* Both sides of the comparison are columns. If one has numeric
  96.     ** affinity, use that. Otherwise use no affinity.
  97.     */
  98.     if( sqlite3IsNumericAffinity(aff1) || sqlite3IsNumericAffinity(aff2) ){
  99.       return SQLITE_AFF_NUMERIC;
  100.     }else{
  101.       return SQLITE_AFF_NONE;
  102.     }
  103.   }else if( !aff1 && !aff2 ){
  104.     /* Neither side of the comparison is a column.  Compare the
  105.     ** results directly.
  106.     */
  107.     return SQLITE_AFF_NONE;
  108.   }else{
  109.     /* One side is a column, the other is not. Use the columns affinity. */
  110.     assert( aff1==0 || aff2==0 );
  111.     return (aff1 + aff2);
  112.   }
  113. }
  114. /*
  115. ** pExpr is a comparison operator.  Return the type affinity that should
  116. ** be applied to both operands prior to doing the comparison.
  117. */
  118. static char comparisonAffinity(Expr *pExpr){
  119.   char aff;
  120.   assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT ||
  121.           pExpr->op==TK_GT || pExpr->op==TK_GE || pExpr->op==TK_LE ||
  122.           pExpr->op==TK_NE );
  123.   assert( pExpr->pLeft );
  124.   aff = sqlite3ExprAffinity(pExpr->pLeft);
  125.   if( pExpr->pRight ){
  126.     aff = sqlite3CompareAffinity(pExpr->pRight, aff);
  127.   }
  128.   else if( pExpr->pSelect ){
  129.     aff = sqlite3CompareAffinity(pExpr->pSelect->pEList->a[0].pExpr, aff);
  130.   }
  131.   else if( !aff ){
  132.     aff = SQLITE_AFF_NONE;
  133.   }
  134.   return aff;
  135. }
  136. /*
  137. ** pExpr is a comparison expression, eg. '=', '<', IN(...) etc.
  138. ** idx_affinity is the affinity of an indexed column. Return true
  139. ** if the index with affinity idx_affinity may be used to implement
  140. ** the comparison in pExpr.
  141. */
  142. int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity){
  143.   char aff = comparisonAffinity(pExpr);
  144.   switch( aff ){
  145.     case SQLITE_AFF_NONE:
  146.       return 1;
  147.     case SQLITE_AFF_TEXT:
  148.       return idx_affinity==SQLITE_AFF_TEXT;
  149.     default:
  150.       return sqlite3IsNumericAffinity(idx_affinity);
  151.   }
  152. }
  153. /*
  154. ** Return the P5 value that should be used for a binary comparison
  155. ** opcode (OP_Eq, OP_Ge etc.) used to compare pExpr1 and pExpr2.
  156. */
  157. static u8 binaryCompareP5(Expr *pExpr1, Expr *pExpr2, int jumpIfNull){
  158.   u8 aff = (char)sqlite3ExprAffinity(pExpr2);
  159.   aff = sqlite3CompareAffinity(pExpr1, aff) | jumpIfNull;
  160.   return aff;
  161. }
  162. /*
  163. ** Return a pointer to the collation sequence that should be used by
  164. ** a binary comparison operator comparing pLeft and pRight.
  165. **
  166. ** If the left hand expression has a collating sequence type, then it is
  167. ** used. Otherwise the collation sequence for the right hand expression
  168. ** is used, or the default (BINARY) if neither expression has a collating
  169. ** type.
  170. **
  171. ** Argument pRight (but not pLeft) may be a null pointer. In this case,
  172. ** it is not considered.
  173. */
  174. CollSeq *sqlite3BinaryCompareCollSeq(
  175.   Parse *pParse, 
  176.   Expr *pLeft, 
  177.   Expr *pRight
  178. ){
  179.   CollSeq *pColl;
  180.   assert( pLeft );
  181.   if( pLeft->flags & EP_ExpCollate ){
  182.     assert( pLeft->pColl );
  183.     pColl = pLeft->pColl;
  184.   }else if( pRight && pRight->flags & EP_ExpCollate ){
  185.     assert( pRight->pColl );
  186.     pColl = pRight->pColl;
  187.   }else{
  188.     pColl = sqlite3ExprCollSeq(pParse, pLeft);
  189.     if( !pColl ){
  190.       pColl = sqlite3ExprCollSeq(pParse, pRight);
  191.     }
  192.   }
  193.   return pColl;
  194. }
  195. /*
  196. ** Generate the operands for a comparison operation.  Before
  197. ** generating the code for each operand, set the EP_AnyAff
  198. ** flag on the expression so that it will be able to used a
  199. ** cached column value that has previously undergone an
  200. ** affinity change.
  201. */
  202. static void codeCompareOperands(
  203.   Parse *pParse,    /* Parsing and code generating context */
  204.   Expr *pLeft,      /* The left operand */
  205.   int *pRegLeft,    /* Register where left operand is stored */
  206.   int *pFreeLeft,   /* Free this register when done */
  207.   Expr *pRight,     /* The right operand */
  208.   int *pRegRight,   /* Register where right operand is stored */
  209.   int *pFreeRight   /* Write temp register for right operand there */
  210. ){
  211.   while( pLeft->op==TK_UPLUS ) pLeft = pLeft->pLeft;
  212.   pLeft->flags |= EP_AnyAff;
  213.   *pRegLeft = sqlite3ExprCodeTemp(pParse, pLeft, pFreeLeft);
  214.   while( pRight->op==TK_UPLUS ) pRight = pRight->pLeft;
  215.   pRight->flags |= EP_AnyAff;
  216.   *pRegRight = sqlite3ExprCodeTemp(pParse, pRight, pFreeRight);
  217. }
  218. /*
  219. ** Generate code for a comparison operator.
  220. */
  221. static int codeCompare(
  222.   Parse *pParse,    /* The parsing (and code generating) context */
  223.   Expr *pLeft,      /* The left operand */
  224.   Expr *pRight,     /* The right operand */
  225.   int opcode,       /* The comparison opcode */
  226.   int in1, int in2, /* Register holding operands */
  227.   int dest,         /* Jump here if true.  */
  228.   int jumpIfNull    /* If true, jump if either operand is NULL */
  229. ){
  230.   int p5;
  231.   int addr;
  232.   CollSeq *p4;
  233.   p4 = sqlite3BinaryCompareCollSeq(pParse, pLeft, pRight);
  234.   p5 = binaryCompareP5(pLeft, pRight, jumpIfNull);
  235.   addr = sqlite3VdbeAddOp4(pParse->pVdbe, opcode, in2, dest, in1,
  236.                            (void*)p4, P4_COLLSEQ);
  237.   sqlite3VdbeChangeP5(pParse->pVdbe, p5);
  238.   if( p5 & SQLITE_AFF_MASK ){
  239.     sqlite3ExprCacheAffinityChange(pParse, in1, 1);
  240.     sqlite3ExprCacheAffinityChange(pParse, in2, 1);
  241.   }
  242.   return addr;
  243. }
  244. /*
  245. ** Construct a new expression node and return a pointer to it.  Memory
  246. ** for this node is obtained from sqlite3_malloc().  The calling function
  247. ** is responsible for making sure the node eventually gets freed.
  248. */
  249. Expr *sqlite3Expr(
  250.   sqlite3 *db,            /* Handle for sqlite3DbMallocZero() (may be null) */
  251.   int op,                 /* Expression opcode */
  252.   Expr *pLeft,            /* Left operand */
  253.   Expr *pRight,           /* Right operand */
  254.   const Token *pToken     /* Argument token */
  255. ){
  256.   Expr *pNew;
  257.   static const Expr zeroExpr;
  258.   pNew = sqlite3DbMallocRaw(db, sizeof(Expr));
  259.   if( pNew==0 ){
  260.     /* When malloc fails, delete pLeft and pRight. Expressions passed to 
  261.     ** this function must always be allocated with sqlite3Expr() for this 
  262.     ** reason. 
  263.     */
  264.     sqlite3ExprDelete(pLeft);
  265.     sqlite3ExprDelete(pRight);
  266.     return 0;
  267.   }
  268.   *pNew = zeroExpr;
  269.   pNew->op = op;
  270.   pNew->pLeft = pLeft;
  271.   pNew->pRight = pRight;
  272.   pNew->iAgg = -1;
  273.   if( pToken ){
  274.     assert( pToken->dyn==0 );
  275.     pNew->span = pNew->token = *pToken;
  276.   }else if( pLeft ){
  277.     if( pRight ){
  278.       sqlite3ExprSpan(pNew, &pLeft->span, &pRight->span);
  279.       if( pRight->flags & EP_ExpCollate ){
  280.         pNew->flags |= EP_ExpCollate;
  281.         pNew->pColl = pRight->pColl;
  282.       }
  283.     }
  284.     if( pLeft->flags & EP_ExpCollate ){
  285.       pNew->flags |= EP_ExpCollate;
  286.       pNew->pColl = pLeft->pColl;
  287.     }
  288.   }
  289.   sqlite3ExprSetHeight(pNew);
  290.   return pNew;
  291. }
  292. /*
  293. ** Works like sqlite3Expr() except that it takes an extra Parse*
  294. ** argument and notifies the associated connection object if malloc fails.
  295. */
  296. Expr *sqlite3PExpr(
  297.   Parse *pParse,          /* Parsing context */
  298.   int op,                 /* Expression opcode */
  299.   Expr *pLeft,            /* Left operand */
  300.   Expr *pRight,           /* Right operand */
  301.   const Token *pToken     /* Argument token */
  302. ){
  303.   return sqlite3Expr(pParse->db, op, pLeft, pRight, pToken);
  304. }
  305. /*
  306. ** When doing a nested parse, you can include terms in an expression
  307. ** that look like this:   #1 #2 ...  These terms refer to registers
  308. ** in the virtual machine.  #N is the N-th register.
  309. **
  310. ** This routine is called by the parser to deal with on of those terms.
  311. ** It immediately generates code to store the value in a memory location.
  312. ** The returns an expression that will code to extract the value from
  313. ** that memory location as needed.
  314. */
  315. Expr *sqlite3RegisterExpr(Parse *pParse, Token *pToken){
  316.   Vdbe *v = pParse->pVdbe;
  317.   Expr *p;
  318.   if( pParse->nested==0 ){
  319.     sqlite3ErrorMsg(pParse, "near "%T": syntax error", pToken);
  320.     return sqlite3PExpr(pParse, TK_NULL, 0, 0, 0);
  321.   }
  322.   if( v==0 ) return 0;
  323.   p = sqlite3PExpr(pParse, TK_REGISTER, 0, 0, pToken);
  324.   if( p==0 ){
  325.     return 0;  /* Malloc failed */
  326.   }
  327.   p->iTable = atoi((char*)&pToken->z[1]);
  328.   return p;
  329. }
  330. /*
  331. ** Join two expressions using an AND operator.  If either expression is
  332. ** NULL, then just return the other expression.
  333. */
  334. Expr *sqlite3ExprAnd(sqlite3 *db, Expr *pLeft, Expr *pRight){
  335.   if( pLeft==0 ){
  336.     return pRight;
  337.   }else if( pRight==0 ){
  338.     return pLeft;
  339.   }else{
  340.     return sqlite3Expr(db, TK_AND, pLeft, pRight, 0);
  341.   }
  342. }
  343. /*
  344. ** Set the Expr.span field of the given expression to span all
  345. ** text between the two given tokens.
  346. */
  347. void sqlite3ExprSpan(Expr *pExpr, Token *pLeft, Token *pRight){
  348.   assert( pRight!=0 );
  349.   assert( pLeft!=0 );
  350.   if( pExpr && pRight->z && pLeft->z ){
  351.     assert( pLeft->dyn==0 || pLeft->z[pLeft->n]==0 );
  352.     if( pLeft->dyn==0 && pRight->dyn==0 ){
  353.       pExpr->span.z = pLeft->z;
  354.       pExpr->span.n = pRight->n + (pRight->z - pLeft->z);
  355.     }else{
  356.       pExpr->span.z = 0;
  357.     }
  358.   }
  359. }
  360. /*
  361. ** Construct a new expression node for a function with multiple
  362. ** arguments.
  363. */
  364. Expr *sqlite3ExprFunction(Parse *pParse, ExprList *pList, Token *pToken){
  365.   Expr *pNew;
  366.   assert( pToken );
  367.   pNew = sqlite3DbMallocZero(pParse->db, sizeof(Expr) );
  368.   if( pNew==0 ){
  369.     sqlite3ExprListDelete(pList); /* Avoid leaking memory when malloc fails */
  370.     return 0;
  371.   }
  372.   pNew->op = TK_FUNCTION;
  373.   pNew->pList = pList;
  374.   assert( pToken->dyn==0 );
  375.   pNew->token = *pToken;
  376.   pNew->span = pNew->token;
  377.   sqlite3ExprSetHeight(pNew);
  378.   return pNew;
  379. }
  380. /*
  381. ** Assign a variable number to an expression that encodes a wildcard
  382. ** in the original SQL statement.  
  383. **
  384. ** Wildcards consisting of a single "?" are assigned the next sequential
  385. ** variable number.
  386. **
  387. ** Wildcards of the form "?nnn" are assigned the number "nnn".  We make
  388. ** sure "nnn" is not too be to avoid a denial of service attack when
  389. ** the SQL statement comes from an external source.
  390. **
  391. ** Wildcards of the form ":aaa" or "$aaa" are assigned the same number
  392. ** as the previous instance of the same wildcard.  Or if this is the first
  393. ** instance of the wildcard, the next sequenial variable number is
  394. ** assigned.
  395. */
  396. void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr){
  397.   Token *pToken;
  398.   sqlite3 *db = pParse->db;
  399.   if( pExpr==0 ) return;
  400.   pToken = &pExpr->token;
  401.   assert( pToken->n>=1 );
  402.   assert( pToken->z!=0 );
  403.   assert( pToken->z[0]!=0 );
  404.   if( pToken->n==1 ){
  405.     /* Wildcard of the form "?".  Assign the next variable number */
  406.     pExpr->iTable = ++pParse->nVar;
  407.   }else if( pToken->z[0]=='?' ){
  408.     /* Wildcard of the form "?nnn".  Convert "nnn" to an integer and
  409.     ** use it as the variable number */
  410.     int i;
  411.     pExpr->iTable = i = atoi((char*)&pToken->z[1]);
  412.     testcase( i==0 );
  413.     testcase( i==1 );
  414.     testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]-1 );
  415.     testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] );
  416.     if( i<1 || i>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){
  417.       sqlite3ErrorMsg(pParse, "variable number must be between ?1 and ?%d",
  418.           db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]);
  419.     }
  420.     if( i>pParse->nVar ){
  421.       pParse->nVar = i;
  422.     }
  423.   }else{
  424.     /* Wildcards of the form ":aaa" or "$aaa".  Reuse the same variable
  425.     ** number as the prior appearance of the same name, or if the name
  426.     ** has never appeared before, reuse the same variable number
  427.     */
  428.     int i, n;
  429.     n = pToken->n;
  430.     for(i=0; i<pParse->nVarExpr; i++){
  431.       Expr *pE;
  432.       if( (pE = pParse->apVarExpr[i])!=0
  433.           && pE->token.n==n
  434.           && memcmp(pE->token.z, pToken->z, n)==0 ){
  435.         pExpr->iTable = pE->iTable;
  436.         break;
  437.       }
  438.     }
  439.     if( i>=pParse->nVarExpr ){
  440.       pExpr->iTable = ++pParse->nVar;
  441.       if( pParse->nVarExpr>=pParse->nVarExprAlloc-1 ){
  442.         pParse->nVarExprAlloc += pParse->nVarExprAlloc + 10;
  443.         pParse->apVarExpr =
  444.             sqlite3DbReallocOrFree(
  445.               db,
  446.               pParse->apVarExpr,
  447.               pParse->nVarExprAlloc*sizeof(pParse->apVarExpr[0])
  448.             );
  449.       }
  450.       if( !db->mallocFailed ){
  451.         assert( pParse->apVarExpr!=0 );
  452.         pParse->apVarExpr[pParse->nVarExpr++] = pExpr;
  453.       }
  454.     }
  455.   } 
  456.   if( !pParse->nErr && pParse->nVar>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){
  457.     sqlite3ErrorMsg(pParse, "too many SQL variables");
  458.   }
  459. }
  460. /*
  461. ** Recursively delete an expression tree.
  462. */
  463. void sqlite3ExprDelete(Expr *p){
  464.   if( p==0 ) return;
  465.   if( p->span.dyn ) sqlite3_free((char*)p->span.z);
  466.   if( p->token.dyn ) sqlite3_free((char*)p->token.z);
  467.   sqlite3ExprDelete(p->pLeft);
  468.   sqlite3ExprDelete(p->pRight);
  469.   sqlite3ExprListDelete(p->pList);
  470.   sqlite3SelectDelete(p->pSelect);
  471.   sqlite3_free(p);
  472. }
  473. /*
  474. ** The Expr.token field might be a string literal that is quoted.
  475. ** If so, remove the quotation marks.
  476. */
  477. void sqlite3DequoteExpr(sqlite3 *db, Expr *p){
  478.   if( ExprHasAnyProperty(p, EP_Dequoted) ){
  479.     return;
  480.   }
  481.   ExprSetProperty(p, EP_Dequoted);
  482.   if( p->token.dyn==0 ){
  483.     sqlite3TokenCopy(db, &p->token, &p->token);
  484.   }
  485.   sqlite3Dequote((char*)p->token.z);
  486. }
  487. /*
  488. ** The following group of routines make deep copies of expressions,
  489. ** expression lists, ID lists, and select statements.  The copies can
  490. ** be deleted (by being passed to their respective ...Delete() routines)
  491. ** without effecting the originals.
  492. **
  493. ** The expression list, ID, and source lists return by sqlite3ExprListDup(),
  494. ** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded 
  495. ** by subsequent calls to sqlite*ListAppend() routines.
  496. **
  497. ** Any tables that the SrcList might point to are not duplicated.
  498. */
  499. Expr *sqlite3ExprDup(sqlite3 *db, Expr *p){
  500.   Expr *pNew;
  501.   if( p==0 ) return 0;
  502.   pNew = sqlite3DbMallocRaw(db, sizeof(*p) );
  503.   if( pNew==0 ) return 0;
  504.   memcpy(pNew, p, sizeof(*pNew));
  505.   if( p->token.z!=0 ){
  506.     pNew->token.z = (u8*)sqlite3DbStrNDup(db, (char*)p->token.z, p->token.n);
  507.     pNew->token.dyn = 1;
  508.   }else{
  509.     assert( pNew->token.z==0 );
  510.   }
  511.   pNew->span.z = 0;
  512.   pNew->pLeft = sqlite3ExprDup(db, p->pLeft);
  513.   pNew->pRight = sqlite3ExprDup(db, p->pRight);
  514.   pNew->pList = sqlite3ExprListDup(db, p->pList);
  515.   pNew->pSelect = sqlite3SelectDup(db, p->pSelect);
  516.   return pNew;
  517. }
  518. void sqlite3TokenCopy(sqlite3 *db, Token *pTo, Token *pFrom){
  519.   if( pTo->dyn ) sqlite3_free((char*)pTo->z);
  520.   if( pFrom->z ){
  521.     pTo->n = pFrom->n;
  522.     pTo->z = (u8*)sqlite3DbStrNDup(db, (char*)pFrom->z, pFrom->n);
  523.     pTo->dyn = 1;
  524.   }else{
  525.     pTo->z = 0;
  526.   }
  527. }
  528. ExprList *sqlite3ExprListDup(sqlite3 *db, ExprList *p){
  529.   ExprList *pNew;
  530.   struct ExprList_item *pItem, *pOldItem;
  531.   int i;
  532.   if( p==0 ) return 0;
  533.   pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
  534.   if( pNew==0 ) return 0;
  535.   pNew->iECursor = 0;
  536.   pNew->nExpr = pNew->nAlloc = p->nExpr;
  537.   pNew->a = pItem = sqlite3DbMallocRaw(db,  p->nExpr*sizeof(p->a[0]) );
  538.   if( pItem==0 ){
  539.     sqlite3_free(pNew);
  540.     return 0;
  541.   } 
  542.   pOldItem = p->a;
  543.   for(i=0; i<p->nExpr; i++, pItem++, pOldItem++){
  544.     Expr *pNewExpr, *pOldExpr;
  545.     pItem->pExpr = pNewExpr = sqlite3ExprDup(db, pOldExpr = pOldItem->pExpr);
  546.     if( pOldExpr->span.z!=0 && pNewExpr ){
  547.       /* Always make a copy of the span for top-level expressions in the
  548.       ** expression list.  The logic in SELECT processing that determines
  549.       ** the names of columns in the result set needs this information */
  550.       sqlite3TokenCopy(db, &pNewExpr->span, &pOldExpr->span);
  551.     }
  552.     assert( pNewExpr==0 || pNewExpr->span.z!=0 
  553.             || pOldExpr->span.z==0
  554.             || db->mallocFailed );
  555.     pItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
  556.     pItem->sortOrder = pOldItem->sortOrder;
  557.     pItem->isAgg = pOldItem->isAgg;
  558.     pItem->done = 0;
  559.   }
  560.   return pNew;
  561. }
  562. /*
  563. ** If cursors, triggers, views and subqueries are all omitted from
  564. ** the build, then none of the following routines, except for 
  565. ** sqlite3SelectDup(), can be called. sqlite3SelectDup() is sometimes
  566. ** called with a NULL argument.
  567. */
  568. #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) 
  569.  || !defined(SQLITE_OMIT_SUBQUERY)
  570. SrcList *sqlite3SrcListDup(sqlite3 *db, SrcList *p){
  571.   SrcList *pNew;
  572.   int i;
  573.   int nByte;
  574.   if( p==0 ) return 0;
  575.   nByte = sizeof(*p) + (p->nSrc>0 ? sizeof(p->a[0]) * (p->nSrc-1) : 0);
  576.   pNew = sqlite3DbMallocRaw(db, nByte );
  577.   if( pNew==0 ) return 0;
  578.   pNew->nSrc = pNew->nAlloc = p->nSrc;
  579.   for(i=0; i<p->nSrc; i++){
  580.     struct SrcList_item *pNewItem = &pNew->a[i];
  581.     struct SrcList_item *pOldItem = &p->a[i];
  582.     Table *pTab;
  583.     pNewItem->zDatabase = sqlite3DbStrDup(db, pOldItem->zDatabase);
  584.     pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
  585.     pNewItem->zAlias = sqlite3DbStrDup(db, pOldItem->zAlias);
  586.     pNewItem->jointype = pOldItem->jointype;
  587.     pNewItem->iCursor = pOldItem->iCursor;
  588.     pNewItem->isPopulated = pOldItem->isPopulated;
  589.     pTab = pNewItem->pTab = pOldItem->pTab;
  590.     if( pTab ){
  591.       pTab->nRef++;
  592.     }
  593.     pNewItem->pSelect = sqlite3SelectDup(db, pOldItem->pSelect);
  594.     pNewItem->pOn = sqlite3ExprDup(db, pOldItem->pOn);
  595.     pNewItem->pUsing = sqlite3IdListDup(db, pOldItem->pUsing);
  596.     pNewItem->colUsed = pOldItem->colUsed;
  597.   }
  598.   return pNew;
  599. }
  600. IdList *sqlite3IdListDup(sqlite3 *db, IdList *p){
  601.   IdList *pNew;
  602.   int i;
  603.   if( p==0 ) return 0;
  604.   pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
  605.   if( pNew==0 ) return 0;
  606.   pNew->nId = pNew->nAlloc = p->nId;
  607.   pNew->a = sqlite3DbMallocRaw(db, p->nId*sizeof(p->a[0]) );
  608.   if( pNew->a==0 ){
  609.     sqlite3_free(pNew);
  610.     return 0;
  611.   }
  612.   for(i=0; i<p->nId; i++){
  613.     struct IdList_item *pNewItem = &pNew->a[i];
  614.     struct IdList_item *pOldItem = &p->a[i];
  615.     pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
  616.     pNewItem->idx = pOldItem->idx;
  617.   }
  618.   return pNew;
  619. }
  620. Select *sqlite3SelectDup(sqlite3 *db, Select *p){
  621.   Select *pNew;
  622.   if( p==0 ) return 0;
  623.   pNew = sqlite3DbMallocRaw(db, sizeof(*p) );
  624.   if( pNew==0 ) return 0;
  625.   pNew->isDistinct = p->isDistinct;
  626.   pNew->pEList = sqlite3ExprListDup(db, p->pEList);
  627.   pNew->pSrc = sqlite3SrcListDup(db, p->pSrc);
  628.   pNew->pWhere = sqlite3ExprDup(db, p->pWhere);
  629.   pNew->pGroupBy = sqlite3ExprListDup(db, p->pGroupBy);
  630.   pNew->pHaving = sqlite3ExprDup(db, p->pHaving);
  631.   pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy);
  632.   pNew->op = p->op;
  633.   pNew->pPrior = sqlite3SelectDup(db, p->pPrior);
  634.   pNew->pLimit = sqlite3ExprDup(db, p->pLimit);
  635.   pNew->pOffset = sqlite3ExprDup(db, p->pOffset);
  636.   pNew->iLimit = -1;
  637.   pNew->iOffset = -1;
  638.   pNew->isResolved = p->isResolved;
  639.   pNew->isAgg = p->isAgg;
  640.   pNew->usesEphm = 0;
  641.   pNew->disallowOrderBy = 0;
  642.   pNew->pRightmost = 0;
  643.   pNew->addrOpenEphm[0] = -1;
  644.   pNew->addrOpenEphm[1] = -1;
  645.   pNew->addrOpenEphm[2] = -1;
  646.   return pNew;
  647. }
  648. #else
  649. Select *sqlite3SelectDup(sqlite3 *db, Select *p){
  650.   assert( p==0 );
  651.   return 0;
  652. }
  653. #endif
  654. /*
  655. ** Add a new element to the end of an expression list.  If pList is
  656. ** initially NULL, then create a new expression list.
  657. */
  658. ExprList *sqlite3ExprListAppend(
  659.   Parse *pParse,          /* Parsing context */
  660.   ExprList *pList,        /* List to which to append. Might be NULL */
  661.   Expr *pExpr,            /* Expression to be appended */
  662.   Token *pName            /* AS keyword for the expression */
  663. ){
  664.   sqlite3 *db = pParse->db;
  665.   if( pList==0 ){
  666.     pList = sqlite3DbMallocZero(db, sizeof(ExprList) );
  667.     if( pList==0 ){
  668.       goto no_mem;
  669.     }
  670.     assert( pList->nAlloc==0 );
  671.   }
  672.   if( pList->nAlloc<=pList->nExpr ){
  673.     struct ExprList_item *a;
  674.     int n = pList->nAlloc*2 + 4;
  675.     a = sqlite3DbRealloc(db, pList->a, n*sizeof(pList->a[0]));
  676.     if( a==0 ){
  677.       goto no_mem;
  678.     }
  679.     pList->a = a;
  680.     pList->nAlloc = n;
  681.   }
  682.   assert( pList->a!=0 );
  683.   if( pExpr || pName ){
  684.     struct ExprList_item *pItem = &pList->a[pList->nExpr++];
  685.     memset(pItem, 0, sizeof(*pItem));
  686.     pItem->zName = sqlite3NameFromToken(db, pName);
  687.     pItem->pExpr = pExpr;
  688.   }
  689.   return pList;
  690. no_mem:     
  691.   /* Avoid leaking memory if malloc has failed. */
  692.   sqlite3ExprDelete(pExpr);
  693.   sqlite3ExprListDelete(pList);
  694.   return 0;
  695. }
  696. /*
  697. ** If the expression list pEList contains more than iLimit elements,
  698. ** leave an error message in pParse.
  699. */
  700. void sqlite3ExprListCheckLength(
  701.   Parse *pParse,
  702.   ExprList *pEList,
  703.   const char *zObject
  704. ){
  705.   int mx = pParse->db->aLimit[SQLITE_LIMIT_COLUMN];
  706.   testcase( pEList && pEList->nExpr==mx );
  707.   testcase( pEList && pEList->nExpr==mx+1 );
  708.   if( pEList && pEList->nExpr>mx ){
  709.     sqlite3ErrorMsg(pParse, "too many columns in %s", zObject);
  710.   }
  711. }
  712. /* The following three functions, heightOfExpr(), heightOfExprList()
  713. ** and heightOfSelect(), are used to determine the maximum height
  714. ** of any expression tree referenced by the structure passed as the
  715. ** first argument.
  716. **
  717. ** If this maximum height is greater than the current value pointed
  718. ** to by pnHeight, the second parameter, then set *pnHeight to that
  719. ** value.
  720. */
  721. static void heightOfExpr(Expr *p, int *pnHeight){
  722.   if( p ){
  723.     if( p->nHeight>*pnHeight ){
  724.       *pnHeight = p->nHeight;
  725.     }
  726.   }
  727. }
  728. static void heightOfExprList(ExprList *p, int *pnHeight){
  729.   if( p ){
  730.     int i;
  731.     for(i=0; i<p->nExpr; i++){
  732.       heightOfExpr(p->a[i].pExpr, pnHeight);
  733.     }
  734.   }
  735. }
  736. static void heightOfSelect(Select *p, int *pnHeight){
  737.   if( p ){
  738.     heightOfExpr(p->pWhere, pnHeight);
  739.     heightOfExpr(p->pHaving, pnHeight);
  740.     heightOfExpr(p->pLimit, pnHeight);
  741.     heightOfExpr(p->pOffset, pnHeight);
  742.     heightOfExprList(p->pEList, pnHeight);
  743.     heightOfExprList(p->pGroupBy, pnHeight);
  744.     heightOfExprList(p->pOrderBy, pnHeight);
  745.     heightOfSelect(p->pPrior, pnHeight);
  746.   }
  747. }
  748. /*
  749. ** Set the Expr.nHeight variable in the structure passed as an 
  750. ** argument. An expression with no children, Expr.pList or 
  751. ** Expr.pSelect member has a height of 1. Any other expression
  752. ** has a height equal to the maximum height of any other 
  753. ** referenced Expr plus one.
  754. */
  755. void sqlite3ExprSetHeight(Expr *p){
  756.   int nHeight = 0;
  757.   heightOfExpr(p->pLeft, &nHeight);
  758.   heightOfExpr(p->pRight, &nHeight);
  759.   heightOfExprList(p->pList, &nHeight);
  760.   heightOfSelect(p->pSelect, &nHeight);
  761.   p->nHeight = nHeight + 1;
  762. }
  763. /*
  764. ** Return the maximum height of any expression tree referenced
  765. ** by the select statement passed as an argument.
  766. */
  767. int sqlite3SelectExprHeight(Select *p){
  768.   int nHeight = 0;
  769.   heightOfSelect(p, &nHeight);
  770.   return nHeight;
  771. }
  772. /*
  773. ** Delete an entire expression list.
  774. */
  775. void sqlite3ExprListDelete(ExprList *pList){
  776.   int i;
  777.   struct ExprList_item *pItem;
  778.   if( pList==0 ) return;
  779.   assert( pList->a!=0 || (pList->nExpr==0 && pList->nAlloc==0) );
  780.   assert( pList->nExpr<=pList->nAlloc );
  781.   for(pItem=pList->a, i=0; i<pList->nExpr; i++, pItem++){
  782.     sqlite3ExprDelete(pItem->pExpr);
  783.     sqlite3_free(pItem->zName);
  784.   }
  785.   sqlite3_free(pList->a);
  786.   sqlite3_free(pList);
  787. }
  788. /*
  789. ** Walk an expression tree.  Call xFunc for each node visited.  xFunc
  790. ** is called on the node before xFunc is called on the nodes children.
  791. **
  792. ** The return value from xFunc determines whether the tree walk continues.
  793. ** 0 means continue walking the tree.  1 means do not walk children
  794. ** of the current node but continue with siblings.  2 means abandon
  795. ** the tree walk completely.
  796. **
  797. ** The return value from this routine is 1 to abandon the tree walk
  798. ** and 0 to continue.
  799. **
  800. ** NOTICE:  This routine does *not* descend into subqueries.
  801. */
  802. static int walkExprList(ExprList *, int (*)(void *, Expr*), void *);
  803. static int walkExprTree(Expr *pExpr, int (*xFunc)(void*,Expr*), void *pArg){
  804.   int rc;
  805.   if( pExpr==0 ) return 0;
  806.   rc = (*xFunc)(pArg, pExpr);
  807.   if( rc==0 ){
  808.     if( walkExprTree(pExpr->pLeft, xFunc, pArg) ) return 1;
  809.     if( walkExprTree(pExpr->pRight, xFunc, pArg) ) return 1;
  810.     if( walkExprList(pExpr->pList, xFunc, pArg) ) return 1;
  811.   }
  812.   return rc>1;
  813. }
  814. /*
  815. ** Call walkExprTree() for every expression in list p.
  816. */
  817. static int walkExprList(ExprList *p, int (*xFunc)(void *, Expr*), void *pArg){
  818.   int i;
  819.   struct ExprList_item *pItem;
  820.   if( !p ) return 0;
  821.   for(i=p->nExpr, pItem=p->a; i>0; i--, pItem++){
  822.     if( walkExprTree(pItem->pExpr, xFunc, pArg) ) return 1;
  823.   }
  824.   return 0;
  825. }
  826. /*
  827. ** Call walkExprTree() for every expression in Select p, not including
  828. ** expressions that are part of sub-selects in any FROM clause or the LIMIT
  829. ** or OFFSET expressions..
  830. */
  831. static int walkSelectExpr(Select *p, int (*xFunc)(void *, Expr*), void *pArg){
  832.   walkExprList(p->pEList, xFunc, pArg);
  833.   walkExprTree(p->pWhere, xFunc, pArg);
  834.   walkExprList(p->pGroupBy, xFunc, pArg);
  835.   walkExprTree(p->pHaving, xFunc, pArg);
  836.   walkExprList(p->pOrderBy, xFunc, pArg);
  837.   if( p->pPrior ){
  838.     walkSelectExpr(p->pPrior, xFunc, pArg);
  839.   }
  840.   return 0;
  841. }
  842. /*
  843. ** This routine is designed as an xFunc for walkExprTree().
  844. **
  845. ** pArg is really a pointer to an integer.  If we can tell by looking
  846. ** at pExpr that the expression that contains pExpr is not a constant
  847. ** expression, then set *pArg to 0 and return 2 to abandon the tree walk.
  848. ** If pExpr does does not disqualify the expression from being a constant
  849. ** then do nothing.
  850. **
  851. ** After walking the whole tree, if no nodes are found that disqualify
  852. ** the expression as constant, then we assume the whole expression
  853. ** is constant.  See sqlite3ExprIsConstant() for additional information.
  854. */
  855. static int exprNodeIsConstant(void *pArg, Expr *pExpr){
  856.   int *pN = (int*)pArg;
  857.   /* If *pArg is 3 then any term of the expression that comes from
  858.   ** the ON or USING clauses of a join disqualifies the expression
  859.   ** from being considered constant. */
  860.   if( (*pN)==3 && ExprHasAnyProperty(pExpr, EP_FromJoin) ){
  861.     *pN = 0;
  862.     return 2;
  863.   }
  864.   switch( pExpr->op ){
  865.     /* Consider functions to be constant if all their arguments are constant
  866.     ** and *pArg==2 */
  867.     case TK_FUNCTION:
  868.       if( (*pN)==2 ) return 0;
  869.       /* Fall through */
  870.     case TK_ID:
  871.     case TK_COLUMN:
  872.     case TK_DOT:
  873.     case TK_AGG_FUNCTION:
  874.     case TK_AGG_COLUMN:
  875. #ifndef SQLITE_OMIT_SUBQUERY
  876.     case TK_SELECT:
  877.     case TK_EXISTS:
  878.       testcase( pExpr->op==TK_SELECT );
  879.       testcase( pExpr->op==TK_EXISTS );
  880. #endif
  881.       testcase( pExpr->op==TK_ID );
  882.       testcase( pExpr->op==TK_COLUMN );
  883.       testcase( pExpr->op==TK_DOT );
  884.       testcase( pExpr->op==TK_AGG_FUNCTION );
  885.       testcase( pExpr->op==TK_AGG_COLUMN );
  886.       *pN = 0;
  887.       return 2;
  888.     case TK_IN:
  889.       if( pExpr->pSelect ){
  890.         *pN = 0;
  891.         return 2;
  892.       }
  893.     default:
  894.       return 0;
  895.   }
  896. }
  897. /*
  898. ** Walk an expression tree.  Return 1 if the expression is constant
  899. ** and 0 if it involves variables or function calls.
  900. **
  901. ** For the purposes of this function, a double-quoted string (ex: "abc")
  902. ** is considered a variable but a single-quoted string (ex: 'abc') is
  903. ** a constant.
  904. */
  905. int sqlite3ExprIsConstant(Expr *p){
  906.   int isConst = 1;
  907.   walkExprTree(p, exprNodeIsConstant, &isConst);
  908.   return isConst;
  909. }
  910. /*
  911. ** Walk an expression tree.  Return 1 if the expression is constant
  912. ** that does no originate from the ON or USING clauses of a join.
  913. ** Return 0 if it involves variables or function calls or terms from
  914. ** an ON or USING clause.
  915. */
  916. int sqlite3ExprIsConstantNotJoin(Expr *p){
  917.   int isConst = 3;
  918.   walkExprTree(p, exprNodeIsConstant, &isConst);
  919.   return isConst!=0;
  920. }
  921. /*
  922. ** Walk an expression tree.  Return 1 if the expression is constant
  923. ** or a function call with constant arguments.  Return and 0 if there
  924. ** are any variables.
  925. **
  926. ** For the purposes of this function, a double-quoted string (ex: "abc")
  927. ** is considered a variable but a single-quoted string (ex: 'abc') is
  928. ** a constant.
  929. */
  930. int sqlite3ExprIsConstantOrFunction(Expr *p){
  931.   int isConst = 2;
  932.   walkExprTree(p, exprNodeIsConstant, &isConst);
  933.   return isConst!=0;
  934. }
  935. /*
  936. ** If the expression p codes a constant integer that is small enough
  937. ** to fit in a 32-bit integer, return 1 and put the value of the integer
  938. ** in *pValue.  If the expression is not an integer or if it is too big
  939. ** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
  940. */
  941. int sqlite3ExprIsInteger(Expr *p, int *pValue){
  942.   switch( p->op ){
  943.     case TK_INTEGER: {
  944.       if( sqlite3GetInt32((char*)p->token.z, pValue) ){
  945.         return 1;
  946.       }
  947.       break;
  948.     }
  949.     case TK_UPLUS: {
  950.       return sqlite3ExprIsInteger(p->pLeft, pValue);
  951.     }
  952.     case TK_UMINUS: {
  953.       int v;
  954.       if( sqlite3ExprIsInteger(p->pLeft, &v) ){
  955.         *pValue = -v;
  956.         return 1;
  957.       }
  958.       break;
  959.     }
  960.     default: break;
  961.   }
  962.   return 0;
  963. }
  964. /*
  965. ** Return TRUE if the given string is a row-id column name.
  966. */
  967. int sqlite3IsRowid(const char *z){
  968.   if( sqlite3StrICmp(z, "_ROWID_")==0 ) return 1;
  969.   if( sqlite3StrICmp(z, "ROWID")==0 ) return 1;
  970.   if( sqlite3StrICmp(z, "OID")==0 ) return 1;
  971.   return 0;
  972. }
  973. /*
  974. ** Given the name of a column of the form X.Y.Z or Y.Z or just Z, look up
  975. ** that name in the set of source tables in pSrcList and make the pExpr 
  976. ** expression node refer back to that source column.  The following changes
  977. ** are made to pExpr:
  978. **
  979. **    pExpr->iDb           Set the index in db->aDb[] of the database holding
  980. **                         the table.
  981. **    pExpr->iTable        Set to the cursor number for the table obtained
  982. **                         from pSrcList.
  983. **    pExpr->iColumn       Set to the column number within the table.
  984. **    pExpr->op            Set to TK_COLUMN.
  985. **    pExpr->pLeft         Any expression this points to is deleted
  986. **    pExpr->pRight        Any expression this points to is deleted.
  987. **
  988. ** The pDbToken is the name of the database (the "X").  This value may be
  989. ** NULL meaning that name is of the form Y.Z or Z.  Any available database
  990. ** can be used.  The pTableToken is the name of the table (the "Y").  This
  991. ** value can be NULL if pDbToken is also NULL.  If pTableToken is NULL it
  992. ** means that the form of the name is Z and that columns from any table
  993. ** can be used.
  994. **
  995. ** If the name cannot be resolved unambiguously, leave an error message
  996. ** in pParse and return non-zero.  Return zero on success.
  997. */
  998. static int lookupName(
  999.   Parse *pParse,       /* The parsing context */
  1000.   Token *pDbToken,     /* Name of the database containing table, or NULL */
  1001.   Token *pTableToken,  /* Name of table containing column, or NULL */
  1002.   Token *pColumnToken, /* Name of the column. */
  1003.   NameContext *pNC,    /* The name context used to resolve the name */
  1004.   Expr *pExpr          /* Make this EXPR node point to the selected column */
  1005. ){
  1006.   char *zDb = 0;       /* Name of the database.  The "X" in X.Y.Z */
  1007.   char *zTab = 0;      /* Name of the table.  The "Y" in X.Y.Z or Y.Z */
  1008.   char *zCol = 0;      /* Name of the column.  The "Z" */
  1009.   int i, j;            /* Loop counters */
  1010.   int cnt = 0;         /* Number of matching column names */
  1011.   int cntTab = 0;      /* Number of matching table names */
  1012.   sqlite3 *db = pParse->db;  /* The database */
  1013.   struct SrcList_item *pItem;       /* Use for looping over pSrcList items */
  1014.   struct SrcList_item *pMatch = 0;  /* The matching pSrcList item */
  1015.   NameContext *pTopNC = pNC;        /* First namecontext in the list */
  1016.   Schema *pSchema = 0;              /* Schema of the expression */
  1017.   assert( pColumnToken && pColumnToken->z ); /* The Z in X.Y.Z cannot be NULL */
  1018.   zDb = sqlite3NameFromToken(db, pDbToken);
  1019.   zTab = sqlite3NameFromToken(db, pTableToken);
  1020.   zCol = sqlite3NameFromToken(db, pColumnToken);
  1021.   if( db->mallocFailed ){
  1022.     goto lookupname_end;
  1023.   }
  1024.   pExpr->iTable = -1;
  1025.   while( pNC && cnt==0 ){
  1026.     ExprList *pEList;
  1027.     SrcList *pSrcList = pNC->pSrcList;
  1028.     if( pSrcList ){
  1029.       for(i=0, pItem=pSrcList->a; i<pSrcList->nSrc; i++, pItem++){
  1030.         Table *pTab;
  1031.         int iDb;
  1032.         Column *pCol;
  1033.   
  1034.         pTab = pItem->pTab;
  1035.         assert( pTab!=0 );
  1036.         iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
  1037.         assert( pTab->nCol>0 );
  1038.         if( zTab ){
  1039.           if( pItem->zAlias ){
  1040.             char *zTabName = pItem->zAlias;
  1041.             if( sqlite3StrICmp(zTabName, zTab)!=0 ) continue;
  1042.           }else{
  1043.             char *zTabName = pTab->zName;
  1044.             if( zTabName==0 || sqlite3StrICmp(zTabName, zTab)!=0 ) continue;
  1045.             if( zDb!=0 && sqlite3StrICmp(db->aDb[iDb].zName, zDb)!=0 ){
  1046.               continue;
  1047.             }
  1048.           }
  1049.         }
  1050.         if( 0==(cntTab++) ){
  1051.           pExpr->iTable = pItem->iCursor;
  1052.           pSchema = pTab->pSchema;
  1053.           pMatch = pItem;
  1054.         }
  1055.         for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
  1056.           if( sqlite3StrICmp(pCol->zName, zCol)==0 ){
  1057.             const char *zColl = pTab->aCol[j].zColl;
  1058.             IdList *pUsing;
  1059.             cnt++;
  1060.             pExpr->iTable = pItem->iCursor;
  1061.             pMatch = pItem;
  1062.             pSchema = pTab->pSchema;
  1063.             /* Substitute the rowid (column -1) for the INTEGER PRIMARY KEY */
  1064.             pExpr->iColumn = j==pTab->iPKey ? -1 : j;
  1065.             pExpr->affinity = pTab->aCol[j].affinity;
  1066.             if( (pExpr->flags & EP_ExpCollate)==0 ){
  1067.               pExpr->pColl = sqlite3FindCollSeq(db, ENC(db), zColl,-1, 0);
  1068.             }
  1069.             if( i<pSrcList->nSrc-1 ){
  1070.               if( pItem[1].jointype & JT_NATURAL ){
  1071.                 /* If this match occurred in the left table of a natural join,
  1072.                 ** then skip the right table to avoid a duplicate match */
  1073.                 pItem++;
  1074.                 i++;
  1075.               }else if( (pUsing = pItem[1].pUsing)!=0 ){
  1076.                 /* If this match occurs on a column that is in the USING clause
  1077.                 ** of a join, skip the search of the right table of the join
  1078.                 ** to avoid a duplicate match there. */
  1079.                 int k;
  1080.                 for(k=0; k<pUsing->nId; k++){
  1081.                   if( sqlite3StrICmp(pUsing->a[k].zName, zCol)==0 ){
  1082.                     pItem++;
  1083.                     i++;
  1084.                     break;
  1085.                   }
  1086.                 }
  1087.               }
  1088.             }
  1089.             break;
  1090.           }
  1091.         }
  1092.       }
  1093.     }
  1094. #ifndef SQLITE_OMIT_TRIGGER
  1095.     /* If we have not already resolved the name, then maybe 
  1096.     ** it is a new.* or old.* trigger argument reference
  1097.     */
  1098.     if( zDb==0 && zTab!=0 && cnt==0 && pParse->trigStack!=0 ){
  1099.       TriggerStack *pTriggerStack = pParse->trigStack;
  1100.       Table *pTab = 0;
  1101.       u32 *piColMask;
  1102.       if( pTriggerStack->newIdx != -1 && sqlite3StrICmp("new", zTab) == 0 ){
  1103.         pExpr->iTable = pTriggerStack->newIdx;
  1104.         assert( pTriggerStack->pTab );
  1105.         pTab = pTriggerStack->pTab;
  1106.         piColMask = &(pTriggerStack->newColMask);
  1107.       }else if( pTriggerStack->oldIdx != -1 && sqlite3StrICmp("old", zTab)==0 ){
  1108.         pExpr->iTable = pTriggerStack->oldIdx;
  1109.         assert( pTriggerStack->pTab );
  1110.         pTab = pTriggerStack->pTab;
  1111.         piColMask = &(pTriggerStack->oldColMask);
  1112.       }
  1113.       if( pTab ){ 
  1114.         int iCol;
  1115.         Column *pCol = pTab->aCol;
  1116.         pSchema = pTab->pSchema;
  1117.         cntTab++;
  1118.         for(iCol=0; iCol < pTab->nCol; iCol++, pCol++) {
  1119.           if( sqlite3StrICmp(pCol->zName, zCol)==0 ){
  1120.             const char *zColl = pTab->aCol[iCol].zColl;
  1121.             cnt++;
  1122.             pExpr->iColumn = iCol==pTab->iPKey ? -1 : iCol;
  1123.             pExpr->affinity = pTab->aCol[iCol].affinity;
  1124.             if( (pExpr->flags & EP_ExpCollate)==0 ){
  1125.               pExpr->pColl = sqlite3FindCollSeq(db, ENC(db), zColl,-1, 0);
  1126.             }
  1127.             pExpr->pTab = pTab;
  1128.             if( iCol>=0 ){
  1129.               testcase( iCol==31 );
  1130.               testcase( iCol==32 );
  1131.               *piColMask |= ((u32)1<<iCol) | (iCol>=32?0xffffffff:0);
  1132.             }
  1133.             break;
  1134.           }
  1135.         }
  1136.       }
  1137.     }
  1138. #endif /* !defined(SQLITE_OMIT_TRIGGER) */
  1139.     /*
  1140.     ** Perhaps the name is a reference to the ROWID
  1141.     */
  1142.     if( cnt==0 && cntTab==1 && sqlite3IsRowid(zCol) ){
  1143.       cnt = 1;
  1144.       pExpr->iColumn = -1;
  1145.       pExpr->affinity = SQLITE_AFF_INTEGER;
  1146.     }
  1147.     /*
  1148.     ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z
  1149.     ** might refer to an result-set alias.  This happens, for example, when
  1150.     ** we are resolving names in the WHERE clause of the following command:
  1151.     **
  1152.     **     SELECT a+b AS x FROM table WHERE x<10;
  1153.     **
  1154.     ** In cases like this, replace pExpr with a copy of the expression that
  1155.     ** forms the result set entry ("a+b" in the example) and return immediately.
  1156.     ** Note that the expression in the result set should have already been
  1157.     ** resolved by the time the WHERE clause is resolved.
  1158.     */
  1159.     if( cnt==0 && (pEList = pNC->pEList)!=0 && zTab==0 ){
  1160.       for(j=0; j<pEList->nExpr; j++){
  1161.         char *zAs = pEList->a[j].zName;
  1162.         if( zAs!=0 && sqlite3StrICmp(zAs, zCol)==0 ){
  1163.           Expr *pDup, *pOrig;
  1164.           assert( pExpr->pLeft==0 && pExpr->pRight==0 );
  1165.           assert( pExpr->pList==0 );
  1166.           assert( pExpr->pSelect==0 );
  1167.           pOrig = pEList->a[j].pExpr;
  1168.           if( !pNC->allowAgg && ExprHasProperty(pOrig, EP_Agg) ){
  1169.             sqlite3ErrorMsg(pParse, "misuse of aliased aggregate %s", zAs);
  1170.             sqlite3_free(zCol);
  1171.             return 2;
  1172.           }
  1173.           pDup = sqlite3ExprDup(db, pOrig);
  1174.           if( pExpr->flags & EP_ExpCollate ){
  1175.             pDup->pColl = pExpr->pColl;
  1176.             pDup->flags |= EP_ExpCollate;
  1177.           }
  1178.           if( pExpr->span.dyn ) sqlite3_free((char*)pExpr->span.z);
  1179.           if( pExpr->token.dyn ) sqlite3_free((char*)pExpr->token.z);
  1180.           memcpy(pExpr, pDup, sizeof(*pExpr));
  1181.           sqlite3_free(pDup);
  1182.           cnt = 1;
  1183.           pMatch = 0;
  1184.           assert( zTab==0 && zDb==0 );
  1185.           goto lookupname_end_2;
  1186.         }
  1187.       } 
  1188.     }
  1189.     /* Advance to the next name context.  The loop will exit when either
  1190.     ** we have a match (cnt>0) or when we run out of name contexts.
  1191.     */
  1192.     if( cnt==0 ){
  1193.       pNC = pNC->pNext;
  1194.     }
  1195.   }
  1196.   /*
  1197.   ** If X and Y are NULL (in other words if only the column name Z is
  1198.   ** supplied) and the value of Z is enclosed in double-quotes, then
  1199.   ** Z is a string literal if it doesn't match any column names.  In that
  1200.   ** case, we need to return right away and not make any changes to
  1201.   ** pExpr.
  1202.   **
  1203.   ** Because no reference was made to outer contexts, the pNC->nRef
  1204.   ** fields are not changed in any context.
  1205.   */
  1206.   if( cnt==0 && zTab==0 && pColumnToken->z[0]=='"' ){
  1207.     sqlite3_free(zCol);
  1208.     return 0;
  1209.   }
  1210.   /*
  1211.   ** cnt==0 means there was not match.  cnt>1 means there were two or
  1212.   ** more matches.  Either way, we have an error.
  1213.   */
  1214.   if( cnt!=1 ){
  1215.     const char *zErr;
  1216.     zErr = cnt==0 ? "no such column" : "ambiguous column name";
  1217.     if( zDb ){
  1218.       sqlite3ErrorMsg(pParse, "%s: %s.%s.%s", zErr, zDb, zTab, zCol);
  1219.     }else if( zTab ){
  1220.       sqlite3ErrorMsg(pParse, "%s: %s.%s", zErr, zTab, zCol);
  1221.     }else{
  1222.       sqlite3ErrorMsg(pParse, "%s: %s", zErr, zCol);
  1223.     }
  1224.     pTopNC->nErr++;
  1225.   }
  1226.   /* If a column from a table in pSrcList is referenced, then record
  1227.   ** this fact in the pSrcList.a[].colUsed bitmask.  Column 0 causes
  1228.   ** bit 0 to be set.  Column 1 sets bit 1.  And so forth.  If the
  1229.   ** column number is greater than the number of bits in the bitmask
  1230.   ** then set the high-order bit of the bitmask.
  1231.   */
  1232.   if( pExpr->iColumn>=0 && pMatch!=0 ){
  1233.     int n = pExpr->iColumn;
  1234.     testcase( n==sizeof(Bitmask)*8-1 );
  1235.     if( n>=sizeof(Bitmask)*8 ){
  1236.       n = sizeof(Bitmask)*8-1;
  1237.     }
  1238.     assert( pMatch->iCursor==pExpr->iTable );
  1239.     pMatch->colUsed |= ((Bitmask)1)<<n;
  1240.   }
  1241. lookupname_end:
  1242.   /* Clean up and return
  1243.   */
  1244.   sqlite3_free(zDb);
  1245.   sqlite3_free(zTab);
  1246.   sqlite3ExprDelete(pExpr->pLeft);
  1247.   pExpr->pLeft = 0;
  1248.   sqlite3ExprDelete(pExpr->pRight);
  1249.   pExpr->pRight = 0;
  1250.   pExpr->op = TK_COLUMN;
  1251. lookupname_end_2:
  1252.   sqlite3_free(zCol);
  1253.   if( cnt==1 ){
  1254.     assert( pNC!=0 );
  1255.     sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList);
  1256.     if( pMatch && !pMatch->pSelect ){
  1257.       pExpr->pTab = pMatch->pTab;
  1258.     }
  1259.     /* Increment the nRef value on all name contexts from TopNC up to
  1260.     ** the point where the name matched. */
  1261.     for(;;){
  1262.       assert( pTopNC!=0 );
  1263.       pTopNC->nRef++;
  1264.       if( pTopNC==pNC ) break;
  1265.       pTopNC = pTopNC->pNext;
  1266.     }
  1267.     return 0;
  1268.   } else {
  1269.     return 1;
  1270.   }
  1271. }
  1272. /*
  1273. ** This routine is designed as an xFunc for walkExprTree().
  1274. **
  1275. ** Resolve symbolic names into TK_COLUMN operators for the current
  1276. ** node in the expression tree.  Return 0 to continue the search down
  1277. ** the tree or 2 to abort the tree walk.
  1278. **
  1279. ** This routine also does error checking and name resolution for
  1280. ** function names.  The operator for aggregate functions is changed
  1281. ** to TK_AGG_FUNCTION.
  1282. */
  1283. static int nameResolverStep(void *pArg, Expr *pExpr){
  1284.   NameContext *pNC = (NameContext*)pArg;
  1285.   Parse *pParse;
  1286.   if( pExpr==0 ) return 1;
  1287.   assert( pNC!=0 );
  1288.   pParse = pNC->pParse;
  1289.   if( ExprHasAnyProperty(pExpr, EP_Resolved) ) return 1;
  1290.   ExprSetProperty(pExpr, EP_Resolved);
  1291. #ifndef NDEBUG
  1292.   if( pNC->pSrcList && pNC->pSrcList->nAlloc>0 ){
  1293.     SrcList *pSrcList = pNC->pSrcList;
  1294.     int i;
  1295.     for(i=0; i<pNC->pSrcList->nSrc; i++){
  1296.       assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursor<pParse->nTab);
  1297.     }
  1298.   }
  1299. #endif
  1300.   switch( pExpr->op ){
  1301.     /* Double-quoted strings (ex: "abc") are used as identifiers if
  1302.     ** possible.  Otherwise they remain as strings.  Single-quoted
  1303.     ** strings (ex: 'abc') are always string literals.
  1304.     */
  1305.     case TK_STRING: {
  1306.       if( pExpr->token.z[0]==''' ) break;
  1307.       /* Fall thru into the TK_ID case if this is a double-quoted string */
  1308.     }
  1309.     /* A lone identifier is the name of a column.
  1310.     */
  1311.     case TK_ID: {
  1312.       lookupName(pParse, 0, 0, &pExpr->token, pNC, pExpr);
  1313.       return 1;
  1314.     }
  1315.   
  1316.     /* A table name and column name:     ID.ID
  1317.     ** Or a database, table and column:  ID.ID.ID
  1318.     */
  1319.     case TK_DOT: {
  1320.       Token *pColumn;
  1321.       Token *pTable;
  1322.       Token *pDb;
  1323.       Expr *pRight;
  1324.       /* if( pSrcList==0 ) break; */
  1325.       pRight = pExpr->pRight;
  1326.       if( pRight->op==TK_ID ){
  1327.         pDb = 0;
  1328.         pTable = &pExpr->pLeft->token;
  1329.         pColumn = &pRight->token;
  1330.       }else{
  1331.         assert( pRight->op==TK_DOT );
  1332.         pDb = &pExpr->pLeft->token;
  1333.         pTable = &pRight->pLeft->token;
  1334.         pColumn = &pRight->pRight->token;
  1335.       }
  1336.       lookupName(pParse, pDb, pTable, pColumn, pNC, pExpr);
  1337.       return 1;
  1338.     }
  1339.     /* Resolve function names
  1340.     */
  1341.     case TK_CONST_FUNC:
  1342.     case TK_FUNCTION: {
  1343.       ExprList *pList = pExpr->pList;    /* The argument list */
  1344.       int n = pList ? pList->nExpr : 0;  /* Number of arguments */
  1345.       int no_such_func = 0;       /* True if no such function exists */
  1346.       int wrong_num_args = 0;     /* True if wrong number of arguments */
  1347.       int is_agg = 0;             /* True if is an aggregate function */
  1348.       int i;
  1349.       int auth;                   /* Authorization to use the function */
  1350.       int nId;                    /* Number of characters in function name */
  1351.       const char *zId;            /* The function name. */
  1352.       FuncDef *pDef;              /* Information about the function */
  1353.       int enc = ENC(pParse->db);  /* The database encoding */
  1354.       zId = (char*)pExpr->token.z;
  1355.       nId = pExpr->token.n;
  1356.       pDef = sqlite3FindFunction(pParse->db, zId, nId, n, enc, 0);
  1357.       if( pDef==0 ){
  1358.         pDef = sqlite3FindFunction(pParse->db, zId, nId, -1, enc, 0);
  1359.         if( pDef==0 ){
  1360.           no_such_func = 1;
  1361.         }else{
  1362.           wrong_num_args = 1;
  1363.         }
  1364.       }else{
  1365.         is_agg = pDef->xFunc==0;
  1366.       }
  1367. #ifndef SQLITE_OMIT_AUTHORIZATION
  1368.       if( pDef ){
  1369.         auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0, pDef->zName, 0);
  1370.         if( auth!=SQLITE_OK ){
  1371.           if( auth==SQLITE_DENY ){
  1372.             sqlite3ErrorMsg(pParse, "not authorized to use function: %s",
  1373.                                     pDef->zName);
  1374.             pNC->nErr++;
  1375.           }
  1376.           pExpr->op = TK_NULL;
  1377.           return 1;
  1378.         }
  1379.       }
  1380. #endif
  1381.       if( is_agg && !pNC->allowAgg ){
  1382.         sqlite3ErrorMsg(pParse, "misuse of aggregate function %.*s()", nId,zId);
  1383.         pNC->nErr++;
  1384.         is_agg = 0;
  1385.       }else if( no_such_func ){
  1386.         sqlite3ErrorMsg(pParse, "no such function: %.*s", nId, zId);
  1387.         pNC->nErr++;
  1388.       }else if( wrong_num_args ){
  1389.         sqlite3ErrorMsg(pParse,"wrong number of arguments to function %.*s()",
  1390.              nId, zId);
  1391.         pNC->nErr++;
  1392.       }
  1393.       if( is_agg ){
  1394.         pExpr->op = TK_AGG_FUNCTION;
  1395.         pNC->hasAgg = 1;
  1396.       }
  1397.       if( is_agg ) pNC->allowAgg = 0;
  1398.       for(i=0; pNC->nErr==0 && i<n; i++){
  1399.         walkExprTree(pList->a[i].pExpr, nameResolverStep, pNC);
  1400.       }
  1401.       if( is_agg ) pNC->allowAgg = 1;
  1402.       /* FIX ME:  Compute pExpr->affinity based on the expected return
  1403.       ** type of the function 
  1404.       */
  1405.       return is_agg;
  1406.     }
  1407. #ifndef SQLITE_OMIT_SUBQUERY
  1408.     case TK_SELECT:
  1409.     case TK_EXISTS:
  1410. #endif
  1411.     case TK_IN: {
  1412.       if( pExpr->pSelect ){
  1413.         int nRef = pNC->nRef;
  1414. #ifndef SQLITE_OMIT_CHECK
  1415.         if( pNC->isCheck ){
  1416.           sqlite3ErrorMsg(pParse,"subqueries prohibited in CHECK constraints");
  1417.         }
  1418. #endif
  1419.         sqlite3SelectResolve(pParse, pExpr->pSelect, pNC);
  1420.         assert( pNC->nRef>=nRef );
  1421.         if( nRef!=pNC->nRef ){
  1422.           ExprSetProperty(pExpr, EP_VarSelect);
  1423.         }
  1424.       }
  1425.       break;
  1426.     }
  1427. #ifndef SQLITE_OMIT_CHECK
  1428.     case TK_VARIABLE: {
  1429.       if( pNC->isCheck ){
  1430.         sqlite3ErrorMsg(pParse,"parameters prohibited in CHECK constraints");
  1431.       }
  1432.       break;
  1433.     }
  1434. #endif
  1435.   }
  1436.   return 0;
  1437. }
  1438. /*
  1439. ** This routine walks an expression tree and resolves references to
  1440. ** table columns.  Nodes of the form ID.ID or ID resolve into an
  1441. ** index to the table in the table list and a column offset.  The 
  1442. ** Expr.opcode for such nodes is changed to TK_COLUMN.  The Expr.iTable
  1443. ** value is changed to the index of the referenced table in pTabList
  1444. ** plus the "base" value.  The base value will ultimately become the
  1445. ** VDBE cursor number for a cursor that is pointing into the referenced
  1446. ** table.  The Expr.iColumn value is changed to the index of the column 
  1447. ** of the referenced table.  The Expr.iColumn value for the special
  1448. ** ROWID column is -1.  Any INTEGER PRIMARY KEY column is tried as an
  1449. ** alias for ROWID.
  1450. **
  1451. ** Also resolve function names and check the functions for proper
  1452. ** usage.  Make sure all function names are recognized and all functions
  1453. ** have the correct number of arguments.  Leave an error message
  1454. ** in pParse->zErrMsg if anything is amiss.  Return the number of errors.
  1455. **
  1456. ** If the expression contains aggregate functions then set the EP_Agg
  1457. ** property on the expression.
  1458. */
  1459. int sqlite3ExprResolveNames( 
  1460.   NameContext *pNC,       /* Namespace to resolve expressions in. */
  1461.   Expr *pExpr             /* The expression to be analyzed. */
  1462. ){
  1463.   int savedHasAgg;
  1464.   if( pExpr==0 ) return 0;
  1465. #if SQLITE_MAX_EXPR_DEPTH>0
  1466.   {
  1467.     int mxDepth = pNC->pParse->db->aLimit[SQLITE_LIMIT_EXPR_DEPTH];
  1468.     if( (pExpr->nHeight+pNC->pParse->nHeight)>mxDepth ){
  1469.       sqlite3ErrorMsg(pNC->pParse, 
  1470.          "Expression tree is too large (maximum depth %d)", mxDepth
  1471.       );
  1472.       return 1;
  1473.     }
  1474.     pNC->pParse->nHeight += pExpr->nHeight;
  1475.   }
  1476. #endif
  1477.   savedHasAgg = pNC->hasAgg;
  1478.   pNC->hasAgg = 0;
  1479.   walkExprTree(pExpr, nameResolverStep, pNC);
  1480. #if SQLITE_MAX_EXPR_DEPTH>0
  1481.   pNC->pParse->nHeight -= pExpr->nHeight;
  1482. #endif
  1483.   if( pNC->nErr>0 ){
  1484.     ExprSetProperty(pExpr, EP_Error);
  1485.   }
  1486.   if( pNC->hasAgg ){
  1487.     ExprSetProperty(pExpr, EP_Agg);
  1488.   }else if( savedHasAgg ){
  1489.     pNC->hasAgg = 1;
  1490.   }
  1491.   return ExprHasProperty(pExpr, EP_Error);
  1492. }
  1493. /*
  1494. ** A pointer instance of this structure is used to pass information
  1495. ** through walkExprTree into codeSubqueryStep().
  1496. */
  1497. typedef struct QueryCoder QueryCoder;
  1498. struct QueryCoder {
  1499.   Parse *pParse;       /* The parsing context */
  1500.   NameContext *pNC;    /* Namespace of first enclosing query */
  1501. };
  1502. #ifdef SQLITE_TEST
  1503.   int sqlite3_enable_in_opt = 1;
  1504. #else
  1505.   #define sqlite3_enable_in_opt 1
  1506. #endif
  1507. /*
  1508. ** This function is used by the implementation of the IN (...) operator.
  1509. ** It's job is to find or create a b-tree structure that may be used
  1510. ** either to test for membership of the (...) set or to iterate through
  1511. ** its members, skipping duplicates.
  1512. **
  1513. ** The cursor opened on the structure (database table, database index 
  1514. ** or ephermal table) is stored in pX->iTable before this function returns.
  1515. ** The returned value indicates the structure type, as follows:
  1516. **
  1517. **   IN_INDEX_ROWID - The cursor was opened on a database table.
  1518. **   IN_INDEX_INDEX - The cursor was opened on a database index.
  1519. **   IN_INDEX_EPH -   The cursor was opened on a specially created and
  1520. **                    populated epheremal table.
  1521. **
  1522. ** An existing structure may only be used if the SELECT is of the simple
  1523. ** form:
  1524. **
  1525. **     SELECT <column> FROM <table>
  1526. **
  1527. ** If the mustBeUnique parameter is false, the structure will be used 
  1528. ** for fast set membership tests. In this case an epheremal table must 
  1529. ** be used unless <column> is an INTEGER PRIMARY KEY or an index can 
  1530. ** be found with <column> as its left-most column.
  1531. **
  1532. ** If mustBeUnique is true, then the structure will be used to iterate
  1533. ** through the set members, skipping any duplicates. In this case an
  1534. ** epheremal table must be used unless the selected <column> is guaranteed
  1535. ** to be unique - either because it is an INTEGER PRIMARY KEY or it
  1536. ** is unique by virtue of a constraint or implicit index.
  1537. */
  1538. #ifndef SQLITE_OMIT_SUBQUERY
  1539. int sqlite3FindInIndex(Parse *pParse, Expr *pX, int mustBeUnique){
  1540.   Select *p;
  1541.   int eType = 0;
  1542.   int iTab = pParse->nTab++;
  1543.   /* The follwing if(...) expression is true if the SELECT is of the 
  1544.   ** simple form:
  1545.   **
  1546.   **     SELECT <column> FROM <table>
  1547.   **
  1548.   ** If this is the case, it may be possible to use an existing table
  1549.   ** or index instead of generating an epheremal table.
  1550.   */
  1551.   if( sqlite3_enable_in_opt
  1552.    && (p=pX->pSelect)!=0 && !p->pPrior
  1553.    && !p->isDistinct && !p->isAgg && !p->pGroupBy
  1554.    && p->pSrc && p->pSrc->nSrc==1 && !p->pSrc->a[0].pSelect
  1555.    && p->pSrc->a[0].pTab && !p->pSrc->a[0].pTab->pSelect
  1556.    && p->pEList->nExpr==1 && p->pEList->a[0].pExpr->op==TK_COLUMN
  1557.    && !p->pLimit && !p->pOffset && !p->pWhere
  1558.   ){
  1559.     sqlite3 *db = pParse->db;
  1560.     Index *pIdx;
  1561.     Expr *pExpr = p->pEList->a[0].pExpr;
  1562.     int iCol = pExpr->iColumn;
  1563.     Vdbe *v = sqlite3GetVdbe(pParse);
  1564.     /* This function is only called from two places. In both cases the vdbe
  1565.     ** has already been allocated. So assume sqlite3GetVdbe() is always
  1566.     ** successful here.
  1567.     */
  1568.     assert(v);
  1569.     if( iCol<0 ){
  1570.       int iMem = ++pParse->nMem;
  1571.       int iAddr;
  1572.       Table *pTab = p->pSrc->a[0].pTab;
  1573.       int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
  1574.       sqlite3VdbeUsesBtree(v, iDb);
  1575.       iAddr = sqlite3VdbeAddOp1(v, OP_If, iMem);
  1576.       sqlite3VdbeAddOp2(v, OP_Integer, 1, iMem);
  1577.       sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
  1578.       eType = IN_INDEX_ROWID;
  1579.       sqlite3VdbeJumpHere(v, iAddr);
  1580.     }else{
  1581.       /* The collation sequence used by the comparison. If an index is to 
  1582.       ** be used in place of a temp-table, it must be ordered according
  1583.       ** to this collation sequence.
  1584.       */
  1585.       CollSeq *pReq = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pExpr);
  1586.       /* Check that the affinity that will be used to perform the 
  1587.       ** comparison is the same as the affinity of the column. If
  1588.       ** it is not, it is not possible to use any index.
  1589.       */
  1590.       Table *pTab = p->pSrc->a[0].pTab;
  1591.       char aff = comparisonAffinity(pX);
  1592.       int affinity_ok = (pTab->aCol[iCol].affinity==aff||aff==SQLITE_AFF_NONE);
  1593.       for(pIdx=pTab->pIndex; pIdx && eType==0 && affinity_ok; pIdx=pIdx->pNext){
  1594.         if( (pIdx->aiColumn[0]==iCol)
  1595.          && (pReq==sqlite3FindCollSeq(db, ENC(db), pIdx->azColl[0], -1, 0))
  1596.          && (!mustBeUnique || (pIdx->nColumn==1 && pIdx->onError!=OE_None))
  1597.         ){
  1598.           int iDb;
  1599.           int iMem = ++pParse->nMem;
  1600.           int iAddr;
  1601.           char *pKey;
  1602.   
  1603.           pKey = (char *)sqlite3IndexKeyinfo(pParse, pIdx);
  1604.           iDb = sqlite3SchemaToIndex(db, pIdx->pSchema);
  1605.           sqlite3VdbeUsesBtree(v, iDb);
  1606.           iAddr = sqlite3VdbeAddOp1(v, OP_If, iMem);
  1607.           sqlite3VdbeAddOp2(v, OP_Integer, 1, iMem);
  1608.   
  1609.           sqlite3VdbeAddOp2(v, OP_SetNumColumns, 0, pIdx->nColumn);
  1610.           sqlite3VdbeAddOp4(v, OP_OpenRead, iTab, pIdx->tnum, iDb,
  1611.                                pKey,P4_KEYINFO_HANDOFF);
  1612.           VdbeComment((v, "%s", pIdx->zName));
  1613.           eType = IN_INDEX_INDEX;
  1614.           sqlite3VdbeJumpHere(v, iAddr);
  1615.         }
  1616.       }
  1617.     }
  1618.   }
  1619.   if( eType==0 ){
  1620.     sqlite3CodeSubselect(pParse, pX);
  1621.     eType = IN_INDEX_EPH;
  1622.   }else{
  1623.     pX->iTable = iTab;
  1624.   }
  1625.   return eType;
  1626. }
  1627. #endif
  1628. /*
  1629. ** Generate code for scalar subqueries used as an expression
  1630. ** and IN operators.  Examples:
  1631. **
  1632. **     (SELECT a FROM b)          -- subquery
  1633. **     EXISTS (SELECT a FROM b)   -- EXISTS subquery
  1634. **     x IN (4,5,11)              -- IN operator with list on right-hand side
  1635. **     x IN (SELECT a FROM b)     -- IN operator with subquery on the right
  1636. **
  1637. ** The pExpr parameter describes the expression that contains the IN
  1638. ** operator or subquery.
  1639. */
  1640. #ifndef SQLITE_OMIT_SUBQUERY
  1641. void sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){
  1642.   int testAddr = 0;                       /* One-time test address */
  1643.   Vdbe *v = sqlite3GetVdbe(pParse);
  1644.   if( v==0 ) return;
  1645.   /* This code must be run in its entirety every time it is encountered
  1646.   ** if any of the following is true:
  1647.   **
  1648.   **    *  The right-hand side is a correlated subquery
  1649.   **    *  The right-hand side is an expression list containing variables
  1650.   **    *  We are inside a trigger
  1651.   **
  1652.   ** If all of the above are false, then we can run this code just once
  1653.   ** save the results, and reuse the same result on subsequent invocations.
  1654.   */
  1655.   if( !ExprHasAnyProperty(pExpr, EP_VarSelect) && !pParse->trigStack ){
  1656.     int mem = ++pParse->nMem;
  1657.     sqlite3VdbeAddOp1(v, OP_If, mem);
  1658.     testAddr = sqlite3VdbeAddOp2(v, OP_Integer, 1, mem);
  1659.     assert( testAddr>0 || pParse->db->mallocFailed );
  1660.   }
  1661.   switch( pExpr->op ){
  1662.     case TK_IN: {
  1663.       char affinity;
  1664.       KeyInfo keyInfo;
  1665.       int addr;        /* Address of OP_OpenEphemeral instruction */
  1666.       affinity = sqlite3ExprAffinity(pExpr->pLeft);
  1667.       /* Whether this is an 'x IN(SELECT...)' or an 'x IN(<exprlist>)'
  1668.       ** expression it is handled the same way. A virtual table is 
  1669.       ** filled with single-field index keys representing the results
  1670.       ** from the SELECT or the <exprlist>.
  1671.       **
  1672.       ** If the 'x' expression is a column value, or the SELECT...
  1673.       ** statement returns a column value, then the affinity of that
  1674.       ** column is used to build the index keys. If both 'x' and the
  1675.       ** SELECT... statement are columns, then numeric affinity is used
  1676.       ** if either column has NUMERIC or INTEGER affinity. If neither
  1677.       ** 'x' nor the SELECT... statement are columns, then numeric affinity
  1678.       ** is used.
  1679.       */
  1680.       pExpr->iTable = pParse->nTab++;
  1681.       addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, 1);
  1682.       memset(&keyInfo, 0, sizeof(keyInfo));
  1683.       keyInfo.nField = 1;
  1684.       if( pExpr->pSelect ){
  1685.         /* Case 1:     expr IN (SELECT ...)
  1686.         **
  1687.         ** Generate code to write the results of the select into the temporary
  1688.         ** table allocated and opened above.
  1689.         */
  1690.         SelectDest dest;
  1691.         ExprList *pEList;
  1692.         sqlite3SelectDestInit(&dest, SRT_Set, pExpr->iTable);
  1693.         dest.affinity = (int)affinity;
  1694.         assert( (pExpr->iTable&0x0000FFFF)==pExpr->iTable );
  1695.         if( sqlite3Select(pParse, pExpr->pSelect, &dest, 0, 0, 0, 0) ){
  1696.           return;
  1697.         }
  1698.         pEList = pExpr->pSelect->pEList;
  1699.         if( pEList && pEList->nExpr>0 ){ 
  1700.           keyInfo.aColl[0] = sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft,
  1701.               pEList->a[0].pExpr);
  1702.         }
  1703.       }else if( pExpr->pList ){
  1704.         /* Case 2:     expr IN (exprlist)
  1705.         **
  1706.         ** For each expression, build an index key from the evaluation and
  1707.         ** store it in the temporary table. If <expr> is a column, then use
  1708.         ** that columns affinity when building index keys. If <expr> is not
  1709.         ** a column, use numeric affinity.
  1710.         */
  1711.         int i;
  1712.         ExprList *pList = pExpr->pList;
  1713.         struct ExprList_item *pItem;
  1714.         int r1, r2;
  1715.         if( !affinity ){
  1716.           affinity = SQLITE_AFF_NONE;
  1717.         }
  1718.         keyInfo.aColl[0] = pExpr->pLeft->pColl;
  1719.         /* Loop through each expression in <exprlist>. */
  1720.         r1 = sqlite3GetTempReg(pParse);
  1721.         r2 = sqlite3GetTempReg(pParse);
  1722.         for(i=pList->nExpr, pItem=pList->a; i>0; i--, pItem++){
  1723.           Expr *pE2 = pItem->pExpr;
  1724.           /* If the expression is not constant then we will need to
  1725.           ** disable the test that was generated above that makes sure
  1726.           ** this code only executes once.  Because for a non-constant
  1727.           ** expression we need to rerun this code each time.
  1728.           */
  1729.           if( testAddr && !sqlite3ExprIsConstant(pE2) ){
  1730.             sqlite3VdbeChangeToNoop(v, testAddr-1, 2);
  1731.             testAddr = 0;
  1732.           }
  1733.           /* Evaluate the expression and insert it into the temp table */
  1734.           pParse->disableColCache++;
  1735.           sqlite3ExprCode(pParse, pE2, r1);
  1736.           assert( pParse->disableColCache>0 );
  1737.           pParse->disableColCache--;
  1738.           sqlite3VdbeAddOp4(v, OP_MakeRecord, r1, 1, r2, &affinity, 1);
  1739.           sqlite3ExprCacheAffinityChange(pParse, r1, 1);
  1740.           sqlite3VdbeAddOp2(v, OP_IdxInsert, pExpr->iTable, r2);
  1741.         }
  1742.         sqlite3ReleaseTempReg(pParse, r1);
  1743.         sqlite3ReleaseTempReg(pParse, r2);
  1744.       }
  1745.       sqlite3VdbeChangeP4(v, addr, (void *)&keyInfo, P4_KEYINFO);
  1746.       break;
  1747.     }
  1748.     case TK_EXISTS:
  1749.     case TK_SELECT: {
  1750.       /* This has to be a scalar SELECT.  Generate code to put the
  1751.       ** value of this select in a memory cell and record the number
  1752.       ** of the memory cell in iColumn.
  1753.       */
  1754.       static const Token one = { (u8*)"1", 0, 1 };
  1755.       Select *pSel;
  1756.       SelectDest dest;
  1757.       pSel = pExpr->pSelect;
  1758.       sqlite3SelectDestInit(&dest, 0, ++pParse->nMem);
  1759.       if( pExpr->op==TK_SELECT ){
  1760.         dest.eDest = SRT_Mem;
  1761.         sqlite3VdbeAddOp2(v, OP_Null, 0, dest.iParm);
  1762.         VdbeComment((v, "Init subquery result"));
  1763.       }else{
  1764.         dest.eDest = SRT_Exists;
  1765.         sqlite3VdbeAddOp2(v, OP_Integer, 0, dest.iParm);
  1766.         VdbeComment((v, "Init EXISTS result"));
  1767.       }
  1768.       sqlite3ExprDelete(pSel->pLimit);
  1769.       pSel->pLimit = sqlite3PExpr(pParse, TK_INTEGER, 0, 0, &one);
  1770.       if( sqlite3Select(pParse, pSel, &dest, 0, 0, 0, 0) ){
  1771.         return;
  1772.       }
  1773.       pExpr->iColumn = dest.iParm;
  1774.       break;
  1775.     }
  1776.   }
  1777.   if( testAddr ){
  1778.     sqlite3VdbeJumpHere(v, testAddr-1);
  1779.   }
  1780.   return;
  1781. }
  1782. #endif /* SQLITE_OMIT_SUBQUERY */
  1783. /*
  1784. ** Duplicate an 8-byte value
  1785. */
  1786. static char *dup8bytes(Vdbe *v, const char *in){
  1787.   char *out = sqlite3DbMallocRaw(sqlite3VdbeDb(v), 8);
  1788.   if( out ){
  1789.     memcpy(out, in, 8);
  1790.   }
  1791.   return out;
  1792. }
  1793. /*
  1794. ** Generate an instruction that will put the floating point
  1795. ** value described by z[0..n-1] into register iMem.
  1796. **
  1797. ** The z[] string will probably not be zero-terminated.  But the 
  1798. ** z[n] character is guaranteed to be something that does not look
  1799. ** like the continuation of the number.
  1800. */
  1801. static void codeReal(Vdbe *v, const char *z, int n, int negateFlag, int iMem){
  1802.   assert( z || v==0 || sqlite3VdbeDb(v)->mallocFailed );
  1803.   if( z ){
  1804.     double value;
  1805.     char *zV;
  1806.     assert( !isdigit(z[n]) );
  1807.     sqlite3AtoF(z, &value);
  1808.     if( negateFlag ) value = -value;
  1809.     zV = dup8bytes(v, (char*)&value);
  1810.     sqlite3VdbeAddOp4(v, OP_Real, 0, iMem, 0, zV, P4_REAL);
  1811.   }
  1812. }
  1813. /*
  1814. ** Generate an instruction that will put the integer describe by
  1815. ** text z[0..n-1] into register iMem.
  1816. **
  1817. ** The z[] string will probably not be zero-terminated.  But the 
  1818. ** z[n] character is guaranteed to be something that does not look
  1819. ** like the continuation of the number.
  1820. */
  1821. static void codeInteger(Vdbe *v, const char *z, int n, int negFlag, int iMem){
  1822.   assert( z || v==0 || sqlite3VdbeDb(v)->mallocFailed );
  1823.   if( z ){
  1824.     int i;
  1825.     assert( !isdigit(z[n]) );
  1826.     if( sqlite3GetInt32(z, &i) ){
  1827.       if( negFlag ) i = -i;
  1828.       sqlite3VdbeAddOp2(v, OP_Integer, i, iMem);
  1829.     }else if( sqlite3FitsIn64Bits(z, negFlag) ){
  1830.       i64 value;
  1831.       char *zV;
  1832.       sqlite3Atoi64(z, &value);
  1833.       if( negFlag ) value = -value;
  1834.       zV = dup8bytes(v, (char*)&value);
  1835.       sqlite3VdbeAddOp4(v, OP_Int64, 0, iMem, 0, zV, P4_INT64);
  1836.     }else{
  1837.       codeReal(v, z, n, negFlag, iMem);
  1838.     }
  1839.   }
  1840. }
  1841. /*
  1842. ** Generate code that will extract the iColumn-th column from
  1843. ** table pTab and store the column value in a register.  An effort
  1844. ** is made to store the column value in register iReg, but this is
  1845. ** not guaranteed.  The location of the column value is returned.
  1846. **
  1847. ** There must be an open cursor to pTab in iTable when this routine
  1848. ** is called.  If iColumn<0 then code is generated that extracts the rowid.
  1849. **
  1850. ** This routine might attempt to reuse the value of the column that
  1851. ** has already been loaded into a register.  The value will always
  1852. ** be used if it has not undergone any affinity changes.  But if
  1853. ** an affinity change has occurred, then the cached value will only be
  1854. ** used if allowAffChng is true.
  1855. */
  1856. int sqlite3ExprCodeGetColumn(
  1857.   Parse *pParse,   /* Parsing and code generating context */
  1858.   Table *pTab,     /* Description of the table we are reading from */
  1859.   int iColumn,     /* Index of the table column */
  1860.   int iTable,      /* The cursor pointing to the table */
  1861.   int iReg,        /* Store results here */
  1862.   int allowAffChng /* True if prior affinity changes are OK */
  1863. ){
  1864.   Vdbe *v = pParse->pVdbe;
  1865.   int i;
  1866.   struct yColCache *p;
  1867.   for(i=0, p=pParse->aColCache; i<pParse->nColCache; i++, p++){
  1868.     if( p->iTable==iTable && p->iColumn==iColumn
  1869.            && (!p->affChange || allowAffChng) ){
  1870. #if 0
  1871.       sqlite3VdbeAddOp0(v, OP_Noop);
  1872.       VdbeComment((v, "OPT: tab%d.col%d -> r%d", iTable, iColumn, p->iReg));
  1873. #endif
  1874.       return p->iReg;
  1875.     }
  1876.   }  
  1877.   assert( v!=0 );
  1878.   if( iColumn<0 ){
  1879.     int op = (pTab && IsVirtual(pTab)) ? OP_VRowid : OP_Rowid;
  1880.     sqlite3VdbeAddOp2(v, op, iTable, iReg);
  1881.   }else if( pTab==0 ){
  1882.     sqlite3VdbeAddOp3(v, OP_Column, iTable, iColumn, iReg);
  1883.   }else{
  1884.     int op = IsVirtual(pTab) ? OP_VColumn : OP_Column;
  1885.     sqlite3VdbeAddOp3(v, op, iTable, iColumn, iReg);
  1886.     sqlite3ColumnDefault(v, pTab, iColumn);
  1887. #ifndef SQLITE_OMIT_FLOATING_POINT
  1888.     if( pTab->aCol[iColumn].affinity==SQLITE_AFF_REAL ){
  1889.       sqlite3VdbeAddOp1(v, OP_RealAffinity, iReg);
  1890.     }
  1891. #endif
  1892.   }
  1893.   if( pParse->disableColCache==0 ){
  1894.     i = pParse->iColCache;
  1895.     p = &pParse->aColCache[i];
  1896.     p->iTable = iTable;
  1897.     p->iColumn = iColumn;
  1898.     p->iReg = iReg;
  1899.     p->affChange = 0;
  1900.     i++;
  1901.     if( i>=ArraySize(pParse->aColCache) ) i = 0;
  1902.     if( i>pParse->nColCache ) pParse->nColCache = i;
  1903.     pParse->iColCache = i;
  1904.   }
  1905.   return iReg;
  1906. }
  1907. /*
  1908. ** Clear all column cache entries associated with the vdbe
  1909. ** cursor with cursor number iTable.
  1910. */
  1911. void sqlite3ExprClearColumnCache(Parse *pParse, int iTable){
  1912.   if( iTable<0 ){
  1913.     pParse->nColCache = 0;
  1914.     pParse->iColCache = 0;
  1915.   }else{
  1916.     int i;
  1917.     for(i=0; i<pParse->nColCache; i++){
  1918.       if( pParse->aColCache[i].iTable==iTable ){
  1919.         testcase( i==pParse->nColCache-1 );
  1920.         pParse->aColCache[i] = pParse->aColCache[--pParse->nColCache];
  1921.         pParse->iColCache = pParse->nColCache;
  1922.       }
  1923.     }
  1924.   }
  1925. }
  1926. /*
  1927. ** Record the fact that an affinity change has occurred on iCount
  1928. ** registers starting with iStart.
  1929. */
  1930. void sqlite3ExprCacheAffinityChange(Parse *pParse, int iStart, int iCount){
  1931.   int iEnd = iStart + iCount - 1;
  1932.   int i;
  1933.   for(i=0; i<pParse->nColCache; i++){
  1934.     int r = pParse->aColCache[i].iReg;
  1935.     if( r>=iStart && r<=iEnd ){
  1936.       pParse->aColCache[i].affChange = 1;
  1937.     }
  1938.   }
  1939. }
  1940. /*
  1941. ** Generate code to moves content from one register to another.
  1942. ** Keep the column cache up-to-date.
  1943. */
  1944. void sqlite3ExprCodeMove(Parse *pParse, int iFrom, int iTo){
  1945.   int i;
  1946.   if( iFrom==iTo ) return;
  1947.   sqlite3VdbeAddOp2(pParse->pVdbe, OP_Move, iFrom, iTo);
  1948.   for(i=0; i<pParse->nColCache; i++){
  1949.     if( pParse->aColCache[i].iReg==iFrom ){
  1950.       pParse->aColCache[i].iReg = iTo;
  1951.     }
  1952.   }
  1953. }
  1954. /*
  1955. ** Return true if any register in the range iFrom..iTo (inclusive)
  1956. ** is used as part of the column cache.
  1957. */
  1958. static int usedAsColumnCache(Parse *pParse, int iFrom, int iTo){
  1959.   int i;
  1960.   for(i=0; i<pParse->nColCache; i++){
  1961.     int r = pParse->aColCache[i].iReg;
  1962.     if( r>=iFrom && r<=iTo ) return 1;
  1963.   }
  1964.   return 0;
  1965. }
  1966. /*
  1967. ** Theres is a value in register iCurrent.  We ultimately want
  1968. ** the value to be in register iTarget.  It might be that
  1969. ** iCurrent and iTarget are the same register.
  1970. **
  1971. ** We are going to modify the value, so we need to make sure it
  1972. ** is not a cached register.  If iCurrent is a cached register,
  1973. ** then try to move the value over to iTarget.  If iTarget is a
  1974. ** cached register, then clear the corresponding cache line.
  1975. **
  1976. ** Return the register that the value ends up in.
  1977. */
  1978. int sqlite3ExprWritableRegister(Parse *pParse, int iCurrent, int iTarget){
  1979.   int i;
  1980.   assert( pParse->pVdbe!=0 );
  1981.   if( !usedAsColumnCache(pParse, iCurrent, iCurrent) ){
  1982.     return iCurrent;
  1983.   }
  1984.   if( iCurrent!=iTarget ){
  1985.     sqlite3VdbeAddOp2(pParse->pVdbe, OP_SCopy, iCurrent, iTarget);
  1986.   }
  1987.   for(i=0; i<pParse->nColCache; i++){
  1988.     if( pParse->aColCache[i].iReg==iTarget ){
  1989.       pParse->aColCache[i] = pParse->aColCache[--pParse->nColCache];
  1990.       pParse->iColCache = pParse->nColCache;
  1991.     }
  1992.   }
  1993.   return iTarget;
  1994. }
  1995. /*
  1996. ** If the last instruction coded is an ephemeral copy of any of
  1997. ** the registers in the nReg registers beginning with iReg, then
  1998. ** convert the last instruction from OP_SCopy to OP_Copy.
  1999. */
  2000. void sqlite3ExprHardCopy(Parse *pParse, int iReg, int nReg){
  2001.   int addr;
  2002.   VdbeOp *pOp;
  2003.   Vdbe *v;
  2004.   v = pParse->pVdbe;
  2005.   addr = sqlite3VdbeCurrentAddr(v);
  2006.   pOp = sqlite3VdbeGetOp(v, addr-1);
  2007.   if( pOp->opcode==OP_SCopy && pOp->p1>=iReg && pOp->p1<iReg+nReg ){
  2008.     pOp->opcode = OP_Copy;
  2009.   }
  2010. }
  2011. /*
  2012. ** Generate code into the current Vdbe to evaluate the given
  2013. ** expression.  Attempt to store the results in register "target".
  2014. ** Return the register where results are stored.
  2015. **
  2016. ** With this routine, there is no guaranteed that results will
  2017. ** be stored in target.  The result might be stored in some other
  2018. ** register if it is convenient to do so.  The calling function
  2019. ** must check the return code and move the results to the desired
  2020. ** register.
  2021. */
  2022. int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){
  2023.   Vdbe *v = pParse->pVdbe;  /* The VM under construction */
  2024.   int op;                   /* The opcode being coded */
  2025.   int inReg = target;       /* Results stored in register inReg */
  2026.   int regFree1 = 0;         /* If non-zero free this temporary register */
  2027.   int regFree2 = 0;         /* If non-zero free this temporary register */
  2028.   int r1, r2, r3, r4;       /* Various register numbers */
  2029.   assert( v!=0 || pParse->db->mallocFailed );
  2030.   assert( target>0 && target<=pParse->nMem );
  2031.   if( v==0 ) return 0;
  2032.   if( pExpr==0 ){
  2033.     op = TK_NULL;
  2034.   }else{
  2035.     op = pExpr->op;
  2036.   }
  2037.   switch( op ){
  2038.     case TK_AGG_COLUMN: {
  2039.       AggInfo *pAggInfo = pExpr->pAggInfo;
  2040.       struct AggInfo_col *pCol = &pAggInfo->aCol[pExpr->iAgg];
  2041.       if( !pAggInfo->directMode ){
  2042.         assert( pCol->iMem>0 );
  2043.         inReg = pCol->iMem;
  2044.         break;
  2045.       }else if( pAggInfo->useSortingIdx ){
  2046.         sqlite3VdbeAddOp3(v, OP_Column, pAggInfo->sortingIdx,
  2047.                               pCol->iSorterColumn, target);
  2048.         break;
  2049.       }
  2050.       /* Otherwise, fall thru into the TK_COLUMN case */
  2051.     }
  2052.     case TK_COLUMN: {
  2053.       if( pExpr->iTable<0 ){
  2054.         /* This only happens when coding check constraints */
  2055.         assert( pParse->ckBase>0 );
  2056.         inReg = pExpr->iColumn + pParse->ckBase;
  2057.       }else{
  2058.         testcase( (pExpr->flags & EP_AnyAff)!=0 );
  2059.         inReg = sqlite3ExprCodeGetColumn(pParse, pExpr->pTab,
  2060.                                  pExpr->iColumn, pExpr->iTable, target,
  2061.                                  pExpr->flags & EP_AnyAff);
  2062.       }
  2063.       break;
  2064.     }
  2065.     case TK_INTEGER: {
  2066.       codeInteger(v, (char*)pExpr->token.z, pExpr->token.n, 0, target);
  2067.       break;
  2068.     }
  2069.     case TK_FLOAT: {
  2070.       codeReal(v, (char*)pExpr->token.z, pExpr->token.n, 0, target);
  2071.       break;
  2072.     }
  2073.     case TK_STRING: {
  2074.       sqlite3DequoteExpr(pParse->db, pExpr);
  2075.       sqlite3VdbeAddOp4(v,OP_String8, 0, target, 0,
  2076.                         (char*)pExpr->token.z, pExpr->token.n);
  2077.       break;
  2078.     }
  2079.     case TK_NULL: {
  2080.       sqlite3VdbeAddOp2(v, OP_Null, 0, target);
  2081.       break;
  2082.     }
  2083. #ifndef SQLITE_OMIT_BLOB_LITERAL
  2084.     case TK_BLOB: {
  2085.       int n;
  2086.       const char *z;
  2087.       char *zBlob;
  2088.       assert( pExpr->token.n>=3 );
  2089.       assert( pExpr->token.z[0]=='x' || pExpr->token.z[0]=='X' );
  2090.       assert( pExpr->token.z[1]==''' );
  2091.       assert( pExpr->token.z[pExpr->token.n-1]==''' );
  2092.       n = pExpr->token.n - 3;
  2093.       z = (char*)pExpr->token.z + 2;
  2094.       zBlob = sqlite3HexToBlob(sqlite3VdbeDb(v), z, n);
  2095.       sqlite3VdbeAddOp4(v, OP_Blob, n/2, target, 0, zBlob, P4_DYNAMIC);
  2096.       break;
  2097.     }
  2098. #endif
  2099.     case TK_VARIABLE: {
  2100.       sqlite3VdbeAddOp2(v, OP_Variable, pExpr->iTable, target);
  2101.       if( pExpr->token.n>1 ){
  2102.         sqlite3VdbeChangeP4(v, -1, (char*)pExpr->token.z, pExpr->token.n);
  2103.       }
  2104.       break;
  2105.     }
  2106.     case TK_REGISTER: {
  2107.       inReg = pExpr->iTable;
  2108.       break;
  2109.     }
  2110. #ifndef SQLITE_OMIT_CAST
  2111.     case TK_CAST: {
  2112.       /* Expressions of the form:   CAST(pLeft AS token) */
  2113.       int aff, to_op;
  2114.       inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
  2115.       aff = sqlite3AffinityType(&pExpr->token);
  2116.       to_op = aff - SQLITE_AFF_TEXT + OP_ToText;
  2117.       assert( to_op==OP_ToText    || aff!=SQLITE_AFF_TEXT    );
  2118.       assert( to_op==OP_ToBlob    || aff!=SQLITE_AFF_NONE    );
  2119.       assert( to_op==OP_ToNumeric || aff!=SQLITE_AFF_NUMERIC );
  2120.       assert( to_op==OP_ToInt     || aff!=SQLITE_AFF_INTEGER );
  2121.       assert( to_op==OP_ToReal    || aff!=SQLITE_AFF_REAL    );
  2122.       testcase( to_op==OP_ToText );
  2123.       testcase( to_op==OP_ToBlob );
  2124.       testcase( to_op==OP_ToNumeric );
  2125.       testcase( to_op==OP_ToInt );
  2126.       testcase( to_op==OP_ToReal );
  2127.       sqlite3VdbeAddOp1(v, to_op, inReg);
  2128.       testcase( usedAsColumnCache(pParse, inReg, inReg) );
  2129.       sqlite3ExprCacheAffinityChange(pParse, inReg, 1);
  2130.       break;
  2131.     }
  2132. #endif /* SQLITE_OMIT_CAST */
  2133.     case TK_LT:
  2134.     case TK_LE:
  2135.     case TK_GT:
  2136.     case TK_GE:
  2137.     case TK_NE:
  2138.     case TK_EQ: {
  2139.       assert( TK_LT==OP_Lt );
  2140.       assert( TK_LE==OP_Le );
  2141.       assert( TK_GT==OP_Gt );
  2142.       assert( TK_GE==OP_Ge );
  2143.       assert( TK_EQ==OP_Eq );
  2144.       assert( TK_NE==OP_Ne );
  2145.       testcase( op==TK_LT );
  2146.       testcase( op==TK_LE );
  2147.       testcase( op==TK_GT );
  2148.       testcase( op==TK_GE );
  2149.       testcase( op==TK_EQ );
  2150.       testcase( op==TK_NE );
  2151.       codeCompareOperands(pParse, pExpr->pLeft, &r1, &regFree1,
  2152.                                   pExpr->pRight, &r2, &regFree2);
  2153.       codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
  2154.                   r1, r2, inReg, SQLITE_STOREP2);
  2155.       testcase( regFree1==0 );
  2156.       testcase( regFree2==0 );
  2157.       break;
  2158.     }
  2159.     case TK_AND:
  2160.     case TK_OR:
  2161.     case TK_PLUS:
  2162.     case TK_STAR:
  2163.     case TK_MINUS:
  2164.     case TK_REM:
  2165.     case TK_BITAND:
  2166.     case TK_BITOR:
  2167.     case TK_SLASH:
  2168.     case TK_LSHIFT:
  2169.     case TK_RSHIFT: 
  2170.     case TK_CONCAT: {
  2171.       assert( TK_AND==OP_And );
  2172.       assert( TK_OR==OP_Or );
  2173.       assert( TK_PLUS==OP_Add );
  2174.       assert( TK_MINUS==OP_Subtract );
  2175.       assert( TK_REM==OP_Remainder );
  2176.       assert( TK_BITAND==OP_BitAnd );
  2177.       assert( TK_BITOR==OP_BitOr );
  2178.       assert( TK_SLASH==OP_Divide );
  2179.       assert( TK_LSHIFT==OP_ShiftLeft );
  2180.       assert( TK_RSHIFT==OP_ShiftRight );
  2181.       assert( TK_CONCAT==OP_Concat );
  2182.       testcase( op==TK_AND );
  2183.       testcase( op==TK_OR );
  2184.       testcase( op==TK_PLUS );
  2185.       testcase( op==TK_MINUS );
  2186.       testcase( op==TK_REM );
  2187.       testcase( op==TK_BITAND );
  2188.       testcase( op==TK_BITOR );
  2189.       testcase( op==TK_SLASH );
  2190.       testcase( op==TK_LSHIFT );
  2191.       testcase( op==TK_RSHIFT );
  2192.       testcase( op==TK_CONCAT );
  2193.       r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
  2194.       r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
  2195.       sqlite3VdbeAddOp3(v, op, r2, r1, target);
  2196.       testcase( regFree1==0 );
  2197.       testcase( regFree2==0 );
  2198.       break;
  2199.     }
  2200.     case TK_UMINUS: {
  2201.       Expr *pLeft = pExpr->pLeft;
  2202.       assert( pLeft );
  2203.       if( pLeft->op==TK_FLOAT || pLeft->op==TK_INTEGER ){
  2204.         Token *p = &pLeft->token;
  2205.         if( pLeft->op==TK_FLOAT ){
  2206.           codeReal(v, (char*)p->z, p->n, 1, target);
  2207.         }else{
  2208.           codeInteger(v, (char*)p->z, p->n, 1, target);
  2209.         }
  2210.       }else{
  2211.         regFree1 = r1 = sqlite3GetTempReg(pParse);
  2212.         sqlite3VdbeAddOp2(v, OP_Integer, 0, r1);
  2213.         r2 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree2);
  2214.         sqlite3VdbeAddOp3(v, OP_Subtract, r2, r1, target);
  2215.         testcase( regFree2==0 );
  2216.       }
  2217.       inReg = target;
  2218.       break;
  2219.     }
  2220.     case TK_BITNOT:
  2221.     case TK_NOT: {
  2222.       assert( TK_BITNOT==OP_BitNot );
  2223.       assert( TK_NOT==OP_Not );
  2224.       testcase( op==TK_BITNOT );
  2225.       testcase( op==TK_NOT );
  2226.       inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
  2227.       testcase( inReg==target );
  2228.       testcase( usedAsColumnCache(pParse, inReg, inReg) );
  2229.       inReg = sqlite3ExprWritableRegister(pParse, inReg, target);
  2230.       sqlite3VdbeAddOp1(v, op, inReg);
  2231.       break;
  2232.     }
  2233.     case TK_ISNULL:
  2234.     case TK_NOTNULL: {
  2235.       int addr;
  2236.       assert( TK_ISNULL==OP_IsNull );
  2237.       assert( TK_NOTNULL==OP_NotNull );
  2238.       testcase( op==TK_ISNULL );
  2239.       testcase( op==TK_NOTNULL );
  2240.       sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
  2241.       r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
  2242.       testcase( regFree1==0 );
  2243.       addr = sqlite3VdbeAddOp1(v, op, r1);
  2244.       sqlite3VdbeAddOp2(v, OP_AddImm, target, -1);
  2245.       sqlite3VdbeJumpHere(v, addr);
  2246.       break;
  2247.     }
  2248.     case TK_AGG_FUNCTION: {
  2249.       AggInfo *pInfo = pExpr->pAggInfo;
  2250.       if( pInfo==0 ){
  2251.         sqlite3ErrorMsg(pParse, "misuse of aggregate: %T",
  2252.             &pExpr->span);
  2253.       }else{
  2254.         inReg = pInfo->aFunc[pExpr->iAgg].iMem;
  2255.       }
  2256.       break;
  2257.     }
  2258.     case TK_CONST_FUNC:
  2259.     case TK_FUNCTION: {
  2260.       ExprList *pList = pExpr->pList;
  2261.       int nExpr = pList ? pList->nExpr : 0;
  2262.       FuncDef *pDef;
  2263.       int nId;
  2264.       const char *zId;
  2265.       int constMask = 0;
  2266.       int i;
  2267.       sqlite3 *db = pParse->db;
  2268.       u8 enc = ENC(db);
  2269.       CollSeq *pColl = 0;
  2270.       testcase( op==TK_CONST_FUNC );
  2271.       testcase( op==TK_FUNCTION );
  2272.       zId = (char*)pExpr->token.z;
  2273.       nId = pExpr->token.n;
  2274.       pDef = sqlite3FindFunction(pParse->db, zId, nId, nExpr, enc, 0);
  2275.       assert( pDef!=0 );
  2276.       if( pList ){
  2277.         nExpr = pList->nExpr;
  2278.         r1 = sqlite3GetTempRange(pParse, nExpr);
  2279.         sqlite3ExprCodeExprList(pParse, pList, r1, 1);
  2280.       }else{
  2281.         nExpr = r1 = 0;
  2282.       }
  2283. #ifndef SQLITE_OMIT_VIRTUALTABLE
  2284.       /* Possibly overload the function if the first argument is
  2285.       ** a virtual table column.
  2286.       **
  2287.       ** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the
  2288.       ** second argument, not the first, as the argument to test to
  2289.       ** see if it is a column in a virtual table.  This is done because
  2290.       ** the left operand of infix functions (the operand we want to
  2291.       ** control overloading) ends up as the second argument to the
  2292.       ** function.  The expression "A glob B" is equivalent to 
  2293.       ** "glob(B,A).  We want to use the A in "A glob B" to test
  2294.       ** for function overloading.  But we use the B term in "glob(B,A)".
  2295.       */
  2296.       if( nExpr>=2 && (pExpr->flags & EP_InfixFunc) ){
  2297.         pDef = sqlite3VtabOverloadFunction(db, pDef, nExpr, pList->a[1].pExpr);
  2298.       }else if( nExpr>0 ){
  2299.         pDef = sqlite3VtabOverloadFunction(db, pDef, nExpr, pList->a[0].pExpr);
  2300.       }
  2301. #endif
  2302.       for(i=0; i<nExpr && i<32; i++){
  2303.         if( sqlite3ExprIsConstant(pList->a[i].pExpr) ){
  2304.           constMask |= (1<<i);
  2305.         }
  2306.         if( pDef->needCollSeq && !pColl ){
  2307.           pColl = sqlite3ExprCollSeq(pParse, pList->a[i].pExpr);
  2308.         }
  2309.       }
  2310.       if( pDef->needCollSeq ){
  2311.         if( !pColl ) pColl = pParse->db->pDfltColl; 
  2312.         sqlite3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ);
  2313.       }
  2314.       sqlite3VdbeAddOp4(v, OP_Function, constMask, r1, target,
  2315.                         (char*)pDef, P4_FUNCDEF);
  2316.       sqlite3VdbeChangeP5(v, nExpr);
  2317.       if( nExpr ){
  2318.         sqlite3ReleaseTempRange(pParse, r1, nExpr);
  2319.       }
  2320.       sqlite3ExprCacheAffinityChange(pParse, r1, nExpr);
  2321.       break;
  2322.     }
  2323. #ifndef SQLITE_OMIT_SUBQUERY
  2324.     case TK_EXISTS:
  2325.     case TK_SELECT: {
  2326.       testcase( op==TK_EXISTS );
  2327.       testcase( op==TK_SELECT );
  2328.       if( pExpr->iColumn==0 ){
  2329.         sqlite3CodeSubselect(pParse, pExpr);
  2330.       }
  2331.       inReg = pExpr->iColumn;
  2332.       break;
  2333.     }
  2334.     case TK_IN: {
  2335.       int j1, j2, j3, j4, j5;
  2336.       char affinity;
  2337.       int eType;
  2338.       eType = sqlite3FindInIndex(pParse, pExpr, 0);
  2339.       /* Figure out the affinity to use to create a key from the results
  2340.       ** of the expression. affinityStr stores a static string suitable for
  2341.       ** P4 of OP_MakeRecord.
  2342.       */
  2343.       affinity = comparisonAffinity(pExpr);
  2344.       sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
  2345.       /* Code the <expr> from "<expr> IN (...)". The temporary table
  2346.       ** pExpr->iTable contains the values that make up the (...) set.
  2347.       */
  2348.       r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
  2349.       testcase( regFree1==0 );
  2350.       j1 = sqlite3VdbeAddOp1(v, OP_NotNull, r1);
  2351.       sqlite3VdbeAddOp2(v, OP_Null, 0, target);
  2352.       j2  = sqlite3VdbeAddOp0(v, OP_Goto);
  2353.       sqlite3VdbeJumpHere(v, j1);
  2354.       if( eType==IN_INDEX_ROWID ){
  2355.         j3 = sqlite3VdbeAddOp1(v, OP_MustBeInt, r1);
  2356.         j4 = sqlite3VdbeAddOp3(v, OP_NotExists, pExpr->iTable, 0, r1);
  2357.         j5 = sqlite3VdbeAddOp0(v, OP_Goto);
  2358.         sqlite3VdbeJumpHere(v, j3);
  2359.         sqlite3VdbeJumpHere(v, j4);
  2360.       }else{
  2361.         r2 = regFree2 = sqlite3GetTempReg(pParse);
  2362.         sqlite3VdbeAddOp4(v, OP_MakeRecord, r1, 1, r2, &affinity, 1);
  2363.         sqlite3ExprCacheAffinityChange(pParse, r1, 1);
  2364.         j5 = sqlite3VdbeAddOp3(v, OP_Found, pExpr->iTable, 0, r2);
  2365.       }
  2366.       sqlite3VdbeAddOp2(v, OP_AddImm, target, -1);
  2367.       sqlite3VdbeJumpHere(v, j2);
  2368.       sqlite3VdbeJumpHere(v, j5);
  2369.       break;
  2370.     }
  2371. #endif
  2372.     /*
  2373.     **    x BETWEEN y AND z
  2374.     **
  2375.     ** This is equivalent to
  2376.     **
  2377.     **    x>=y AND x<=z
  2378.     **
  2379.     ** X is stored in pExpr->pLeft.
  2380.     ** Y is stored in pExpr->pList->a[0].pExpr.
  2381.     ** Z is stored in pExpr->pList->a[1].pExpr.
  2382.     */
  2383.     case TK_BETWEEN: {
  2384.       Expr *pLeft = pExpr->pLeft;
  2385.       struct ExprList_item *pLItem = pExpr->pList->a;
  2386.       Expr *pRight = pLItem->pExpr;
  2387.       codeCompareOperands(pParse, pLeft, &r1, &regFree1,
  2388.                                   pRight, &r2, &regFree2);
  2389.       testcase( regFree1==0 );
  2390.       testcase( regFree2==0 );
  2391.       r3 = sqlite3GetTempReg(pParse);
  2392.       r4 = sqlite3GetTempReg(pParse);
  2393.       codeCompare(pParse, pLeft, pRight, OP_Ge,
  2394.                   r1, r2, r3, SQLITE_STOREP2);
  2395.       pLItem++;
  2396.       pRight = pLItem->pExpr;
  2397.       sqlite3ReleaseTempReg(pParse, regFree2);
  2398.       r2 = sqlite3ExprCodeTemp(pParse, pRight, &regFree2);
  2399.       testcase( regFree2==0 );
  2400.       codeCompare(pParse, pLeft, pRight, OP_Le, r1, r2, r4, SQLITE_STOREP2);
  2401.       sqlite3VdbeAddOp3(v, OP_And, r3, r4, target);
  2402.       sqlite3ReleaseTempReg(pParse, r3);
  2403.       sqlite3ReleaseTempReg(pParse, r4);
  2404.       break;
  2405.     }
  2406.     case TK_UPLUS: {
  2407.       inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
  2408.       break;
  2409.     }
  2410.     /*
  2411.     ** Form A:
  2412.     **   CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
  2413.     **
  2414.     ** Form B:
  2415.     **   CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
  2416.     **
  2417.     ** Form A is can be transformed into the equivalent form B as follows:
  2418.     **   CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ...
  2419.     **        WHEN x=eN THEN rN ELSE y END
  2420.     **
  2421.     ** X (if it exists) is in pExpr->pLeft.
  2422.     ** Y is in pExpr->pRight.  The Y is also optional.  If there is no
  2423.     ** ELSE clause and no other term matches, then the result of the
  2424.     ** exprssion is NULL.
  2425.     ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1].
  2426.     **
  2427.     ** The result of the expression is the Ri for the first matching Ei,
  2428.     ** or if there is no matching Ei, the ELSE term Y, or if there is
  2429.     ** no ELSE term, NULL.
  2430.     */
  2431.     case TK_CASE: {
  2432.       int endLabel;                     /* GOTO label for end of CASE stmt */
  2433.       int nextCase;                     /* GOTO label for next WHEN clause */
  2434.       int nExpr;                        /* 2x number of WHEN terms */
  2435.       int i;                            /* Loop counter */
  2436.       ExprList *pEList;                 /* List of WHEN terms */
  2437.       struct ExprList_item *aListelem;  /* Array of WHEN terms */
  2438.       Expr opCompare;                   /* The X==Ei expression */
  2439.       Expr cacheX;                      /* Cached expression X */
  2440.       Expr *pX;                         /* The X expression */
  2441.       Expr *pTest;                      /* X==Ei (form A) or just Ei (form B) */
  2442.       assert(pExpr->pList);
  2443.       assert((pExpr->pList->nExpr % 2) == 0);
  2444.       assert(pExpr->pList->nExpr > 0);
  2445.       pEList = pExpr->pList;
  2446.       aListelem = pEList->a;
  2447.       nExpr = pEList->nExpr;
  2448.       endLabel = sqlite3VdbeMakeLabel(v);
  2449.       if( (pX = pExpr->pLeft)!=0 ){
  2450.         cacheX = *pX;
  2451.         testcase( pX->op==TK_COLUMN || pX->op==TK_REGISTER );
  2452.         cacheX.iTable = sqlite3ExprCodeTemp(pParse, pX, &regFree1);
  2453.         testcase( regFree1==0 );
  2454.         cacheX.op = TK_REGISTER;
  2455.         cacheX.iColumn = 0;
  2456.         opCompare.op = TK_EQ;
  2457.         opCompare.pLeft = &cacheX;
  2458.         pTest = &opCompare;
  2459.       }
  2460.       pParse->disableColCache++;
  2461.       for(i=0; i<nExpr; i=i+2){
  2462.         if( pX ){
  2463.           opCompare.pRight = aListelem[i].pExpr;
  2464.         }else{
  2465.           pTest = aListelem[i].pExpr;
  2466.         }
  2467.         nextCase = sqlite3VdbeMakeLabel(v);
  2468.         testcase( pTest->op==TK_COLUMN || pTest->op==TK_REGISTER );
  2469.         sqlite3ExprIfFalse(pParse, pTest, nextCase, SQLITE_JUMPIFNULL);
  2470.         testcase( aListelem[i+1].pExpr->op==TK_COLUMN );
  2471.         testcase( aListelem[i+1].pExpr->op==TK_REGISTER );
  2472.         sqlite3ExprCode(pParse, aListelem[i+1].pExpr, target);
  2473.         sqlite3VdbeAddOp2(v, OP_Goto, 0, endLabel);
  2474.         sqlite3VdbeResolveLabel(v, nextCase);
  2475.       }
  2476.       if( pExpr->pRight ){
  2477.         sqlite3ExprCode(pParse, pExpr->pRight, target);
  2478.       }else{
  2479.         sqlite3VdbeAddOp2(v, OP_Null, 0, target);
  2480.       }
  2481.       sqlite3VdbeResolveLabel(v, endLabel);
  2482.       assert( pParse->disableColCache>0 );
  2483.       pParse->disableColCache--;
  2484.       break;
  2485.     }
  2486. #ifndef SQLITE_OMIT_TRIGGER
  2487.     case TK_RAISE: {
  2488.       if( !pParse->trigStack ){
  2489.         sqlite3ErrorMsg(pParse,
  2490.                        "RAISE() may only be used within a trigger-program");
  2491.         return 0;
  2492.       }
  2493.       if( pExpr->iColumn!=OE_Ignore ){
  2494.          assert( pExpr->iColumn==OE_Rollback ||
  2495.                  pExpr->iColumn == OE_Abort ||
  2496.                  pExpr->iColumn == OE_Fail );
  2497.          sqlite3DequoteExpr(pParse->db, pExpr);
  2498.          sqlite3VdbeAddOp4(v, OP_Halt, SQLITE_CONSTRAINT, pExpr->iColumn, 0,
  2499.                         (char*)pExpr->token.z, pExpr->token.n);
  2500.       } else {
  2501.          assert( pExpr->iColumn == OE_Ignore );
  2502.          sqlite3VdbeAddOp2(v, OP_ContextPop, 0, 0);
  2503.          sqlite3VdbeAddOp2(v, OP_Goto, 0, pParse->trigStack->ignoreJump);
  2504.          VdbeComment((v, "raise(IGNORE)"));
  2505.       }
  2506.       break;
  2507.     }
  2508. #endif
  2509.   }
  2510.   sqlite3ReleaseTempReg(pParse, regFree1);
  2511.   sqlite3ReleaseTempReg(pParse, regFree2);
  2512.   return inReg;
  2513. }
  2514. /*
  2515. ** Generate code to evaluate an expression and store the results
  2516. ** into a register.  Return the register number where the results
  2517. ** are stored.
  2518. **
  2519. ** If the register is a temporary register that can be deallocated,
  2520. ** then write its number into *pReg.  If the result register is not
  2521. ** a temporary, then set *pReg to zero.
  2522. */
  2523. int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){
  2524.   int r1 = sqlite3GetTempReg(pParse);
  2525.   int r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
  2526.   if( r2==r1 ){
  2527.     *pReg = r1;
  2528.   }else{
  2529.     sqlite3ReleaseTempReg(pParse, r1);
  2530.     *pReg = 0;
  2531.   }
  2532.   return r2;
  2533. }
  2534. /*
  2535. ** Generate code that will evaluate expression pExpr and store the
  2536. ** results in register target.  The results are guaranteed to appear
  2537. ** in register target.
  2538. */
  2539. int sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){
  2540.   int inReg;
  2541.   assert( target>0 && target<=pParse->nMem );
  2542.   inReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
  2543.   assert( pParse->pVdbe || pParse->db->mallocFailed );
  2544.   if( inReg!=target && pParse->pVdbe ){
  2545.     sqlite3VdbeAddOp2(pParse->pVdbe, OP_SCopy, inReg, target);
  2546.   }
  2547.   return target;
  2548. }
  2549. /*
  2550. ** Generate code that evalutes the given expression and puts the result
  2551. ** in register target.
  2552. **
  2553. ** Also make a copy of the expression results into another "cache" register
  2554. ** and modify the expression so that the next time it is evaluated,
  2555. ** the result is a copy of the cache register.
  2556. **
  2557. ** This routine is used for expressions that are used multiple 
  2558. ** times.  They are evaluated once and the results of the expression
  2559. ** are reused.
  2560. */
  2561. int sqlite3ExprCodeAndCache(Parse *pParse, Expr *pExpr, int target){
  2562.   Vdbe *v = pParse->pVdbe;
  2563.   int inReg;
  2564.   inReg = sqlite3ExprCode(pParse, pExpr, target);
  2565.   assert( target>0 );
  2566.   if( pExpr->op!=TK_REGISTER ){  
  2567.     int iMem;
  2568.     iMem = ++pParse->nMem;
  2569.     sqlite3VdbeAddOp2(v, OP_Copy, inReg, iMem);
  2570.     pExpr->iTable = iMem;
  2571.     pExpr->iColumn = pExpr->op;
  2572.     pExpr->op = TK_REGISTER;
  2573.   }
  2574.   return inReg;
  2575. }
  2576. /*
  2577. ** Return TRUE if pExpr is an constant expression that is appropriate
  2578. ** for factoring out of a loop.  Appropriate expressions are:
  2579. **
  2580. **    *  Any expression that evaluates to two or more opcodes.
  2581. **
  2582. **    *  Any OP_Integer, OP_Real, OP_String, OP_Blob, OP_Null, 
  2583. **       or OP_Variable that does not need to be placed in a 
  2584. **       specific register.
  2585. **
  2586. ** There is no point in factoring out single-instruction constant
  2587. ** expressions that need to be placed in a particular register.  
  2588. ** We could factor them out, but then we would end up adding an
  2589. ** OP_SCopy instruction to move the value into the correct register
  2590. ** later.  We might as well just use the original instruction and
  2591. ** avoid the OP_SCopy.
  2592. */
  2593. static int isAppropriateForFactoring(Expr *p){
  2594.   if( !sqlite3ExprIsConstantNotJoin(p) ){
  2595.     return 0;  /* Only constant expressions are appropriate for factoring */
  2596.   }
  2597.   if( (p->flags & EP_FixedDest)==0 ){
  2598.     return 1;  /* Any constant without a fixed destination is appropriate */
  2599.   }
  2600.   while( p->op==TK_UPLUS ) p = p->pLeft;
  2601.   switch( p->op ){
  2602. #ifndef SQLITE_OMIT_BLOB_LITERAL
  2603.     case TK_BLOB:
  2604. #endif
  2605.     case TK_VARIABLE:
  2606.     case TK_INTEGER:
  2607.     case TK_FLOAT:
  2608.     case TK_NULL:
  2609.     case TK_STRING: {
  2610.       testcase( p->op==TK_BLOB );
  2611.       testcase( p->op==TK_VARIABLE );
  2612.       testcase( p->op==TK_INTEGER );
  2613.       testcase( p->op==TK_FLOAT );
  2614.       testcase( p->op==TK_NULL );
  2615.       testcase( p->op==TK_STRING );
  2616.       /* Single-instruction constants with a fixed destination are
  2617.       ** better done in-line.  If we factor them, they will just end
  2618.       ** up generating an OP_SCopy to move the value to the destination
  2619.       ** register. */
  2620.       return 0;
  2621.     }
  2622.     case TK_UMINUS: {
  2623.        if( p->pLeft->op==TK_FLOAT || p->pLeft->op==TK_INTEGER ){
  2624.          return 0;
  2625.        }
  2626.        break;
  2627.     }
  2628.     default: {
  2629.       break;
  2630.     }
  2631.   }
  2632.   return 1;
  2633. }
  2634. /*
  2635. ** If pExpr is a constant expression that is appropriate for
  2636. ** factoring out of a loop, then evaluate the expression
  2637. ** into a register and convert the expression into a TK_REGISTER
  2638. ** expression.
  2639. */
  2640. static int evalConstExpr(void *pArg, Expr *pExpr){
  2641.   Parse *pParse = (Parse*)pArg;
  2642.   switch( pExpr->op ){
  2643.     case TK_REGISTER: {
  2644.       return 1;
  2645.     }
  2646.     case TK_FUNCTION:
  2647.     case TK_AGG_FUNCTION:
  2648.     case TK_CONST_FUNC: {
  2649.       /* The arguments to a function have a fixed destination.
  2650.       ** Mark them this way to avoid generated unneeded OP_SCopy
  2651.       ** instructions. 
  2652.       */
  2653.       ExprList *pList = pExpr->pList;
  2654.       if( pList ){
  2655.         int i = pList->nExpr;
  2656.         struct ExprList_item *pItem = pList->a;
  2657.         for(; i>0; i--, pItem++){
  2658.           if( pItem->pExpr ) pItem->pExpr->flags |= EP_FixedDest;
  2659.         }
  2660.       }
  2661.       break;
  2662.     }
  2663.   }
  2664.   if( isAppropriateForFactoring(pExpr) ){
  2665.     int r1 = ++pParse->nMem;
  2666.     int r2;
  2667.     r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
  2668.     if( r1!=r2 ) sqlite3ReleaseTempReg(pParse, r1);
  2669.     pExpr->iColumn = pExpr->op;
  2670.     pExpr->op = TK_REGISTER;
  2671.     pExpr->iTable = r2;
  2672.     return 1;
  2673.   }
  2674.   return 0;
  2675. }
  2676. /*
  2677. ** Preevaluate constant subexpressions within pExpr and store the
  2678. ** results in registers.  Modify pExpr so that the constant subexpresions
  2679. ** are TK_REGISTER opcodes that refer to the precomputed values.
  2680. */
  2681. void sqlite3ExprCodeConstants(Parse *pParse, Expr *pExpr){
  2682.    walkExprTree(pExpr, evalConstExpr, pParse);
  2683. }
  2684. /*
  2685. ** Generate code that pushes the value of every element of the given
  2686. ** expression list into a sequence of registers beginning at target.
  2687. **
  2688. ** Return the number of elements evaluated.
  2689. */
  2690. int sqlite3ExprCodeExprList(
  2691.   Parse *pParse,     /* Parsing context */
  2692.   ExprList *pList,   /* The expression list to be coded */
  2693.   int target,        /* Where to write results */
  2694.   int doHardCopy     /* Call sqlite3ExprHardCopy on each element if true */
  2695. ){
  2696.   struct ExprList_item *pItem;
  2697.   int i, n;
  2698.   assert( pList!=0 || pParse->db->mallocFailed );
  2699.   if( pList==0 ){
  2700.     return 0;
  2701.   }
  2702.   assert( target>0 );
  2703.   n = pList->nExpr;
  2704.   for(pItem=pList->a, i=0; i<n; i++, pItem++){
  2705.     sqlite3ExprCode(pParse, pItem->pExpr, target+i);
  2706.     if( doHardCopy ) sqlite3ExprHardCopy(pParse, target, n);
  2707.   }
  2708.   return n;
  2709. }
  2710. /*
  2711. ** Generate code for a boolean expression such that a jump is made
  2712. ** to the label "dest" if the expression is true but execution
  2713. ** continues straight thru if the expression is false.
  2714. **
  2715. ** If the expression evaluates to NULL (neither true nor false), then
  2716. ** take the jump if the jumpIfNull flag is SQLITE_JUMPIFNULL.
  2717. **
  2718. ** This code depends on the fact that certain token values (ex: TK_EQ)
  2719. ** are the same as opcode values (ex: OP_Eq) that implement the corresponding
  2720. ** operation.  Special comments in vdbe.c and the mkopcodeh.awk script in
  2721. ** the make process cause these values to align.  Assert()s in the code
  2722. ** below verify that the numbers are aligned correctly.
  2723. */
  2724. void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
  2725.   Vdbe *v = pParse->pVdbe;
  2726.   int op = 0;
  2727.   int regFree1 = 0;
  2728.   int regFree2 = 0;
  2729.   int r1, r2;
  2730.   assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 );
  2731.   if( v==0 || pExpr==0 ) return;
  2732.   op = pExpr->op;
  2733.   switch( op ){
  2734.     case TK_AND: {
  2735.       int d2 = sqlite3VdbeMakeLabel(v);
  2736.       testcase( jumpIfNull==0 );
  2737.       testcase( pParse->disableColCache==0 );
  2738.       sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2,jumpIfNull^SQLITE_JUMPIFNULL);
  2739.       pParse->disableColCache++;
  2740.       sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
  2741.       assert( pParse->disableColCache>0 );
  2742.       pParse->disableColCache--;
  2743.       sqlite3VdbeResolveLabel(v, d2);
  2744.       break;
  2745.     }
  2746.     case TK_OR: {
  2747.       testcase( jumpIfNull==0 );
  2748.       testcase( pParse->disableColCache==0 );
  2749.       sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
  2750.       pParse->disableColCache++;
  2751.       sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
  2752.       assert( pParse->disableColCache>0 );
  2753.       pParse->disableColCache--;
  2754.       break;
  2755.     }
  2756.     case TK_NOT: {
  2757.       testcase( jumpIfNull==0 );
  2758.       sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
  2759.       break;
  2760.     }
  2761.     case TK_LT:
  2762.     case TK_LE:
  2763.     case TK_GT:
  2764.     case TK_GE:
  2765.     case TK_NE:
  2766.     case TK_EQ: {
  2767.       assert( TK_LT==OP_Lt );
  2768.       assert( TK_LE==OP_Le );
  2769.       assert( TK_GT==OP_Gt );
  2770.       assert( TK_GE==OP_Ge );
  2771.       assert( TK_EQ==OP_Eq );
  2772.       assert( TK_NE==OP_Ne );
  2773.       testcase( op==TK_LT );
  2774.       testcase( op==TK_LE );
  2775.       testcase( op==TK_GT );
  2776.       testcase( op==TK_GE );
  2777.       testcase( op==TK_EQ );
  2778.       testcase( op==TK_NE );
  2779.       testcase( jumpIfNull==0 );
  2780.       codeCompareOperands(pParse, pExpr->pLeft, &r1, &regFree1,
  2781.                                   pExpr->pRight, &r2, &regFree2);
  2782.       codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
  2783.                   r1, r2, dest, jumpIfNull);
  2784.       testcase( regFree1==0 );
  2785.       testcase( regFree2==0 );
  2786.       break;
  2787.     }
  2788.     case TK_ISNULL:
  2789.     case TK_NOTNULL: {
  2790.       assert( TK_ISNULL==OP_IsNull );
  2791.       assert( TK_NOTNULL==OP_NotNull );
  2792.       testcase( op==TK_ISNULL );
  2793.       testcase( op==TK_NOTNULL );
  2794.       r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
  2795.       sqlite3VdbeAddOp2(v, op, r1, dest);
  2796.       testcase( regFree1==0 );
  2797.       break;
  2798.     }
  2799.     case TK_BETWEEN: {
  2800.       /*    x BETWEEN y AND z
  2801.       **
  2802.       ** Is equivalent to 
  2803.       **
  2804.       **    x>=y AND x<=z
  2805.       **
  2806.       ** Code it as such, taking care to do the common subexpression
  2807.       ** elementation of x.
  2808.       */
  2809.       Expr exprAnd;
  2810.       Expr compLeft;
  2811.       Expr compRight;
  2812.       Expr exprX;
  2813.       exprX = *pExpr->pLeft;
  2814.       exprAnd.op = TK_AND;
  2815.       exprAnd.pLeft = &compLeft;
  2816.       exprAnd.pRight = &compRight;
  2817.       compLeft.op = TK_GE;
  2818.       compLeft.pLeft = &exprX;
  2819.       compLeft.pRight = pExpr->pList->a[0].pExpr;
  2820.       compRight.op = TK_LE;
  2821.       compRight.pLeft = &exprX;
  2822.       compRight.pRight = pExpr->pList->a[1].pExpr;
  2823.       exprX.iTable = sqlite3ExprCodeTemp(pParse, &exprX, &regFree1);
  2824.       testcase( regFree1==0 );
  2825.       exprX.op = TK_REGISTER;
  2826.       testcase( jumpIfNull==0 );
  2827.       sqlite3ExprIfTrue(pParse, &exprAnd, dest, jumpIfNull);
  2828.       break;
  2829.     }
  2830.     default: {
  2831.       r1 = sqlite3ExprCodeTemp(pParse, pExpr, &regFree1);
  2832.       sqlite3VdbeAddOp3(v, OP_If, r1, dest, jumpIfNull!=0);
  2833.       testcase( regFree1==0 );
  2834.       testcase( jumpIfNull==0 );
  2835.       break;
  2836.     }
  2837.   }
  2838.   sqlite3ReleaseTempReg(pParse, regFree1);
  2839.   sqlite3ReleaseTempReg(pParse, regFree2);  
  2840. }
  2841. /*
  2842. ** Generate code for a boolean expression such that a jump is made
  2843. ** to the label "dest" if the expression is false but execution
  2844. ** continues straight thru if the expression is true.
  2845. **
  2846. ** If the expression evaluates to NULL (neither true nor false) then
  2847. ** jump if jumpIfNull is SQLITE_JUMPIFNULL or fall through if jumpIfNull
  2848. ** is 0.
  2849. */
  2850. void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
  2851.   Vdbe *v = pParse->pVdbe;
  2852.   int op = 0;
  2853.   int regFree1 = 0;
  2854.   int regFree2 = 0;
  2855.   int r1, r2;
  2856.   assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 );
  2857.   if( v==0 || pExpr==0 ) return;
  2858.   /* The value of pExpr->op and op are related as follows:
  2859.   **
  2860.   **       pExpr->op            op
  2861.   **       ---------          ----------
  2862.   **       TK_ISNULL          OP_NotNull
  2863.   **       TK_NOTNULL         OP_IsNull
  2864.   **       TK_NE              OP_Eq
  2865.   **       TK_EQ              OP_Ne
  2866.   **       TK_GT              OP_Le
  2867.   **       TK_LE              OP_Gt
  2868.   **       TK_GE              OP_Lt
  2869.   **       TK_LT              OP_Ge
  2870.   **
  2871.   ** For other values of pExpr->op, op is undefined and unused.
  2872.   ** The value of TK_ and OP_ constants are arranged such that we
  2873.   ** can compute the mapping above using the following expression.
  2874.   ** Assert()s verify that the computation is correct.
  2875.   */
  2876.   op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1);
  2877.   /* Verify correct alignment of TK_ and OP_ constants
  2878.   */
  2879.   assert( pExpr->op!=TK_ISNULL || op==OP_NotNull );
  2880.   assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull );
  2881.   assert( pExpr->op!=TK_NE || op==OP_Eq );
  2882.   assert( pExpr->op!=TK_EQ || op==OP_Ne );
  2883.   assert( pExpr->op!=TK_LT || op==OP_Ge );
  2884.   assert( pExpr->op!=TK_LE || op==OP_Gt );
  2885.   assert( pExpr->op!=TK_GT || op==OP_Le );
  2886.   assert( pExpr->op!=TK_GE || op==OP_Lt );
  2887.   switch( pExpr->op ){
  2888.     case TK_AND: {
  2889.       testcase( jumpIfNull==0 );
  2890.       testcase( pParse->disableColCache==0 );
  2891.       sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
  2892.       pParse->disableColCache++;
  2893.       sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
  2894.       assert( pParse->disableColCache>0 );
  2895.       pParse->disableColCache--;
  2896.       break;
  2897.     }
  2898.     case TK_OR: {
  2899.       int d2 = sqlite3VdbeMakeLabel(v);
  2900.       testcase( jumpIfNull==0 );
  2901.       testcase( pParse->disableColCache==0 );
  2902.       sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2, jumpIfNull^SQLITE_JUMPIFNULL);
  2903.       pParse->disableColCache++;
  2904.       sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
  2905.       assert( pParse->disableColCache>0 );
  2906.       pParse->disableColCache--;
  2907.       sqlite3VdbeResolveLabel(v, d2);
  2908.       break;
  2909.     }
  2910.     case TK_NOT: {
  2911.       sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
  2912.       break;
  2913.     }
  2914.     case TK_LT:
  2915.     case TK_LE:
  2916.     case TK_GT:
  2917.     case TK_GE:
  2918.     case TK_NE:
  2919.     case TK_EQ: {
  2920.       testcase( op==TK_LT );
  2921.       testcase( op==TK_LE );
  2922.       testcase( op==TK_GT );
  2923.       testcase( op==TK_GE );
  2924.       testcase( op==TK_EQ );
  2925.       testcase( op==TK_NE );
  2926.       testcase( jumpIfNull==0 );
  2927.       codeCompareOperands(pParse, pExpr->pLeft, &r1, &regFree1,
  2928.                                   pExpr->pRight, &r2, &regFree2);
  2929.       codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
  2930.                   r1, r2, dest, jumpIfNull);
  2931.       testcase( regFree1==0 );
  2932.       testcase( regFree2==0 );
  2933.       break;
  2934.     }
  2935.     case TK_ISNULL:
  2936.     case TK_NOTNULL: {
  2937.       testcase( op==TK_ISNULL );
  2938.       testcase( op==TK_NOTNULL );
  2939.       r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
  2940.       sqlite3VdbeAddOp2(v, op, r1, dest);
  2941.       testcase( regFree1==0 );
  2942.       break;
  2943.     }
  2944.     case TK_BETWEEN: {
  2945.       /*    x BETWEEN y AND z
  2946.       **
  2947.       ** Is equivalent to 
  2948.       **
  2949.       **    x>=y AND x<=z
  2950.       **
  2951.       ** Code it as such, taking care to do the common subexpression
  2952.       ** elementation of x.
  2953.       */
  2954.       Expr exprAnd;
  2955.       Expr compLeft;
  2956.       Expr compRight;
  2957.       Expr exprX;
  2958.       exprX = *pExpr->pLeft;
  2959.       exprAnd.op = TK_AND;
  2960.       exprAnd.pLeft = &compLeft;
  2961.       exprAnd.pRight = &compRight;
  2962.       compLeft.op = TK_GE;
  2963.       compLeft.pLeft = &exprX;
  2964.       compLeft.pRight = pExpr->pList->a[0].pExpr;
  2965.       compRight.op = TK_LE;
  2966.       compRight.pLeft = &exprX;
  2967.       compRight.pRight = pExpr->pList->a[1].pExpr;
  2968.       exprX.iTable = sqlite3ExprCodeTemp(pParse, &exprX, &regFree1);
  2969.       testcase( regFree1==0 );
  2970.       exprX.op = TK_REGISTER;
  2971.       testcase( jumpIfNull==0 );
  2972.       sqlite3ExprIfFalse(pParse, &exprAnd, dest, jumpIfNull);
  2973.       break;
  2974.     }
  2975.     default: {
  2976.       r1 = sqlite3ExprCodeTemp(pParse, pExpr, &regFree1);
  2977.       sqlite3VdbeAddOp3(v, OP_IfNot, r1, dest, jumpIfNull!=0);
  2978.       testcase( regFree1==0 );
  2979.       testcase( jumpIfNull==0 );
  2980.       break;
  2981.     }
  2982.   }
  2983.   sqlite3ReleaseTempReg(pParse, regFree1);
  2984.   sqlite3ReleaseTempReg(pParse, regFree2);
  2985. }
  2986. /*
  2987. ** Do a deep comparison of two expression trees.  Return TRUE (non-zero)
  2988. ** if they are identical and return FALSE if they differ in any way.
  2989. **
  2990. ** Sometimes this routine will return FALSE even if the two expressions
  2991. ** really are equivalent.  If we cannot prove that the expressions are
  2992. ** identical, we return FALSE just to be safe.  So if this routine
  2993. ** returns false, then you do not really know for certain if the two
  2994. ** expressions are the same.  But if you get a TRUE return, then you
  2995. ** can be sure the expressions are the same.  In the places where
  2996. ** this routine is used, it does not hurt to get an extra FALSE - that
  2997. ** just might result in some slightly slower code.  But returning
  2998. ** an incorrect TRUE could lead to a malfunction.
  2999. */
  3000. int sqlite3ExprCompare(Expr *pA, Expr *pB){
  3001.   int i;
  3002.   if( pA==0||pB==0 ){
  3003.     return pB==pA;
  3004.   }
  3005.   if( pA->op!=pB->op ) return 0;
  3006.   if( (pA->flags & EP_Distinct)!=(pB->flags & EP_Distinct) ) return 0;
  3007.   if( !sqlite3ExprCompare(pA->pLeft, pB->pLeft) ) return 0;
  3008.   if( !sqlite3ExprCompare(pA->pRight, pB->pRight) ) return 0;
  3009.   if( pA->pList ){
  3010.     if( pB->pList==0 ) return 0;
  3011.     if( pA->pList->nExpr!=pB->pList->nExpr ) return 0;
  3012.     for(i=0; i<pA->pList->nExpr; i++){
  3013.       if( !sqlite3ExprCompare(pA->pList->a[i].pExpr, pB->pList->a[i].pExpr) ){
  3014.         return 0;
  3015.       }
  3016.     }
  3017.   }else if( pB->pList ){
  3018.     return 0;
  3019.   }
  3020.   if( pA->pSelect || pB->pSelect ) return 0;
  3021.   if( pA->iTable!=pB->iTable || pA->iColumn!=pB->iColumn ) return 0;
  3022.   if( pA->op!=TK_COLUMN && pA->token.z ){
  3023.     if( pB->token.z==0 ) return 0;
  3024.     if( pB->token.n!=pA->token.n ) return 0;
  3025.     if( sqlite3StrNICmp((char*)pA->token.z,(char*)pB->token.z,pB->token.n)!=0 ){
  3026.       return 0;
  3027.     }
  3028.   }
  3029.   return 1;
  3030. }
  3031. /*
  3032. ** Add a new element to the pAggInfo->aCol[] array.  Return the index of
  3033. ** the new element.  Return a negative number if malloc fails.
  3034. */
  3035. static int addAggInfoColumn(sqlite3 *db, AggInfo *pInfo){
  3036.   int i;
  3037.   pInfo->aCol = sqlite3ArrayAllocate(
  3038.        db,
  3039.        pInfo->aCol,
  3040.        sizeof(pInfo->aCol[0]),
  3041.        3,
  3042.        &pInfo->nColumn,
  3043.        &pInfo->nColumnAlloc,
  3044.        &i
  3045.   );
  3046.   return i;
  3047. }    
  3048. /*
  3049. ** Add a new element to the pAggInfo->aFunc[] array.  Return the index of
  3050. ** the new element.  Return a negative number if malloc fails.
  3051. */
  3052. static int addAggInfoFunc(sqlite3 *db, AggInfo *pInfo){
  3053.   int i;
  3054.   pInfo->aFunc = sqlite3ArrayAllocate(
  3055.        db, 
  3056.        pInfo->aFunc,
  3057.        sizeof(pInfo->aFunc[0]),
  3058.        3,
  3059.        &pInfo->nFunc,
  3060.        &pInfo->nFuncAlloc,
  3061.        &i
  3062.   );
  3063.   return i;
  3064. }    
  3065. /*
  3066. ** This is an xFunc for walkExprTree() used to implement 
  3067. ** sqlite3ExprAnalyzeAggregates().  See sqlite3ExprAnalyzeAggregates
  3068. ** for additional information.
  3069. **
  3070. ** This routine analyzes the aggregate function at pExpr.
  3071. */
  3072. static int analyzeAggregate(void *pArg, Expr *pExpr){
  3073.   int i;
  3074.   NameContext *pNC = (NameContext *)pArg;
  3075.   Parse *pParse = pNC->pParse;
  3076.   SrcList *pSrcList = pNC->pSrcList;
  3077.   AggInfo *pAggInfo = pNC->pAggInfo;
  3078.   switch( pExpr->op ){
  3079.     case TK_AGG_COLUMN:
  3080.     case TK_COLUMN: {
  3081.       /* Check to see if the column is in one of the tables in the FROM
  3082.       ** clause of the aggregate query */
  3083.       if( pSrcList ){
  3084.         struct SrcList_item *pItem = pSrcList->a;
  3085.         for(i=0; i<pSrcList->nSrc; i++, pItem++){
  3086.           struct AggInfo_col *pCol;
  3087.           if( pExpr->iTable==pItem->iCursor ){
  3088.             /* If we reach this point, it means that pExpr refers to a table
  3089.             ** that is in the FROM clause of the aggregate query.  
  3090.             **
  3091.             ** Make an entry for the column in pAggInfo->aCol[] if there
  3092.             ** is not an entry there already.
  3093.             */
  3094.             int k;
  3095.             pCol = pAggInfo->aCol;
  3096.             for(k=0; k<pAggInfo->nColumn; k++, pCol++){
  3097.               if( pCol->iTable==pExpr->iTable &&
  3098.                   pCol->iColumn==pExpr->iColumn ){
  3099.                 break;
  3100.               }
  3101.             }
  3102.             if( (k>=pAggInfo->nColumn)
  3103.              && (k = addAggInfoColumn(pParse->db, pAggInfo))>=0 
  3104.             ){
  3105.               pCol = &pAggInfo->aCol[k];
  3106.               pCol->pTab = pExpr->pTab;
  3107.               pCol->iTable = pExpr->iTable;
  3108.               pCol->iColumn = pExpr->iColumn;
  3109.               pCol->iMem = ++pParse->nMem;
  3110.               pCol->iSorterColumn = -1;
  3111.               pCol->pExpr = pExpr;
  3112.               if( pAggInfo->pGroupBy ){
  3113.                 int j, n;
  3114.                 ExprList *pGB = pAggInfo->pGroupBy;
  3115.                 struct ExprList_item *pTerm = pGB->a;
  3116.                 n = pGB->nExpr;
  3117.                 for(j=0; j<n; j++, pTerm++){
  3118.                   Expr *pE = pTerm->pExpr;
  3119.                   if( pE->op==TK_COLUMN && pE->iTable==pExpr->iTable &&
  3120.                       pE->iColumn==pExpr->iColumn ){
  3121.                     pCol->iSorterColumn = j;
  3122.                     break;
  3123.                   }
  3124.                 }
  3125.               }
  3126.               if( pCol->iSorterColumn<0 ){
  3127.                 pCol->iSorterColumn = pAggInfo->nSortingColumn++;
  3128.               }
  3129.             }
  3130.             /* There is now an entry for pExpr in pAggInfo->aCol[] (either
  3131.             ** because it was there before or because we just created it).
  3132.             ** Convert the pExpr to be a TK_AGG_COLUMN referring to that
  3133.             ** pAggInfo->aCol[] entry.
  3134.             */
  3135.             pExpr->pAggInfo = pAggInfo;
  3136.             pExpr->op = TK_AGG_COLUMN;
  3137.             pExpr->iAgg = k;
  3138.             break;
  3139.           } /* endif pExpr->iTable==pItem->iCursor */
  3140.         } /* end loop over pSrcList */
  3141.       }
  3142.       return 1;
  3143.     }
  3144.     case TK_AGG_FUNCTION: {
  3145.       /* The pNC->nDepth==0 test causes aggregate functions in subqueries
  3146.       ** to be ignored */
  3147.       if( pNC->nDepth==0 ){
  3148.         /* Check to see if pExpr is a duplicate of another aggregate 
  3149.         ** function that is already in the pAggInfo structure
  3150.         */
  3151.         struct AggInfo_func *pItem = pAggInfo->aFunc;
  3152.         for(i=0; i<pAggInfo->nFunc; i++, pItem++){
  3153.           if( sqlite3ExprCompare(pItem->pExpr, pExpr) ){
  3154.             break;
  3155.           }
  3156.         }
  3157.         if( i>=pAggInfo->nFunc ){
  3158.           /* pExpr is original.  Make a new entry in pAggInfo->aFunc[]
  3159.           */
  3160.           u8 enc = ENC(pParse->db);
  3161.           i = addAggInfoFunc(pParse->db, pAggInfo);
  3162.           if( i>=0 ){
  3163.             pItem = &pAggInfo->aFunc[i];
  3164.             pItem->pExpr = pExpr;
  3165.             pItem->iMem = ++pParse->nMem;
  3166.             pItem->pFunc = sqlite3FindFunction(pParse->db,
  3167.                    (char*)pExpr->token.z, pExpr->token.n,
  3168.                    pExpr->pList ? pExpr->pList->nExpr : 0, enc, 0);
  3169.             if( pExpr->flags & EP_Distinct ){
  3170.               pItem->iDistinct = pParse->nTab++;
  3171.             }else{
  3172.               pItem->iDistinct = -1;
  3173.             }
  3174.           }
  3175.         }
  3176.         /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry
  3177.         */
  3178.         pExpr->iAgg = i;
  3179.         pExpr->pAggInfo = pAggInfo;
  3180.         return 1;
  3181.       }
  3182.     }
  3183.   }
  3184.   /* Recursively walk subqueries looking for TK_COLUMN nodes that need
  3185.   ** to be changed to TK_AGG_COLUMN.  But increment nDepth so that
  3186.   ** TK_AGG_FUNCTION nodes in subqueries will be unchanged.
  3187.   */
  3188.   if( pExpr->pSelect ){
  3189.     pNC->nDepth++;
  3190.     walkSelectExpr(pExpr->pSelect, analyzeAggregate, pNC);
  3191.     pNC->nDepth--;
  3192.   }
  3193.   return 0;
  3194. }
  3195. /*
  3196. ** Analyze the given expression looking for aggregate functions and
  3197. ** for variables that need to be added to the pParse->aAgg[] array.
  3198. ** Make additional entries to the pParse->aAgg[] array as necessary.
  3199. **
  3200. ** This routine should only be called after the expression has been
  3201. ** analyzed by sqlite3ExprResolveNames().
  3202. */
  3203. void sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){
  3204.   walkExprTree(pExpr, analyzeAggregate, pNC);
  3205. }
  3206. /*
  3207. ** Call sqlite3ExprAnalyzeAggregates() for every expression in an
  3208. ** expression list.  Return the number of errors.
  3209. **
  3210. ** If an error is found, the analysis is cut short.
  3211. */
  3212. void sqlite3ExprAnalyzeAggList(NameContext *pNC, ExprList *pList){
  3213.   struct ExprList_item *pItem;
  3214.   int i;
  3215.   if( pList ){
  3216.     for(pItem=pList->a, i=0; i<pList->nExpr; i++, pItem++){
  3217.       sqlite3ExprAnalyzeAggregates(pNC, pItem->pExpr);
  3218.     }
  3219.   }
  3220. }
  3221. /*
  3222. ** Allocate or deallocate temporary use registers during code generation.
  3223. */
  3224. int sqlite3GetTempReg(Parse *pParse){
  3225.   int i, r;
  3226.   if( pParse->nTempReg==0 ){
  3227.     return ++pParse->nMem;
  3228.   }
  3229.   for(i=0; i<pParse->nTempReg; i++){
  3230.     r = pParse->aTempReg[i];
  3231.     if( usedAsColumnCache(pParse, r, r) ) continue;
  3232.   }
  3233.   if( i>=pParse->nTempReg ){
  3234.     return ++pParse->nMem;
  3235.   }
  3236.   while( i<pParse->nTempReg-1 ){
  3237.     pParse->aTempReg[i] = pParse->aTempReg[i+1];
  3238.   }
  3239.   pParse->nTempReg--;
  3240.   return r;
  3241. }
  3242. void sqlite3ReleaseTempReg(Parse *pParse, int iReg){
  3243.   if( iReg && pParse->nTempReg<ArraySize(pParse->aTempReg) ){
  3244.     pParse->aTempReg[pParse->nTempReg++] = iReg;
  3245.   }
  3246. }
  3247. /*
  3248. ** Allocate or deallocate a block of nReg consecutive registers
  3249. */
  3250. int sqlite3GetTempRange(Parse *pParse, int nReg){
  3251.   int i, n;
  3252.   i = pParse->iRangeReg;
  3253.   n = pParse->nRangeReg;
  3254.   if( nReg<=n && !usedAsColumnCache(pParse, i, i+n-1) ){
  3255.     pParse->iRangeReg += nReg;
  3256.     pParse->nRangeReg -= nReg;
  3257.   }else{
  3258.     i = pParse->nMem+1;
  3259.     pParse->nMem += nReg;
  3260.   }
  3261.   return i;
  3262. }
  3263. void sqlite3ReleaseTempRange(Parse *pParse, int iReg, int nReg){
  3264.   if( nReg>pParse->nRangeReg ){
  3265.     pParse->nRangeReg = nReg;
  3266.     pParse->iRangeReg = iReg;
  3267.   }
  3268. }