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