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