Annotation of embedaddon/sqlite3/src/expr.c, revision 1.1

1.1     ! misho       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: #include "sqliteInt.h"
        !            16: 
        !            17: /*
        !            18: ** Return the 'affinity' of the expression pExpr if any.
        !            19: **
        !            20: ** If pExpr is a column, a reference to a column via an 'AS' alias,
        !            21: ** or a sub-select with a column as the return value, then the 
        !            22: ** affinity of that column is returned. Otherwise, 0x00 is returned,
        !            23: ** indicating no affinity for the expression.
        !            24: **
        !            25: ** i.e. the WHERE clause expresssions in the following statements all
        !            26: ** have an affinity:
        !            27: **
        !            28: ** CREATE TABLE t1(a);
        !            29: ** SELECT * FROM t1 WHERE a;
        !            30: ** SELECT a AS b FROM t1 WHERE b;
        !            31: ** SELECT * FROM t1 WHERE (select a from t1);
        !            32: */
        !            33: char sqlite3ExprAffinity(Expr *pExpr){
        !            34:   int op = pExpr->op;
        !            35:   if( op==TK_SELECT ){
        !            36:     assert( pExpr->flags&EP_xIsSelect );
        !            37:     return sqlite3ExprAffinity(pExpr->x.pSelect->pEList->a[0].pExpr);
        !            38:   }
        !            39: #ifndef SQLITE_OMIT_CAST
        !            40:   if( op==TK_CAST ){
        !            41:     assert( !ExprHasProperty(pExpr, EP_IntValue) );
        !            42:     return sqlite3AffinityType(pExpr->u.zToken);
        !            43:   }
        !            44: #endif
        !            45:   if( (op==TK_AGG_COLUMN || op==TK_COLUMN || op==TK_REGISTER) 
        !            46:    && pExpr->pTab!=0
        !            47:   ){
        !            48:     /* op==TK_REGISTER && pExpr->pTab!=0 happens when pExpr was originally
        !            49:     ** a TK_COLUMN but was previously evaluated and cached in a register */
        !            50:     int j = pExpr->iColumn;
        !            51:     if( j<0 ) return SQLITE_AFF_INTEGER;
        !            52:     assert( pExpr->pTab && j<pExpr->pTab->nCol );
        !            53:     return pExpr->pTab->aCol[j].affinity;
        !            54:   }
        !            55:   return pExpr->affinity;
        !            56: }
        !            57: 
        !            58: /*
        !            59: ** Set the explicit collating sequence for an expression to the
        !            60: ** collating sequence supplied in the second argument.
        !            61: */
        !            62: Expr *sqlite3ExprSetColl(Expr *pExpr, CollSeq *pColl){
        !            63:   if( pExpr && pColl ){
        !            64:     pExpr->pColl = pColl;
        !            65:     pExpr->flags |= EP_ExpCollate;
        !            66:   }
        !            67:   return pExpr;
        !            68: }
        !            69: 
        !            70: /*
        !            71: ** Set the collating sequence for expression pExpr to be the collating
        !            72: ** sequence named by pToken.   Return a pointer to the revised expression.
        !            73: ** The collating sequence is marked as "explicit" using the EP_ExpCollate
        !            74: ** flag.  An explicit collating sequence will override implicit
        !            75: ** collating sequences.
        !            76: */
        !            77: Expr *sqlite3ExprSetCollByToken(Parse *pParse, Expr *pExpr, Token *pCollName){
        !            78:   char *zColl = 0;            /* Dequoted name of collation sequence */
        !            79:   CollSeq *pColl;
        !            80:   sqlite3 *db = pParse->db;
        !            81:   zColl = sqlite3NameFromToken(db, pCollName);
        !            82:   pColl = sqlite3LocateCollSeq(pParse, zColl);
        !            83:   sqlite3ExprSetColl(pExpr, pColl);
        !            84:   sqlite3DbFree(db, zColl);
        !            85:   return pExpr;
        !            86: }
        !            87: 
        !            88: /*
        !            89: ** Return the default collation sequence for the expression pExpr. If
        !            90: ** there is no default collation type, return 0.
        !            91: */
        !            92: CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr){
        !            93:   CollSeq *pColl = 0;
        !            94:   Expr *p = pExpr;
        !            95:   while( p ){
        !            96:     int op;
        !            97:     pColl = p->pColl;
        !            98:     if( pColl ) break;
        !            99:     op = p->op;
        !           100:     if( p->pTab!=0 && (
        !           101:         op==TK_AGG_COLUMN || op==TK_COLUMN || op==TK_REGISTER || op==TK_TRIGGER
        !           102:     )){
        !           103:       /* op==TK_REGISTER && p->pTab!=0 happens when pExpr was originally
        !           104:       ** a TK_COLUMN but was previously evaluated and cached in a register */
        !           105:       const char *zColl;
        !           106:       int j = p->iColumn;
        !           107:       if( j>=0 ){
        !           108:         sqlite3 *db = pParse->db;
        !           109:         zColl = p->pTab->aCol[j].zColl;
        !           110:         pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0);
        !           111:         pExpr->pColl = pColl;
        !           112:       }
        !           113:       break;
        !           114:     }
        !           115:     if( op!=TK_CAST && op!=TK_UPLUS ){
        !           116:       break;
        !           117:     }
        !           118:     p = p->pLeft;
        !           119:   }
        !           120:   if( sqlite3CheckCollSeq(pParse, pColl) ){ 
        !           121:     pColl = 0;
        !           122:   }
        !           123:   return pColl;
        !           124: }
        !           125: 
        !           126: /*
        !           127: ** pExpr is an operand of a comparison operator.  aff2 is the
        !           128: ** type affinity of the other operand.  This routine returns the
        !           129: ** type affinity that should be used for the comparison operator.
        !           130: */
        !           131: char sqlite3CompareAffinity(Expr *pExpr, char aff2){
        !           132:   char aff1 = sqlite3ExprAffinity(pExpr);
        !           133:   if( aff1 && aff2 ){
        !           134:     /* Both sides of the comparison are columns. If one has numeric
        !           135:     ** affinity, use that. Otherwise use no affinity.
        !           136:     */
        !           137:     if( sqlite3IsNumericAffinity(aff1) || sqlite3IsNumericAffinity(aff2) ){
        !           138:       return SQLITE_AFF_NUMERIC;
        !           139:     }else{
        !           140:       return SQLITE_AFF_NONE;
        !           141:     }
        !           142:   }else if( !aff1 && !aff2 ){
        !           143:     /* Neither side of the comparison is a column.  Compare the
        !           144:     ** results directly.
        !           145:     */
        !           146:     return SQLITE_AFF_NONE;
        !           147:   }else{
        !           148:     /* One side is a column, the other is not. Use the columns affinity. */
        !           149:     assert( aff1==0 || aff2==0 );
        !           150:     return (aff1 + aff2);
        !           151:   }
        !           152: }
        !           153: 
        !           154: /*
        !           155: ** pExpr is a comparison operator.  Return the type affinity that should
        !           156: ** be applied to both operands prior to doing the comparison.
        !           157: */
        !           158: static char comparisonAffinity(Expr *pExpr){
        !           159:   char aff;
        !           160:   assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT ||
        !           161:           pExpr->op==TK_GT || pExpr->op==TK_GE || pExpr->op==TK_LE ||
        !           162:           pExpr->op==TK_NE || pExpr->op==TK_IS || pExpr->op==TK_ISNOT );
        !           163:   assert( pExpr->pLeft );
        !           164:   aff = sqlite3ExprAffinity(pExpr->pLeft);
        !           165:   if( pExpr->pRight ){
        !           166:     aff = sqlite3CompareAffinity(pExpr->pRight, aff);
        !           167:   }else if( ExprHasProperty(pExpr, EP_xIsSelect) ){
        !           168:     aff = sqlite3CompareAffinity(pExpr->x.pSelect->pEList->a[0].pExpr, aff);
        !           169:   }else if( !aff ){
        !           170:     aff = SQLITE_AFF_NONE;
        !           171:   }
        !           172:   return aff;
        !           173: }
        !           174: 
        !           175: /*
        !           176: ** pExpr is a comparison expression, eg. '=', '<', IN(...) etc.
        !           177: ** idx_affinity is the affinity of an indexed column. Return true
        !           178: ** if the index with affinity idx_affinity may be used to implement
        !           179: ** the comparison in pExpr.
        !           180: */
        !           181: int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity){
        !           182:   char aff = comparisonAffinity(pExpr);
        !           183:   switch( aff ){
        !           184:     case SQLITE_AFF_NONE:
        !           185:       return 1;
        !           186:     case SQLITE_AFF_TEXT:
        !           187:       return idx_affinity==SQLITE_AFF_TEXT;
        !           188:     default:
        !           189:       return sqlite3IsNumericAffinity(idx_affinity);
        !           190:   }
        !           191: }
        !           192: 
        !           193: /*
        !           194: ** Return the P5 value that should be used for a binary comparison
        !           195: ** opcode (OP_Eq, OP_Ge etc.) used to compare pExpr1 and pExpr2.
        !           196: */
        !           197: static u8 binaryCompareP5(Expr *pExpr1, Expr *pExpr2, int jumpIfNull){
        !           198:   u8 aff = (char)sqlite3ExprAffinity(pExpr2);
        !           199:   aff = (u8)sqlite3CompareAffinity(pExpr1, aff) | (u8)jumpIfNull;
        !           200:   return aff;
        !           201: }
        !           202: 
        !           203: /*
        !           204: ** Return a pointer to the collation sequence that should be used by
        !           205: ** a binary comparison operator comparing pLeft and pRight.
        !           206: **
        !           207: ** If the left hand expression has a collating sequence type, then it is
        !           208: ** used. Otherwise the collation sequence for the right hand expression
        !           209: ** is used, or the default (BINARY) if neither expression has a collating
        !           210: ** type.
        !           211: **
        !           212: ** Argument pRight (but not pLeft) may be a null pointer. In this case,
        !           213: ** it is not considered.
        !           214: */
        !           215: CollSeq *sqlite3BinaryCompareCollSeq(
        !           216:   Parse *pParse, 
        !           217:   Expr *pLeft, 
        !           218:   Expr *pRight
        !           219: ){
        !           220:   CollSeq *pColl;
        !           221:   assert( pLeft );
        !           222:   if( pLeft->flags & EP_ExpCollate ){
        !           223:     assert( pLeft->pColl );
        !           224:     pColl = pLeft->pColl;
        !           225:   }else if( pRight && pRight->flags & EP_ExpCollate ){
        !           226:     assert( pRight->pColl );
        !           227:     pColl = pRight->pColl;
        !           228:   }else{
        !           229:     pColl = sqlite3ExprCollSeq(pParse, pLeft);
        !           230:     if( !pColl ){
        !           231:       pColl = sqlite3ExprCollSeq(pParse, pRight);
        !           232:     }
        !           233:   }
        !           234:   return pColl;
        !           235: }
        !           236: 
        !           237: /*
        !           238: ** Generate code for a comparison operator.
        !           239: */
        !           240: static int codeCompare(
        !           241:   Parse *pParse,    /* The parsing (and code generating) context */
        !           242:   Expr *pLeft,      /* The left operand */
        !           243:   Expr *pRight,     /* The right operand */
        !           244:   int opcode,       /* The comparison opcode */
        !           245:   int in1, int in2, /* Register holding operands */
        !           246:   int dest,         /* Jump here if true.  */
        !           247:   int jumpIfNull    /* If true, jump if either operand is NULL */
        !           248: ){
        !           249:   int p5;
        !           250:   int addr;
        !           251:   CollSeq *p4;
        !           252: 
        !           253:   p4 = sqlite3BinaryCompareCollSeq(pParse, pLeft, pRight);
        !           254:   p5 = binaryCompareP5(pLeft, pRight, jumpIfNull);
        !           255:   addr = sqlite3VdbeAddOp4(pParse->pVdbe, opcode, in2, dest, in1,
        !           256:                            (void*)p4, P4_COLLSEQ);
        !           257:   sqlite3VdbeChangeP5(pParse->pVdbe, (u8)p5);
        !           258:   return addr;
        !           259: }
        !           260: 
        !           261: #if SQLITE_MAX_EXPR_DEPTH>0
        !           262: /*
        !           263: ** Check that argument nHeight is less than or equal to the maximum
        !           264: ** expression depth allowed. If it is not, leave an error message in
        !           265: ** pParse.
        !           266: */
        !           267: int sqlite3ExprCheckHeight(Parse *pParse, int nHeight){
        !           268:   int rc = SQLITE_OK;
        !           269:   int mxHeight = pParse->db->aLimit[SQLITE_LIMIT_EXPR_DEPTH];
        !           270:   if( nHeight>mxHeight ){
        !           271:     sqlite3ErrorMsg(pParse, 
        !           272:        "Expression tree is too large (maximum depth %d)", mxHeight
        !           273:     );
        !           274:     rc = SQLITE_ERROR;
        !           275:   }
        !           276:   return rc;
        !           277: }
        !           278: 
        !           279: /* The following three functions, heightOfExpr(), heightOfExprList()
        !           280: ** and heightOfSelect(), are used to determine the maximum height
        !           281: ** of any expression tree referenced by the structure passed as the
        !           282: ** first argument.
        !           283: **
        !           284: ** If this maximum height is greater than the current value pointed
        !           285: ** to by pnHeight, the second parameter, then set *pnHeight to that
        !           286: ** value.
        !           287: */
        !           288: static void heightOfExpr(Expr *p, int *pnHeight){
        !           289:   if( p ){
        !           290:     if( p->nHeight>*pnHeight ){
        !           291:       *pnHeight = p->nHeight;
        !           292:     }
        !           293:   }
        !           294: }
        !           295: static void heightOfExprList(ExprList *p, int *pnHeight){
        !           296:   if( p ){
        !           297:     int i;
        !           298:     for(i=0; i<p->nExpr; i++){
        !           299:       heightOfExpr(p->a[i].pExpr, pnHeight);
        !           300:     }
        !           301:   }
        !           302: }
        !           303: static void heightOfSelect(Select *p, int *pnHeight){
        !           304:   if( p ){
        !           305:     heightOfExpr(p->pWhere, pnHeight);
        !           306:     heightOfExpr(p->pHaving, pnHeight);
        !           307:     heightOfExpr(p->pLimit, pnHeight);
        !           308:     heightOfExpr(p->pOffset, pnHeight);
        !           309:     heightOfExprList(p->pEList, pnHeight);
        !           310:     heightOfExprList(p->pGroupBy, pnHeight);
        !           311:     heightOfExprList(p->pOrderBy, pnHeight);
        !           312:     heightOfSelect(p->pPrior, pnHeight);
        !           313:   }
        !           314: }
        !           315: 
        !           316: /*
        !           317: ** Set the Expr.nHeight variable in the structure passed as an 
        !           318: ** argument. An expression with no children, Expr.pList or 
        !           319: ** Expr.pSelect member has a height of 1. Any other expression
        !           320: ** has a height equal to the maximum height of any other 
        !           321: ** referenced Expr plus one.
        !           322: */
        !           323: static void exprSetHeight(Expr *p){
        !           324:   int nHeight = 0;
        !           325:   heightOfExpr(p->pLeft, &nHeight);
        !           326:   heightOfExpr(p->pRight, &nHeight);
        !           327:   if( ExprHasProperty(p, EP_xIsSelect) ){
        !           328:     heightOfSelect(p->x.pSelect, &nHeight);
        !           329:   }else{
        !           330:     heightOfExprList(p->x.pList, &nHeight);
        !           331:   }
        !           332:   p->nHeight = nHeight + 1;
        !           333: }
        !           334: 
        !           335: /*
        !           336: ** Set the Expr.nHeight variable using the exprSetHeight() function. If
        !           337: ** the height is greater than the maximum allowed expression depth,
        !           338: ** leave an error in pParse.
        !           339: */
        !           340: void sqlite3ExprSetHeight(Parse *pParse, Expr *p){
        !           341:   exprSetHeight(p);
        !           342:   sqlite3ExprCheckHeight(pParse, p->nHeight);
        !           343: }
        !           344: 
        !           345: /*
        !           346: ** Return the maximum height of any expression tree referenced
        !           347: ** by the select statement passed as an argument.
        !           348: */
        !           349: int sqlite3SelectExprHeight(Select *p){
        !           350:   int nHeight = 0;
        !           351:   heightOfSelect(p, &nHeight);
        !           352:   return nHeight;
        !           353: }
        !           354: #else
        !           355:   #define exprSetHeight(y)
        !           356: #endif /* SQLITE_MAX_EXPR_DEPTH>0 */
        !           357: 
        !           358: /*
        !           359: ** This routine is the core allocator for Expr nodes.
        !           360: **
        !           361: ** Construct a new expression node and return a pointer to it.  Memory
        !           362: ** for this node and for the pToken argument is a single allocation
        !           363: ** obtained from sqlite3DbMalloc().  The calling function
        !           364: ** is responsible for making sure the node eventually gets freed.
        !           365: **
        !           366: ** If dequote is true, then the token (if it exists) is dequoted.
        !           367: ** If dequote is false, no dequoting is performance.  The deQuote
        !           368: ** parameter is ignored if pToken is NULL or if the token does not
        !           369: ** appear to be quoted.  If the quotes were of the form "..." (double-quotes)
        !           370: ** then the EP_DblQuoted flag is set on the expression node.
        !           371: **
        !           372: ** Special case:  If op==TK_INTEGER and pToken points to a string that
        !           373: ** can be translated into a 32-bit integer, then the token is not
        !           374: ** stored in u.zToken.  Instead, the integer values is written
        !           375: ** into u.iValue and the EP_IntValue flag is set.  No extra storage
        !           376: ** is allocated to hold the integer text and the dequote flag is ignored.
        !           377: */
        !           378: Expr *sqlite3ExprAlloc(
        !           379:   sqlite3 *db,            /* Handle for sqlite3DbMallocZero() (may be null) */
        !           380:   int op,                 /* Expression opcode */
        !           381:   const Token *pToken,    /* Token argument.  Might be NULL */
        !           382:   int dequote             /* True to dequote */
        !           383: ){
        !           384:   Expr *pNew;
        !           385:   int nExtra = 0;
        !           386:   int iValue = 0;
        !           387: 
        !           388:   if( pToken ){
        !           389:     if( op!=TK_INTEGER || pToken->z==0
        !           390:           || sqlite3GetInt32(pToken->z, &iValue)==0 ){
        !           391:       nExtra = pToken->n+1;
        !           392:       assert( iValue>=0 );
        !           393:     }
        !           394:   }
        !           395:   pNew = sqlite3DbMallocZero(db, sizeof(Expr)+nExtra);
        !           396:   if( pNew ){
        !           397:     pNew->op = (u8)op;
        !           398:     pNew->iAgg = -1;
        !           399:     if( pToken ){
        !           400:       if( nExtra==0 ){
        !           401:         pNew->flags |= EP_IntValue;
        !           402:         pNew->u.iValue = iValue;
        !           403:       }else{
        !           404:         int c;
        !           405:         pNew->u.zToken = (char*)&pNew[1];
        !           406:         assert( pToken->z!=0 || pToken->n==0 );
        !           407:         if( pToken->n ) memcpy(pNew->u.zToken, pToken->z, pToken->n);
        !           408:         pNew->u.zToken[pToken->n] = 0;
        !           409:         if( dequote && nExtra>=3 
        !           410:              && ((c = pToken->z[0])=='\'' || c=='"' || c=='[' || c=='`') ){
        !           411:           sqlite3Dequote(pNew->u.zToken);
        !           412:           if( c=='"' ) pNew->flags |= EP_DblQuoted;
        !           413:         }
        !           414:       }
        !           415:     }
        !           416: #if SQLITE_MAX_EXPR_DEPTH>0
        !           417:     pNew->nHeight = 1;
        !           418: #endif  
        !           419:   }
        !           420:   return pNew;
        !           421: }
        !           422: 
        !           423: /*
        !           424: ** Allocate a new expression node from a zero-terminated token that has
        !           425: ** already been dequoted.
        !           426: */
        !           427: Expr *sqlite3Expr(
        !           428:   sqlite3 *db,            /* Handle for sqlite3DbMallocZero() (may be null) */
        !           429:   int op,                 /* Expression opcode */
        !           430:   const char *zToken      /* Token argument.  Might be NULL */
        !           431: ){
        !           432:   Token x;
        !           433:   x.z = zToken;
        !           434:   x.n = zToken ? sqlite3Strlen30(zToken) : 0;
        !           435:   return sqlite3ExprAlloc(db, op, &x, 0);
        !           436: }
        !           437: 
        !           438: /*
        !           439: ** Attach subtrees pLeft and pRight to the Expr node pRoot.
        !           440: **
        !           441: ** If pRoot==NULL that means that a memory allocation error has occurred.
        !           442: ** In that case, delete the subtrees pLeft and pRight.
        !           443: */
        !           444: void sqlite3ExprAttachSubtrees(
        !           445:   sqlite3 *db,
        !           446:   Expr *pRoot,
        !           447:   Expr *pLeft,
        !           448:   Expr *pRight
        !           449: ){
        !           450:   if( pRoot==0 ){
        !           451:     assert( db->mallocFailed );
        !           452:     sqlite3ExprDelete(db, pLeft);
        !           453:     sqlite3ExprDelete(db, pRight);
        !           454:   }else{
        !           455:     if( pRight ){
        !           456:       pRoot->pRight = pRight;
        !           457:       if( pRight->flags & EP_ExpCollate ){
        !           458:         pRoot->flags |= EP_ExpCollate;
        !           459:         pRoot->pColl = pRight->pColl;
        !           460:       }
        !           461:     }
        !           462:     if( pLeft ){
        !           463:       pRoot->pLeft = pLeft;
        !           464:       if( pLeft->flags & EP_ExpCollate ){
        !           465:         pRoot->flags |= EP_ExpCollate;
        !           466:         pRoot->pColl = pLeft->pColl;
        !           467:       }
        !           468:     }
        !           469:     exprSetHeight(pRoot);
        !           470:   }
        !           471: }
        !           472: 
        !           473: /*
        !           474: ** Allocate a Expr node which joins as many as two subtrees.
        !           475: **
        !           476: ** One or both of the subtrees can be NULL.  Return a pointer to the new
        !           477: ** Expr node.  Or, if an OOM error occurs, set pParse->db->mallocFailed,
        !           478: ** free the subtrees and return NULL.
        !           479: */
        !           480: Expr *sqlite3PExpr(
        !           481:   Parse *pParse,          /* Parsing context */
        !           482:   int op,                 /* Expression opcode */
        !           483:   Expr *pLeft,            /* Left operand */
        !           484:   Expr *pRight,           /* Right operand */
        !           485:   const Token *pToken     /* Argument token */
        !           486: ){
        !           487:   Expr *p = sqlite3ExprAlloc(pParse->db, op, pToken, 1);
        !           488:   sqlite3ExprAttachSubtrees(pParse->db, p, pLeft, pRight);
        !           489:   if( p ) {
        !           490:     sqlite3ExprCheckHeight(pParse, p->nHeight);
        !           491:   }
        !           492:   return p;
        !           493: }
        !           494: 
        !           495: /*
        !           496: ** Join two expressions using an AND operator.  If either expression is
        !           497: ** NULL, then just return the other expression.
        !           498: */
        !           499: Expr *sqlite3ExprAnd(sqlite3 *db, Expr *pLeft, Expr *pRight){
        !           500:   if( pLeft==0 ){
        !           501:     return pRight;
        !           502:   }else if( pRight==0 ){
        !           503:     return pLeft;
        !           504:   }else{
        !           505:     Expr *pNew = sqlite3ExprAlloc(db, TK_AND, 0, 0);
        !           506:     sqlite3ExprAttachSubtrees(db, pNew, pLeft, pRight);
        !           507:     return pNew;
        !           508:   }
        !           509: }
        !           510: 
        !           511: /*
        !           512: ** Construct a new expression node for a function with multiple
        !           513: ** arguments.
        !           514: */
        !           515: Expr *sqlite3ExprFunction(Parse *pParse, ExprList *pList, Token *pToken){
        !           516:   Expr *pNew;
        !           517:   sqlite3 *db = pParse->db;
        !           518:   assert( pToken );
        !           519:   pNew = sqlite3ExprAlloc(db, TK_FUNCTION, pToken, 1);
        !           520:   if( pNew==0 ){
        !           521:     sqlite3ExprListDelete(db, pList); /* Avoid memory leak when malloc fails */
        !           522:     return 0;
        !           523:   }
        !           524:   pNew->x.pList = pList;
        !           525:   assert( !ExprHasProperty(pNew, EP_xIsSelect) );
        !           526:   sqlite3ExprSetHeight(pParse, pNew);
        !           527:   return pNew;
        !           528: }
        !           529: 
        !           530: /*
        !           531: ** Assign a variable number to an expression that encodes a wildcard
        !           532: ** in the original SQL statement.  
        !           533: **
        !           534: ** Wildcards consisting of a single "?" are assigned the next sequential
        !           535: ** variable number.
        !           536: **
        !           537: ** Wildcards of the form "?nnn" are assigned the number "nnn".  We make
        !           538: ** sure "nnn" is not too be to avoid a denial of service attack when
        !           539: ** the SQL statement comes from an external source.
        !           540: **
        !           541: ** Wildcards of the form ":aaa", "@aaa", or "$aaa" are assigned the same number
        !           542: ** as the previous instance of the same wildcard.  Or if this is the first
        !           543: ** instance of the wildcard, the next sequenial variable number is
        !           544: ** assigned.
        !           545: */
        !           546: void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr){
        !           547:   sqlite3 *db = pParse->db;
        !           548:   const char *z;
        !           549: 
        !           550:   if( pExpr==0 ) return;
        !           551:   assert( !ExprHasAnyProperty(pExpr, EP_IntValue|EP_Reduced|EP_TokenOnly) );
        !           552:   z = pExpr->u.zToken;
        !           553:   assert( z!=0 );
        !           554:   assert( z[0]!=0 );
        !           555:   if( z[1]==0 ){
        !           556:     /* Wildcard of the form "?".  Assign the next variable number */
        !           557:     assert( z[0]=='?' );
        !           558:     pExpr->iColumn = (ynVar)(++pParse->nVar);
        !           559:   }else{
        !           560:     ynVar x = 0;
        !           561:     u32 n = sqlite3Strlen30(z);
        !           562:     if( z[0]=='?' ){
        !           563:       /* Wildcard of the form "?nnn".  Convert "nnn" to an integer and
        !           564:       ** use it as the variable number */
        !           565:       i64 i;
        !           566:       int bOk = 0==sqlite3Atoi64(&z[1], &i, n-1, SQLITE_UTF8);
        !           567:       pExpr->iColumn = x = (ynVar)i;
        !           568:       testcase( i==0 );
        !           569:       testcase( i==1 );
        !           570:       testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]-1 );
        !           571:       testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] );
        !           572:       if( bOk==0 || i<1 || i>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){
        !           573:         sqlite3ErrorMsg(pParse, "variable number must be between ?1 and ?%d",
        !           574:             db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]);
        !           575:         x = 0;
        !           576:       }
        !           577:       if( i>pParse->nVar ){
        !           578:         pParse->nVar = (int)i;
        !           579:       }
        !           580:     }else{
        !           581:       /* Wildcards like ":aaa", "$aaa" or "@aaa".  Reuse the same variable
        !           582:       ** number as the prior appearance of the same name, or if the name
        !           583:       ** has never appeared before, reuse the same variable number
        !           584:       */
        !           585:       ynVar i;
        !           586:       for(i=0; i<pParse->nzVar; i++){
        !           587:         if( pParse->azVar[i] && memcmp(pParse->azVar[i],z,n+1)==0 ){
        !           588:           pExpr->iColumn = x = (ynVar)i+1;
        !           589:           break;
        !           590:         }
        !           591:       }
        !           592:       if( x==0 ) x = pExpr->iColumn = (ynVar)(++pParse->nVar);
        !           593:     }
        !           594:     if( x>0 ){
        !           595:       if( x>pParse->nzVar ){
        !           596:         char **a;
        !           597:         a = sqlite3DbRealloc(db, pParse->azVar, x*sizeof(a[0]));
        !           598:         if( a==0 ) return;  /* Error reported through db->mallocFailed */
        !           599:         pParse->azVar = a;
        !           600:         memset(&a[pParse->nzVar], 0, (x-pParse->nzVar)*sizeof(a[0]));
        !           601:         pParse->nzVar = x;
        !           602:       }
        !           603:       if( z[0]!='?' || pParse->azVar[x-1]==0 ){
        !           604:         sqlite3DbFree(db, pParse->azVar[x-1]);
        !           605:         pParse->azVar[x-1] = sqlite3DbStrNDup(db, z, n);
        !           606:       }
        !           607:     }
        !           608:   } 
        !           609:   if( !pParse->nErr && pParse->nVar>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){
        !           610:     sqlite3ErrorMsg(pParse, "too many SQL variables");
        !           611:   }
        !           612: }
        !           613: 
        !           614: /*
        !           615: ** Recursively delete an expression tree.
        !           616: */
        !           617: void sqlite3ExprDelete(sqlite3 *db, Expr *p){
        !           618:   if( p==0 ) return;
        !           619:   /* Sanity check: Assert that the IntValue is non-negative if it exists */
        !           620:   assert( !ExprHasProperty(p, EP_IntValue) || p->u.iValue>=0 );
        !           621:   if( !ExprHasAnyProperty(p, EP_TokenOnly) ){
        !           622:     sqlite3ExprDelete(db, p->pLeft);
        !           623:     sqlite3ExprDelete(db, p->pRight);
        !           624:     if( !ExprHasProperty(p, EP_Reduced) && (p->flags2 & EP2_MallocedToken)!=0 ){
        !           625:       sqlite3DbFree(db, p->u.zToken);
        !           626:     }
        !           627:     if( ExprHasProperty(p, EP_xIsSelect) ){
        !           628:       sqlite3SelectDelete(db, p->x.pSelect);
        !           629:     }else{
        !           630:       sqlite3ExprListDelete(db, p->x.pList);
        !           631:     }
        !           632:   }
        !           633:   if( !ExprHasProperty(p, EP_Static) ){
        !           634:     sqlite3DbFree(db, p);
        !           635:   }
        !           636: }
        !           637: 
        !           638: /*
        !           639: ** Return the number of bytes allocated for the expression structure 
        !           640: ** passed as the first argument. This is always one of EXPR_FULLSIZE,
        !           641: ** EXPR_REDUCEDSIZE or EXPR_TOKENONLYSIZE.
        !           642: */
        !           643: static int exprStructSize(Expr *p){
        !           644:   if( ExprHasProperty(p, EP_TokenOnly) ) return EXPR_TOKENONLYSIZE;
        !           645:   if( ExprHasProperty(p, EP_Reduced) ) return EXPR_REDUCEDSIZE;
        !           646:   return EXPR_FULLSIZE;
        !           647: }
        !           648: 
        !           649: /*
        !           650: ** The dupedExpr*Size() routines each return the number of bytes required
        !           651: ** to store a copy of an expression or expression tree.  They differ in
        !           652: ** how much of the tree is measured.
        !           653: **
        !           654: **     dupedExprStructSize()     Size of only the Expr structure 
        !           655: **     dupedExprNodeSize()       Size of Expr + space for token
        !           656: **     dupedExprSize()           Expr + token + subtree components
        !           657: **
        !           658: ***************************************************************************
        !           659: **
        !           660: ** The dupedExprStructSize() function returns two values OR-ed together:  
        !           661: ** (1) the space required for a copy of the Expr structure only and 
        !           662: ** (2) the EP_xxx flags that indicate what the structure size should be.
        !           663: ** The return values is always one of:
        !           664: **
        !           665: **      EXPR_FULLSIZE
        !           666: **      EXPR_REDUCEDSIZE   | EP_Reduced
        !           667: **      EXPR_TOKENONLYSIZE | EP_TokenOnly
        !           668: **
        !           669: ** The size of the structure can be found by masking the return value
        !           670: ** of this routine with 0xfff.  The flags can be found by masking the
        !           671: ** return value with EP_Reduced|EP_TokenOnly.
        !           672: **
        !           673: ** Note that with flags==EXPRDUP_REDUCE, this routines works on full-size
        !           674: ** (unreduced) Expr objects as they or originally constructed by the parser.
        !           675: ** During expression analysis, extra information is computed and moved into
        !           676: ** later parts of teh Expr object and that extra information might get chopped
        !           677: ** off if the expression is reduced.  Note also that it does not work to
        !           678: ** make a EXPRDUP_REDUCE copy of a reduced expression.  It is only legal
        !           679: ** to reduce a pristine expression tree from the parser.  The implementation
        !           680: ** of dupedExprStructSize() contain multiple assert() statements that attempt
        !           681: ** to enforce this constraint.
        !           682: */
        !           683: static int dupedExprStructSize(Expr *p, int flags){
        !           684:   int nSize;
        !           685:   assert( flags==EXPRDUP_REDUCE || flags==0 ); /* Only one flag value allowed */
        !           686:   if( 0==(flags&EXPRDUP_REDUCE) ){
        !           687:     nSize = EXPR_FULLSIZE;
        !           688:   }else{
        !           689:     assert( !ExprHasAnyProperty(p, EP_TokenOnly|EP_Reduced) );
        !           690:     assert( !ExprHasProperty(p, EP_FromJoin) ); 
        !           691:     assert( (p->flags2 & EP2_MallocedToken)==0 );
        !           692:     assert( (p->flags2 & EP2_Irreducible)==0 );
        !           693:     if( p->pLeft || p->pRight || p->pColl || p->x.pList ){
        !           694:       nSize = EXPR_REDUCEDSIZE | EP_Reduced;
        !           695:     }else{
        !           696:       nSize = EXPR_TOKENONLYSIZE | EP_TokenOnly;
        !           697:     }
        !           698:   }
        !           699:   return nSize;
        !           700: }
        !           701: 
        !           702: /*
        !           703: ** This function returns the space in bytes required to store the copy 
        !           704: ** of the Expr structure and a copy of the Expr.u.zToken string (if that
        !           705: ** string is defined.)
        !           706: */
        !           707: static int dupedExprNodeSize(Expr *p, int flags){
        !           708:   int nByte = dupedExprStructSize(p, flags) & 0xfff;
        !           709:   if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){
        !           710:     nByte += sqlite3Strlen30(p->u.zToken)+1;
        !           711:   }
        !           712:   return ROUND8(nByte);
        !           713: }
        !           714: 
        !           715: /*
        !           716: ** Return the number of bytes required to create a duplicate of the 
        !           717: ** expression passed as the first argument. The second argument is a
        !           718: ** mask containing EXPRDUP_XXX flags.
        !           719: **
        !           720: ** The value returned includes space to create a copy of the Expr struct
        !           721: ** itself and the buffer referred to by Expr.u.zToken, if any.
        !           722: **
        !           723: ** If the EXPRDUP_REDUCE flag is set, then the return value includes 
        !           724: ** space to duplicate all Expr nodes in the tree formed by Expr.pLeft 
        !           725: ** and Expr.pRight variables (but not for any structures pointed to or 
        !           726: ** descended from the Expr.x.pList or Expr.x.pSelect variables).
        !           727: */
        !           728: static int dupedExprSize(Expr *p, int flags){
        !           729:   int nByte = 0;
        !           730:   if( p ){
        !           731:     nByte = dupedExprNodeSize(p, flags);
        !           732:     if( flags&EXPRDUP_REDUCE ){
        !           733:       nByte += dupedExprSize(p->pLeft, flags) + dupedExprSize(p->pRight, flags);
        !           734:     }
        !           735:   }
        !           736:   return nByte;
        !           737: }
        !           738: 
        !           739: /*
        !           740: ** This function is similar to sqlite3ExprDup(), except that if pzBuffer 
        !           741: ** is not NULL then *pzBuffer is assumed to point to a buffer large enough 
        !           742: ** to store the copy of expression p, the copies of p->u.zToken
        !           743: ** (if applicable), and the copies of the p->pLeft and p->pRight expressions,
        !           744: ** if any. Before returning, *pzBuffer is set to the first byte passed the
        !           745: ** portion of the buffer copied into by this function.
        !           746: */
        !           747: static Expr *exprDup(sqlite3 *db, Expr *p, int flags, u8 **pzBuffer){
        !           748:   Expr *pNew = 0;                      /* Value to return */
        !           749:   if( p ){
        !           750:     const int isReduced = (flags&EXPRDUP_REDUCE);
        !           751:     u8 *zAlloc;
        !           752:     u32 staticFlag = 0;
        !           753: 
        !           754:     assert( pzBuffer==0 || isReduced );
        !           755: 
        !           756:     /* Figure out where to write the new Expr structure. */
        !           757:     if( pzBuffer ){
        !           758:       zAlloc = *pzBuffer;
        !           759:       staticFlag = EP_Static;
        !           760:     }else{
        !           761:       zAlloc = sqlite3DbMallocRaw(db, dupedExprSize(p, flags));
        !           762:     }
        !           763:     pNew = (Expr *)zAlloc;
        !           764: 
        !           765:     if( pNew ){
        !           766:       /* Set nNewSize to the size allocated for the structure pointed to
        !           767:       ** by pNew. This is either EXPR_FULLSIZE, EXPR_REDUCEDSIZE or
        !           768:       ** EXPR_TOKENONLYSIZE. nToken is set to the number of bytes consumed
        !           769:       ** by the copy of the p->u.zToken string (if any).
        !           770:       */
        !           771:       const unsigned nStructSize = dupedExprStructSize(p, flags);
        !           772:       const int nNewSize = nStructSize & 0xfff;
        !           773:       int nToken;
        !           774:       if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){
        !           775:         nToken = sqlite3Strlen30(p->u.zToken) + 1;
        !           776:       }else{
        !           777:         nToken = 0;
        !           778:       }
        !           779:       if( isReduced ){
        !           780:         assert( ExprHasProperty(p, EP_Reduced)==0 );
        !           781:         memcpy(zAlloc, p, nNewSize);
        !           782:       }else{
        !           783:         int nSize = exprStructSize(p);
        !           784:         memcpy(zAlloc, p, nSize);
        !           785:         memset(&zAlloc[nSize], 0, EXPR_FULLSIZE-nSize);
        !           786:       }
        !           787: 
        !           788:       /* Set the EP_Reduced, EP_TokenOnly, and EP_Static flags appropriately. */
        !           789:       pNew->flags &= ~(EP_Reduced|EP_TokenOnly|EP_Static);
        !           790:       pNew->flags |= nStructSize & (EP_Reduced|EP_TokenOnly);
        !           791:       pNew->flags |= staticFlag;
        !           792: 
        !           793:       /* Copy the p->u.zToken string, if any. */
        !           794:       if( nToken ){
        !           795:         char *zToken = pNew->u.zToken = (char*)&zAlloc[nNewSize];
        !           796:         memcpy(zToken, p->u.zToken, nToken);
        !           797:       }
        !           798: 
        !           799:       if( 0==((p->flags|pNew->flags) & EP_TokenOnly) ){
        !           800:         /* Fill in the pNew->x.pSelect or pNew->x.pList member. */
        !           801:         if( ExprHasProperty(p, EP_xIsSelect) ){
        !           802:           pNew->x.pSelect = sqlite3SelectDup(db, p->x.pSelect, isReduced);
        !           803:         }else{
        !           804:           pNew->x.pList = sqlite3ExprListDup(db, p->x.pList, isReduced);
        !           805:         }
        !           806:       }
        !           807: 
        !           808:       /* Fill in pNew->pLeft and pNew->pRight. */
        !           809:       if( ExprHasAnyProperty(pNew, EP_Reduced|EP_TokenOnly) ){
        !           810:         zAlloc += dupedExprNodeSize(p, flags);
        !           811:         if( ExprHasProperty(pNew, EP_Reduced) ){
        !           812:           pNew->pLeft = exprDup(db, p->pLeft, EXPRDUP_REDUCE, &zAlloc);
        !           813:           pNew->pRight = exprDup(db, p->pRight, EXPRDUP_REDUCE, &zAlloc);
        !           814:         }
        !           815:         if( pzBuffer ){
        !           816:           *pzBuffer = zAlloc;
        !           817:         }
        !           818:       }else{
        !           819:         pNew->flags2 = 0;
        !           820:         if( !ExprHasAnyProperty(p, EP_TokenOnly) ){
        !           821:           pNew->pLeft = sqlite3ExprDup(db, p->pLeft, 0);
        !           822:           pNew->pRight = sqlite3ExprDup(db, p->pRight, 0);
        !           823:         }
        !           824:       }
        !           825: 
        !           826:     }
        !           827:   }
        !           828:   return pNew;
        !           829: }
        !           830: 
        !           831: /*
        !           832: ** The following group of routines make deep copies of expressions,
        !           833: ** expression lists, ID lists, and select statements.  The copies can
        !           834: ** be deleted (by being passed to their respective ...Delete() routines)
        !           835: ** without effecting the originals.
        !           836: **
        !           837: ** The expression list, ID, and source lists return by sqlite3ExprListDup(),
        !           838: ** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded 
        !           839: ** by subsequent calls to sqlite*ListAppend() routines.
        !           840: **
        !           841: ** Any tables that the SrcList might point to are not duplicated.
        !           842: **
        !           843: ** The flags parameter contains a combination of the EXPRDUP_XXX flags.
        !           844: ** If the EXPRDUP_REDUCE flag is set, then the structure returned is a
        !           845: ** truncated version of the usual Expr structure that will be stored as
        !           846: ** part of the in-memory representation of the database schema.
        !           847: */
        !           848: Expr *sqlite3ExprDup(sqlite3 *db, Expr *p, int flags){
        !           849:   return exprDup(db, p, flags, 0);
        !           850: }
        !           851: ExprList *sqlite3ExprListDup(sqlite3 *db, ExprList *p, int flags){
        !           852:   ExprList *pNew;
        !           853:   struct ExprList_item *pItem, *pOldItem;
        !           854:   int i;
        !           855:   if( p==0 ) return 0;
        !           856:   pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
        !           857:   if( pNew==0 ) return 0;
        !           858:   pNew->iECursor = 0;
        !           859:   pNew->nExpr = pNew->nAlloc = p->nExpr;
        !           860:   pNew->a = pItem = sqlite3DbMallocRaw(db,  p->nExpr*sizeof(p->a[0]) );
        !           861:   if( pItem==0 ){
        !           862:     sqlite3DbFree(db, pNew);
        !           863:     return 0;
        !           864:   } 
        !           865:   pOldItem = p->a;
        !           866:   for(i=0; i<p->nExpr; i++, pItem++, pOldItem++){
        !           867:     Expr *pOldExpr = pOldItem->pExpr;
        !           868:     pItem->pExpr = sqlite3ExprDup(db, pOldExpr, flags);
        !           869:     pItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
        !           870:     pItem->zSpan = sqlite3DbStrDup(db, pOldItem->zSpan);
        !           871:     pItem->sortOrder = pOldItem->sortOrder;
        !           872:     pItem->done = 0;
        !           873:     pItem->iOrderByCol = pOldItem->iOrderByCol;
        !           874:     pItem->iAlias = pOldItem->iAlias;
        !           875:   }
        !           876:   return pNew;
        !           877: }
        !           878: 
        !           879: /*
        !           880: ** If cursors, triggers, views and subqueries are all omitted from
        !           881: ** the build, then none of the following routines, except for 
        !           882: ** sqlite3SelectDup(), can be called. sqlite3SelectDup() is sometimes
        !           883: ** called with a NULL argument.
        !           884: */
        !           885: #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) \
        !           886:  || !defined(SQLITE_OMIT_SUBQUERY)
        !           887: SrcList *sqlite3SrcListDup(sqlite3 *db, SrcList *p, int flags){
        !           888:   SrcList *pNew;
        !           889:   int i;
        !           890:   int nByte;
        !           891:   if( p==0 ) return 0;
        !           892:   nByte = sizeof(*p) + (p->nSrc>0 ? sizeof(p->a[0]) * (p->nSrc-1) : 0);
        !           893:   pNew = sqlite3DbMallocRaw(db, nByte );
        !           894:   if( pNew==0 ) return 0;
        !           895:   pNew->nSrc = pNew->nAlloc = p->nSrc;
        !           896:   for(i=0; i<p->nSrc; i++){
        !           897:     struct SrcList_item *pNewItem = &pNew->a[i];
        !           898:     struct SrcList_item *pOldItem = &p->a[i];
        !           899:     Table *pTab;
        !           900:     pNewItem->zDatabase = sqlite3DbStrDup(db, pOldItem->zDatabase);
        !           901:     pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
        !           902:     pNewItem->zAlias = sqlite3DbStrDup(db, pOldItem->zAlias);
        !           903:     pNewItem->jointype = pOldItem->jointype;
        !           904:     pNewItem->iCursor = pOldItem->iCursor;
        !           905:     pNewItem->addrFillSub = pOldItem->addrFillSub;
        !           906:     pNewItem->regReturn = pOldItem->regReturn;
        !           907:     pNewItem->isCorrelated = pOldItem->isCorrelated;
        !           908:     pNewItem->zIndex = sqlite3DbStrDup(db, pOldItem->zIndex);
        !           909:     pNewItem->notIndexed = pOldItem->notIndexed;
        !           910:     pNewItem->pIndex = pOldItem->pIndex;
        !           911:     pTab = pNewItem->pTab = pOldItem->pTab;
        !           912:     if( pTab ){
        !           913:       pTab->nRef++;
        !           914:     }
        !           915:     pNewItem->pSelect = sqlite3SelectDup(db, pOldItem->pSelect, flags);
        !           916:     pNewItem->pOn = sqlite3ExprDup(db, pOldItem->pOn, flags);
        !           917:     pNewItem->pUsing = sqlite3IdListDup(db, pOldItem->pUsing);
        !           918:     pNewItem->colUsed = pOldItem->colUsed;
        !           919:   }
        !           920:   return pNew;
        !           921: }
        !           922: IdList *sqlite3IdListDup(sqlite3 *db, IdList *p){
        !           923:   IdList *pNew;
        !           924:   int i;
        !           925:   if( p==0 ) return 0;
        !           926:   pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
        !           927:   if( pNew==0 ) return 0;
        !           928:   pNew->nId = pNew->nAlloc = p->nId;
        !           929:   pNew->a = sqlite3DbMallocRaw(db, p->nId*sizeof(p->a[0]) );
        !           930:   if( pNew->a==0 ){
        !           931:     sqlite3DbFree(db, pNew);
        !           932:     return 0;
        !           933:   }
        !           934:   for(i=0; i<p->nId; i++){
        !           935:     struct IdList_item *pNewItem = &pNew->a[i];
        !           936:     struct IdList_item *pOldItem = &p->a[i];
        !           937:     pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
        !           938:     pNewItem->idx = pOldItem->idx;
        !           939:   }
        !           940:   return pNew;
        !           941: }
        !           942: Select *sqlite3SelectDup(sqlite3 *db, Select *p, int flags){
        !           943:   Select *pNew, *pPrior;
        !           944:   if( p==0 ) return 0;
        !           945:   pNew = sqlite3DbMallocRaw(db, sizeof(*p) );
        !           946:   if( pNew==0 ) return 0;
        !           947:   pNew->pEList = sqlite3ExprListDup(db, p->pEList, flags);
        !           948:   pNew->pSrc = sqlite3SrcListDup(db, p->pSrc, flags);
        !           949:   pNew->pWhere = sqlite3ExprDup(db, p->pWhere, flags);
        !           950:   pNew->pGroupBy = sqlite3ExprListDup(db, p->pGroupBy, flags);
        !           951:   pNew->pHaving = sqlite3ExprDup(db, p->pHaving, flags);
        !           952:   pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, flags);
        !           953:   pNew->op = p->op;
        !           954:   pNew->pPrior = pPrior = sqlite3SelectDup(db, p->pPrior, flags);
        !           955:   if( pPrior ) pPrior->pNext = pNew;
        !           956:   pNew->pNext = 0;
        !           957:   pNew->pLimit = sqlite3ExprDup(db, p->pLimit, flags);
        !           958:   pNew->pOffset = sqlite3ExprDup(db, p->pOffset, flags);
        !           959:   pNew->iLimit = 0;
        !           960:   pNew->iOffset = 0;
        !           961:   pNew->selFlags = p->selFlags & ~SF_UsesEphemeral;
        !           962:   pNew->pRightmost = 0;
        !           963:   pNew->addrOpenEphm[0] = -1;
        !           964:   pNew->addrOpenEphm[1] = -1;
        !           965:   pNew->addrOpenEphm[2] = -1;
        !           966:   return pNew;
        !           967: }
        !           968: #else
        !           969: Select *sqlite3SelectDup(sqlite3 *db, Select *p, int flags){
        !           970:   assert( p==0 );
        !           971:   return 0;
        !           972: }
        !           973: #endif
        !           974: 
        !           975: 
        !           976: /*
        !           977: ** Add a new element to the end of an expression list.  If pList is
        !           978: ** initially NULL, then create a new expression list.
        !           979: **
        !           980: ** If a memory allocation error occurs, the entire list is freed and
        !           981: ** NULL is returned.  If non-NULL is returned, then it is guaranteed
        !           982: ** that the new entry was successfully appended.
        !           983: */
        !           984: ExprList *sqlite3ExprListAppend(
        !           985:   Parse *pParse,          /* Parsing context */
        !           986:   ExprList *pList,        /* List to which to append. Might be NULL */
        !           987:   Expr *pExpr             /* Expression to be appended. Might be NULL */
        !           988: ){
        !           989:   sqlite3 *db = pParse->db;
        !           990:   if( pList==0 ){
        !           991:     pList = sqlite3DbMallocZero(db, sizeof(ExprList) );
        !           992:     if( pList==0 ){
        !           993:       goto no_mem;
        !           994:     }
        !           995:     assert( pList->nAlloc==0 );
        !           996:   }
        !           997:   if( pList->nAlloc<=pList->nExpr ){
        !           998:     struct ExprList_item *a;
        !           999:     int n = pList->nAlloc*2 + 4;
        !          1000:     a = sqlite3DbRealloc(db, pList->a, n*sizeof(pList->a[0]));
        !          1001:     if( a==0 ){
        !          1002:       goto no_mem;
        !          1003:     }
        !          1004:     pList->a = a;
        !          1005:     pList->nAlloc = sqlite3DbMallocSize(db, a)/sizeof(a[0]);
        !          1006:   }
        !          1007:   assert( pList->a!=0 );
        !          1008:   if( 1 ){
        !          1009:     struct ExprList_item *pItem = &pList->a[pList->nExpr++];
        !          1010:     memset(pItem, 0, sizeof(*pItem));
        !          1011:     pItem->pExpr = pExpr;
        !          1012:   }
        !          1013:   return pList;
        !          1014: 
        !          1015: no_mem:     
        !          1016:   /* Avoid leaking memory if malloc has failed. */
        !          1017:   sqlite3ExprDelete(db, pExpr);
        !          1018:   sqlite3ExprListDelete(db, pList);
        !          1019:   return 0;
        !          1020: }
        !          1021: 
        !          1022: /*
        !          1023: ** Set the ExprList.a[].zName element of the most recently added item
        !          1024: ** on the expression list.
        !          1025: **
        !          1026: ** pList might be NULL following an OOM error.  But pName should never be
        !          1027: ** NULL.  If a memory allocation fails, the pParse->db->mallocFailed flag
        !          1028: ** is set.
        !          1029: */
        !          1030: void sqlite3ExprListSetName(
        !          1031:   Parse *pParse,          /* Parsing context */
        !          1032:   ExprList *pList,        /* List to which to add the span. */
        !          1033:   Token *pName,           /* Name to be added */
        !          1034:   int dequote             /* True to cause the name to be dequoted */
        !          1035: ){
        !          1036:   assert( pList!=0 || pParse->db->mallocFailed!=0 );
        !          1037:   if( pList ){
        !          1038:     struct ExprList_item *pItem;
        !          1039:     assert( pList->nExpr>0 );
        !          1040:     pItem = &pList->a[pList->nExpr-1];
        !          1041:     assert( pItem->zName==0 );
        !          1042:     pItem->zName = sqlite3DbStrNDup(pParse->db, pName->z, pName->n);
        !          1043:     if( dequote && pItem->zName ) sqlite3Dequote(pItem->zName);
        !          1044:   }
        !          1045: }
        !          1046: 
        !          1047: /*
        !          1048: ** Set the ExprList.a[].zSpan element of the most recently added item
        !          1049: ** on the expression list.
        !          1050: **
        !          1051: ** pList might be NULL following an OOM error.  But pSpan should never be
        !          1052: ** NULL.  If a memory allocation fails, the pParse->db->mallocFailed flag
        !          1053: ** is set.
        !          1054: */
        !          1055: void sqlite3ExprListSetSpan(
        !          1056:   Parse *pParse,          /* Parsing context */
        !          1057:   ExprList *pList,        /* List to which to add the span. */
        !          1058:   ExprSpan *pSpan         /* The span to be added */
        !          1059: ){
        !          1060:   sqlite3 *db = pParse->db;
        !          1061:   assert( pList!=0 || db->mallocFailed!=0 );
        !          1062:   if( pList ){
        !          1063:     struct ExprList_item *pItem = &pList->a[pList->nExpr-1];
        !          1064:     assert( pList->nExpr>0 );
        !          1065:     assert( db->mallocFailed || pItem->pExpr==pSpan->pExpr );
        !          1066:     sqlite3DbFree(db, pItem->zSpan);
        !          1067:     pItem->zSpan = sqlite3DbStrNDup(db, (char*)pSpan->zStart,
        !          1068:                                     (int)(pSpan->zEnd - pSpan->zStart));
        !          1069:   }
        !          1070: }
        !          1071: 
        !          1072: /*
        !          1073: ** If the expression list pEList contains more than iLimit elements,
        !          1074: ** leave an error message in pParse.
        !          1075: */
        !          1076: void sqlite3ExprListCheckLength(
        !          1077:   Parse *pParse,
        !          1078:   ExprList *pEList,
        !          1079:   const char *zObject
        !          1080: ){
        !          1081:   int mx = pParse->db->aLimit[SQLITE_LIMIT_COLUMN];
        !          1082:   testcase( pEList && pEList->nExpr==mx );
        !          1083:   testcase( pEList && pEList->nExpr==mx+1 );
        !          1084:   if( pEList && pEList->nExpr>mx ){
        !          1085:     sqlite3ErrorMsg(pParse, "too many columns in %s", zObject);
        !          1086:   }
        !          1087: }
        !          1088: 
        !          1089: /*
        !          1090: ** Delete an entire expression list.
        !          1091: */
        !          1092: void sqlite3ExprListDelete(sqlite3 *db, ExprList *pList){
        !          1093:   int i;
        !          1094:   struct ExprList_item *pItem;
        !          1095:   if( pList==0 ) return;
        !          1096:   assert( pList->a!=0 || (pList->nExpr==0 && pList->nAlloc==0) );
        !          1097:   assert( pList->nExpr<=pList->nAlloc );
        !          1098:   for(pItem=pList->a, i=0; i<pList->nExpr; i++, pItem++){
        !          1099:     sqlite3ExprDelete(db, pItem->pExpr);
        !          1100:     sqlite3DbFree(db, pItem->zName);
        !          1101:     sqlite3DbFree(db, pItem->zSpan);
        !          1102:   }
        !          1103:   sqlite3DbFree(db, pList->a);
        !          1104:   sqlite3DbFree(db, pList);
        !          1105: }
        !          1106: 
        !          1107: /*
        !          1108: ** These routines are Walker callbacks.  Walker.u.pi is a pointer
        !          1109: ** to an integer.  These routines are checking an expression to see
        !          1110: ** if it is a constant.  Set *Walker.u.pi to 0 if the expression is
        !          1111: ** not constant.
        !          1112: **
        !          1113: ** These callback routines are used to implement the following:
        !          1114: **
        !          1115: **     sqlite3ExprIsConstant()
        !          1116: **     sqlite3ExprIsConstantNotJoin()
        !          1117: **     sqlite3ExprIsConstantOrFunction()
        !          1118: **
        !          1119: */
        !          1120: static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){
        !          1121: 
        !          1122:   /* If pWalker->u.i is 3 then any term of the expression that comes from
        !          1123:   ** the ON or USING clauses of a join disqualifies the expression
        !          1124:   ** from being considered constant. */
        !          1125:   if( pWalker->u.i==3 && ExprHasAnyProperty(pExpr, EP_FromJoin) ){
        !          1126:     pWalker->u.i = 0;
        !          1127:     return WRC_Abort;
        !          1128:   }
        !          1129: 
        !          1130:   switch( pExpr->op ){
        !          1131:     /* Consider functions to be constant if all their arguments are constant
        !          1132:     ** and pWalker->u.i==2 */
        !          1133:     case TK_FUNCTION:
        !          1134:       if( pWalker->u.i==2 ) return 0;
        !          1135:       /* Fall through */
        !          1136:     case TK_ID:
        !          1137:     case TK_COLUMN:
        !          1138:     case TK_AGG_FUNCTION:
        !          1139:     case TK_AGG_COLUMN:
        !          1140:       testcase( pExpr->op==TK_ID );
        !          1141:       testcase( pExpr->op==TK_COLUMN );
        !          1142:       testcase( pExpr->op==TK_AGG_FUNCTION );
        !          1143:       testcase( pExpr->op==TK_AGG_COLUMN );
        !          1144:       pWalker->u.i = 0;
        !          1145:       return WRC_Abort;
        !          1146:     default:
        !          1147:       testcase( pExpr->op==TK_SELECT ); /* selectNodeIsConstant will disallow */
        !          1148:       testcase( pExpr->op==TK_EXISTS ); /* selectNodeIsConstant will disallow */
        !          1149:       return WRC_Continue;
        !          1150:   }
        !          1151: }
        !          1152: static int selectNodeIsConstant(Walker *pWalker, Select *NotUsed){
        !          1153:   UNUSED_PARAMETER(NotUsed);
        !          1154:   pWalker->u.i = 0;
        !          1155:   return WRC_Abort;
        !          1156: }
        !          1157: static int exprIsConst(Expr *p, int initFlag){
        !          1158:   Walker w;
        !          1159:   w.u.i = initFlag;
        !          1160:   w.xExprCallback = exprNodeIsConstant;
        !          1161:   w.xSelectCallback = selectNodeIsConstant;
        !          1162:   sqlite3WalkExpr(&w, p);
        !          1163:   return w.u.i;
        !          1164: }
        !          1165: 
        !          1166: /*
        !          1167: ** Walk an expression tree.  Return 1 if the expression is constant
        !          1168: ** and 0 if it involves variables or function calls.
        !          1169: **
        !          1170: ** For the purposes of this function, a double-quoted string (ex: "abc")
        !          1171: ** is considered a variable but a single-quoted string (ex: 'abc') is
        !          1172: ** a constant.
        !          1173: */
        !          1174: int sqlite3ExprIsConstant(Expr *p){
        !          1175:   return exprIsConst(p, 1);
        !          1176: }
        !          1177: 
        !          1178: /*
        !          1179: ** Walk an expression tree.  Return 1 if the expression is constant
        !          1180: ** that does no originate from the ON or USING clauses of a join.
        !          1181: ** Return 0 if it involves variables or function calls or terms from
        !          1182: ** an ON or USING clause.
        !          1183: */
        !          1184: int sqlite3ExprIsConstantNotJoin(Expr *p){
        !          1185:   return exprIsConst(p, 3);
        !          1186: }
        !          1187: 
        !          1188: /*
        !          1189: ** Walk an expression tree.  Return 1 if the expression is constant
        !          1190: ** or a function call with constant arguments.  Return and 0 if there
        !          1191: ** are any variables.
        !          1192: **
        !          1193: ** For the purposes of this function, a double-quoted string (ex: "abc")
        !          1194: ** is considered a variable but a single-quoted string (ex: 'abc') is
        !          1195: ** a constant.
        !          1196: */
        !          1197: int sqlite3ExprIsConstantOrFunction(Expr *p){
        !          1198:   return exprIsConst(p, 2);
        !          1199: }
        !          1200: 
        !          1201: /*
        !          1202: ** If the expression p codes a constant integer that is small enough
        !          1203: ** to fit in a 32-bit integer, return 1 and put the value of the integer
        !          1204: ** in *pValue.  If the expression is not an integer or if it is too big
        !          1205: ** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
        !          1206: */
        !          1207: int sqlite3ExprIsInteger(Expr *p, int *pValue){
        !          1208:   int rc = 0;
        !          1209: 
        !          1210:   /* If an expression is an integer literal that fits in a signed 32-bit
        !          1211:   ** integer, then the EP_IntValue flag will have already been set */
        !          1212:   assert( p->op!=TK_INTEGER || (p->flags & EP_IntValue)!=0
        !          1213:            || sqlite3GetInt32(p->u.zToken, &rc)==0 );
        !          1214: 
        !          1215:   if( p->flags & EP_IntValue ){
        !          1216:     *pValue = p->u.iValue;
        !          1217:     return 1;
        !          1218:   }
        !          1219:   switch( p->op ){
        !          1220:     case TK_UPLUS: {
        !          1221:       rc = sqlite3ExprIsInteger(p->pLeft, pValue);
        !          1222:       break;
        !          1223:     }
        !          1224:     case TK_UMINUS: {
        !          1225:       int v;
        !          1226:       if( sqlite3ExprIsInteger(p->pLeft, &v) ){
        !          1227:         *pValue = -v;
        !          1228:         rc = 1;
        !          1229:       }
        !          1230:       break;
        !          1231:     }
        !          1232:     default: break;
        !          1233:   }
        !          1234:   return rc;
        !          1235: }
        !          1236: 
        !          1237: /*
        !          1238: ** Return FALSE if there is no chance that the expression can be NULL.
        !          1239: **
        !          1240: ** If the expression might be NULL or if the expression is too complex
        !          1241: ** to tell return TRUE.  
        !          1242: **
        !          1243: ** This routine is used as an optimization, to skip OP_IsNull opcodes
        !          1244: ** when we know that a value cannot be NULL.  Hence, a false positive
        !          1245: ** (returning TRUE when in fact the expression can never be NULL) might
        !          1246: ** be a small performance hit but is otherwise harmless.  On the other
        !          1247: ** hand, a false negative (returning FALSE when the result could be NULL)
        !          1248: ** will likely result in an incorrect answer.  So when in doubt, return
        !          1249: ** TRUE.
        !          1250: */
        !          1251: int sqlite3ExprCanBeNull(const Expr *p){
        !          1252:   u8 op;
        !          1253:   while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ p = p->pLeft; }
        !          1254:   op = p->op;
        !          1255:   if( op==TK_REGISTER ) op = p->op2;
        !          1256:   switch( op ){
        !          1257:     case TK_INTEGER:
        !          1258:     case TK_STRING:
        !          1259:     case TK_FLOAT:
        !          1260:     case TK_BLOB:
        !          1261:       return 0;
        !          1262:     default:
        !          1263:       return 1;
        !          1264:   }
        !          1265: }
        !          1266: 
        !          1267: /*
        !          1268: ** Generate an OP_IsNull instruction that tests register iReg and jumps
        !          1269: ** to location iDest if the value in iReg is NULL.  The value in iReg 
        !          1270: ** was computed by pExpr.  If we can look at pExpr at compile-time and
        !          1271: ** determine that it can never generate a NULL, then the OP_IsNull operation
        !          1272: ** can be omitted.
        !          1273: */
        !          1274: void sqlite3ExprCodeIsNullJump(
        !          1275:   Vdbe *v,            /* The VDBE under construction */
        !          1276:   const Expr *pExpr,  /* Only generate OP_IsNull if this expr can be NULL */
        !          1277:   int iReg,           /* Test the value in this register for NULL */
        !          1278:   int iDest           /* Jump here if the value is null */
        !          1279: ){
        !          1280:   if( sqlite3ExprCanBeNull(pExpr) ){
        !          1281:     sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iDest);
        !          1282:   }
        !          1283: }
        !          1284: 
        !          1285: /*
        !          1286: ** Return TRUE if the given expression is a constant which would be
        !          1287: ** unchanged by OP_Affinity with the affinity given in the second
        !          1288: ** argument.
        !          1289: **
        !          1290: ** This routine is used to determine if the OP_Affinity operation
        !          1291: ** can be omitted.  When in doubt return FALSE.  A false negative
        !          1292: ** is harmless.  A false positive, however, can result in the wrong
        !          1293: ** answer.
        !          1294: */
        !          1295: int sqlite3ExprNeedsNoAffinityChange(const Expr *p, char aff){
        !          1296:   u8 op;
        !          1297:   if( aff==SQLITE_AFF_NONE ) return 1;
        !          1298:   while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ p = p->pLeft; }
        !          1299:   op = p->op;
        !          1300:   if( op==TK_REGISTER ) op = p->op2;
        !          1301:   switch( op ){
        !          1302:     case TK_INTEGER: {
        !          1303:       return aff==SQLITE_AFF_INTEGER || aff==SQLITE_AFF_NUMERIC;
        !          1304:     }
        !          1305:     case TK_FLOAT: {
        !          1306:       return aff==SQLITE_AFF_REAL || aff==SQLITE_AFF_NUMERIC;
        !          1307:     }
        !          1308:     case TK_STRING: {
        !          1309:       return aff==SQLITE_AFF_TEXT;
        !          1310:     }
        !          1311:     case TK_BLOB: {
        !          1312:       return 1;
        !          1313:     }
        !          1314:     case TK_COLUMN: {
        !          1315:       assert( p->iTable>=0 );  /* p cannot be part of a CHECK constraint */
        !          1316:       return p->iColumn<0
        !          1317:           && (aff==SQLITE_AFF_INTEGER || aff==SQLITE_AFF_NUMERIC);
        !          1318:     }
        !          1319:     default: {
        !          1320:       return 0;
        !          1321:     }
        !          1322:   }
        !          1323: }
        !          1324: 
        !          1325: /*
        !          1326: ** Return TRUE if the given string is a row-id column name.
        !          1327: */
        !          1328: int sqlite3IsRowid(const char *z){
        !          1329:   if( sqlite3StrICmp(z, "_ROWID_")==0 ) return 1;
        !          1330:   if( sqlite3StrICmp(z, "ROWID")==0 ) return 1;
        !          1331:   if( sqlite3StrICmp(z, "OID")==0 ) return 1;
        !          1332:   return 0;
        !          1333: }
        !          1334: 
        !          1335: /*
        !          1336: ** Return true if we are able to the IN operator optimization on a
        !          1337: ** query of the form
        !          1338: **
        !          1339: **       x IN (SELECT ...)
        !          1340: **
        !          1341: ** Where the SELECT... clause is as specified by the parameter to this
        !          1342: ** routine.
        !          1343: **
        !          1344: ** The Select object passed in has already been preprocessed and no
        !          1345: ** errors have been found.
        !          1346: */
        !          1347: #ifndef SQLITE_OMIT_SUBQUERY
        !          1348: static int isCandidateForInOpt(Select *p){
        !          1349:   SrcList *pSrc;
        !          1350:   ExprList *pEList;
        !          1351:   Table *pTab;
        !          1352:   if( p==0 ) return 0;                   /* right-hand side of IN is SELECT */
        !          1353:   if( p->pPrior ) return 0;              /* Not a compound SELECT */
        !          1354:   if( p->selFlags & (SF_Distinct|SF_Aggregate) ){
        !          1355:     testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct );
        !          1356:     testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate );
        !          1357:     return 0; /* No DISTINCT keyword and no aggregate functions */
        !          1358:   }
        !          1359:   assert( p->pGroupBy==0 );              /* Has no GROUP BY clause */
        !          1360:   if( p->pLimit ) return 0;              /* Has no LIMIT clause */
        !          1361:   assert( p->pOffset==0 );               /* No LIMIT means no OFFSET */
        !          1362:   if( p->pWhere ) return 0;              /* Has no WHERE clause */
        !          1363:   pSrc = p->pSrc;
        !          1364:   assert( pSrc!=0 );
        !          1365:   if( pSrc->nSrc!=1 ) return 0;          /* Single term in FROM clause */
        !          1366:   if( pSrc->a[0].pSelect ) return 0;     /* FROM is not a subquery or view */
        !          1367:   pTab = pSrc->a[0].pTab;
        !          1368:   if( NEVER(pTab==0) ) return 0;
        !          1369:   assert( pTab->pSelect==0 );            /* FROM clause is not a view */
        !          1370:   if( IsVirtual(pTab) ) return 0;        /* FROM clause not a virtual table */
        !          1371:   pEList = p->pEList;
        !          1372:   if( pEList->nExpr!=1 ) return 0;       /* One column in the result set */
        !          1373:   if( pEList->a[0].pExpr->op!=TK_COLUMN ) return 0; /* Result is a column */
        !          1374:   return 1;
        !          1375: }
        !          1376: #endif /* SQLITE_OMIT_SUBQUERY */
        !          1377: 
        !          1378: /*
        !          1379: ** Code an OP_Once instruction and allocate space for its flag. Return the 
        !          1380: ** address of the new instruction.
        !          1381: */
        !          1382: int sqlite3CodeOnce(Parse *pParse){
        !          1383:   Vdbe *v = sqlite3GetVdbe(pParse);      /* Virtual machine being coded */
        !          1384:   return sqlite3VdbeAddOp1(v, OP_Once, pParse->nOnce++);
        !          1385: }
        !          1386: 
        !          1387: /*
        !          1388: ** This function is used by the implementation of the IN (...) operator.
        !          1389: ** It's job is to find or create a b-tree structure that may be used
        !          1390: ** either to test for membership of the (...) set or to iterate through
        !          1391: ** its members, skipping duplicates.
        !          1392: **
        !          1393: ** The index of the cursor opened on the b-tree (database table, database index 
        !          1394: ** or ephermal table) is stored in pX->iTable before this function returns.
        !          1395: ** The returned value of this function indicates the b-tree type, as follows:
        !          1396: **
        !          1397: **   IN_INDEX_ROWID - The cursor was opened on a database table.
        !          1398: **   IN_INDEX_INDEX - The cursor was opened on a database index.
        !          1399: **   IN_INDEX_EPH -   The cursor was opened on a specially created and
        !          1400: **                    populated epheremal table.
        !          1401: **
        !          1402: ** An existing b-tree may only be used if the SELECT is of the simple
        !          1403: ** form:
        !          1404: **
        !          1405: **     SELECT <column> FROM <table>
        !          1406: **
        !          1407: ** If the prNotFound parameter is 0, then the b-tree will be used to iterate
        !          1408: ** through the set members, skipping any duplicates. In this case an
        !          1409: ** epheremal table must be used unless the selected <column> is guaranteed
        !          1410: ** to be unique - either because it is an INTEGER PRIMARY KEY or it
        !          1411: ** has a UNIQUE constraint or UNIQUE index.
        !          1412: **
        !          1413: ** If the prNotFound parameter is not 0, then the b-tree will be used 
        !          1414: ** for fast set membership tests. In this case an epheremal table must 
        !          1415: ** be used unless <column> is an INTEGER PRIMARY KEY or an index can 
        !          1416: ** be found with <column> as its left-most column.
        !          1417: **
        !          1418: ** When the b-tree is being used for membership tests, the calling function
        !          1419: ** needs to know whether or not the structure contains an SQL NULL 
        !          1420: ** value in order to correctly evaluate expressions like "X IN (Y, Z)".
        !          1421: ** If there is any chance that the (...) might contain a NULL value at
        !          1422: ** runtime, then a register is allocated and the register number written
        !          1423: ** to *prNotFound. If there is no chance that the (...) contains a
        !          1424: ** NULL value, then *prNotFound is left unchanged.
        !          1425: **
        !          1426: ** If a register is allocated and its location stored in *prNotFound, then
        !          1427: ** its initial value is NULL.  If the (...) does not remain constant
        !          1428: ** for the duration of the query (i.e. the SELECT within the (...)
        !          1429: ** is a correlated subquery) then the value of the allocated register is
        !          1430: ** reset to NULL each time the subquery is rerun. This allows the
        !          1431: ** caller to use vdbe code equivalent to the following:
        !          1432: **
        !          1433: **   if( register==NULL ){
        !          1434: **     has_null = <test if data structure contains null>
        !          1435: **     register = 1
        !          1436: **   }
        !          1437: **
        !          1438: ** in order to avoid running the <test if data structure contains null>
        !          1439: ** test more often than is necessary.
        !          1440: */
        !          1441: #ifndef SQLITE_OMIT_SUBQUERY
        !          1442: int sqlite3FindInIndex(Parse *pParse, Expr *pX, int *prNotFound){
        !          1443:   Select *p;                            /* SELECT to the right of IN operator */
        !          1444:   int eType = 0;                        /* Type of RHS table. IN_INDEX_* */
        !          1445:   int iTab = pParse->nTab++;            /* Cursor of the RHS table */
        !          1446:   int mustBeUnique = (prNotFound==0);   /* True if RHS must be unique */
        !          1447:   Vdbe *v = sqlite3GetVdbe(pParse);     /* Virtual machine being coded */
        !          1448: 
        !          1449:   assert( pX->op==TK_IN );
        !          1450: 
        !          1451:   /* Check to see if an existing table or index can be used to
        !          1452:   ** satisfy the query.  This is preferable to generating a new 
        !          1453:   ** ephemeral table.
        !          1454:   */
        !          1455:   p = (ExprHasProperty(pX, EP_xIsSelect) ? pX->x.pSelect : 0);
        !          1456:   if( ALWAYS(pParse->nErr==0) && isCandidateForInOpt(p) ){
        !          1457:     sqlite3 *db = pParse->db;              /* Database connection */
        !          1458:     Table *pTab;                           /* Table <table>. */
        !          1459:     Expr *pExpr;                           /* Expression <column> */
        !          1460:     int iCol;                              /* Index of column <column> */
        !          1461:     int iDb;                               /* Database idx for pTab */
        !          1462: 
        !          1463:     assert( p );                        /* Because of isCandidateForInOpt(p) */
        !          1464:     assert( p->pEList!=0 );             /* Because of isCandidateForInOpt(p) */
        !          1465:     assert( p->pEList->a[0].pExpr!=0 ); /* Because of isCandidateForInOpt(p) */
        !          1466:     assert( p->pSrc!=0 );               /* Because of isCandidateForInOpt(p) */
        !          1467:     pTab = p->pSrc->a[0].pTab;
        !          1468:     pExpr = p->pEList->a[0].pExpr;
        !          1469:     iCol = pExpr->iColumn;
        !          1470:    
        !          1471:     /* Code an OP_VerifyCookie and OP_TableLock for <table>. */
        !          1472:     iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
        !          1473:     sqlite3CodeVerifySchema(pParse, iDb);
        !          1474:     sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
        !          1475: 
        !          1476:     /* This function is only called from two places. In both cases the vdbe
        !          1477:     ** has already been allocated. So assume sqlite3GetVdbe() is always
        !          1478:     ** successful here.
        !          1479:     */
        !          1480:     assert(v);
        !          1481:     if( iCol<0 ){
        !          1482:       int iAddr;
        !          1483: 
        !          1484:       iAddr = sqlite3CodeOnce(pParse);
        !          1485: 
        !          1486:       sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
        !          1487:       eType = IN_INDEX_ROWID;
        !          1488: 
        !          1489:       sqlite3VdbeJumpHere(v, iAddr);
        !          1490:     }else{
        !          1491:       Index *pIdx;                         /* Iterator variable */
        !          1492: 
        !          1493:       /* The collation sequence used by the comparison. If an index is to
        !          1494:       ** be used in place of a temp-table, it must be ordered according
        !          1495:       ** to this collation sequence.  */
        !          1496:       CollSeq *pReq = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pExpr);
        !          1497: 
        !          1498:       /* Check that the affinity that will be used to perform the 
        !          1499:       ** comparison is the same as the affinity of the column. If
        !          1500:       ** it is not, it is not possible to use any index.
        !          1501:       */
        !          1502:       char aff = comparisonAffinity(pX);
        !          1503:       int affinity_ok = (pTab->aCol[iCol].affinity==aff||aff==SQLITE_AFF_NONE);
        !          1504: 
        !          1505:       for(pIdx=pTab->pIndex; pIdx && eType==0 && affinity_ok; pIdx=pIdx->pNext){
        !          1506:         if( (pIdx->aiColumn[0]==iCol)
        !          1507:          && sqlite3FindCollSeq(db, ENC(db), pIdx->azColl[0], 0)==pReq
        !          1508:          && (!mustBeUnique || (pIdx->nColumn==1 && pIdx->onError!=OE_None))
        !          1509:         ){
        !          1510:           int iAddr;
        !          1511:           char *pKey;
        !          1512:   
        !          1513:           pKey = (char *)sqlite3IndexKeyinfo(pParse, pIdx);
        !          1514:           iAddr = sqlite3CodeOnce(pParse);
        !          1515:   
        !          1516:           sqlite3VdbeAddOp4(v, OP_OpenRead, iTab, pIdx->tnum, iDb,
        !          1517:                                pKey,P4_KEYINFO_HANDOFF);
        !          1518:           VdbeComment((v, "%s", pIdx->zName));
        !          1519:           eType = IN_INDEX_INDEX;
        !          1520: 
        !          1521:           sqlite3VdbeJumpHere(v, iAddr);
        !          1522:           if( prNotFound && !pTab->aCol[iCol].notNull ){
        !          1523:             *prNotFound = ++pParse->nMem;
        !          1524:             sqlite3VdbeAddOp2(v, OP_Null, 0, *prNotFound);
        !          1525:           }
        !          1526:         }
        !          1527:       }
        !          1528:     }
        !          1529:   }
        !          1530: 
        !          1531:   if( eType==0 ){
        !          1532:     /* Could not found an existing table or index to use as the RHS b-tree.
        !          1533:     ** We will have to generate an ephemeral table to do the job.
        !          1534:     */
        !          1535:     double savedNQueryLoop = pParse->nQueryLoop;
        !          1536:     int rMayHaveNull = 0;
        !          1537:     eType = IN_INDEX_EPH;
        !          1538:     if( prNotFound ){
        !          1539:       *prNotFound = rMayHaveNull = ++pParse->nMem;
        !          1540:       sqlite3VdbeAddOp2(v, OP_Null, 0, *prNotFound);
        !          1541:     }else{
        !          1542:       testcase( pParse->nQueryLoop>(double)1 );
        !          1543:       pParse->nQueryLoop = (double)1;
        !          1544:       if( pX->pLeft->iColumn<0 && !ExprHasAnyProperty(pX, EP_xIsSelect) ){
        !          1545:         eType = IN_INDEX_ROWID;
        !          1546:       }
        !          1547:     }
        !          1548:     sqlite3CodeSubselect(pParse, pX, rMayHaveNull, eType==IN_INDEX_ROWID);
        !          1549:     pParse->nQueryLoop = savedNQueryLoop;
        !          1550:   }else{
        !          1551:     pX->iTable = iTab;
        !          1552:   }
        !          1553:   return eType;
        !          1554: }
        !          1555: #endif
        !          1556: 
        !          1557: /*
        !          1558: ** Generate code for scalar subqueries used as a subquery expression, EXISTS,
        !          1559: ** or IN operators.  Examples:
        !          1560: **
        !          1561: **     (SELECT a FROM b)          -- subquery
        !          1562: **     EXISTS (SELECT a FROM b)   -- EXISTS subquery
        !          1563: **     x IN (4,5,11)              -- IN operator with list on right-hand side
        !          1564: **     x IN (SELECT a FROM b)     -- IN operator with subquery on the right
        !          1565: **
        !          1566: ** The pExpr parameter describes the expression that contains the IN
        !          1567: ** operator or subquery.
        !          1568: **
        !          1569: ** If parameter isRowid is non-zero, then expression pExpr is guaranteed
        !          1570: ** to be of the form "<rowid> IN (?, ?, ?)", where <rowid> is a reference
        !          1571: ** to some integer key column of a table B-Tree. In this case, use an
        !          1572: ** intkey B-Tree to store the set of IN(...) values instead of the usual
        !          1573: ** (slower) variable length keys B-Tree.
        !          1574: **
        !          1575: ** If rMayHaveNull is non-zero, that means that the operation is an IN
        !          1576: ** (not a SELECT or EXISTS) and that the RHS might contains NULLs.
        !          1577: ** Furthermore, the IN is in a WHERE clause and that we really want
        !          1578: ** to iterate over the RHS of the IN operator in order to quickly locate
        !          1579: ** all corresponding LHS elements.  All this routine does is initialize
        !          1580: ** the register given by rMayHaveNull to NULL.  Calling routines will take
        !          1581: ** care of changing this register value to non-NULL if the RHS is NULL-free.
        !          1582: **
        !          1583: ** If rMayHaveNull is zero, that means that the subquery is being used
        !          1584: ** for membership testing only.  There is no need to initialize any
        !          1585: ** registers to indicate the presense or absence of NULLs on the RHS.
        !          1586: **
        !          1587: ** For a SELECT or EXISTS operator, return the register that holds the
        !          1588: ** result.  For IN operators or if an error occurs, the return value is 0.
        !          1589: */
        !          1590: #ifndef SQLITE_OMIT_SUBQUERY
        !          1591: int sqlite3CodeSubselect(
        !          1592:   Parse *pParse,          /* Parsing context */
        !          1593:   Expr *pExpr,            /* The IN, SELECT, or EXISTS operator */
        !          1594:   int rMayHaveNull,       /* Register that records whether NULLs exist in RHS */
        !          1595:   int isRowid             /* If true, LHS of IN operator is a rowid */
        !          1596: ){
        !          1597:   int testAddr = -1;                      /* One-time test address */
        !          1598:   int rReg = 0;                           /* Register storing resulting */
        !          1599:   Vdbe *v = sqlite3GetVdbe(pParse);
        !          1600:   if( NEVER(v==0) ) return 0;
        !          1601:   sqlite3ExprCachePush(pParse);
        !          1602: 
        !          1603:   /* This code must be run in its entirety every time it is encountered
        !          1604:   ** if any of the following is true:
        !          1605:   **
        !          1606:   **    *  The right-hand side is a correlated subquery
        !          1607:   **    *  The right-hand side is an expression list containing variables
        !          1608:   **    *  We are inside a trigger
        !          1609:   **
        !          1610:   ** If all of the above are false, then we can run this code just once
        !          1611:   ** save the results, and reuse the same result on subsequent invocations.
        !          1612:   */
        !          1613:   if( !ExprHasAnyProperty(pExpr, EP_VarSelect) ){
        !          1614:     testAddr = sqlite3CodeOnce(pParse);
        !          1615:   }
        !          1616: 
        !          1617: #ifndef SQLITE_OMIT_EXPLAIN
        !          1618:   if( pParse->explain==2 ){
        !          1619:     char *zMsg = sqlite3MPrintf(
        !          1620:         pParse->db, "EXECUTE %s%s SUBQUERY %d", testAddr>=0?"":"CORRELATED ",
        !          1621:         pExpr->op==TK_IN?"LIST":"SCALAR", pParse->iNextSelectId
        !          1622:     );
        !          1623:     sqlite3VdbeAddOp4(v, OP_Explain, pParse->iSelectId, 0, 0, zMsg, P4_DYNAMIC);
        !          1624:   }
        !          1625: #endif
        !          1626: 
        !          1627:   switch( pExpr->op ){
        !          1628:     case TK_IN: {
        !          1629:       char affinity;              /* Affinity of the LHS of the IN */
        !          1630:       KeyInfo keyInfo;            /* Keyinfo for the generated table */
        !          1631:       int addr;                   /* Address of OP_OpenEphemeral instruction */
        !          1632:       Expr *pLeft = pExpr->pLeft; /* the LHS of the IN operator */
        !          1633: 
        !          1634:       if( rMayHaveNull ){
        !          1635:         sqlite3VdbeAddOp2(v, OP_Null, 0, rMayHaveNull);
        !          1636:       }
        !          1637: 
        !          1638:       affinity = sqlite3ExprAffinity(pLeft);
        !          1639: 
        !          1640:       /* Whether this is an 'x IN(SELECT...)' or an 'x IN(<exprlist>)'
        !          1641:       ** expression it is handled the same way.  An ephemeral table is 
        !          1642:       ** filled with single-field index keys representing the results
        !          1643:       ** from the SELECT or the <exprlist>.
        !          1644:       **
        !          1645:       ** If the 'x' expression is a column value, or the SELECT...
        !          1646:       ** statement returns a column value, then the affinity of that
        !          1647:       ** column is used to build the index keys. If both 'x' and the
        !          1648:       ** SELECT... statement are columns, then numeric affinity is used
        !          1649:       ** if either column has NUMERIC or INTEGER affinity. If neither
        !          1650:       ** 'x' nor the SELECT... statement are columns, then numeric affinity
        !          1651:       ** is used.
        !          1652:       */
        !          1653:       pExpr->iTable = pParse->nTab++;
        !          1654:       addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, !isRowid);
        !          1655:       if( rMayHaveNull==0 ) sqlite3VdbeChangeP5(v, BTREE_UNORDERED);
        !          1656:       memset(&keyInfo, 0, sizeof(keyInfo));
        !          1657:       keyInfo.nField = 1;
        !          1658: 
        !          1659:       if( ExprHasProperty(pExpr, EP_xIsSelect) ){
        !          1660:         /* Case 1:     expr IN (SELECT ...)
        !          1661:         **
        !          1662:         ** Generate code to write the results of the select into the temporary
        !          1663:         ** table allocated and opened above.
        !          1664:         */
        !          1665:         SelectDest dest;
        !          1666:         ExprList *pEList;
        !          1667: 
        !          1668:         assert( !isRowid );
        !          1669:         sqlite3SelectDestInit(&dest, SRT_Set, pExpr->iTable);
        !          1670:         dest.affinity = (u8)affinity;
        !          1671:         assert( (pExpr->iTable&0x0000FFFF)==pExpr->iTable );
        !          1672:         pExpr->x.pSelect->iLimit = 0;
        !          1673:         if( sqlite3Select(pParse, pExpr->x.pSelect, &dest) ){
        !          1674:           return 0;
        !          1675:         }
        !          1676:         pEList = pExpr->x.pSelect->pEList;
        !          1677:         if( ALWAYS(pEList!=0 && pEList->nExpr>0) ){ 
        !          1678:           keyInfo.aColl[0] = sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft,
        !          1679:               pEList->a[0].pExpr);
        !          1680:         }
        !          1681:       }else if( ALWAYS(pExpr->x.pList!=0) ){
        !          1682:         /* Case 2:     expr IN (exprlist)
        !          1683:         **
        !          1684:         ** For each expression, build an index key from the evaluation and
        !          1685:         ** store it in the temporary table. If <expr> is a column, then use
        !          1686:         ** that columns affinity when building index keys. If <expr> is not
        !          1687:         ** a column, use numeric affinity.
        !          1688:         */
        !          1689:         int i;
        !          1690:         ExprList *pList = pExpr->x.pList;
        !          1691:         struct ExprList_item *pItem;
        !          1692:         int r1, r2, r3;
        !          1693: 
        !          1694:         if( !affinity ){
        !          1695:           affinity = SQLITE_AFF_NONE;
        !          1696:         }
        !          1697:         keyInfo.aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
        !          1698: 
        !          1699:         /* Loop through each expression in <exprlist>. */
        !          1700:         r1 = sqlite3GetTempReg(pParse);
        !          1701:         r2 = sqlite3GetTempReg(pParse);
        !          1702:         sqlite3VdbeAddOp2(v, OP_Null, 0, r2);
        !          1703:         for(i=pList->nExpr, pItem=pList->a; i>0; i--, pItem++){
        !          1704:           Expr *pE2 = pItem->pExpr;
        !          1705:           int iValToIns;
        !          1706: 
        !          1707:           /* If the expression is not constant then we will need to
        !          1708:           ** disable the test that was generated above that makes sure
        !          1709:           ** this code only executes once.  Because for a non-constant
        !          1710:           ** expression we need to rerun this code each time.
        !          1711:           */
        !          1712:           if( testAddr>=0 && !sqlite3ExprIsConstant(pE2) ){
        !          1713:             sqlite3VdbeChangeToNoop(v, testAddr);
        !          1714:             testAddr = -1;
        !          1715:           }
        !          1716: 
        !          1717:           /* Evaluate the expression and insert it into the temp table */
        !          1718:           if( isRowid && sqlite3ExprIsInteger(pE2, &iValToIns) ){
        !          1719:             sqlite3VdbeAddOp3(v, OP_InsertInt, pExpr->iTable, r2, iValToIns);
        !          1720:           }else{
        !          1721:             r3 = sqlite3ExprCodeTarget(pParse, pE2, r1);
        !          1722:             if( isRowid ){
        !          1723:               sqlite3VdbeAddOp2(v, OP_MustBeInt, r3,
        !          1724:                                 sqlite3VdbeCurrentAddr(v)+2);
        !          1725:               sqlite3VdbeAddOp3(v, OP_Insert, pExpr->iTable, r2, r3);
        !          1726:             }else{
        !          1727:               sqlite3VdbeAddOp4(v, OP_MakeRecord, r3, 1, r2, &affinity, 1);
        !          1728:               sqlite3ExprCacheAffinityChange(pParse, r3, 1);
        !          1729:               sqlite3VdbeAddOp2(v, OP_IdxInsert, pExpr->iTable, r2);
        !          1730:             }
        !          1731:           }
        !          1732:         }
        !          1733:         sqlite3ReleaseTempReg(pParse, r1);
        !          1734:         sqlite3ReleaseTempReg(pParse, r2);
        !          1735:       }
        !          1736:       if( !isRowid ){
        !          1737:         sqlite3VdbeChangeP4(v, addr, (void *)&keyInfo, P4_KEYINFO);
        !          1738:       }
        !          1739:       break;
        !          1740:     }
        !          1741: 
        !          1742:     case TK_EXISTS:
        !          1743:     case TK_SELECT:
        !          1744:     default: {
        !          1745:       /* If this has to be a scalar SELECT.  Generate code to put the
        !          1746:       ** value of this select in a memory cell and record the number
        !          1747:       ** of the memory cell in iColumn.  If this is an EXISTS, write
        !          1748:       ** an integer 0 (not exists) or 1 (exists) into a memory cell
        !          1749:       ** and record that memory cell in iColumn.
        !          1750:       */
        !          1751:       Select *pSel;                         /* SELECT statement to encode */
        !          1752:       SelectDest dest;                      /* How to deal with SELECt result */
        !          1753: 
        !          1754:       testcase( pExpr->op==TK_EXISTS );
        !          1755:       testcase( pExpr->op==TK_SELECT );
        !          1756:       assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT );
        !          1757: 
        !          1758:       assert( ExprHasProperty(pExpr, EP_xIsSelect) );
        !          1759:       pSel = pExpr->x.pSelect;
        !          1760:       sqlite3SelectDestInit(&dest, 0, ++pParse->nMem);
        !          1761:       if( pExpr->op==TK_SELECT ){
        !          1762:         dest.eDest = SRT_Mem;
        !          1763:         sqlite3VdbeAddOp2(v, OP_Null, 0, dest.iParm);
        !          1764:         VdbeComment((v, "Init subquery result"));
        !          1765:       }else{
        !          1766:         dest.eDest = SRT_Exists;
        !          1767:         sqlite3VdbeAddOp2(v, OP_Integer, 0, dest.iParm);
        !          1768:         VdbeComment((v, "Init EXISTS result"));
        !          1769:       }
        !          1770:       sqlite3ExprDelete(pParse->db, pSel->pLimit);
        !          1771:       pSel->pLimit = sqlite3PExpr(pParse, TK_INTEGER, 0, 0,
        !          1772:                                   &sqlite3IntTokens[1]);
        !          1773:       pSel->iLimit = 0;
        !          1774:       if( sqlite3Select(pParse, pSel, &dest) ){
        !          1775:         return 0;
        !          1776:       }
        !          1777:       rReg = dest.iParm;
        !          1778:       ExprSetIrreducible(pExpr);
        !          1779:       break;
        !          1780:     }
        !          1781:   }
        !          1782: 
        !          1783:   if( testAddr>=0 ){
        !          1784:     sqlite3VdbeJumpHere(v, testAddr);
        !          1785:   }
        !          1786:   sqlite3ExprCachePop(pParse, 1);
        !          1787: 
        !          1788:   return rReg;
        !          1789: }
        !          1790: #endif /* SQLITE_OMIT_SUBQUERY */
        !          1791: 
        !          1792: #ifndef SQLITE_OMIT_SUBQUERY
        !          1793: /*
        !          1794: ** Generate code for an IN expression.
        !          1795: **
        !          1796: **      x IN (SELECT ...)
        !          1797: **      x IN (value, value, ...)
        !          1798: **
        !          1799: ** The left-hand side (LHS) is a scalar expression.  The right-hand side (RHS)
        !          1800: ** is an array of zero or more values.  The expression is true if the LHS is
        !          1801: ** contained within the RHS.  The value of the expression is unknown (NULL)
        !          1802: ** if the LHS is NULL or if the LHS is not contained within the RHS and the
        !          1803: ** RHS contains one or more NULL values.
        !          1804: **
        !          1805: ** This routine generates code will jump to destIfFalse if the LHS is not 
        !          1806: ** contained within the RHS.  If due to NULLs we cannot determine if the LHS
        !          1807: ** is contained in the RHS then jump to destIfNull.  If the LHS is contained
        !          1808: ** within the RHS then fall through.
        !          1809: */
        !          1810: static void sqlite3ExprCodeIN(
        !          1811:   Parse *pParse,        /* Parsing and code generating context */
        !          1812:   Expr *pExpr,          /* The IN expression */
        !          1813:   int destIfFalse,      /* Jump here if LHS is not contained in the RHS */
        !          1814:   int destIfNull        /* Jump here if the results are unknown due to NULLs */
        !          1815: ){
        !          1816:   int rRhsHasNull = 0;  /* Register that is true if RHS contains NULL values */
        !          1817:   char affinity;        /* Comparison affinity to use */
        !          1818:   int eType;            /* Type of the RHS */
        !          1819:   int r1;               /* Temporary use register */
        !          1820:   Vdbe *v;              /* Statement under construction */
        !          1821: 
        !          1822:   /* Compute the RHS.   After this step, the table with cursor
        !          1823:   ** pExpr->iTable will contains the values that make up the RHS.
        !          1824:   */
        !          1825:   v = pParse->pVdbe;
        !          1826:   assert( v!=0 );       /* OOM detected prior to this routine */
        !          1827:   VdbeNoopComment((v, "begin IN expr"));
        !          1828:   eType = sqlite3FindInIndex(pParse, pExpr, &rRhsHasNull);
        !          1829: 
        !          1830:   /* Figure out the affinity to use to create a key from the results
        !          1831:   ** of the expression. affinityStr stores a static string suitable for
        !          1832:   ** P4 of OP_MakeRecord.
        !          1833:   */
        !          1834:   affinity = comparisonAffinity(pExpr);
        !          1835: 
        !          1836:   /* Code the LHS, the <expr> from "<expr> IN (...)".
        !          1837:   */
        !          1838:   sqlite3ExprCachePush(pParse);
        !          1839:   r1 = sqlite3GetTempReg(pParse);
        !          1840:   sqlite3ExprCode(pParse, pExpr->pLeft, r1);
        !          1841: 
        !          1842:   /* If the LHS is NULL, then the result is either false or NULL depending
        !          1843:   ** on whether the RHS is empty or not, respectively.
        !          1844:   */
        !          1845:   if( destIfNull==destIfFalse ){
        !          1846:     /* Shortcut for the common case where the false and NULL outcomes are
        !          1847:     ** the same. */
        !          1848:     sqlite3VdbeAddOp2(v, OP_IsNull, r1, destIfNull);
        !          1849:   }else{
        !          1850:     int addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, r1);
        !          1851:     sqlite3VdbeAddOp2(v, OP_Rewind, pExpr->iTable, destIfFalse);
        !          1852:     sqlite3VdbeAddOp2(v, OP_Goto, 0, destIfNull);
        !          1853:     sqlite3VdbeJumpHere(v, addr1);
        !          1854:   }
        !          1855: 
        !          1856:   if( eType==IN_INDEX_ROWID ){
        !          1857:     /* In this case, the RHS is the ROWID of table b-tree
        !          1858:     */
        !          1859:     sqlite3VdbeAddOp2(v, OP_MustBeInt, r1, destIfFalse);
        !          1860:     sqlite3VdbeAddOp3(v, OP_NotExists, pExpr->iTable, destIfFalse, r1);
        !          1861:   }else{
        !          1862:     /* In this case, the RHS is an index b-tree.
        !          1863:     */
        !          1864:     sqlite3VdbeAddOp4(v, OP_Affinity, r1, 1, 0, &affinity, 1);
        !          1865: 
        !          1866:     /* If the set membership test fails, then the result of the 
        !          1867:     ** "x IN (...)" expression must be either 0 or NULL. If the set
        !          1868:     ** contains no NULL values, then the result is 0. If the set 
        !          1869:     ** contains one or more NULL values, then the result of the
        !          1870:     ** expression is also NULL.
        !          1871:     */
        !          1872:     if( rRhsHasNull==0 || destIfFalse==destIfNull ){
        !          1873:       /* This branch runs if it is known at compile time that the RHS
        !          1874:       ** cannot contain NULL values. This happens as the result
        !          1875:       ** of a "NOT NULL" constraint in the database schema.
        !          1876:       **
        !          1877:       ** Also run this branch if NULL is equivalent to FALSE
        !          1878:       ** for this particular IN operator.
        !          1879:       */
        !          1880:       sqlite3VdbeAddOp4Int(v, OP_NotFound, pExpr->iTable, destIfFalse, r1, 1);
        !          1881: 
        !          1882:     }else{
        !          1883:       /* In this branch, the RHS of the IN might contain a NULL and
        !          1884:       ** the presence of a NULL on the RHS makes a difference in the
        !          1885:       ** outcome.
        !          1886:       */
        !          1887:       int j1, j2, j3;
        !          1888: 
        !          1889:       /* First check to see if the LHS is contained in the RHS.  If so,
        !          1890:       ** then the presence of NULLs in the RHS does not matter, so jump
        !          1891:       ** over all of the code that follows.
        !          1892:       */
        !          1893:       j1 = sqlite3VdbeAddOp4Int(v, OP_Found, pExpr->iTable, 0, r1, 1);
        !          1894: 
        !          1895:       /* Here we begin generating code that runs if the LHS is not
        !          1896:       ** contained within the RHS.  Generate additional code that
        !          1897:       ** tests the RHS for NULLs.  If the RHS contains a NULL then
        !          1898:       ** jump to destIfNull.  If there are no NULLs in the RHS then
        !          1899:       ** jump to destIfFalse.
        !          1900:       */
        !          1901:       j2 = sqlite3VdbeAddOp1(v, OP_NotNull, rRhsHasNull);
        !          1902:       j3 = sqlite3VdbeAddOp4Int(v, OP_Found, pExpr->iTable, 0, rRhsHasNull, 1);
        !          1903:       sqlite3VdbeAddOp2(v, OP_Integer, -1, rRhsHasNull);
        !          1904:       sqlite3VdbeJumpHere(v, j3);
        !          1905:       sqlite3VdbeAddOp2(v, OP_AddImm, rRhsHasNull, 1);
        !          1906:       sqlite3VdbeJumpHere(v, j2);
        !          1907: 
        !          1908:       /* Jump to the appropriate target depending on whether or not
        !          1909:       ** the RHS contains a NULL
        !          1910:       */
        !          1911:       sqlite3VdbeAddOp2(v, OP_If, rRhsHasNull, destIfNull);
        !          1912:       sqlite3VdbeAddOp2(v, OP_Goto, 0, destIfFalse);
        !          1913: 
        !          1914:       /* The OP_Found at the top of this branch jumps here when true, 
        !          1915:       ** causing the overall IN expression evaluation to fall through.
        !          1916:       */
        !          1917:       sqlite3VdbeJumpHere(v, j1);
        !          1918:     }
        !          1919:   }
        !          1920:   sqlite3ReleaseTempReg(pParse, r1);
        !          1921:   sqlite3ExprCachePop(pParse, 1);
        !          1922:   VdbeComment((v, "end IN expr"));
        !          1923: }
        !          1924: #endif /* SQLITE_OMIT_SUBQUERY */
        !          1925: 
        !          1926: /*
        !          1927: ** Duplicate an 8-byte value
        !          1928: */
        !          1929: static char *dup8bytes(Vdbe *v, const char *in){
        !          1930:   char *out = sqlite3DbMallocRaw(sqlite3VdbeDb(v), 8);
        !          1931:   if( out ){
        !          1932:     memcpy(out, in, 8);
        !          1933:   }
        !          1934:   return out;
        !          1935: }
        !          1936: 
        !          1937: #ifndef SQLITE_OMIT_FLOATING_POINT
        !          1938: /*
        !          1939: ** Generate an instruction that will put the floating point
        !          1940: ** value described by z[0..n-1] into register iMem.
        !          1941: **
        !          1942: ** The z[] string will probably not be zero-terminated.  But the 
        !          1943: ** z[n] character is guaranteed to be something that does not look
        !          1944: ** like the continuation of the number.
        !          1945: */
        !          1946: static void codeReal(Vdbe *v, const char *z, int negateFlag, int iMem){
        !          1947:   if( ALWAYS(z!=0) ){
        !          1948:     double value;
        !          1949:     char *zV;
        !          1950:     sqlite3AtoF(z, &value, sqlite3Strlen30(z), SQLITE_UTF8);
        !          1951:     assert( !sqlite3IsNaN(value) ); /* The new AtoF never returns NaN */
        !          1952:     if( negateFlag ) value = -value;
        !          1953:     zV = dup8bytes(v, (char*)&value);
        !          1954:     sqlite3VdbeAddOp4(v, OP_Real, 0, iMem, 0, zV, P4_REAL);
        !          1955:   }
        !          1956: }
        !          1957: #endif
        !          1958: 
        !          1959: 
        !          1960: /*
        !          1961: ** Generate an instruction that will put the integer describe by
        !          1962: ** text z[0..n-1] into register iMem.
        !          1963: **
        !          1964: ** Expr.u.zToken is always UTF8 and zero-terminated.
        !          1965: */
        !          1966: static void codeInteger(Parse *pParse, Expr *pExpr, int negFlag, int iMem){
        !          1967:   Vdbe *v = pParse->pVdbe;
        !          1968:   if( pExpr->flags & EP_IntValue ){
        !          1969:     int i = pExpr->u.iValue;
        !          1970:     assert( i>=0 );
        !          1971:     if( negFlag ) i = -i;
        !          1972:     sqlite3VdbeAddOp2(v, OP_Integer, i, iMem);
        !          1973:   }else{
        !          1974:     int c;
        !          1975:     i64 value;
        !          1976:     const char *z = pExpr->u.zToken;
        !          1977:     assert( z!=0 );
        !          1978:     c = sqlite3Atoi64(z, &value, sqlite3Strlen30(z), SQLITE_UTF8);
        !          1979:     if( c==0 || (c==2 && negFlag) ){
        !          1980:       char *zV;
        !          1981:       if( negFlag ){ value = c==2 ? SMALLEST_INT64 : -value; }
        !          1982:       zV = dup8bytes(v, (char*)&value);
        !          1983:       sqlite3VdbeAddOp4(v, OP_Int64, 0, iMem, 0, zV, P4_INT64);
        !          1984:     }else{
        !          1985: #ifdef SQLITE_OMIT_FLOATING_POINT
        !          1986:       sqlite3ErrorMsg(pParse, "oversized integer: %s%s", negFlag ? "-" : "", z);
        !          1987: #else
        !          1988:       codeReal(v, z, negFlag, iMem);
        !          1989: #endif
        !          1990:     }
        !          1991:   }
        !          1992: }
        !          1993: 
        !          1994: /*
        !          1995: ** Clear a cache entry.
        !          1996: */
        !          1997: static void cacheEntryClear(Parse *pParse, struct yColCache *p){
        !          1998:   if( p->tempReg ){
        !          1999:     if( pParse->nTempReg<ArraySize(pParse->aTempReg) ){
        !          2000:       pParse->aTempReg[pParse->nTempReg++] = p->iReg;
        !          2001:     }
        !          2002:     p->tempReg = 0;
        !          2003:   }
        !          2004: }
        !          2005: 
        !          2006: 
        !          2007: /*
        !          2008: ** Record in the column cache that a particular column from a
        !          2009: ** particular table is stored in a particular register.
        !          2010: */
        !          2011: void sqlite3ExprCacheStore(Parse *pParse, int iTab, int iCol, int iReg){
        !          2012:   int i;
        !          2013:   int minLru;
        !          2014:   int idxLru;
        !          2015:   struct yColCache *p;
        !          2016: 
        !          2017:   assert( iReg>0 );  /* Register numbers are always positive */
        !          2018:   assert( iCol>=-1 && iCol<32768 );  /* Finite column numbers */
        !          2019: 
        !          2020:   /* The SQLITE_ColumnCache flag disables the column cache.  This is used
        !          2021:   ** for testing only - to verify that SQLite always gets the same answer
        !          2022:   ** with and without the column cache.
        !          2023:   */
        !          2024:   if( pParse->db->flags & SQLITE_ColumnCache ) return;
        !          2025: 
        !          2026:   /* First replace any existing entry.
        !          2027:   **
        !          2028:   ** Actually, the way the column cache is currently used, we are guaranteed
        !          2029:   ** that the object will never already be in cache.  Verify this guarantee.
        !          2030:   */
        !          2031: #ifndef NDEBUG
        !          2032:   for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
        !          2033: #if 0 /* This code wold remove the entry from the cache if it existed */
        !          2034:     if( p->iReg && p->iTable==iTab && p->iColumn==iCol ){
        !          2035:       cacheEntryClear(pParse, p);
        !          2036:       p->iLevel = pParse->iCacheLevel;
        !          2037:       p->iReg = iReg;
        !          2038:       p->lru = pParse->iCacheCnt++;
        !          2039:       return;
        !          2040:     }
        !          2041: #endif
        !          2042:     assert( p->iReg==0 || p->iTable!=iTab || p->iColumn!=iCol );
        !          2043:   }
        !          2044: #endif
        !          2045: 
        !          2046:   /* Find an empty slot and replace it */
        !          2047:   for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
        !          2048:     if( p->iReg==0 ){
        !          2049:       p->iLevel = pParse->iCacheLevel;
        !          2050:       p->iTable = iTab;
        !          2051:       p->iColumn = iCol;
        !          2052:       p->iReg = iReg;
        !          2053:       p->tempReg = 0;
        !          2054:       p->lru = pParse->iCacheCnt++;
        !          2055:       return;
        !          2056:     }
        !          2057:   }
        !          2058: 
        !          2059:   /* Replace the last recently used */
        !          2060:   minLru = 0x7fffffff;
        !          2061:   idxLru = -1;
        !          2062:   for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
        !          2063:     if( p->lru<minLru ){
        !          2064:       idxLru = i;
        !          2065:       minLru = p->lru;
        !          2066:     }
        !          2067:   }
        !          2068:   if( ALWAYS(idxLru>=0) ){
        !          2069:     p = &pParse->aColCache[idxLru];
        !          2070:     p->iLevel = pParse->iCacheLevel;
        !          2071:     p->iTable = iTab;
        !          2072:     p->iColumn = iCol;
        !          2073:     p->iReg = iReg;
        !          2074:     p->tempReg = 0;
        !          2075:     p->lru = pParse->iCacheCnt++;
        !          2076:     return;
        !          2077:   }
        !          2078: }
        !          2079: 
        !          2080: /*
        !          2081: ** Indicate that registers between iReg..iReg+nReg-1 are being overwritten.
        !          2082: ** Purge the range of registers from the column cache.
        !          2083: */
        !          2084: void sqlite3ExprCacheRemove(Parse *pParse, int iReg, int nReg){
        !          2085:   int i;
        !          2086:   int iLast = iReg + nReg - 1;
        !          2087:   struct yColCache *p;
        !          2088:   for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
        !          2089:     int r = p->iReg;
        !          2090:     if( r>=iReg && r<=iLast ){
        !          2091:       cacheEntryClear(pParse, p);
        !          2092:       p->iReg = 0;
        !          2093:     }
        !          2094:   }
        !          2095: }
        !          2096: 
        !          2097: /*
        !          2098: ** Remember the current column cache context.  Any new entries added
        !          2099: ** added to the column cache after this call are removed when the
        !          2100: ** corresponding pop occurs.
        !          2101: */
        !          2102: void sqlite3ExprCachePush(Parse *pParse){
        !          2103:   pParse->iCacheLevel++;
        !          2104: }
        !          2105: 
        !          2106: /*
        !          2107: ** Remove from the column cache any entries that were added since the
        !          2108: ** the previous N Push operations.  In other words, restore the cache
        !          2109: ** to the state it was in N Pushes ago.
        !          2110: */
        !          2111: void sqlite3ExprCachePop(Parse *pParse, int N){
        !          2112:   int i;
        !          2113:   struct yColCache *p;
        !          2114:   assert( N>0 );
        !          2115:   assert( pParse->iCacheLevel>=N );
        !          2116:   pParse->iCacheLevel -= N;
        !          2117:   for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
        !          2118:     if( p->iReg && p->iLevel>pParse->iCacheLevel ){
        !          2119:       cacheEntryClear(pParse, p);
        !          2120:       p->iReg = 0;
        !          2121:     }
        !          2122:   }
        !          2123: }
        !          2124: 
        !          2125: /*
        !          2126: ** When a cached column is reused, make sure that its register is
        !          2127: ** no longer available as a temp register.  ticket #3879:  that same
        !          2128: ** register might be in the cache in multiple places, so be sure to
        !          2129: ** get them all.
        !          2130: */
        !          2131: static void sqlite3ExprCachePinRegister(Parse *pParse, int iReg){
        !          2132:   int i;
        !          2133:   struct yColCache *p;
        !          2134:   for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
        !          2135:     if( p->iReg==iReg ){
        !          2136:       p->tempReg = 0;
        !          2137:     }
        !          2138:   }
        !          2139: }
        !          2140: 
        !          2141: /*
        !          2142: ** Generate code to extract the value of the iCol-th column of a table.
        !          2143: */
        !          2144: void sqlite3ExprCodeGetColumnOfTable(
        !          2145:   Vdbe *v,        /* The VDBE under construction */
        !          2146:   Table *pTab,    /* The table containing the value */
        !          2147:   int iTabCur,    /* The cursor for this table */
        !          2148:   int iCol,       /* Index of the column to extract */
        !          2149:   int regOut      /* Extract the valud into this register */
        !          2150: ){
        !          2151:   if( iCol<0 || iCol==pTab->iPKey ){
        !          2152:     sqlite3VdbeAddOp2(v, OP_Rowid, iTabCur, regOut);
        !          2153:   }else{
        !          2154:     int op = IsVirtual(pTab) ? OP_VColumn : OP_Column;
        !          2155:     sqlite3VdbeAddOp3(v, op, iTabCur, iCol, regOut);
        !          2156:   }
        !          2157:   if( iCol>=0 ){
        !          2158:     sqlite3ColumnDefault(v, pTab, iCol, regOut);
        !          2159:   }
        !          2160: }
        !          2161: 
        !          2162: /*
        !          2163: ** Generate code that will extract the iColumn-th column from
        !          2164: ** table pTab and store the column value in a register.  An effort
        !          2165: ** is made to store the column value in register iReg, but this is
        !          2166: ** not guaranteed.  The location of the column value is returned.
        !          2167: **
        !          2168: ** There must be an open cursor to pTab in iTable when this routine
        !          2169: ** is called.  If iColumn<0 then code is generated that extracts the rowid.
        !          2170: */
        !          2171: int sqlite3ExprCodeGetColumn(
        !          2172:   Parse *pParse,   /* Parsing and code generating context */
        !          2173:   Table *pTab,     /* Description of the table we are reading from */
        !          2174:   int iColumn,     /* Index of the table column */
        !          2175:   int iTable,      /* The cursor pointing to the table */
        !          2176:   int iReg         /* Store results here */
        !          2177: ){
        !          2178:   Vdbe *v = pParse->pVdbe;
        !          2179:   int i;
        !          2180:   struct yColCache *p;
        !          2181: 
        !          2182:   for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
        !          2183:     if( p->iReg>0 && p->iTable==iTable && p->iColumn==iColumn ){
        !          2184:       p->lru = pParse->iCacheCnt++;
        !          2185:       sqlite3ExprCachePinRegister(pParse, p->iReg);
        !          2186:       return p->iReg;
        !          2187:     }
        !          2188:   }  
        !          2189:   assert( v!=0 );
        !          2190:   sqlite3ExprCodeGetColumnOfTable(v, pTab, iTable, iColumn, iReg);
        !          2191:   sqlite3ExprCacheStore(pParse, iTable, iColumn, iReg);
        !          2192:   return iReg;
        !          2193: }
        !          2194: 
        !          2195: /*
        !          2196: ** Clear all column cache entries.
        !          2197: */
        !          2198: void sqlite3ExprCacheClear(Parse *pParse){
        !          2199:   int i;
        !          2200:   struct yColCache *p;
        !          2201: 
        !          2202:   for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
        !          2203:     if( p->iReg ){
        !          2204:       cacheEntryClear(pParse, p);
        !          2205:       p->iReg = 0;
        !          2206:     }
        !          2207:   }
        !          2208: }
        !          2209: 
        !          2210: /*
        !          2211: ** Record the fact that an affinity change has occurred on iCount
        !          2212: ** registers starting with iStart.
        !          2213: */
        !          2214: void sqlite3ExprCacheAffinityChange(Parse *pParse, int iStart, int iCount){
        !          2215:   sqlite3ExprCacheRemove(pParse, iStart, iCount);
        !          2216: }
        !          2217: 
        !          2218: /*
        !          2219: ** Generate code to move content from registers iFrom...iFrom+nReg-1
        !          2220: ** over to iTo..iTo+nReg-1. Keep the column cache up-to-date.
        !          2221: */
        !          2222: void sqlite3ExprCodeMove(Parse *pParse, int iFrom, int iTo, int nReg){
        !          2223:   int i;
        !          2224:   struct yColCache *p;
        !          2225:   if( NEVER(iFrom==iTo) ) return;
        !          2226:   sqlite3VdbeAddOp3(pParse->pVdbe, OP_Move, iFrom, iTo, nReg);
        !          2227:   for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
        !          2228:     int x = p->iReg;
        !          2229:     if( x>=iFrom && x<iFrom+nReg ){
        !          2230:       p->iReg += iTo-iFrom;
        !          2231:     }
        !          2232:   }
        !          2233: }
        !          2234: 
        !          2235: /*
        !          2236: ** Generate code to copy content from registers iFrom...iFrom+nReg-1
        !          2237: ** over to iTo..iTo+nReg-1.
        !          2238: */
        !          2239: void sqlite3ExprCodeCopy(Parse *pParse, int iFrom, int iTo, int nReg){
        !          2240:   int i;
        !          2241:   if( NEVER(iFrom==iTo) ) return;
        !          2242:   for(i=0; i<nReg; i++){
        !          2243:     sqlite3VdbeAddOp2(pParse->pVdbe, OP_Copy, iFrom+i, iTo+i);
        !          2244:   }
        !          2245: }
        !          2246: 
        !          2247: #if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST)
        !          2248: /*
        !          2249: ** Return true if any register in the range iFrom..iTo (inclusive)
        !          2250: ** is used as part of the column cache.
        !          2251: **
        !          2252: ** This routine is used within assert() and testcase() macros only
        !          2253: ** and does not appear in a normal build.
        !          2254: */
        !          2255: static int usedAsColumnCache(Parse *pParse, int iFrom, int iTo){
        !          2256:   int i;
        !          2257:   struct yColCache *p;
        !          2258:   for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
        !          2259:     int r = p->iReg;
        !          2260:     if( r>=iFrom && r<=iTo ) return 1;    /*NO_TEST*/
        !          2261:   }
        !          2262:   return 0;
        !          2263: }
        !          2264: #endif /* SQLITE_DEBUG || SQLITE_COVERAGE_TEST */
        !          2265: 
        !          2266: /*
        !          2267: ** Generate code into the current Vdbe to evaluate the given
        !          2268: ** expression.  Attempt to store the results in register "target".
        !          2269: ** Return the register where results are stored.
        !          2270: **
        !          2271: ** With this routine, there is no guarantee that results will
        !          2272: ** be stored in target.  The result might be stored in some other
        !          2273: ** register if it is convenient to do so.  The calling function
        !          2274: ** must check the return code and move the results to the desired
        !          2275: ** register.
        !          2276: */
        !          2277: int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){
        !          2278:   Vdbe *v = pParse->pVdbe;  /* The VM under construction */
        !          2279:   int op;                   /* The opcode being coded */
        !          2280:   int inReg = target;       /* Results stored in register inReg */
        !          2281:   int regFree1 = 0;         /* If non-zero free this temporary register */
        !          2282:   int regFree2 = 0;         /* If non-zero free this temporary register */
        !          2283:   int r1, r2, r3, r4;       /* Various register numbers */
        !          2284:   sqlite3 *db = pParse->db; /* The database connection */
        !          2285: 
        !          2286:   assert( target>0 && target<=pParse->nMem );
        !          2287:   if( v==0 ){
        !          2288:     assert( pParse->db->mallocFailed );
        !          2289:     return 0;
        !          2290:   }
        !          2291: 
        !          2292:   if( pExpr==0 ){
        !          2293:     op = TK_NULL;
        !          2294:   }else{
        !          2295:     op = pExpr->op;
        !          2296:   }
        !          2297:   switch( op ){
        !          2298:     case TK_AGG_COLUMN: {
        !          2299:       AggInfo *pAggInfo = pExpr->pAggInfo;
        !          2300:       struct AggInfo_col *pCol = &pAggInfo->aCol[pExpr->iAgg];
        !          2301:       if( !pAggInfo->directMode ){
        !          2302:         assert( pCol->iMem>0 );
        !          2303:         inReg = pCol->iMem;
        !          2304:         break;
        !          2305:       }else if( pAggInfo->useSortingIdx ){
        !          2306:         sqlite3VdbeAddOp3(v, OP_Column, pAggInfo->sortingIdxPTab,
        !          2307:                               pCol->iSorterColumn, target);
        !          2308:         break;
        !          2309:       }
        !          2310:       /* Otherwise, fall thru into the TK_COLUMN case */
        !          2311:     }
        !          2312:     case TK_COLUMN: {
        !          2313:       if( pExpr->iTable<0 ){
        !          2314:         /* This only happens when coding check constraints */
        !          2315:         assert( pParse->ckBase>0 );
        !          2316:         inReg = pExpr->iColumn + pParse->ckBase;
        !          2317:       }else{
        !          2318:         inReg = sqlite3ExprCodeGetColumn(pParse, pExpr->pTab,
        !          2319:                                  pExpr->iColumn, pExpr->iTable, target);
        !          2320:       }
        !          2321:       break;
        !          2322:     }
        !          2323:     case TK_INTEGER: {
        !          2324:       codeInteger(pParse, pExpr, 0, target);
        !          2325:       break;
        !          2326:     }
        !          2327: #ifndef SQLITE_OMIT_FLOATING_POINT
        !          2328:     case TK_FLOAT: {
        !          2329:       assert( !ExprHasProperty(pExpr, EP_IntValue) );
        !          2330:       codeReal(v, pExpr->u.zToken, 0, target);
        !          2331:       break;
        !          2332:     }
        !          2333: #endif
        !          2334:     case TK_STRING: {
        !          2335:       assert( !ExprHasProperty(pExpr, EP_IntValue) );
        !          2336:       sqlite3VdbeAddOp4(v, OP_String8, 0, target, 0, pExpr->u.zToken, 0);
        !          2337:       break;
        !          2338:     }
        !          2339:     case TK_NULL: {
        !          2340:       sqlite3VdbeAddOp2(v, OP_Null, 0, target);
        !          2341:       break;
        !          2342:     }
        !          2343: #ifndef SQLITE_OMIT_BLOB_LITERAL
        !          2344:     case TK_BLOB: {
        !          2345:       int n;
        !          2346:       const char *z;
        !          2347:       char *zBlob;
        !          2348:       assert( !ExprHasProperty(pExpr, EP_IntValue) );
        !          2349:       assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
        !          2350:       assert( pExpr->u.zToken[1]=='\'' );
        !          2351:       z = &pExpr->u.zToken[2];
        !          2352:       n = sqlite3Strlen30(z) - 1;
        !          2353:       assert( z[n]=='\'' );
        !          2354:       zBlob = sqlite3HexToBlob(sqlite3VdbeDb(v), z, n);
        !          2355:       sqlite3VdbeAddOp4(v, OP_Blob, n/2, target, 0, zBlob, P4_DYNAMIC);
        !          2356:       break;
        !          2357:     }
        !          2358: #endif
        !          2359:     case TK_VARIABLE: {
        !          2360:       assert( !ExprHasProperty(pExpr, EP_IntValue) );
        !          2361:       assert( pExpr->u.zToken!=0 );
        !          2362:       assert( pExpr->u.zToken[0]!=0 );
        !          2363:       sqlite3VdbeAddOp2(v, OP_Variable, pExpr->iColumn, target);
        !          2364:       if( pExpr->u.zToken[1]!=0 ){
        !          2365:         assert( pExpr->u.zToken[0]=='?' 
        !          2366:              || strcmp(pExpr->u.zToken, pParse->azVar[pExpr->iColumn-1])==0 );
        !          2367:         sqlite3VdbeChangeP4(v, -1, pParse->azVar[pExpr->iColumn-1], P4_STATIC);
        !          2368:       }
        !          2369:       break;
        !          2370:     }
        !          2371:     case TK_REGISTER: {
        !          2372:       inReg = pExpr->iTable;
        !          2373:       break;
        !          2374:     }
        !          2375:     case TK_AS: {
        !          2376:       inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
        !          2377:       break;
        !          2378:     }
        !          2379: #ifndef SQLITE_OMIT_CAST
        !          2380:     case TK_CAST: {
        !          2381:       /* Expressions of the form:   CAST(pLeft AS token) */
        !          2382:       int aff, to_op;
        !          2383:       inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
        !          2384:       assert( !ExprHasProperty(pExpr, EP_IntValue) );
        !          2385:       aff = sqlite3AffinityType(pExpr->u.zToken);
        !          2386:       to_op = aff - SQLITE_AFF_TEXT + OP_ToText;
        !          2387:       assert( to_op==OP_ToText    || aff!=SQLITE_AFF_TEXT    );
        !          2388:       assert( to_op==OP_ToBlob    || aff!=SQLITE_AFF_NONE    );
        !          2389:       assert( to_op==OP_ToNumeric || aff!=SQLITE_AFF_NUMERIC );
        !          2390:       assert( to_op==OP_ToInt     || aff!=SQLITE_AFF_INTEGER );
        !          2391:       assert( to_op==OP_ToReal    || aff!=SQLITE_AFF_REAL    );
        !          2392:       testcase( to_op==OP_ToText );
        !          2393:       testcase( to_op==OP_ToBlob );
        !          2394:       testcase( to_op==OP_ToNumeric );
        !          2395:       testcase( to_op==OP_ToInt );
        !          2396:       testcase( to_op==OP_ToReal );
        !          2397:       if( inReg!=target ){
        !          2398:         sqlite3VdbeAddOp2(v, OP_SCopy, inReg, target);
        !          2399:         inReg = target;
        !          2400:       }
        !          2401:       sqlite3VdbeAddOp1(v, to_op, inReg);
        !          2402:       testcase( usedAsColumnCache(pParse, inReg, inReg) );
        !          2403:       sqlite3ExprCacheAffinityChange(pParse, inReg, 1);
        !          2404:       break;
        !          2405:     }
        !          2406: #endif /* SQLITE_OMIT_CAST */
        !          2407:     case TK_LT:
        !          2408:     case TK_LE:
        !          2409:     case TK_GT:
        !          2410:     case TK_GE:
        !          2411:     case TK_NE:
        !          2412:     case TK_EQ: {
        !          2413:       assert( TK_LT==OP_Lt );
        !          2414:       assert( TK_LE==OP_Le );
        !          2415:       assert( TK_GT==OP_Gt );
        !          2416:       assert( TK_GE==OP_Ge );
        !          2417:       assert( TK_EQ==OP_Eq );
        !          2418:       assert( TK_NE==OP_Ne );
        !          2419:       testcase( op==TK_LT );
        !          2420:       testcase( op==TK_LE );
        !          2421:       testcase( op==TK_GT );
        !          2422:       testcase( op==TK_GE );
        !          2423:       testcase( op==TK_EQ );
        !          2424:       testcase( op==TK_NE );
        !          2425:       r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
        !          2426:       r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
        !          2427:       codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
        !          2428:                   r1, r2, inReg, SQLITE_STOREP2);
        !          2429:       testcase( regFree1==0 );
        !          2430:       testcase( regFree2==0 );
        !          2431:       break;
        !          2432:     }
        !          2433:     case TK_IS:
        !          2434:     case TK_ISNOT: {
        !          2435:       testcase( op==TK_IS );
        !          2436:       testcase( op==TK_ISNOT );
        !          2437:       r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
        !          2438:       r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
        !          2439:       op = (op==TK_IS) ? TK_EQ : TK_NE;
        !          2440:       codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
        !          2441:                   r1, r2, inReg, SQLITE_STOREP2 | SQLITE_NULLEQ);
        !          2442:       testcase( regFree1==0 );
        !          2443:       testcase( regFree2==0 );
        !          2444:       break;
        !          2445:     }
        !          2446:     case TK_AND:
        !          2447:     case TK_OR:
        !          2448:     case TK_PLUS:
        !          2449:     case TK_STAR:
        !          2450:     case TK_MINUS:
        !          2451:     case TK_REM:
        !          2452:     case TK_BITAND:
        !          2453:     case TK_BITOR:
        !          2454:     case TK_SLASH:
        !          2455:     case TK_LSHIFT:
        !          2456:     case TK_RSHIFT: 
        !          2457:     case TK_CONCAT: {
        !          2458:       assert( TK_AND==OP_And );
        !          2459:       assert( TK_OR==OP_Or );
        !          2460:       assert( TK_PLUS==OP_Add );
        !          2461:       assert( TK_MINUS==OP_Subtract );
        !          2462:       assert( TK_REM==OP_Remainder );
        !          2463:       assert( TK_BITAND==OP_BitAnd );
        !          2464:       assert( TK_BITOR==OP_BitOr );
        !          2465:       assert( TK_SLASH==OP_Divide );
        !          2466:       assert( TK_LSHIFT==OP_ShiftLeft );
        !          2467:       assert( TK_RSHIFT==OP_ShiftRight );
        !          2468:       assert( TK_CONCAT==OP_Concat );
        !          2469:       testcase( op==TK_AND );
        !          2470:       testcase( op==TK_OR );
        !          2471:       testcase( op==TK_PLUS );
        !          2472:       testcase( op==TK_MINUS );
        !          2473:       testcase( op==TK_REM );
        !          2474:       testcase( op==TK_BITAND );
        !          2475:       testcase( op==TK_BITOR );
        !          2476:       testcase( op==TK_SLASH );
        !          2477:       testcase( op==TK_LSHIFT );
        !          2478:       testcase( op==TK_RSHIFT );
        !          2479:       testcase( op==TK_CONCAT );
        !          2480:       r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
        !          2481:       r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
        !          2482:       sqlite3VdbeAddOp3(v, op, r2, r1, target);
        !          2483:       testcase( regFree1==0 );
        !          2484:       testcase( regFree2==0 );
        !          2485:       break;
        !          2486:     }
        !          2487:     case TK_UMINUS: {
        !          2488:       Expr *pLeft = pExpr->pLeft;
        !          2489:       assert( pLeft );
        !          2490:       if( pLeft->op==TK_INTEGER ){
        !          2491:         codeInteger(pParse, pLeft, 1, target);
        !          2492: #ifndef SQLITE_OMIT_FLOATING_POINT
        !          2493:       }else if( pLeft->op==TK_FLOAT ){
        !          2494:         assert( !ExprHasProperty(pExpr, EP_IntValue) );
        !          2495:         codeReal(v, pLeft->u.zToken, 1, target);
        !          2496: #endif
        !          2497:       }else{
        !          2498:         regFree1 = r1 = sqlite3GetTempReg(pParse);
        !          2499:         sqlite3VdbeAddOp2(v, OP_Integer, 0, r1);
        !          2500:         r2 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree2);
        !          2501:         sqlite3VdbeAddOp3(v, OP_Subtract, r2, r1, target);
        !          2502:         testcase( regFree2==0 );
        !          2503:       }
        !          2504:       inReg = target;
        !          2505:       break;
        !          2506:     }
        !          2507:     case TK_BITNOT:
        !          2508:     case TK_NOT: {
        !          2509:       assert( TK_BITNOT==OP_BitNot );
        !          2510:       assert( TK_NOT==OP_Not );
        !          2511:       testcase( op==TK_BITNOT );
        !          2512:       testcase( op==TK_NOT );
        !          2513:       r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
        !          2514:       testcase( regFree1==0 );
        !          2515:       inReg = target;
        !          2516:       sqlite3VdbeAddOp2(v, op, r1, inReg);
        !          2517:       break;
        !          2518:     }
        !          2519:     case TK_ISNULL:
        !          2520:     case TK_NOTNULL: {
        !          2521:       int addr;
        !          2522:       assert( TK_ISNULL==OP_IsNull );
        !          2523:       assert( TK_NOTNULL==OP_NotNull );
        !          2524:       testcase( op==TK_ISNULL );
        !          2525:       testcase( op==TK_NOTNULL );
        !          2526:       sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
        !          2527:       r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
        !          2528:       testcase( regFree1==0 );
        !          2529:       addr = sqlite3VdbeAddOp1(v, op, r1);
        !          2530:       sqlite3VdbeAddOp2(v, OP_AddImm, target, -1);
        !          2531:       sqlite3VdbeJumpHere(v, addr);
        !          2532:       break;
        !          2533:     }
        !          2534:     case TK_AGG_FUNCTION: {
        !          2535:       AggInfo *pInfo = pExpr->pAggInfo;
        !          2536:       if( pInfo==0 ){
        !          2537:         assert( !ExprHasProperty(pExpr, EP_IntValue) );
        !          2538:         sqlite3ErrorMsg(pParse, "misuse of aggregate: %s()", pExpr->u.zToken);
        !          2539:       }else{
        !          2540:         inReg = pInfo->aFunc[pExpr->iAgg].iMem;
        !          2541:       }
        !          2542:       break;
        !          2543:     }
        !          2544:     case TK_CONST_FUNC:
        !          2545:     case TK_FUNCTION: {
        !          2546:       ExprList *pFarg;       /* List of function arguments */
        !          2547:       int nFarg;             /* Number of function arguments */
        !          2548:       FuncDef *pDef;         /* The function definition object */
        !          2549:       int nId;               /* Length of the function name in bytes */
        !          2550:       const char *zId;       /* The function name */
        !          2551:       int constMask = 0;     /* Mask of function arguments that are constant */
        !          2552:       int i;                 /* Loop counter */
        !          2553:       u8 enc = ENC(db);      /* The text encoding used by this database */
        !          2554:       CollSeq *pColl = 0;    /* A collating sequence */
        !          2555: 
        !          2556:       assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
        !          2557:       testcase( op==TK_CONST_FUNC );
        !          2558:       testcase( op==TK_FUNCTION );
        !          2559:       if( ExprHasAnyProperty(pExpr, EP_TokenOnly) ){
        !          2560:         pFarg = 0;
        !          2561:       }else{
        !          2562:         pFarg = pExpr->x.pList;
        !          2563:       }
        !          2564:       nFarg = pFarg ? pFarg->nExpr : 0;
        !          2565:       assert( !ExprHasProperty(pExpr, EP_IntValue) );
        !          2566:       zId = pExpr->u.zToken;
        !          2567:       nId = sqlite3Strlen30(zId);
        !          2568:       pDef = sqlite3FindFunction(db, zId, nId, nFarg, enc, 0);
        !          2569:       if( pDef==0 ){
        !          2570:         sqlite3ErrorMsg(pParse, "unknown function: %.*s()", nId, zId);
        !          2571:         break;
        !          2572:       }
        !          2573: 
        !          2574:       /* Attempt a direct implementation of the built-in COALESCE() and
        !          2575:       ** IFNULL() functions.  This avoids unnecessary evalation of
        !          2576:       ** arguments past the first non-NULL argument.
        !          2577:       */
        !          2578:       if( pDef->flags & SQLITE_FUNC_COALESCE ){
        !          2579:         int endCoalesce = sqlite3VdbeMakeLabel(v);
        !          2580:         assert( nFarg>=2 );
        !          2581:         sqlite3ExprCode(pParse, pFarg->a[0].pExpr, target);
        !          2582:         for(i=1; i<nFarg; i++){
        !          2583:           sqlite3VdbeAddOp2(v, OP_NotNull, target, endCoalesce);
        !          2584:           sqlite3ExprCacheRemove(pParse, target, 1);
        !          2585:           sqlite3ExprCachePush(pParse);
        !          2586:           sqlite3ExprCode(pParse, pFarg->a[i].pExpr, target);
        !          2587:           sqlite3ExprCachePop(pParse, 1);
        !          2588:         }
        !          2589:         sqlite3VdbeResolveLabel(v, endCoalesce);
        !          2590:         break;
        !          2591:       }
        !          2592: 
        !          2593: 
        !          2594:       if( pFarg ){
        !          2595:         r1 = sqlite3GetTempRange(pParse, nFarg);
        !          2596:         sqlite3ExprCachePush(pParse);     /* Ticket 2ea2425d34be */
        !          2597:         sqlite3ExprCodeExprList(pParse, pFarg, r1, 1);
        !          2598:         sqlite3ExprCachePop(pParse, 1);   /* Ticket 2ea2425d34be */
        !          2599:       }else{
        !          2600:         r1 = 0;
        !          2601:       }
        !          2602: #ifndef SQLITE_OMIT_VIRTUALTABLE
        !          2603:       /* Possibly overload the function if the first argument is
        !          2604:       ** a virtual table column.
        !          2605:       **
        !          2606:       ** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the
        !          2607:       ** second argument, not the first, as the argument to test to
        !          2608:       ** see if it is a column in a virtual table.  This is done because
        !          2609:       ** the left operand of infix functions (the operand we want to
        !          2610:       ** control overloading) ends up as the second argument to the
        !          2611:       ** function.  The expression "A glob B" is equivalent to 
        !          2612:       ** "glob(B,A).  We want to use the A in "A glob B" to test
        !          2613:       ** for function overloading.  But we use the B term in "glob(B,A)".
        !          2614:       */
        !          2615:       if( nFarg>=2 && (pExpr->flags & EP_InfixFunc) ){
        !          2616:         pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[1].pExpr);
        !          2617:       }else if( nFarg>0 ){
        !          2618:         pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[0].pExpr);
        !          2619:       }
        !          2620: #endif
        !          2621:       for(i=0; i<nFarg; i++){
        !          2622:         if( i<32 && sqlite3ExprIsConstant(pFarg->a[i].pExpr) ){
        !          2623:           constMask |= (1<<i);
        !          2624:         }
        !          2625:         if( (pDef->flags & SQLITE_FUNC_NEEDCOLL)!=0 && !pColl ){
        !          2626:           pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr);
        !          2627:         }
        !          2628:       }
        !          2629:       if( pDef->flags & SQLITE_FUNC_NEEDCOLL ){
        !          2630:         if( !pColl ) pColl = db->pDfltColl; 
        !          2631:         sqlite3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ);
        !          2632:       }
        !          2633:       sqlite3VdbeAddOp4(v, OP_Function, constMask, r1, target,
        !          2634:                         (char*)pDef, P4_FUNCDEF);
        !          2635:       sqlite3VdbeChangeP5(v, (u8)nFarg);
        !          2636:       if( nFarg ){
        !          2637:         sqlite3ReleaseTempRange(pParse, r1, nFarg);
        !          2638:       }
        !          2639:       break;
        !          2640:     }
        !          2641: #ifndef SQLITE_OMIT_SUBQUERY
        !          2642:     case TK_EXISTS:
        !          2643:     case TK_SELECT: {
        !          2644:       testcase( op==TK_EXISTS );
        !          2645:       testcase( op==TK_SELECT );
        !          2646:       inReg = sqlite3CodeSubselect(pParse, pExpr, 0, 0);
        !          2647:       break;
        !          2648:     }
        !          2649:     case TK_IN: {
        !          2650:       int destIfFalse = sqlite3VdbeMakeLabel(v);
        !          2651:       int destIfNull = sqlite3VdbeMakeLabel(v);
        !          2652:       sqlite3VdbeAddOp2(v, OP_Null, 0, target);
        !          2653:       sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
        !          2654:       sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
        !          2655:       sqlite3VdbeResolveLabel(v, destIfFalse);
        !          2656:       sqlite3VdbeAddOp2(v, OP_AddImm, target, 0);
        !          2657:       sqlite3VdbeResolveLabel(v, destIfNull);
        !          2658:       break;
        !          2659:     }
        !          2660: #endif /* SQLITE_OMIT_SUBQUERY */
        !          2661: 
        !          2662: 
        !          2663:     /*
        !          2664:     **    x BETWEEN y AND z
        !          2665:     **
        !          2666:     ** This is equivalent to
        !          2667:     **
        !          2668:     **    x>=y AND x<=z
        !          2669:     **
        !          2670:     ** X is stored in pExpr->pLeft.
        !          2671:     ** Y is stored in pExpr->pList->a[0].pExpr.
        !          2672:     ** Z is stored in pExpr->pList->a[1].pExpr.
        !          2673:     */
        !          2674:     case TK_BETWEEN: {
        !          2675:       Expr *pLeft = pExpr->pLeft;
        !          2676:       struct ExprList_item *pLItem = pExpr->x.pList->a;
        !          2677:       Expr *pRight = pLItem->pExpr;
        !          2678: 
        !          2679:       r1 = sqlite3ExprCodeTemp(pParse, pLeft, &regFree1);
        !          2680:       r2 = sqlite3ExprCodeTemp(pParse, pRight, &regFree2);
        !          2681:       testcase( regFree1==0 );
        !          2682:       testcase( regFree2==0 );
        !          2683:       r3 = sqlite3GetTempReg(pParse);
        !          2684:       r4 = sqlite3GetTempReg(pParse);
        !          2685:       codeCompare(pParse, pLeft, pRight, OP_Ge,
        !          2686:                   r1, r2, r3, SQLITE_STOREP2);
        !          2687:       pLItem++;
        !          2688:       pRight = pLItem->pExpr;
        !          2689:       sqlite3ReleaseTempReg(pParse, regFree2);
        !          2690:       r2 = sqlite3ExprCodeTemp(pParse, pRight, &regFree2);
        !          2691:       testcase( regFree2==0 );
        !          2692:       codeCompare(pParse, pLeft, pRight, OP_Le, r1, r2, r4, SQLITE_STOREP2);
        !          2693:       sqlite3VdbeAddOp3(v, OP_And, r3, r4, target);
        !          2694:       sqlite3ReleaseTempReg(pParse, r3);
        !          2695:       sqlite3ReleaseTempReg(pParse, r4);
        !          2696:       break;
        !          2697:     }
        !          2698:     case TK_UPLUS: {
        !          2699:       inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
        !          2700:       break;
        !          2701:     }
        !          2702: 
        !          2703:     case TK_TRIGGER: {
        !          2704:       /* If the opcode is TK_TRIGGER, then the expression is a reference
        !          2705:       ** to a column in the new.* or old.* pseudo-tables available to
        !          2706:       ** trigger programs. In this case Expr.iTable is set to 1 for the
        !          2707:       ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
        !          2708:       ** is set to the column of the pseudo-table to read, or to -1 to
        !          2709:       ** read the rowid field.
        !          2710:       **
        !          2711:       ** The expression is implemented using an OP_Param opcode. The p1
        !          2712:       ** parameter is set to 0 for an old.rowid reference, or to (i+1)
        !          2713:       ** to reference another column of the old.* pseudo-table, where 
        !          2714:       ** i is the index of the column. For a new.rowid reference, p1 is
        !          2715:       ** set to (n+1), where n is the number of columns in each pseudo-table.
        !          2716:       ** For a reference to any other column in the new.* pseudo-table, p1
        !          2717:       ** is set to (n+2+i), where n and i are as defined previously. For
        !          2718:       ** example, if the table on which triggers are being fired is
        !          2719:       ** declared as:
        !          2720:       **
        !          2721:       **   CREATE TABLE t1(a, b);
        !          2722:       **
        !          2723:       ** Then p1 is interpreted as follows:
        !          2724:       **
        !          2725:       **   p1==0   ->    old.rowid     p1==3   ->    new.rowid
        !          2726:       **   p1==1   ->    old.a         p1==4   ->    new.a
        !          2727:       **   p1==2   ->    old.b         p1==5   ->    new.b       
        !          2728:       */
        !          2729:       Table *pTab = pExpr->pTab;
        !          2730:       int p1 = pExpr->iTable * (pTab->nCol+1) + 1 + pExpr->iColumn;
        !          2731: 
        !          2732:       assert( pExpr->iTable==0 || pExpr->iTable==1 );
        !          2733:       assert( pExpr->iColumn>=-1 && pExpr->iColumn<pTab->nCol );
        !          2734:       assert( pTab->iPKey<0 || pExpr->iColumn!=pTab->iPKey );
        !          2735:       assert( p1>=0 && p1<(pTab->nCol*2+2) );
        !          2736: 
        !          2737:       sqlite3VdbeAddOp2(v, OP_Param, p1, target);
        !          2738:       VdbeComment((v, "%s.%s -> $%d",
        !          2739:         (pExpr->iTable ? "new" : "old"),
        !          2740:         (pExpr->iColumn<0 ? "rowid" : pExpr->pTab->aCol[pExpr->iColumn].zName),
        !          2741:         target
        !          2742:       ));
        !          2743: 
        !          2744: #ifndef SQLITE_OMIT_FLOATING_POINT
        !          2745:       /* If the column has REAL affinity, it may currently be stored as an
        !          2746:       ** integer. Use OP_RealAffinity to make sure it is really real.  */
        !          2747:       if( pExpr->iColumn>=0 
        !          2748:        && pTab->aCol[pExpr->iColumn].affinity==SQLITE_AFF_REAL
        !          2749:       ){
        !          2750:         sqlite3VdbeAddOp1(v, OP_RealAffinity, target);
        !          2751:       }
        !          2752: #endif
        !          2753:       break;
        !          2754:     }
        !          2755: 
        !          2756: 
        !          2757:     /*
        !          2758:     ** Form A:
        !          2759:     **   CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
        !          2760:     **
        !          2761:     ** Form B:
        !          2762:     **   CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
        !          2763:     **
        !          2764:     ** Form A is can be transformed into the equivalent form B as follows:
        !          2765:     **   CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ...
        !          2766:     **        WHEN x=eN THEN rN ELSE y END
        !          2767:     **
        !          2768:     ** X (if it exists) is in pExpr->pLeft.
        !          2769:     ** Y is in pExpr->pRight.  The Y is also optional.  If there is no
        !          2770:     ** ELSE clause and no other term matches, then the result of the
        !          2771:     ** exprssion is NULL.
        !          2772:     ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1].
        !          2773:     **
        !          2774:     ** The result of the expression is the Ri for the first matching Ei,
        !          2775:     ** or if there is no matching Ei, the ELSE term Y, or if there is
        !          2776:     ** no ELSE term, NULL.
        !          2777:     */
        !          2778:     default: assert( op==TK_CASE ); {
        !          2779:       int endLabel;                     /* GOTO label for end of CASE stmt */
        !          2780:       int nextCase;                     /* GOTO label for next WHEN clause */
        !          2781:       int nExpr;                        /* 2x number of WHEN terms */
        !          2782:       int i;                            /* Loop counter */
        !          2783:       ExprList *pEList;                 /* List of WHEN terms */
        !          2784:       struct ExprList_item *aListelem;  /* Array of WHEN terms */
        !          2785:       Expr opCompare;                   /* The X==Ei expression */
        !          2786:       Expr cacheX;                      /* Cached expression X */
        !          2787:       Expr *pX;                         /* The X expression */
        !          2788:       Expr *pTest = 0;                  /* X==Ei (form A) or just Ei (form B) */
        !          2789:       VVA_ONLY( int iCacheLevel = pParse->iCacheLevel; )
        !          2790: 
        !          2791:       assert( !ExprHasProperty(pExpr, EP_xIsSelect) && pExpr->x.pList );
        !          2792:       assert((pExpr->x.pList->nExpr % 2) == 0);
        !          2793:       assert(pExpr->x.pList->nExpr > 0);
        !          2794:       pEList = pExpr->x.pList;
        !          2795:       aListelem = pEList->a;
        !          2796:       nExpr = pEList->nExpr;
        !          2797:       endLabel = sqlite3VdbeMakeLabel(v);
        !          2798:       if( (pX = pExpr->pLeft)!=0 ){
        !          2799:         cacheX = *pX;
        !          2800:         testcase( pX->op==TK_COLUMN );
        !          2801:         testcase( pX->op==TK_REGISTER );
        !          2802:         cacheX.iTable = sqlite3ExprCodeTemp(pParse, pX, &regFree1);
        !          2803:         testcase( regFree1==0 );
        !          2804:         cacheX.op = TK_REGISTER;
        !          2805:         opCompare.op = TK_EQ;
        !          2806:         opCompare.pLeft = &cacheX;
        !          2807:         pTest = &opCompare;
        !          2808:         /* Ticket b351d95f9cd5ef17e9d9dbae18f5ca8611190001:
        !          2809:         ** The value in regFree1 might get SCopy-ed into the file result.
        !          2810:         ** So make sure that the regFree1 register is not reused for other
        !          2811:         ** purposes and possibly overwritten.  */
        !          2812:         regFree1 = 0;
        !          2813:       }
        !          2814:       for(i=0; i<nExpr; i=i+2){
        !          2815:         sqlite3ExprCachePush(pParse);
        !          2816:         if( pX ){
        !          2817:           assert( pTest!=0 );
        !          2818:           opCompare.pRight = aListelem[i].pExpr;
        !          2819:         }else{
        !          2820:           pTest = aListelem[i].pExpr;
        !          2821:         }
        !          2822:         nextCase = sqlite3VdbeMakeLabel(v);
        !          2823:         testcase( pTest->op==TK_COLUMN );
        !          2824:         sqlite3ExprIfFalse(pParse, pTest, nextCase, SQLITE_JUMPIFNULL);
        !          2825:         testcase( aListelem[i+1].pExpr->op==TK_COLUMN );
        !          2826:         testcase( aListelem[i+1].pExpr->op==TK_REGISTER );
        !          2827:         sqlite3ExprCode(pParse, aListelem[i+1].pExpr, target);
        !          2828:         sqlite3VdbeAddOp2(v, OP_Goto, 0, endLabel);
        !          2829:         sqlite3ExprCachePop(pParse, 1);
        !          2830:         sqlite3VdbeResolveLabel(v, nextCase);
        !          2831:       }
        !          2832:       if( pExpr->pRight ){
        !          2833:         sqlite3ExprCachePush(pParse);
        !          2834:         sqlite3ExprCode(pParse, pExpr->pRight, target);
        !          2835:         sqlite3ExprCachePop(pParse, 1);
        !          2836:       }else{
        !          2837:         sqlite3VdbeAddOp2(v, OP_Null, 0, target);
        !          2838:       }
        !          2839:       assert( db->mallocFailed || pParse->nErr>0 
        !          2840:            || pParse->iCacheLevel==iCacheLevel );
        !          2841:       sqlite3VdbeResolveLabel(v, endLabel);
        !          2842:       break;
        !          2843:     }
        !          2844: #ifndef SQLITE_OMIT_TRIGGER
        !          2845:     case TK_RAISE: {
        !          2846:       assert( pExpr->affinity==OE_Rollback 
        !          2847:            || pExpr->affinity==OE_Abort
        !          2848:            || pExpr->affinity==OE_Fail
        !          2849:            || pExpr->affinity==OE_Ignore
        !          2850:       );
        !          2851:       if( !pParse->pTriggerTab ){
        !          2852:         sqlite3ErrorMsg(pParse,
        !          2853:                        "RAISE() may only be used within a trigger-program");
        !          2854:         return 0;
        !          2855:       }
        !          2856:       if( pExpr->affinity==OE_Abort ){
        !          2857:         sqlite3MayAbort(pParse);
        !          2858:       }
        !          2859:       assert( !ExprHasProperty(pExpr, EP_IntValue) );
        !          2860:       if( pExpr->affinity==OE_Ignore ){
        !          2861:         sqlite3VdbeAddOp4(
        !          2862:             v, OP_Halt, SQLITE_OK, OE_Ignore, 0, pExpr->u.zToken,0);
        !          2863:       }else{
        !          2864:         sqlite3HaltConstraint(pParse, pExpr->affinity, pExpr->u.zToken, 0);
        !          2865:       }
        !          2866: 
        !          2867:       break;
        !          2868:     }
        !          2869: #endif
        !          2870:   }
        !          2871:   sqlite3ReleaseTempReg(pParse, regFree1);
        !          2872:   sqlite3ReleaseTempReg(pParse, regFree2);
        !          2873:   return inReg;
        !          2874: }
        !          2875: 
        !          2876: /*
        !          2877: ** Generate code to evaluate an expression and store the results
        !          2878: ** into a register.  Return the register number where the results
        !          2879: ** are stored.
        !          2880: **
        !          2881: ** If the register is a temporary register that can be deallocated,
        !          2882: ** then write its number into *pReg.  If the result register is not
        !          2883: ** a temporary, then set *pReg to zero.
        !          2884: */
        !          2885: int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){
        !          2886:   int r1 = sqlite3GetTempReg(pParse);
        !          2887:   int r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
        !          2888:   if( r2==r1 ){
        !          2889:     *pReg = r1;
        !          2890:   }else{
        !          2891:     sqlite3ReleaseTempReg(pParse, r1);
        !          2892:     *pReg = 0;
        !          2893:   }
        !          2894:   return r2;
        !          2895: }
        !          2896: 
        !          2897: /*
        !          2898: ** Generate code that will evaluate expression pExpr and store the
        !          2899: ** results in register target.  The results are guaranteed to appear
        !          2900: ** in register target.
        !          2901: */
        !          2902: int sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){
        !          2903:   int inReg;
        !          2904: 
        !          2905:   assert( target>0 && target<=pParse->nMem );
        !          2906:   if( pExpr && pExpr->op==TK_REGISTER ){
        !          2907:     sqlite3VdbeAddOp2(pParse->pVdbe, OP_Copy, pExpr->iTable, target);
        !          2908:   }else{
        !          2909:     inReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
        !          2910:     assert( pParse->pVdbe || pParse->db->mallocFailed );
        !          2911:     if( inReg!=target && pParse->pVdbe ){
        !          2912:       sqlite3VdbeAddOp2(pParse->pVdbe, OP_SCopy, inReg, target);
        !          2913:     }
        !          2914:   }
        !          2915:   return target;
        !          2916: }
        !          2917: 
        !          2918: /*
        !          2919: ** Generate code that evalutes the given expression and puts the result
        !          2920: ** in register target.
        !          2921: **
        !          2922: ** Also make a copy of the expression results into another "cache" register
        !          2923: ** and modify the expression so that the next time it is evaluated,
        !          2924: ** the result is a copy of the cache register.
        !          2925: **
        !          2926: ** This routine is used for expressions that are used multiple 
        !          2927: ** times.  They are evaluated once and the results of the expression
        !          2928: ** are reused.
        !          2929: */
        !          2930: int sqlite3ExprCodeAndCache(Parse *pParse, Expr *pExpr, int target){
        !          2931:   Vdbe *v = pParse->pVdbe;
        !          2932:   int inReg;
        !          2933:   inReg = sqlite3ExprCode(pParse, pExpr, target);
        !          2934:   assert( target>0 );
        !          2935:   /* This routine is called for terms to INSERT or UPDATE.  And the only
        !          2936:   ** other place where expressions can be converted into TK_REGISTER is
        !          2937:   ** in WHERE clause processing.  So as currently implemented, there is
        !          2938:   ** no way for a TK_REGISTER to exist here.  But it seems prudent to
        !          2939:   ** keep the ALWAYS() in case the conditions above change with future
        !          2940:   ** modifications or enhancements. */
        !          2941:   if( ALWAYS(pExpr->op!=TK_REGISTER) ){  
        !          2942:     int iMem;
        !          2943:     iMem = ++pParse->nMem;
        !          2944:     sqlite3VdbeAddOp2(v, OP_Copy, inReg, iMem);
        !          2945:     pExpr->iTable = iMem;
        !          2946:     pExpr->op2 = pExpr->op;
        !          2947:     pExpr->op = TK_REGISTER;
        !          2948:   }
        !          2949:   return inReg;
        !          2950: }
        !          2951: 
        !          2952: #if defined(SQLITE_ENABLE_TREE_EXPLAIN)
        !          2953: /*
        !          2954: ** Generate a human-readable explanation of an expression tree.
        !          2955: */
        !          2956: void sqlite3ExplainExpr(Vdbe *pOut, Expr *pExpr){
        !          2957:   int op;                   /* The opcode being coded */
        !          2958:   const char *zBinOp = 0;   /* Binary operator */
        !          2959:   const char *zUniOp = 0;   /* Unary operator */
        !          2960:   if( pExpr==0 ){
        !          2961:     op = TK_NULL;
        !          2962:   }else{
        !          2963:     op = pExpr->op;
        !          2964:   }
        !          2965:   switch( op ){
        !          2966:     case TK_AGG_COLUMN: {
        !          2967:       sqlite3ExplainPrintf(pOut, "AGG{%d:%d}",
        !          2968:             pExpr->iTable, pExpr->iColumn);
        !          2969:       break;
        !          2970:     }
        !          2971:     case TK_COLUMN: {
        !          2972:       if( pExpr->iTable<0 ){
        !          2973:         /* This only happens when coding check constraints */
        !          2974:         sqlite3ExplainPrintf(pOut, "COLUMN(%d)", pExpr->iColumn);
        !          2975:       }else{
        !          2976:         sqlite3ExplainPrintf(pOut, "{%d:%d}",
        !          2977:                              pExpr->iTable, pExpr->iColumn);
        !          2978:       }
        !          2979:       break;
        !          2980:     }
        !          2981:     case TK_INTEGER: {
        !          2982:       if( pExpr->flags & EP_IntValue ){
        !          2983:         sqlite3ExplainPrintf(pOut, "%d", pExpr->u.iValue);
        !          2984:       }else{
        !          2985:         sqlite3ExplainPrintf(pOut, "%s", pExpr->u.zToken);
        !          2986:       }
        !          2987:       break;
        !          2988:     }
        !          2989: #ifndef SQLITE_OMIT_FLOATING_POINT
        !          2990:     case TK_FLOAT: {
        !          2991:       sqlite3ExplainPrintf(pOut,"%s", pExpr->u.zToken);
        !          2992:       break;
        !          2993:     }
        !          2994: #endif
        !          2995:     case TK_STRING: {
        !          2996:       sqlite3ExplainPrintf(pOut,"%Q", pExpr->u.zToken);
        !          2997:       break;
        !          2998:     }
        !          2999:     case TK_NULL: {
        !          3000:       sqlite3ExplainPrintf(pOut,"NULL");
        !          3001:       break;
        !          3002:     }
        !          3003: #ifndef SQLITE_OMIT_BLOB_LITERAL
        !          3004:     case TK_BLOB: {
        !          3005:       sqlite3ExplainPrintf(pOut,"%s", pExpr->u.zToken);
        !          3006:       break;
        !          3007:     }
        !          3008: #endif
        !          3009:     case TK_VARIABLE: {
        !          3010:       sqlite3ExplainPrintf(pOut,"VARIABLE(%s,%d)",
        !          3011:                            pExpr->u.zToken, pExpr->iColumn);
        !          3012:       break;
        !          3013:     }
        !          3014:     case TK_REGISTER: {
        !          3015:       sqlite3ExplainPrintf(pOut,"REGISTER(%d)", pExpr->iTable);
        !          3016:       break;
        !          3017:     }
        !          3018:     case TK_AS: {
        !          3019:       sqlite3ExplainExpr(pOut, pExpr->pLeft);
        !          3020:       break;
        !          3021:     }
        !          3022: #ifndef SQLITE_OMIT_CAST
        !          3023:     case TK_CAST: {
        !          3024:       /* Expressions of the form:   CAST(pLeft AS token) */
        !          3025:       const char *zAff = "unk";
        !          3026:       switch( sqlite3AffinityType(pExpr->u.zToken) ){
        !          3027:         case SQLITE_AFF_TEXT:    zAff = "TEXT";     break;
        !          3028:         case SQLITE_AFF_NONE:    zAff = "NONE";     break;
        !          3029:         case SQLITE_AFF_NUMERIC: zAff = "NUMERIC";  break;
        !          3030:         case SQLITE_AFF_INTEGER: zAff = "INTEGER";  break;
        !          3031:         case SQLITE_AFF_REAL:    zAff = "REAL";     break;
        !          3032:       }
        !          3033:       sqlite3ExplainPrintf(pOut, "CAST-%s(", zAff);
        !          3034:       sqlite3ExplainExpr(pOut, pExpr->pLeft);
        !          3035:       sqlite3ExplainPrintf(pOut, ")");
        !          3036:       break;
        !          3037:     }
        !          3038: #endif /* SQLITE_OMIT_CAST */
        !          3039:     case TK_LT:      zBinOp = "LT";     break;
        !          3040:     case TK_LE:      zBinOp = "LE";     break;
        !          3041:     case TK_GT:      zBinOp = "GT";     break;
        !          3042:     case TK_GE:      zBinOp = "GE";     break;
        !          3043:     case TK_NE:      zBinOp = "NE";     break;
        !          3044:     case TK_EQ:      zBinOp = "EQ";     break;
        !          3045:     case TK_IS:      zBinOp = "IS";     break;
        !          3046:     case TK_ISNOT:   zBinOp = "ISNOT";  break;
        !          3047:     case TK_AND:     zBinOp = "AND";    break;
        !          3048:     case TK_OR:      zBinOp = "OR";     break;
        !          3049:     case TK_PLUS:    zBinOp = "ADD";    break;
        !          3050:     case TK_STAR:    zBinOp = "MUL";    break;
        !          3051:     case TK_MINUS:   zBinOp = "SUB";    break;
        !          3052:     case TK_REM:     zBinOp = "REM";    break;
        !          3053:     case TK_BITAND:  zBinOp = "BITAND"; break;
        !          3054:     case TK_BITOR:   zBinOp = "BITOR";  break;
        !          3055:     case TK_SLASH:   zBinOp = "DIV";    break;
        !          3056:     case TK_LSHIFT:  zBinOp = "LSHIFT"; break;
        !          3057:     case TK_RSHIFT:  zBinOp = "RSHIFT"; break;
        !          3058:     case TK_CONCAT:  zBinOp = "CONCAT"; break;
        !          3059: 
        !          3060:     case TK_UMINUS:  zUniOp = "UMINUS"; break;
        !          3061:     case TK_UPLUS:   zUniOp = "UPLUS";  break;
        !          3062:     case TK_BITNOT:  zUniOp = "BITNOT"; break;
        !          3063:     case TK_NOT:     zUniOp = "NOT";    break;
        !          3064:     case TK_ISNULL:  zUniOp = "ISNULL"; break;
        !          3065:     case TK_NOTNULL: zUniOp = "NOTNULL"; break;
        !          3066: 
        !          3067:     case TK_AGG_FUNCTION:
        !          3068:     case TK_CONST_FUNC:
        !          3069:     case TK_FUNCTION: {
        !          3070:       ExprList *pFarg;       /* List of function arguments */
        !          3071:       if( ExprHasAnyProperty(pExpr, EP_TokenOnly) ){
        !          3072:         pFarg = 0;
        !          3073:       }else{
        !          3074:         pFarg = pExpr->x.pList;
        !          3075:       }
        !          3076:       sqlite3ExplainPrintf(pOut, "%sFUNCTION:%s(",
        !          3077:                            op==TK_AGG_FUNCTION ? "AGG_" : "",
        !          3078:                            pExpr->u.zToken);
        !          3079:       if( pFarg ){
        !          3080:         sqlite3ExplainExprList(pOut, pFarg);
        !          3081:       }
        !          3082:       sqlite3ExplainPrintf(pOut, ")");
        !          3083:       break;
        !          3084:     }
        !          3085: #ifndef SQLITE_OMIT_SUBQUERY
        !          3086:     case TK_EXISTS: {
        !          3087:       sqlite3ExplainPrintf(pOut, "EXISTS(");
        !          3088:       sqlite3ExplainSelect(pOut, pExpr->x.pSelect);
        !          3089:       sqlite3ExplainPrintf(pOut,")");
        !          3090:       break;
        !          3091:     }
        !          3092:     case TK_SELECT: {
        !          3093:       sqlite3ExplainPrintf(pOut, "(");
        !          3094:       sqlite3ExplainSelect(pOut, pExpr->x.pSelect);
        !          3095:       sqlite3ExplainPrintf(pOut, ")");
        !          3096:       break;
        !          3097:     }
        !          3098:     case TK_IN: {
        !          3099:       sqlite3ExplainPrintf(pOut, "IN(");
        !          3100:       sqlite3ExplainExpr(pOut, pExpr->pLeft);
        !          3101:       sqlite3ExplainPrintf(pOut, ",");
        !          3102:       if( ExprHasProperty(pExpr, EP_xIsSelect) ){
        !          3103:         sqlite3ExplainSelect(pOut, pExpr->x.pSelect);
        !          3104:       }else{
        !          3105:         sqlite3ExplainExprList(pOut, pExpr->x.pList);
        !          3106:       }
        !          3107:       sqlite3ExplainPrintf(pOut, ")");
        !          3108:       break;
        !          3109:     }
        !          3110: #endif /* SQLITE_OMIT_SUBQUERY */
        !          3111: 
        !          3112:     /*
        !          3113:     **    x BETWEEN y AND z
        !          3114:     **
        !          3115:     ** This is equivalent to
        !          3116:     **
        !          3117:     **    x>=y AND x<=z
        !          3118:     **
        !          3119:     ** X is stored in pExpr->pLeft.
        !          3120:     ** Y is stored in pExpr->pList->a[0].pExpr.
        !          3121:     ** Z is stored in pExpr->pList->a[1].pExpr.
        !          3122:     */
        !          3123:     case TK_BETWEEN: {
        !          3124:       Expr *pX = pExpr->pLeft;
        !          3125:       Expr *pY = pExpr->x.pList->a[0].pExpr;
        !          3126:       Expr *pZ = pExpr->x.pList->a[1].pExpr;
        !          3127:       sqlite3ExplainPrintf(pOut, "BETWEEN(");
        !          3128:       sqlite3ExplainExpr(pOut, pX);
        !          3129:       sqlite3ExplainPrintf(pOut, ",");
        !          3130:       sqlite3ExplainExpr(pOut, pY);
        !          3131:       sqlite3ExplainPrintf(pOut, ",");
        !          3132:       sqlite3ExplainExpr(pOut, pZ);
        !          3133:       sqlite3ExplainPrintf(pOut, ")");
        !          3134:       break;
        !          3135:     }
        !          3136:     case TK_TRIGGER: {
        !          3137:       /* If the opcode is TK_TRIGGER, then the expression is a reference
        !          3138:       ** to a column in the new.* or old.* pseudo-tables available to
        !          3139:       ** trigger programs. In this case Expr.iTable is set to 1 for the
        !          3140:       ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
        !          3141:       ** is set to the column of the pseudo-table to read, or to -1 to
        !          3142:       ** read the rowid field.
        !          3143:       */
        !          3144:       sqlite3ExplainPrintf(pOut, "%s(%d)", 
        !          3145:           pExpr->iTable ? "NEW" : "OLD", pExpr->iColumn);
        !          3146:       break;
        !          3147:     }
        !          3148:     case TK_CASE: {
        !          3149:       sqlite3ExplainPrintf(pOut, "CASE(");
        !          3150:       sqlite3ExplainExpr(pOut, pExpr->pLeft);
        !          3151:       sqlite3ExplainPrintf(pOut, ",");
        !          3152:       sqlite3ExplainExprList(pOut, pExpr->x.pList);
        !          3153:       break;
        !          3154:     }
        !          3155: #ifndef SQLITE_OMIT_TRIGGER
        !          3156:     case TK_RAISE: {
        !          3157:       const char *zType = "unk";
        !          3158:       switch( pExpr->affinity ){
        !          3159:         case OE_Rollback:   zType = "rollback";  break;
        !          3160:         case OE_Abort:      zType = "abort";     break;
        !          3161:         case OE_Fail:       zType = "fail";      break;
        !          3162:         case OE_Ignore:     zType = "ignore";    break;
        !          3163:       }
        !          3164:       sqlite3ExplainPrintf(pOut, "RAISE-%s(%s)", zType, pExpr->u.zToken);
        !          3165:       break;
        !          3166:     }
        !          3167: #endif
        !          3168:   }
        !          3169:   if( zBinOp ){
        !          3170:     sqlite3ExplainPrintf(pOut,"%s(", zBinOp);
        !          3171:     sqlite3ExplainExpr(pOut, pExpr->pLeft);
        !          3172:     sqlite3ExplainPrintf(pOut,",");
        !          3173:     sqlite3ExplainExpr(pOut, pExpr->pRight);
        !          3174:     sqlite3ExplainPrintf(pOut,")");
        !          3175:   }else if( zUniOp ){
        !          3176:     sqlite3ExplainPrintf(pOut,"%s(", zUniOp);
        !          3177:     sqlite3ExplainExpr(pOut, pExpr->pLeft);
        !          3178:     sqlite3ExplainPrintf(pOut,")");
        !          3179:   }
        !          3180: }
        !          3181: #endif /* defined(SQLITE_ENABLE_TREE_EXPLAIN) */
        !          3182: 
        !          3183: #if defined(SQLITE_ENABLE_TREE_EXPLAIN)
        !          3184: /*
        !          3185: ** Generate a human-readable explanation of an expression list.
        !          3186: */
        !          3187: void sqlite3ExplainExprList(Vdbe *pOut, ExprList *pList){
        !          3188:   int i;
        !          3189:   if( pList==0 || pList->nExpr==0 ){
        !          3190:     sqlite3ExplainPrintf(pOut, "(empty-list)");
        !          3191:     return;
        !          3192:   }else if( pList->nExpr==1 ){
        !          3193:     sqlite3ExplainExpr(pOut, pList->a[0].pExpr);
        !          3194:   }else{
        !          3195:     sqlite3ExplainPush(pOut);
        !          3196:     for(i=0; i<pList->nExpr; i++){
        !          3197:       sqlite3ExplainPrintf(pOut, "item[%d] = ", i);
        !          3198:       sqlite3ExplainPush(pOut);
        !          3199:       sqlite3ExplainExpr(pOut, pList->a[i].pExpr);
        !          3200:       sqlite3ExplainPop(pOut);
        !          3201:       if( i<pList->nExpr-1 ){
        !          3202:         sqlite3ExplainNL(pOut);
        !          3203:       }
        !          3204:     }
        !          3205:     sqlite3ExplainPop(pOut);
        !          3206:   }
        !          3207: }
        !          3208: #endif /* SQLITE_DEBUG */
        !          3209: 
        !          3210: /*
        !          3211: ** Return TRUE if pExpr is an constant expression that is appropriate
        !          3212: ** for factoring out of a loop.  Appropriate expressions are:
        !          3213: **
        !          3214: **    *  Any expression that evaluates to two or more opcodes.
        !          3215: **
        !          3216: **    *  Any OP_Integer, OP_Real, OP_String, OP_Blob, OP_Null, 
        !          3217: **       or OP_Variable that does not need to be placed in a 
        !          3218: **       specific register.
        !          3219: **
        !          3220: ** There is no point in factoring out single-instruction constant
        !          3221: ** expressions that need to be placed in a particular register.  
        !          3222: ** We could factor them out, but then we would end up adding an
        !          3223: ** OP_SCopy instruction to move the value into the correct register
        !          3224: ** later.  We might as well just use the original instruction and
        !          3225: ** avoid the OP_SCopy.
        !          3226: */
        !          3227: static int isAppropriateForFactoring(Expr *p){
        !          3228:   if( !sqlite3ExprIsConstantNotJoin(p) ){
        !          3229:     return 0;  /* Only constant expressions are appropriate for factoring */
        !          3230:   }
        !          3231:   if( (p->flags & EP_FixedDest)==0 ){
        !          3232:     return 1;  /* Any constant without a fixed destination is appropriate */
        !          3233:   }
        !          3234:   while( p->op==TK_UPLUS ) p = p->pLeft;
        !          3235:   switch( p->op ){
        !          3236: #ifndef SQLITE_OMIT_BLOB_LITERAL
        !          3237:     case TK_BLOB:
        !          3238: #endif
        !          3239:     case TK_VARIABLE:
        !          3240:     case TK_INTEGER:
        !          3241:     case TK_FLOAT:
        !          3242:     case TK_NULL:
        !          3243:     case TK_STRING: {
        !          3244:       testcase( p->op==TK_BLOB );
        !          3245:       testcase( p->op==TK_VARIABLE );
        !          3246:       testcase( p->op==TK_INTEGER );
        !          3247:       testcase( p->op==TK_FLOAT );
        !          3248:       testcase( p->op==TK_NULL );
        !          3249:       testcase( p->op==TK_STRING );
        !          3250:       /* Single-instruction constants with a fixed destination are
        !          3251:       ** better done in-line.  If we factor them, they will just end
        !          3252:       ** up generating an OP_SCopy to move the value to the destination
        !          3253:       ** register. */
        !          3254:       return 0;
        !          3255:     }
        !          3256:     case TK_UMINUS: {
        !          3257:       if( p->pLeft->op==TK_FLOAT || p->pLeft->op==TK_INTEGER ){
        !          3258:         return 0;
        !          3259:       }
        !          3260:       break;
        !          3261:     }
        !          3262:     default: {
        !          3263:       break;
        !          3264:     }
        !          3265:   }
        !          3266:   return 1;
        !          3267: }
        !          3268: 
        !          3269: /*
        !          3270: ** If pExpr is a constant expression that is appropriate for
        !          3271: ** factoring out of a loop, then evaluate the expression
        !          3272: ** into a register and convert the expression into a TK_REGISTER
        !          3273: ** expression.
        !          3274: */
        !          3275: static int evalConstExpr(Walker *pWalker, Expr *pExpr){
        !          3276:   Parse *pParse = pWalker->pParse;
        !          3277:   switch( pExpr->op ){
        !          3278:     case TK_IN:
        !          3279:     case TK_REGISTER: {
        !          3280:       return WRC_Prune;
        !          3281:     }
        !          3282:     case TK_FUNCTION:
        !          3283:     case TK_AGG_FUNCTION:
        !          3284:     case TK_CONST_FUNC: {
        !          3285:       /* The arguments to a function have a fixed destination.
        !          3286:       ** Mark them this way to avoid generated unneeded OP_SCopy
        !          3287:       ** instructions. 
        !          3288:       */
        !          3289:       ExprList *pList = pExpr->x.pList;
        !          3290:       assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
        !          3291:       if( pList ){
        !          3292:         int i = pList->nExpr;
        !          3293:         struct ExprList_item *pItem = pList->a;
        !          3294:         for(; i>0; i--, pItem++){
        !          3295:           if( ALWAYS(pItem->pExpr) ) pItem->pExpr->flags |= EP_FixedDest;
        !          3296:         }
        !          3297:       }
        !          3298:       break;
        !          3299:     }
        !          3300:   }
        !          3301:   if( isAppropriateForFactoring(pExpr) ){
        !          3302:     int r1 = ++pParse->nMem;
        !          3303:     int r2;
        !          3304:     r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
        !          3305:     if( NEVER(r1!=r2) ) sqlite3ReleaseTempReg(pParse, r1);
        !          3306:     pExpr->op2 = pExpr->op;
        !          3307:     pExpr->op = TK_REGISTER;
        !          3308:     pExpr->iTable = r2;
        !          3309:     return WRC_Prune;
        !          3310:   }
        !          3311:   return WRC_Continue;
        !          3312: }
        !          3313: 
        !          3314: /*
        !          3315: ** Preevaluate constant subexpressions within pExpr and store the
        !          3316: ** results in registers.  Modify pExpr so that the constant subexpresions
        !          3317: ** are TK_REGISTER opcodes that refer to the precomputed values.
        !          3318: **
        !          3319: ** This routine is a no-op if the jump to the cookie-check code has
        !          3320: ** already occur.  Since the cookie-check jump is generated prior to
        !          3321: ** any other serious processing, this check ensures that there is no
        !          3322: ** way to accidently bypass the constant initializations.
        !          3323: **
        !          3324: ** This routine is also a no-op if the SQLITE_FactorOutConst optimization
        !          3325: ** is disabled via the sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS)
        !          3326: ** interface.  This allows test logic to verify that the same answer is
        !          3327: ** obtained for queries regardless of whether or not constants are
        !          3328: ** precomputed into registers or if they are inserted in-line.
        !          3329: */
        !          3330: void sqlite3ExprCodeConstants(Parse *pParse, Expr *pExpr){
        !          3331:   Walker w;
        !          3332:   if( pParse->cookieGoto ) return;
        !          3333:   if( (pParse->db->flags & SQLITE_FactorOutConst)!=0 ) return;
        !          3334:   w.xExprCallback = evalConstExpr;
        !          3335:   w.xSelectCallback = 0;
        !          3336:   w.pParse = pParse;
        !          3337:   sqlite3WalkExpr(&w, pExpr);
        !          3338: }
        !          3339: 
        !          3340: 
        !          3341: /*
        !          3342: ** Generate code that pushes the value of every element of the given
        !          3343: ** expression list into a sequence of registers beginning at target.
        !          3344: **
        !          3345: ** Return the number of elements evaluated.
        !          3346: */
        !          3347: int sqlite3ExprCodeExprList(
        !          3348:   Parse *pParse,     /* Parsing context */
        !          3349:   ExprList *pList,   /* The expression list to be coded */
        !          3350:   int target,        /* Where to write results */
        !          3351:   int doHardCopy     /* Make a hard copy of every element */
        !          3352: ){
        !          3353:   struct ExprList_item *pItem;
        !          3354:   int i, n;
        !          3355:   assert( pList!=0 );
        !          3356:   assert( target>0 );
        !          3357:   assert( pParse->pVdbe!=0 );  /* Never gets this far otherwise */
        !          3358:   n = pList->nExpr;
        !          3359:   for(pItem=pList->a, i=0; i<n; i++, pItem++){
        !          3360:     Expr *pExpr = pItem->pExpr;
        !          3361:     int inReg = sqlite3ExprCodeTarget(pParse, pExpr, target+i);
        !          3362:     if( inReg!=target+i ){
        !          3363:       sqlite3VdbeAddOp2(pParse->pVdbe, doHardCopy ? OP_Copy : OP_SCopy,
        !          3364:                         inReg, target+i);
        !          3365:     }
        !          3366:   }
        !          3367:   return n;
        !          3368: }
        !          3369: 
        !          3370: /*
        !          3371: ** Generate code for a BETWEEN operator.
        !          3372: **
        !          3373: **    x BETWEEN y AND z
        !          3374: **
        !          3375: ** The above is equivalent to 
        !          3376: **
        !          3377: **    x>=y AND x<=z
        !          3378: **
        !          3379: ** Code it as such, taking care to do the common subexpression
        !          3380: ** elementation of x.
        !          3381: */
        !          3382: static void exprCodeBetween(
        !          3383:   Parse *pParse,    /* Parsing and code generating context */
        !          3384:   Expr *pExpr,      /* The BETWEEN expression */
        !          3385:   int dest,         /* Jump here if the jump is taken */
        !          3386:   int jumpIfTrue,   /* Take the jump if the BETWEEN is true */
        !          3387:   int jumpIfNull    /* Take the jump if the BETWEEN is NULL */
        !          3388: ){
        !          3389:   Expr exprAnd;     /* The AND operator in  x>=y AND x<=z  */
        !          3390:   Expr compLeft;    /* The  x>=y  term */
        !          3391:   Expr compRight;   /* The  x<=z  term */
        !          3392:   Expr exprX;       /* The  x  subexpression */
        !          3393:   int regFree1 = 0; /* Temporary use register */
        !          3394: 
        !          3395:   assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
        !          3396:   exprX = *pExpr->pLeft;
        !          3397:   exprAnd.op = TK_AND;
        !          3398:   exprAnd.pLeft = &compLeft;
        !          3399:   exprAnd.pRight = &compRight;
        !          3400:   compLeft.op = TK_GE;
        !          3401:   compLeft.pLeft = &exprX;
        !          3402:   compLeft.pRight = pExpr->x.pList->a[0].pExpr;
        !          3403:   compRight.op = TK_LE;
        !          3404:   compRight.pLeft = &exprX;
        !          3405:   compRight.pRight = pExpr->x.pList->a[1].pExpr;
        !          3406:   exprX.iTable = sqlite3ExprCodeTemp(pParse, &exprX, &regFree1);
        !          3407:   exprX.op = TK_REGISTER;
        !          3408:   if( jumpIfTrue ){
        !          3409:     sqlite3ExprIfTrue(pParse, &exprAnd, dest, jumpIfNull);
        !          3410:   }else{
        !          3411:     sqlite3ExprIfFalse(pParse, &exprAnd, dest, jumpIfNull);
        !          3412:   }
        !          3413:   sqlite3ReleaseTempReg(pParse, regFree1);
        !          3414: 
        !          3415:   /* Ensure adequate test coverage */
        !          3416:   testcase( jumpIfTrue==0 && jumpIfNull==0 && regFree1==0 );
        !          3417:   testcase( jumpIfTrue==0 && jumpIfNull==0 && regFree1!=0 );
        !          3418:   testcase( jumpIfTrue==0 && jumpIfNull!=0 && regFree1==0 );
        !          3419:   testcase( jumpIfTrue==0 && jumpIfNull!=0 && regFree1!=0 );
        !          3420:   testcase( jumpIfTrue!=0 && jumpIfNull==0 && regFree1==0 );
        !          3421:   testcase( jumpIfTrue!=0 && jumpIfNull==0 && regFree1!=0 );
        !          3422:   testcase( jumpIfTrue!=0 && jumpIfNull!=0 && regFree1==0 );
        !          3423:   testcase( jumpIfTrue!=0 && jumpIfNull!=0 && regFree1!=0 );
        !          3424: }
        !          3425: 
        !          3426: /*
        !          3427: ** Generate code for a boolean expression such that a jump is made
        !          3428: ** to the label "dest" if the expression is true but execution
        !          3429: ** continues straight thru if the expression is false.
        !          3430: **
        !          3431: ** If the expression evaluates to NULL (neither true nor false), then
        !          3432: ** take the jump if the jumpIfNull flag is SQLITE_JUMPIFNULL.
        !          3433: **
        !          3434: ** This code depends on the fact that certain token values (ex: TK_EQ)
        !          3435: ** are the same as opcode values (ex: OP_Eq) that implement the corresponding
        !          3436: ** operation.  Special comments in vdbe.c and the mkopcodeh.awk script in
        !          3437: ** the make process cause these values to align.  Assert()s in the code
        !          3438: ** below verify that the numbers are aligned correctly.
        !          3439: */
        !          3440: void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
        !          3441:   Vdbe *v = pParse->pVdbe;
        !          3442:   int op = 0;
        !          3443:   int regFree1 = 0;
        !          3444:   int regFree2 = 0;
        !          3445:   int r1, r2;
        !          3446: 
        !          3447:   assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 );
        !          3448:   if( NEVER(v==0) )     return;  /* Existance of VDBE checked by caller */
        !          3449:   if( NEVER(pExpr==0) ) return;  /* No way this can happen */
        !          3450:   op = pExpr->op;
        !          3451:   switch( op ){
        !          3452:     case TK_AND: {
        !          3453:       int d2 = sqlite3VdbeMakeLabel(v);
        !          3454:       testcase( jumpIfNull==0 );
        !          3455:       sqlite3ExprCachePush(pParse);
        !          3456:       sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2,jumpIfNull^SQLITE_JUMPIFNULL);
        !          3457:       sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
        !          3458:       sqlite3VdbeResolveLabel(v, d2);
        !          3459:       sqlite3ExprCachePop(pParse, 1);
        !          3460:       break;
        !          3461:     }
        !          3462:     case TK_OR: {
        !          3463:       testcase( jumpIfNull==0 );
        !          3464:       sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
        !          3465:       sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
        !          3466:       break;
        !          3467:     }
        !          3468:     case TK_NOT: {
        !          3469:       testcase( jumpIfNull==0 );
        !          3470:       sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
        !          3471:       break;
        !          3472:     }
        !          3473:     case TK_LT:
        !          3474:     case TK_LE:
        !          3475:     case TK_GT:
        !          3476:     case TK_GE:
        !          3477:     case TK_NE:
        !          3478:     case TK_EQ: {
        !          3479:       assert( TK_LT==OP_Lt );
        !          3480:       assert( TK_LE==OP_Le );
        !          3481:       assert( TK_GT==OP_Gt );
        !          3482:       assert( TK_GE==OP_Ge );
        !          3483:       assert( TK_EQ==OP_Eq );
        !          3484:       assert( TK_NE==OP_Ne );
        !          3485:       testcase( op==TK_LT );
        !          3486:       testcase( op==TK_LE );
        !          3487:       testcase( op==TK_GT );
        !          3488:       testcase( op==TK_GE );
        !          3489:       testcase( op==TK_EQ );
        !          3490:       testcase( op==TK_NE );
        !          3491:       testcase( jumpIfNull==0 );
        !          3492:       r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
        !          3493:       r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
        !          3494:       codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
        !          3495:                   r1, r2, dest, jumpIfNull);
        !          3496:       testcase( regFree1==0 );
        !          3497:       testcase( regFree2==0 );
        !          3498:       break;
        !          3499:     }
        !          3500:     case TK_IS:
        !          3501:     case TK_ISNOT: {
        !          3502:       testcase( op==TK_IS );
        !          3503:       testcase( op==TK_ISNOT );
        !          3504:       r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
        !          3505:       r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
        !          3506:       op = (op==TK_IS) ? TK_EQ : TK_NE;
        !          3507:       codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
        !          3508:                   r1, r2, dest, SQLITE_NULLEQ);
        !          3509:       testcase( regFree1==0 );
        !          3510:       testcase( regFree2==0 );
        !          3511:       break;
        !          3512:     }
        !          3513:     case TK_ISNULL:
        !          3514:     case TK_NOTNULL: {
        !          3515:       assert( TK_ISNULL==OP_IsNull );
        !          3516:       assert( TK_NOTNULL==OP_NotNull );
        !          3517:       testcase( op==TK_ISNULL );
        !          3518:       testcase( op==TK_NOTNULL );
        !          3519:       r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
        !          3520:       sqlite3VdbeAddOp2(v, op, r1, dest);
        !          3521:       testcase( regFree1==0 );
        !          3522:       break;
        !          3523:     }
        !          3524:     case TK_BETWEEN: {
        !          3525:       testcase( jumpIfNull==0 );
        !          3526:       exprCodeBetween(pParse, pExpr, dest, 1, jumpIfNull);
        !          3527:       break;
        !          3528:     }
        !          3529: #ifndef SQLITE_OMIT_SUBQUERY
        !          3530:     case TK_IN: {
        !          3531:       int destIfFalse = sqlite3VdbeMakeLabel(v);
        !          3532:       int destIfNull = jumpIfNull ? dest : destIfFalse;
        !          3533:       sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
        !          3534:       sqlite3VdbeAddOp2(v, OP_Goto, 0, dest);
        !          3535:       sqlite3VdbeResolveLabel(v, destIfFalse);
        !          3536:       break;
        !          3537:     }
        !          3538: #endif
        !          3539:     default: {
        !          3540:       r1 = sqlite3ExprCodeTemp(pParse, pExpr, &regFree1);
        !          3541:       sqlite3VdbeAddOp3(v, OP_If, r1, dest, jumpIfNull!=0);
        !          3542:       testcase( regFree1==0 );
        !          3543:       testcase( jumpIfNull==0 );
        !          3544:       break;
        !          3545:     }
        !          3546:   }
        !          3547:   sqlite3ReleaseTempReg(pParse, regFree1);
        !          3548:   sqlite3ReleaseTempReg(pParse, regFree2);  
        !          3549: }
        !          3550: 
        !          3551: /*
        !          3552: ** Generate code for a boolean expression such that a jump is made
        !          3553: ** to the label "dest" if the expression is false but execution
        !          3554: ** continues straight thru if the expression is true.
        !          3555: **
        !          3556: ** If the expression evaluates to NULL (neither true nor false) then
        !          3557: ** jump if jumpIfNull is SQLITE_JUMPIFNULL or fall through if jumpIfNull
        !          3558: ** is 0.
        !          3559: */
        !          3560: void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
        !          3561:   Vdbe *v = pParse->pVdbe;
        !          3562:   int op = 0;
        !          3563:   int regFree1 = 0;
        !          3564:   int regFree2 = 0;
        !          3565:   int r1, r2;
        !          3566: 
        !          3567:   assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 );
        !          3568:   if( NEVER(v==0) ) return; /* Existance of VDBE checked by caller */
        !          3569:   if( pExpr==0 )    return;
        !          3570: 
        !          3571:   /* The value of pExpr->op and op are related as follows:
        !          3572:   **
        !          3573:   **       pExpr->op            op
        !          3574:   **       ---------          ----------
        !          3575:   **       TK_ISNULL          OP_NotNull
        !          3576:   **       TK_NOTNULL         OP_IsNull
        !          3577:   **       TK_NE              OP_Eq
        !          3578:   **       TK_EQ              OP_Ne
        !          3579:   **       TK_GT              OP_Le
        !          3580:   **       TK_LE              OP_Gt
        !          3581:   **       TK_GE              OP_Lt
        !          3582:   **       TK_LT              OP_Ge
        !          3583:   **
        !          3584:   ** For other values of pExpr->op, op is undefined and unused.
        !          3585:   ** The value of TK_ and OP_ constants are arranged such that we
        !          3586:   ** can compute the mapping above using the following expression.
        !          3587:   ** Assert()s verify that the computation is correct.
        !          3588:   */
        !          3589:   op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1);
        !          3590: 
        !          3591:   /* Verify correct alignment of TK_ and OP_ constants
        !          3592:   */
        !          3593:   assert( pExpr->op!=TK_ISNULL || op==OP_NotNull );
        !          3594:   assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull );
        !          3595:   assert( pExpr->op!=TK_NE || op==OP_Eq );
        !          3596:   assert( pExpr->op!=TK_EQ || op==OP_Ne );
        !          3597:   assert( pExpr->op!=TK_LT || op==OP_Ge );
        !          3598:   assert( pExpr->op!=TK_LE || op==OP_Gt );
        !          3599:   assert( pExpr->op!=TK_GT || op==OP_Le );
        !          3600:   assert( pExpr->op!=TK_GE || op==OP_Lt );
        !          3601: 
        !          3602:   switch( pExpr->op ){
        !          3603:     case TK_AND: {
        !          3604:       testcase( jumpIfNull==0 );
        !          3605:       sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
        !          3606:       sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
        !          3607:       break;
        !          3608:     }
        !          3609:     case TK_OR: {
        !          3610:       int d2 = sqlite3VdbeMakeLabel(v);
        !          3611:       testcase( jumpIfNull==0 );
        !          3612:       sqlite3ExprCachePush(pParse);
        !          3613:       sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2, jumpIfNull^SQLITE_JUMPIFNULL);
        !          3614:       sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
        !          3615:       sqlite3VdbeResolveLabel(v, d2);
        !          3616:       sqlite3ExprCachePop(pParse, 1);
        !          3617:       break;
        !          3618:     }
        !          3619:     case TK_NOT: {
        !          3620:       testcase( jumpIfNull==0 );
        !          3621:       sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
        !          3622:       break;
        !          3623:     }
        !          3624:     case TK_LT:
        !          3625:     case TK_LE:
        !          3626:     case TK_GT:
        !          3627:     case TK_GE:
        !          3628:     case TK_NE:
        !          3629:     case TK_EQ: {
        !          3630:       testcase( op==TK_LT );
        !          3631:       testcase( op==TK_LE );
        !          3632:       testcase( op==TK_GT );
        !          3633:       testcase( op==TK_GE );
        !          3634:       testcase( op==TK_EQ );
        !          3635:       testcase( op==TK_NE );
        !          3636:       testcase( jumpIfNull==0 );
        !          3637:       r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
        !          3638:       r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
        !          3639:       codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
        !          3640:                   r1, r2, dest, jumpIfNull);
        !          3641:       testcase( regFree1==0 );
        !          3642:       testcase( regFree2==0 );
        !          3643:       break;
        !          3644:     }
        !          3645:     case TK_IS:
        !          3646:     case TK_ISNOT: {
        !          3647:       testcase( pExpr->op==TK_IS );
        !          3648:       testcase( pExpr->op==TK_ISNOT );
        !          3649:       r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
        !          3650:       r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
        !          3651:       op = (pExpr->op==TK_IS) ? TK_NE : TK_EQ;
        !          3652:       codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
        !          3653:                   r1, r2, dest, SQLITE_NULLEQ);
        !          3654:       testcase( regFree1==0 );
        !          3655:       testcase( regFree2==0 );
        !          3656:       break;
        !          3657:     }
        !          3658:     case TK_ISNULL:
        !          3659:     case TK_NOTNULL: {
        !          3660:       testcase( op==TK_ISNULL );
        !          3661:       testcase( op==TK_NOTNULL );
        !          3662:       r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
        !          3663:       sqlite3VdbeAddOp2(v, op, r1, dest);
        !          3664:       testcase( regFree1==0 );
        !          3665:       break;
        !          3666:     }
        !          3667:     case TK_BETWEEN: {
        !          3668:       testcase( jumpIfNull==0 );
        !          3669:       exprCodeBetween(pParse, pExpr, dest, 0, jumpIfNull);
        !          3670:       break;
        !          3671:     }
        !          3672: #ifndef SQLITE_OMIT_SUBQUERY
        !          3673:     case TK_IN: {
        !          3674:       if( jumpIfNull ){
        !          3675:         sqlite3ExprCodeIN(pParse, pExpr, dest, dest);
        !          3676:       }else{
        !          3677:         int destIfNull = sqlite3VdbeMakeLabel(v);
        !          3678:         sqlite3ExprCodeIN(pParse, pExpr, dest, destIfNull);
        !          3679:         sqlite3VdbeResolveLabel(v, destIfNull);
        !          3680:       }
        !          3681:       break;
        !          3682:     }
        !          3683: #endif
        !          3684:     default: {
        !          3685:       r1 = sqlite3ExprCodeTemp(pParse, pExpr, &regFree1);
        !          3686:       sqlite3VdbeAddOp3(v, OP_IfNot, r1, dest, jumpIfNull!=0);
        !          3687:       testcase( regFree1==0 );
        !          3688:       testcase( jumpIfNull==0 );
        !          3689:       break;
        !          3690:     }
        !          3691:   }
        !          3692:   sqlite3ReleaseTempReg(pParse, regFree1);
        !          3693:   sqlite3ReleaseTempReg(pParse, regFree2);
        !          3694: }
        !          3695: 
        !          3696: /*
        !          3697: ** Do a deep comparison of two expression trees.  Return 0 if the two
        !          3698: ** expressions are completely identical.  Return 1 if they differ only
        !          3699: ** by a COLLATE operator at the top level.  Return 2 if there are differences
        !          3700: ** other than the top-level COLLATE operator.
        !          3701: **
        !          3702: ** Sometimes this routine will return 2 even if the two expressions
        !          3703: ** really are equivalent.  If we cannot prove that the expressions are
        !          3704: ** identical, we return 2 just to be safe.  So if this routine
        !          3705: ** returns 2, then you do not really know for certain if the two
        !          3706: ** expressions are the same.  But if you get a 0 or 1 return, then you
        !          3707: ** can be sure the expressions are the same.  In the places where
        !          3708: ** this routine is used, it does not hurt to get an extra 2 - that
        !          3709: ** just might result in some slightly slower code.  But returning
        !          3710: ** an incorrect 0 or 1 could lead to a malfunction.
        !          3711: */
        !          3712: int sqlite3ExprCompare(Expr *pA, Expr *pB){
        !          3713:   if( pA==0||pB==0 ){
        !          3714:     return pB==pA ? 0 : 2;
        !          3715:   }
        !          3716:   assert( !ExprHasAnyProperty(pA, EP_TokenOnly|EP_Reduced) );
        !          3717:   assert( !ExprHasAnyProperty(pB, EP_TokenOnly|EP_Reduced) );
        !          3718:   if( ExprHasProperty(pA, EP_xIsSelect) || ExprHasProperty(pB, EP_xIsSelect) ){
        !          3719:     return 2;
        !          3720:   }
        !          3721:   if( (pA->flags & EP_Distinct)!=(pB->flags & EP_Distinct) ) return 2;
        !          3722:   if( pA->op!=pB->op ) return 2;
        !          3723:   if( sqlite3ExprCompare(pA->pLeft, pB->pLeft) ) return 2;
        !          3724:   if( sqlite3ExprCompare(pA->pRight, pB->pRight) ) return 2;
        !          3725:   if( sqlite3ExprListCompare(pA->x.pList, pB->x.pList) ) return 2;
        !          3726:   if( pA->iTable!=pB->iTable || pA->iColumn!=pB->iColumn ) return 2;
        !          3727:   if( ExprHasProperty(pA, EP_IntValue) ){
        !          3728:     if( !ExprHasProperty(pB, EP_IntValue) || pA->u.iValue!=pB->u.iValue ){
        !          3729:       return 2;
        !          3730:     }
        !          3731:   }else if( pA->op!=TK_COLUMN && pA->u.zToken ){
        !          3732:     if( ExprHasProperty(pB, EP_IntValue) || NEVER(pB->u.zToken==0) ) return 2;
        !          3733:     if( strcmp(pA->u.zToken,pB->u.zToken)!=0 ){
        !          3734:       return 2;
        !          3735:     }
        !          3736:   }
        !          3737:   if( (pA->flags & EP_ExpCollate)!=(pB->flags & EP_ExpCollate) ) return 1;
        !          3738:   if( (pA->flags & EP_ExpCollate)!=0 && pA->pColl!=pB->pColl ) return 2;
        !          3739:   return 0;
        !          3740: }
        !          3741: 
        !          3742: /*
        !          3743: ** Compare two ExprList objects.  Return 0 if they are identical and 
        !          3744: ** non-zero if they differ in any way.
        !          3745: **
        !          3746: ** This routine might return non-zero for equivalent ExprLists.  The
        !          3747: ** only consequence will be disabled optimizations.  But this routine
        !          3748: ** must never return 0 if the two ExprList objects are different, or
        !          3749: ** a malfunction will result.
        !          3750: **
        !          3751: ** Two NULL pointers are considered to be the same.  But a NULL pointer
        !          3752: ** always differs from a non-NULL pointer.
        !          3753: */
        !          3754: int sqlite3ExprListCompare(ExprList *pA, ExprList *pB){
        !          3755:   int i;
        !          3756:   if( pA==0 && pB==0 ) return 0;
        !          3757:   if( pA==0 || pB==0 ) return 1;
        !          3758:   if( pA->nExpr!=pB->nExpr ) return 1;
        !          3759:   for(i=0; i<pA->nExpr; i++){
        !          3760:     Expr *pExprA = pA->a[i].pExpr;
        !          3761:     Expr *pExprB = pB->a[i].pExpr;
        !          3762:     if( pA->a[i].sortOrder!=pB->a[i].sortOrder ) return 1;
        !          3763:     if( sqlite3ExprCompare(pExprA, pExprB) ) return 1;
        !          3764:   }
        !          3765:   return 0;
        !          3766: }
        !          3767: 
        !          3768: /*
        !          3769: ** Add a new element to the pAggInfo->aCol[] array.  Return the index of
        !          3770: ** the new element.  Return a negative number if malloc fails.
        !          3771: */
        !          3772: static int addAggInfoColumn(sqlite3 *db, AggInfo *pInfo){
        !          3773:   int i;
        !          3774:   pInfo->aCol = sqlite3ArrayAllocate(
        !          3775:        db,
        !          3776:        pInfo->aCol,
        !          3777:        sizeof(pInfo->aCol[0]),
        !          3778:        3,
        !          3779:        &pInfo->nColumn,
        !          3780:        &pInfo->nColumnAlloc,
        !          3781:        &i
        !          3782:   );
        !          3783:   return i;
        !          3784: }    
        !          3785: 
        !          3786: /*
        !          3787: ** Add a new element to the pAggInfo->aFunc[] array.  Return the index of
        !          3788: ** the new element.  Return a negative number if malloc fails.
        !          3789: */
        !          3790: static int addAggInfoFunc(sqlite3 *db, AggInfo *pInfo){
        !          3791:   int i;
        !          3792:   pInfo->aFunc = sqlite3ArrayAllocate(
        !          3793:        db, 
        !          3794:        pInfo->aFunc,
        !          3795:        sizeof(pInfo->aFunc[0]),
        !          3796:        3,
        !          3797:        &pInfo->nFunc,
        !          3798:        &pInfo->nFuncAlloc,
        !          3799:        &i
        !          3800:   );
        !          3801:   return i;
        !          3802: }    
        !          3803: 
        !          3804: /*
        !          3805: ** This is the xExprCallback for a tree walker.  It is used to
        !          3806: ** implement sqlite3ExprAnalyzeAggregates().  See sqlite3ExprAnalyzeAggregates
        !          3807: ** for additional information.
        !          3808: */
        !          3809: static int analyzeAggregate(Walker *pWalker, Expr *pExpr){
        !          3810:   int i;
        !          3811:   NameContext *pNC = pWalker->u.pNC;
        !          3812:   Parse *pParse = pNC->pParse;
        !          3813:   SrcList *pSrcList = pNC->pSrcList;
        !          3814:   AggInfo *pAggInfo = pNC->pAggInfo;
        !          3815: 
        !          3816:   switch( pExpr->op ){
        !          3817:     case TK_AGG_COLUMN:
        !          3818:     case TK_COLUMN: {
        !          3819:       testcase( pExpr->op==TK_AGG_COLUMN );
        !          3820:       testcase( pExpr->op==TK_COLUMN );
        !          3821:       /* Check to see if the column is in one of the tables in the FROM
        !          3822:       ** clause of the aggregate query */
        !          3823:       if( ALWAYS(pSrcList!=0) ){
        !          3824:         struct SrcList_item *pItem = pSrcList->a;
        !          3825:         for(i=0; i<pSrcList->nSrc; i++, pItem++){
        !          3826:           struct AggInfo_col *pCol;
        !          3827:           assert( !ExprHasAnyProperty(pExpr, EP_TokenOnly|EP_Reduced) );
        !          3828:           if( pExpr->iTable==pItem->iCursor ){
        !          3829:             /* If we reach this point, it means that pExpr refers to a table
        !          3830:             ** that is in the FROM clause of the aggregate query.  
        !          3831:             **
        !          3832:             ** Make an entry for the column in pAggInfo->aCol[] if there
        !          3833:             ** is not an entry there already.
        !          3834:             */
        !          3835:             int k;
        !          3836:             pCol = pAggInfo->aCol;
        !          3837:             for(k=0; k<pAggInfo->nColumn; k++, pCol++){
        !          3838:               if( pCol->iTable==pExpr->iTable &&
        !          3839:                   pCol->iColumn==pExpr->iColumn ){
        !          3840:                 break;
        !          3841:               }
        !          3842:             }
        !          3843:             if( (k>=pAggInfo->nColumn)
        !          3844:              && (k = addAggInfoColumn(pParse->db, pAggInfo))>=0 
        !          3845:             ){
        !          3846:               pCol = &pAggInfo->aCol[k];
        !          3847:               pCol->pTab = pExpr->pTab;
        !          3848:               pCol->iTable = pExpr->iTable;
        !          3849:               pCol->iColumn = pExpr->iColumn;
        !          3850:               pCol->iMem = ++pParse->nMem;
        !          3851:               pCol->iSorterColumn = -1;
        !          3852:               pCol->pExpr = pExpr;
        !          3853:               if( pAggInfo->pGroupBy ){
        !          3854:                 int j, n;
        !          3855:                 ExprList *pGB = pAggInfo->pGroupBy;
        !          3856:                 struct ExprList_item *pTerm = pGB->a;
        !          3857:                 n = pGB->nExpr;
        !          3858:                 for(j=0; j<n; j++, pTerm++){
        !          3859:                   Expr *pE = pTerm->pExpr;
        !          3860:                   if( pE->op==TK_COLUMN && pE->iTable==pExpr->iTable &&
        !          3861:                       pE->iColumn==pExpr->iColumn ){
        !          3862:                     pCol->iSorterColumn = j;
        !          3863:                     break;
        !          3864:                   }
        !          3865:                 }
        !          3866:               }
        !          3867:               if( pCol->iSorterColumn<0 ){
        !          3868:                 pCol->iSorterColumn = pAggInfo->nSortingColumn++;
        !          3869:               }
        !          3870:             }
        !          3871:             /* There is now an entry for pExpr in pAggInfo->aCol[] (either
        !          3872:             ** because it was there before or because we just created it).
        !          3873:             ** Convert the pExpr to be a TK_AGG_COLUMN referring to that
        !          3874:             ** pAggInfo->aCol[] entry.
        !          3875:             */
        !          3876:             ExprSetIrreducible(pExpr);
        !          3877:             pExpr->pAggInfo = pAggInfo;
        !          3878:             pExpr->op = TK_AGG_COLUMN;
        !          3879:             pExpr->iAgg = (i16)k;
        !          3880:             break;
        !          3881:           } /* endif pExpr->iTable==pItem->iCursor */
        !          3882:         } /* end loop over pSrcList */
        !          3883:       }
        !          3884:       return WRC_Prune;
        !          3885:     }
        !          3886:     case TK_AGG_FUNCTION: {
        !          3887:       /* The pNC->nDepth==0 test causes aggregate functions in subqueries
        !          3888:       ** to be ignored */
        !          3889:       if( pNC->nDepth==0 ){
        !          3890:         /* Check to see if pExpr is a duplicate of another aggregate 
        !          3891:         ** function that is already in the pAggInfo structure
        !          3892:         */
        !          3893:         struct AggInfo_func *pItem = pAggInfo->aFunc;
        !          3894:         for(i=0; i<pAggInfo->nFunc; i++, pItem++){
        !          3895:           if( sqlite3ExprCompare(pItem->pExpr, pExpr)==0 ){
        !          3896:             break;
        !          3897:           }
        !          3898:         }
        !          3899:         if( i>=pAggInfo->nFunc ){
        !          3900:           /* pExpr is original.  Make a new entry in pAggInfo->aFunc[]
        !          3901:           */
        !          3902:           u8 enc = ENC(pParse->db);
        !          3903:           i = addAggInfoFunc(pParse->db, pAggInfo);
        !          3904:           if( i>=0 ){
        !          3905:             assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
        !          3906:             pItem = &pAggInfo->aFunc[i];
        !          3907:             pItem->pExpr = pExpr;
        !          3908:             pItem->iMem = ++pParse->nMem;
        !          3909:             assert( !ExprHasProperty(pExpr, EP_IntValue) );
        !          3910:             pItem->pFunc = sqlite3FindFunction(pParse->db,
        !          3911:                    pExpr->u.zToken, sqlite3Strlen30(pExpr->u.zToken),
        !          3912:                    pExpr->x.pList ? pExpr->x.pList->nExpr : 0, enc, 0);
        !          3913:             if( pExpr->flags & EP_Distinct ){
        !          3914:               pItem->iDistinct = pParse->nTab++;
        !          3915:             }else{
        !          3916:               pItem->iDistinct = -1;
        !          3917:             }
        !          3918:           }
        !          3919:         }
        !          3920:         /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry
        !          3921:         */
        !          3922:         assert( !ExprHasAnyProperty(pExpr, EP_TokenOnly|EP_Reduced) );
        !          3923:         ExprSetIrreducible(pExpr);
        !          3924:         pExpr->iAgg = (i16)i;
        !          3925:         pExpr->pAggInfo = pAggInfo;
        !          3926:         return WRC_Prune;
        !          3927:       }
        !          3928:     }
        !          3929:   }
        !          3930:   return WRC_Continue;
        !          3931: }
        !          3932: static int analyzeAggregatesInSelect(Walker *pWalker, Select *pSelect){
        !          3933:   NameContext *pNC = pWalker->u.pNC;
        !          3934:   if( pNC->nDepth==0 ){
        !          3935:     pNC->nDepth++;
        !          3936:     sqlite3WalkSelect(pWalker, pSelect);
        !          3937:     pNC->nDepth--;
        !          3938:     return WRC_Prune;
        !          3939:   }else{
        !          3940:     return WRC_Continue;
        !          3941:   }
        !          3942: }
        !          3943: 
        !          3944: /*
        !          3945: ** Analyze the given expression looking for aggregate functions and
        !          3946: ** for variables that need to be added to the pParse->aAgg[] array.
        !          3947: ** Make additional entries to the pParse->aAgg[] array as necessary.
        !          3948: **
        !          3949: ** This routine should only be called after the expression has been
        !          3950: ** analyzed by sqlite3ResolveExprNames().
        !          3951: */
        !          3952: void sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){
        !          3953:   Walker w;
        !          3954:   w.xExprCallback = analyzeAggregate;
        !          3955:   w.xSelectCallback = analyzeAggregatesInSelect;
        !          3956:   w.u.pNC = pNC;
        !          3957:   assert( pNC->pSrcList!=0 );
        !          3958:   sqlite3WalkExpr(&w, pExpr);
        !          3959: }
        !          3960: 
        !          3961: /*
        !          3962: ** Call sqlite3ExprAnalyzeAggregates() for every expression in an
        !          3963: ** expression list.  Return the number of errors.
        !          3964: **
        !          3965: ** If an error is found, the analysis is cut short.
        !          3966: */
        !          3967: void sqlite3ExprAnalyzeAggList(NameContext *pNC, ExprList *pList){
        !          3968:   struct ExprList_item *pItem;
        !          3969:   int i;
        !          3970:   if( pList ){
        !          3971:     for(pItem=pList->a, i=0; i<pList->nExpr; i++, pItem++){
        !          3972:       sqlite3ExprAnalyzeAggregates(pNC, pItem->pExpr);
        !          3973:     }
        !          3974:   }
        !          3975: }
        !          3976: 
        !          3977: /*
        !          3978: ** Allocate a single new register for use to hold some intermediate result.
        !          3979: */
        !          3980: int sqlite3GetTempReg(Parse *pParse){
        !          3981:   if( pParse->nTempReg==0 ){
        !          3982:     return ++pParse->nMem;
        !          3983:   }
        !          3984:   return pParse->aTempReg[--pParse->nTempReg];
        !          3985: }
        !          3986: 
        !          3987: /*
        !          3988: ** Deallocate a register, making available for reuse for some other
        !          3989: ** purpose.
        !          3990: **
        !          3991: ** If a register is currently being used by the column cache, then
        !          3992: ** the dallocation is deferred until the column cache line that uses
        !          3993: ** the register becomes stale.
        !          3994: */
        !          3995: void sqlite3ReleaseTempReg(Parse *pParse, int iReg){
        !          3996:   if( iReg && pParse->nTempReg<ArraySize(pParse->aTempReg) ){
        !          3997:     int i;
        !          3998:     struct yColCache *p;
        !          3999:     for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
        !          4000:       if( p->iReg==iReg ){
        !          4001:         p->tempReg = 1;
        !          4002:         return;
        !          4003:       }
        !          4004:     }
        !          4005:     pParse->aTempReg[pParse->nTempReg++] = iReg;
        !          4006:   }
        !          4007: }
        !          4008: 
        !          4009: /*
        !          4010: ** Allocate or deallocate a block of nReg consecutive registers
        !          4011: */
        !          4012: int sqlite3GetTempRange(Parse *pParse, int nReg){
        !          4013:   int i, n;
        !          4014:   i = pParse->iRangeReg;
        !          4015:   n = pParse->nRangeReg;
        !          4016:   if( nReg<=n ){
        !          4017:     assert( !usedAsColumnCache(pParse, i, i+n-1) );
        !          4018:     pParse->iRangeReg += nReg;
        !          4019:     pParse->nRangeReg -= nReg;
        !          4020:   }else{
        !          4021:     i = pParse->nMem+1;
        !          4022:     pParse->nMem += nReg;
        !          4023:   }
        !          4024:   return i;
        !          4025: }
        !          4026: void sqlite3ReleaseTempRange(Parse *pParse, int iReg, int nReg){
        !          4027:   sqlite3ExprCacheRemove(pParse, iReg, nReg);
        !          4028:   if( nReg>pParse->nRangeReg ){
        !          4029:     pParse->nRangeReg = nReg;
        !          4030:     pParse->iRangeReg = iReg;
        !          4031:   }
        !          4032: }
        !          4033: 
        !          4034: /*
        !          4035: ** Mark all temporary registers as being unavailable for reuse.
        !          4036: */
        !          4037: void sqlite3ClearTempRegCache(Parse *pParse){
        !          4038:   pParse->nTempReg = 0;
        !          4039:   pParse->nRangeReg = 0;
        !          4040: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>