1 /* 2 ** 2001 September 15 3 ** 4 ** The author disclaims copyright to this source code. In place of 5 ** a legal notice, here is a blessing: 6 ** 7 ** May you do good and not evil. 8 ** May you find forgiveness for yourself and forgive others. 9 ** May you share freely, never taking more than you give. 10 ** 11 ************************************************************************* 12 ** This file contains routines used for analyzing expressions and 13 ** for generating VDBE code that evaluates expressions in SQLite. 14 ** 15 ** $Id: expr.c,v 1.114.2.3 2004/07/22 17:10:10 drh Exp $ 16 */ 17 #include "sqliteInt.h" 18 #include <ctype.h> 19 20 /* 21 ** Construct a new expression node and return a pointer to it. Memory 22 ** for this node is obtained from sqliteMalloc(). The calling function 23 ** is responsible for making sure the node eventually gets freed. 24 */ 25 Expr *sqliteExpr(int op, Expr *pLeft, Expr *pRight, Token *pToken){ 26 Expr *pNew; 27 pNew = sqliteMalloc( sizeof(Expr) ); 28 if( pNew==0 ){ 29 /* When malloc fails, we leak memory from pLeft and pRight */ 30 return 0; 31 } 32 pNew->op = op; 33 pNew->pLeft = pLeft; 34 pNew->pRight = pRight; 35 if( pToken ){ 36 assert( pToken->dyn==0 ); 37 pNew->token = *pToken; 38 pNew->span = *pToken; 39 }else{ 40 assert( pNew->token.dyn==0 ); 41 assert( pNew->token.z==0 ); 42 assert( pNew->token.n==0 ); 43 if( pLeft && pRight ){ 44 sqliteExprSpan(pNew, &pLeft->span, &pRight->span); 45 }else{ 46 pNew->span = pNew->token; 47 } 48 } 49 return pNew; 50 } 51 52 /* 53 ** Set the Expr.span field of the given expression to span all 54 ** text between the two given tokens. 55 */ 56 void sqliteExprSpan(Expr *pExpr, Token *pLeft, Token *pRight){ 57 assert( pRight!=0 ); 58 assert( pLeft!=0 ); 59 /* Note: pExpr might be NULL due to a prior malloc failure */ 60 if( pExpr && pRight->z && pLeft->z ){ 61 if( pLeft->dyn==0 && pRight->dyn==0 ){ 62 pExpr->span.z = pLeft->z; 63 pExpr->span.n = pRight->n + Addr(pRight->z) - Addr(pLeft->z); 64 }else{ 65 pExpr->span.z = 0; 66 } 67 } 68 } 69 70 /* 71 ** Construct a new expression node for a function with multiple 72 ** arguments. 73 */ 74 Expr *sqliteExprFunction(ExprList *pList, Token *pToken){ 75 Expr *pNew; 76 pNew = sqliteMalloc( sizeof(Expr) ); 77 if( pNew==0 ){ 78 /* sqliteExprListDelete(pList); // Leak pList when malloc fails */ 79 return 0; 80 } 81 pNew->op = TK_FUNCTION; 82 pNew->pList = pList; 83 if( pToken ){ 84 assert( pToken->dyn==0 ); 85 pNew->token = *pToken; 86 }else{ 87 pNew->token.z = 0; 88 } 89 pNew->span = pNew->token; 90 return pNew; 91 } 92 93 /* 94 ** Recursively delete an expression tree. 95 */ 96 void sqliteExprDelete(Expr *p){ 97 if( p==0 ) return; 98 if( p->span.dyn ) sqliteFree((char*)p->span.z); 99 if( p->token.dyn ) sqliteFree((char*)p->token.z); 100 sqliteExprDelete(p->pLeft); 101 sqliteExprDelete(p->pRight); 102 sqliteExprListDelete(p->pList); 103 sqliteSelectDelete(p->pSelect); 104 sqliteFree(p); 105 } 106 107 108 /* 109 ** The following group of routines make deep copies of expressions, 110 ** expression lists, ID lists, and select statements. The copies can 111 ** be deleted (by being passed to their respective ...Delete() routines) 112 ** without effecting the originals. 113 ** 114 ** The expression list, ID, and source lists return by sqliteExprListDup(), 115 ** sqliteIdListDup(), and sqliteSrcListDup() can not be further expanded 116 ** by subsequent calls to sqlite*ListAppend() routines. 117 ** 118 ** Any tables that the SrcList might point to are not duplicated. 119 */ 120 Expr *sqliteExprDup(Expr *p){ 121 Expr *pNew; 122 if( p==0 ) return 0; 123 pNew = sqliteMallocRaw( sizeof(*p) ); 124 if( pNew==0 ) return 0; 125 memcpy(pNew, p, sizeof(*pNew)); 126 if( p->token.z!=0 ){ 127 pNew->token.z = sqliteStrDup(p->token.z); 128 pNew->token.dyn = 1; 129 }else{ 130 assert( pNew->token.z==0 ); 131 } 132 pNew->span.z = 0; 133 pNew->pLeft = sqliteExprDup(p->pLeft); 134 pNew->pRight = sqliteExprDup(p->pRight); 135 pNew->pList = sqliteExprListDup(p->pList); 136 pNew->pSelect = sqliteSelectDup(p->pSelect); 137 return pNew; 138 } 139 void sqliteTokenCopy(Token *pTo, Token *pFrom){ 140 if( pTo->dyn ) sqliteFree((char*)pTo->z); 141 if( pFrom->z ){ 142 pTo->n = pFrom->n; 143 pTo->z = sqliteStrNDup(pFrom->z, pFrom->n); 144 pTo->dyn = 1; 145 }else{ 146 pTo->z = 0; 147 } 148 } 149 ExprList *sqliteExprListDup(ExprList *p){ 150 ExprList *pNew; 151 struct ExprList_item *pItem; 152 int i; 153 if( p==0 ) return 0; 154 pNew = sqliteMalloc( sizeof(*pNew) ); 155 if( pNew==0 ) return 0; 156 pNew->nExpr = pNew->nAlloc = p->nExpr; 157 pNew->a = pItem = sqliteMalloc( p->nExpr*sizeof(p->a[0]) ); 158 if( pItem==0 ){ 159 sqliteFree(pNew); 160 return 0; 161 } 162 for(i=0; i<p->nExpr; i++, pItem++){ 163 Expr *pNewExpr, *pOldExpr; 164 pItem->pExpr = pNewExpr = sqliteExprDup(pOldExpr = p->a[i].pExpr); 165 if( pOldExpr->span.z!=0 && pNewExpr ){ 166 /* Always make a copy of the span for top-level expressions in the 167 ** expression list. The logic in SELECT processing that determines 168 ** the names of columns in the result set needs this information */ 169 sqliteTokenCopy(&pNewExpr->span, &pOldExpr->span); 170 } 171 assert( pNewExpr==0 || pNewExpr->span.z!=0 172 || pOldExpr->span.z==0 || sqlite_malloc_failed ); 173 pItem->zName = sqliteStrDup(p->a[i].zName); 174 pItem->sortOrder = p->a[i].sortOrder; 175 pItem->isAgg = p->a[i].isAgg; 176 pItem->done = 0; 177 } 178 return pNew; 179 } 180 SrcList *sqliteSrcListDup(SrcList *p){ 181 SrcList *pNew; 182 int i; 183 int nByte; 184 if( p==0 ) return 0; 185 nByte = sizeof(*p) + (p->nSrc>0 ? sizeof(p->a[0]) * (p->nSrc-1) : 0); 186 pNew = sqliteMallocRaw( nByte ); 187 if( pNew==0 ) return 0; 188 pNew->nSrc = pNew->nAlloc = p->nSrc; 189 for(i=0; i<p->nSrc; i++){ 190 struct SrcList_item *pNewItem = &pNew->a[i]; 191 struct SrcList_item *pOldItem = &p->a[i]; 192 pNewItem->zDatabase = sqliteStrDup(pOldItem->zDatabase); 193 pNewItem->zName = sqliteStrDup(pOldItem->zName); 194 pNewItem->zAlias = sqliteStrDup(pOldItem->zAlias); 195 pNewItem->jointype = pOldItem->jointype; 196 pNewItem->iCursor = pOldItem->iCursor; 197 pNewItem->pTab = 0; 198 pNewItem->pSelect = sqliteSelectDup(pOldItem->pSelect); 199 pNewItem->pOn = sqliteExprDup(pOldItem->pOn); 200 pNewItem->pUsing = sqliteIdListDup(pOldItem->pUsing); 201 } 202 return pNew; 203 } 204 IdList *sqliteIdListDup(IdList *p){ 205 IdList *pNew; 206 int i; 207 if( p==0 ) return 0; 208 pNew = sqliteMallocRaw( sizeof(*pNew) ); 209 if( pNew==0 ) return 0; 210 pNew->nId = pNew->nAlloc = p->nId; 211 pNew->a = sqliteMallocRaw( p->nId*sizeof(p->a[0]) ); 212 if( pNew->a==0 ) return 0; 213 for(i=0; i<p->nId; i++){ 214 struct IdList_item *pNewItem = &pNew->a[i]; 215 struct IdList_item *pOldItem = &p->a[i]; 216 pNewItem->zName = sqliteStrDup(pOldItem->zName); 217 pNewItem->idx = pOldItem->idx; 218 } 219 return pNew; 220 } 221 Select *sqliteSelectDup(Select *p){ 222 Select *pNew; 223 if( p==0 ) return 0; 224 pNew = sqliteMallocRaw( sizeof(*p) ); 225 if( pNew==0 ) return 0; 226 pNew->isDistinct = p->isDistinct; 227 pNew->pEList = sqliteExprListDup(p->pEList); 228 pNew->pSrc = sqliteSrcListDup(p->pSrc); 229 pNew->pWhere = sqliteExprDup(p->pWhere); 230 pNew->pGroupBy = sqliteExprListDup(p->pGroupBy); 231 pNew->pHaving = sqliteExprDup(p->pHaving); 232 pNew->pOrderBy = sqliteExprListDup(p->pOrderBy); 233 pNew->op = p->op; 234 pNew->pPrior = sqliteSelectDup(p->pPrior); 235 pNew->nLimit = p->nLimit; 236 pNew->nOffset = p->nOffset; 237 pNew->zSelect = 0; 238 pNew->iLimit = -1; 239 pNew->iOffset = -1; 240 return pNew; 241 } 242 243 244 /* 245 ** Add a new element to the end of an expression list. If pList is 246 ** initially NULL, then create a new expression list. 247 */ 248 ExprList *sqliteExprListAppend(ExprList *pList, Expr *pExpr, Token *pName){ 249 if( pList==0 ){ 250 pList = sqliteMalloc( sizeof(ExprList) ); 251 if( pList==0 ){ 252 /* sqliteExprDelete(pExpr); // Leak memory if malloc fails */ 253 return 0; 254 } 255 assert( pList->nAlloc==0 ); 256 } 257 if( pList->nAlloc<=pList->nExpr ){ 258 pList->nAlloc = pList->nAlloc*2 + 4; 259 pList->a = sqliteRealloc(pList->a, pList->nAlloc*sizeof(pList->a[0])); 260 if( pList->a==0 ){ 261 /* sqliteExprDelete(pExpr); // Leak memory if malloc fails */ 262 pList->nExpr = pList->nAlloc = 0; 263 return pList; 264 } 265 } 266 assert( pList->a!=0 ); 267 if( pExpr || pName ){ 268 struct ExprList_item *pItem = &pList->a[pList->nExpr++]; 269 memset(pItem, 0, sizeof(*pItem)); 270 pItem->pExpr = pExpr; 271 if( pName ){ 272 sqliteSetNString(&pItem->zName, pName->z, pName->n, 0); 273 sqliteDequote(pItem->zName); 274 } 275 } 276 return pList; 277 } 278 279 /* 280 ** Delete an entire expression list. 281 */ 282 void sqliteExprListDelete(ExprList *pList){ 283 int i; 284 if( pList==0 ) return; 285 assert( pList->a!=0 || (pList->nExpr==0 && pList->nAlloc==0) ); 286 assert( pList->nExpr<=pList->nAlloc ); 287 for(i=0; i<pList->nExpr; i++){ 288 sqliteExprDelete(pList->a[i].pExpr); 289 sqliteFree(pList->a[i].zName); 290 } 291 sqliteFree(pList->a); 292 sqliteFree(pList); 293 } 294 295 /* 296 ** Walk an expression tree. Return 1 if the expression is constant 297 ** and 0 if it involves variables. 298 ** 299 ** For the purposes of this function, a double-quoted string (ex: "abc") 300 ** is considered a variable but a single-quoted string (ex: 'abc') is 301 ** a constant. 302 */ 303 int sqliteExprIsConstant(Expr *p){ 304 switch( p->op ){ 305 case TK_ID: 306 case TK_COLUMN: 307 case TK_DOT: 308 case TK_FUNCTION: 309 return 0; 310 case TK_NULL: 311 case TK_STRING: 312 case TK_INTEGER: 313 case TK_FLOAT: 314 case TK_VARIABLE: 315 return 1; 316 default: { 317 if( p->pLeft && !sqliteExprIsConstant(p->pLeft) ) return 0; 318 if( p->pRight && !sqliteExprIsConstant(p->pRight) ) return 0; 319 if( p->pList ){ 320 int i; 321 for(i=0; i<p->pList->nExpr; i++){ 322 if( !sqliteExprIsConstant(p->pList->a[i].pExpr) ) return 0; 323 } 324 } 325 return p->pLeft!=0 || p->pRight!=0 || (p->pList && p->pList->nExpr>0); 326 } 327 } 328 return 0; 329 } 330 331 /* 332 ** If the given expression codes a constant integer that is small enough 333 ** to fit in a 32-bit integer, return 1 and put the value of the integer 334 ** in *pValue. If the expression is not an integer or if it is too big 335 ** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged. 336 */ 337 int sqliteExprIsInteger(Expr *p, int *pValue){ 338 switch( p->op ){ 339 case TK_INTEGER: { 340 if( sqliteFitsIn32Bits(p->token.z) ){ 341 *pValue = atoi(p->token.z); 342 return 1; 343 } 344 break; 345 } 346 case TK_STRING: { 347 const char *z = p->token.z; 348 int n = p->token.n; 349 if( n>0 && z[0]=='-' ){ z++; n--; } 350 while( n>0 && *z && isdigit(*z) ){ z++; n--; } 351 if( n==0 && sqliteFitsIn32Bits(p->token.z) ){ 352 *pValue = atoi(p->token.z); 353 return 1; 354 } 355 break; 356 } 357 case TK_UPLUS: { 358 return sqliteExprIsInteger(p->pLeft, pValue); 359 } 360 case TK_UMINUS: { 361 int v; 362 if( sqliteExprIsInteger(p->pLeft, &v) ){ 363 *pValue = -v; 364 return 1; 365 } 366 break; 367 } 368 default: break; 369 } 370 return 0; 371 } 372 373 /* 374 ** Return TRUE if the given string is a row-id column name. 375 */ 376 int sqliteIsRowid(const char *z){ 377 if( sqliteStrICmp(z, "_ROWID_")==0 ) return 1; 378 if( sqliteStrICmp(z, "ROWID")==0 ) return 1; 379 if( sqliteStrICmp(z, "OID")==0 ) return 1; 380 return 0; 381 } 382 383 /* 384 ** Given the name of a column of the form X.Y.Z or Y.Z or just Z, look up 385 ** that name in the set of source tables in pSrcList and make the pExpr 386 ** expression node refer back to that source column. The following changes 387 ** are made to pExpr: 388 ** 389 ** pExpr->iDb Set the index in db->aDb[] of the database holding 390 ** the table. 391 ** pExpr->iTable Set to the cursor number for the table obtained 392 ** from pSrcList. 393 ** pExpr->iColumn Set to the column number within the table. 394 ** pExpr->dataType Set to the appropriate data type for the column. 395 ** pExpr->op Set to TK_COLUMN. 396 ** pExpr->pLeft Any expression this points to is deleted 397 ** pExpr->pRight Any expression this points to is deleted. 398 ** 399 ** The pDbToken is the name of the database (the "X"). This value may be 400 ** NULL meaning that name is of the form Y.Z or Z. Any available database 401 ** can be used. The pTableToken is the name of the table (the "Y"). This 402 ** value can be NULL if pDbToken is also NULL. If pTableToken is NULL it 403 ** means that the form of the name is Z and that columns from any table 404 ** can be used. 405 ** 406 ** If the name cannot be resolved unambiguously, leave an error message 407 ** in pParse and return non-zero. Return zero on success. 408 */ 409 static int lookupName( 410 Parse *pParse, /* The parsing context */ 411 Token *pDbToken, /* Name of the database containing table, or NULL */ 412 Token *pTableToken, /* Name of table containing column, or NULL */ 413 Token *pColumnToken, /* Name of the column. */ 414 SrcList *pSrcList, /* List of tables used to resolve column names */ 415 ExprList *pEList, /* List of expressions used to resolve "AS" */ 416 Expr *pExpr /* Make this EXPR node point to the selected column */ 417 ){ 418 char *zDb = 0; /* Name of the database. The "X" in X.Y.Z */ 419 char *zTab = 0; /* Name of the table. The "Y" in X.Y.Z or Y.Z */ 420 char *zCol = 0; /* Name of the column. The "Z" */ 421 int i, j; /* Loop counters */ 422 int cnt = 0; /* Number of matching column names */ 423 int cntTab = 0; /* Number of matching table names */ 424 sqlite *db = pParse->db; /* The database */ 425 426 assert( pColumnToken && pColumnToken->z ); /* The Z in X.Y.Z cannot be NULL */ 427 if( pDbToken && pDbToken->z ){ 428 zDb = sqliteStrNDup(pDbToken->z, pDbToken->n); 429 sqliteDequote(zDb); 430 }else{ 431 zDb = 0; 432 } 433 if( pTableToken && pTableToken->z ){ 434 zTab = sqliteStrNDup(pTableToken->z, pTableToken->n); 435 sqliteDequote(zTab); 436 }else{ 437 assert( zDb==0 ); 438 zTab = 0; 439 } 440 zCol = sqliteStrNDup(pColumnToken->z, pColumnToken->n); 441 sqliteDequote(zCol); 442 if( sqlite_malloc_failed ){ 443 return 1; /* Leak memory (zDb and zTab) if malloc fails */ 444 } 445 assert( zTab==0 || pEList==0 ); 446 447 pExpr->iTable = -1; 448 for(i=0; i<pSrcList->nSrc; i++){ 449 struct SrcList_item *pItem = &pSrcList->a[i]; 450 Table *pTab = pItem->pTab; 451 Column *pCol; 452 453 if( pTab==0 ) continue; 454 assert( pTab->nCol>0 ); 455 if( zTab ){ 456 if( pItem->zAlias ){ 457 char *zTabName = pItem->zAlias; 458 if( sqliteStrICmp(zTabName, zTab)!=0 ) continue; 459 }else{ 460 char *zTabName = pTab->zName; 461 if( zTabName==0 || sqliteStrICmp(zTabName, zTab)!=0 ) continue; 462 if( zDb!=0 && sqliteStrICmp(db->aDb[pTab->iDb].zName, zDb)!=0 ){ 463 continue; 464 } 465 } 466 } 467 if( 0==(cntTab++) ){ 468 pExpr->iTable = pItem->iCursor; 469 pExpr->iDb = pTab->iDb; 470 } 471 for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){ 472 if( sqliteStrICmp(pCol->zName, zCol)==0 ){ 473 cnt++; 474 pExpr->iTable = pItem->iCursor; 475 pExpr->iDb = pTab->iDb; 476 /* Substitute the rowid (column -1) for the INTEGER PRIMARY KEY */ 477 pExpr->iColumn = j==pTab->iPKey ? -1 : j; 478 pExpr->dataType = pCol->sortOrder & SQLITE_SO_TYPEMASK; 479 break; 480 } 481 } 482 } 483 484 /* If we have not already resolved the name, then maybe 485 ** it is a new.* or old.* trigger argument reference 486 */ 487 if( zDb==0 && zTab!=0 && cnt==0 && pParse->trigStack!=0 ){ 488 TriggerStack *pTriggerStack = pParse->trigStack; 489 Table *pTab = 0; 490 if( pTriggerStack->newIdx != -1 && sqliteStrICmp("new", zTab) == 0 ){ 491 pExpr->iTable = pTriggerStack->newIdx; 492 assert( pTriggerStack->pTab ); 493 pTab = pTriggerStack->pTab; 494 }else if( pTriggerStack->oldIdx != -1 && sqliteStrICmp("old", zTab) == 0 ){ 495 pExpr->iTable = pTriggerStack->oldIdx; 496 assert( pTriggerStack->pTab ); 497 pTab = pTriggerStack->pTab; 498 } 499 500 if( pTab ){ 501 int j; 502 Column *pCol = pTab->aCol; 503 504 pExpr->iDb = pTab->iDb; 505 cntTab++; 506 for(j=0; j < pTab->nCol; j++, pCol++) { 507 if( sqliteStrICmp(pCol->zName, zCol)==0 ){ 508 cnt++; 509 pExpr->iColumn = j==pTab->iPKey ? -1 : j; 510 pExpr->dataType = pCol->sortOrder & SQLITE_SO_TYPEMASK; 511 break; 512 } 513 } 514 } 515 } 516 517 /* 518 ** Perhaps the name is a reference to the ROWID 519 */ 520 if( cnt==0 && cntTab==1 && sqliteIsRowid(zCol) ){ 521 cnt = 1; 522 pExpr->iColumn = -1; 523 pExpr->dataType = SQLITE_SO_NUM; 524 } 525 526 /* 527 ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z 528 ** might refer to an result-set alias. This happens, for example, when 529 ** we are resolving names in the WHERE clause of the following command: 530 ** 531 ** SELECT a+b AS x FROM table WHERE x<10; 532 ** 533 ** In cases like this, replace pExpr with a copy of the expression that 534 ** forms the result set entry ("a+b" in the example) and return immediately. 535 ** Note that the expression in the result set should have already been 536 ** resolved by the time the WHERE clause is resolved. 537 */ 538 if( cnt==0 && pEList!=0 ){ 539 for(j=0; j<pEList->nExpr; j++){ 540 char *zAs = pEList->a[j].zName; 541 if( zAs!=0 && sqliteStrICmp(zAs, zCol)==0 ){ 542 assert( pExpr->pLeft==0 && pExpr->pRight==0 ); 543 pExpr->op = TK_AS; 544 pExpr->iColumn = j; 545 pExpr->pLeft = sqliteExprDup(pEList->a[j].pExpr); 546 sqliteFree(zCol); 547 assert( zTab==0 && zDb==0 ); 548 return 0; 549 } 550 } 551 } 552 553 /* 554 ** If X and Y are NULL (in other words if only the column name Z is 555 ** supplied) and the value of Z is enclosed in double-quotes, then 556 ** Z is a string literal if it doesn't match any column names. In that 557 ** case, we need to return right away and not make any changes to 558 ** pExpr. 559 */ 560 if( cnt==0 && zTab==0 && pColumnToken->z[0]=='"' ){ 561 sqliteFree(zCol); 562 return 0; 563 } 564 565 /* 566 ** cnt==0 means there was not match. cnt>1 means there were two or 567 ** more matches. Either way, we have an error. 568 */ 569 if( cnt!=1 ){ 570 char *z = 0; 571 char *zErr; 572 zErr = cnt==0 ? "no such column: %s" : "ambiguous column name: %s"; 573 if( zDb ){ 574 sqliteSetString(&z, zDb, ".", zTab, ".", zCol, 0); 575 }else if( zTab ){ 576 sqliteSetString(&z, zTab, ".", zCol, 0); 577 }else{ 578 z = sqliteStrDup(zCol); 579 } 580 sqliteErrorMsg(pParse, zErr, z); 581 sqliteFree(z); 582 } 583 584 /* Clean up and return 585 */ 586 sqliteFree(zDb); 587 sqliteFree(zTab); 588 sqliteFree(zCol); 589 sqliteExprDelete(pExpr->pLeft); 590 pExpr->pLeft = 0; 591 sqliteExprDelete(pExpr->pRight); 592 pExpr->pRight = 0; 593 pExpr->op = TK_COLUMN; 594 sqliteAuthRead(pParse, pExpr, pSrcList); 595 return cnt!=1; 596 } 597 598 /* 599 ** This routine walks an expression tree and resolves references to 600 ** table columns. Nodes of the form ID.ID or ID resolve into an 601 ** index to the table in the table list and a column offset. The 602 ** Expr.opcode for such nodes is changed to TK_COLUMN. The Expr.iTable 603 ** value is changed to the index of the referenced table in pTabList 604 ** plus the "base" value. The base value will ultimately become the 605 ** VDBE cursor number for a cursor that is pointing into the referenced 606 ** table. The Expr.iColumn value is changed to the index of the column 607 ** of the referenced table. The Expr.iColumn value for the special 608 ** ROWID column is -1. Any INTEGER PRIMARY KEY column is tried as an 609 ** alias for ROWID. 610 ** 611 ** We also check for instances of the IN operator. IN comes in two 612 ** forms: 613 ** 614 ** expr IN (exprlist) 615 ** and 616 ** expr IN (SELECT ...) 617 ** 618 ** The first form is handled by creating a set holding the list 619 ** of allowed values. The second form causes the SELECT to generate 620 ** a temporary table. 621 ** 622 ** This routine also looks for scalar SELECTs that are part of an expression. 623 ** If it finds any, it generates code to write the value of that select 624 ** into a memory cell. 625 ** 626 ** Unknown columns or tables provoke an error. The function returns 627 ** the number of errors seen and leaves an error message on pParse->zErrMsg. 628 */ 629 int sqliteExprResolveIds( 630 Parse *pParse, /* The parser context */ 631 SrcList *pSrcList, /* List of tables used to resolve column names */ 632 ExprList *pEList, /* List of expressions used to resolve "AS" */ 633 Expr *pExpr /* The expression to be analyzed. */ 634 ){ 635 int i; 636 637 if( pExpr==0 || pSrcList==0 ) return 0; 638 for(i=0; i<pSrcList->nSrc; i++){ 639 assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursor<pParse->nTab ); 640 } 641 switch( pExpr->op ){ 642 /* Double-quoted strings (ex: "abc") are used as identifiers if 643 ** possible. Otherwise they remain as strings. Single-quoted 644 ** strings (ex: 'abc') are always string literals. 645 */ 646 case TK_STRING: { 647 if( pExpr->token.z[0]=='\'' ) break; 648 /* Fall thru into the TK_ID case if this is a double-quoted string */ 649 } 650 /* A lone identifier is the name of a columnd. 651 */ 652 /* FALLTHROUGH */ 653 case TK_ID: { 654 if( lookupName(pParse, 0, 0, &pExpr->token, pSrcList, pEList, pExpr) ){ 655 return 1; 656 } 657 break; 658 } 659 660 /* A table name and column name: ID.ID 661 ** Or a database, table and column: ID.ID.ID 662 */ 663 case TK_DOT: { 664 Token *pColumn; 665 Token *pTable; 666 Token *pDb; 667 Expr *pRight; 668 669 pRight = pExpr->pRight; 670 if( pRight->op==TK_ID ){ 671 pDb = 0; 672 pTable = &pExpr->pLeft->token; 673 pColumn = &pRight->token; 674 }else{ 675 assert( pRight->op==TK_DOT ); 676 pDb = &pExpr->pLeft->token; 677 pTable = &pRight->pLeft->token; 678 pColumn = &pRight->pRight->token; 679 } 680 if( lookupName(pParse, pDb, pTable, pColumn, pSrcList, 0, pExpr) ){ 681 return 1; 682 } 683 break; 684 } 685 686 case TK_IN: { 687 Vdbe *v = sqliteGetVdbe(pParse); 688 if( v==0 ) return 1; 689 if( sqliteExprResolveIds(pParse, pSrcList, pEList, pExpr->pLeft) ){ 690 return 1; 691 } 692 if( pExpr->pSelect ){ 693 /* Case 1: expr IN (SELECT ...) 694 ** 695 ** Generate code to write the results of the select into a temporary 696 ** table. The cursor number of the temporary table has already 697 ** been put in iTable by sqliteExprResolveInSelect(). 698 */ 699 pExpr->iTable = pParse->nTab++; 700 sqliteVdbeAddOp(v, OP_OpenTemp, pExpr->iTable, 1); 701 sqliteSelect(pParse, pExpr->pSelect, SRT_Set, pExpr->iTable, 0,0,0); 702 }else if( pExpr->pList ){ 703 /* Case 2: expr IN (exprlist) 704 ** 705 ** Create a set to put the exprlist values in. The Set id is stored 706 ** in iTable. 707 */ 708 int i, iSet; 709 for(i=0; i<pExpr->pList->nExpr; i++){ 710 Expr *pE2 = pExpr->pList->a[i].pExpr; 711 if( !sqliteExprIsConstant(pE2) ){ 712 sqliteErrorMsg(pParse, 713 "right-hand side of IN operator must be constant"); 714 return 1; 715 } 716 if( sqliteExprCheck(pParse, pE2, 0, 0) ){ 717 return 1; 718 } 719 } 720 iSet = pExpr->iTable = pParse->nSet++; 721 for(i=0; i<pExpr->pList->nExpr; i++){ 722 Expr *pE2 = pExpr->pList->a[i].pExpr; 723 switch( pE2->op ){ 724 case TK_FLOAT: 725 case TK_INTEGER: 726 case TK_STRING: { 727 int addr; 728 assert( pE2->token.z ); 729 addr = sqliteVdbeOp3(v, OP_SetInsert, iSet, 0, 730 pE2->token.z, pE2->token.n); 731 sqliteVdbeDequoteP3(v, addr); 732 break; 733 } 734 default: { 735 sqliteExprCode(pParse, pE2); 736 sqliteVdbeAddOp(v, OP_SetInsert, iSet, 0); 737 break; 738 } 739 } 740 } 741 } 742 break; 743 } 744 745 case TK_SELECT: { 746 /* This has to be a scalar SELECT. Generate code to put the 747 ** value of this select in a memory cell and record the number 748 ** of the memory cell in iColumn. 749 */ 750 pExpr->iColumn = pParse->nMem++; 751 if( sqliteSelect(pParse, pExpr->pSelect, SRT_Mem, pExpr->iColumn,0,0,0) ){ 752 return 1; 753 } 754 break; 755 } 756 757 /* For all else, just recursively walk the tree */ 758 default: { 759 if( pExpr->pLeft 760 && sqliteExprResolveIds(pParse, pSrcList, pEList, pExpr->pLeft) ){ 761 return 1; 762 } 763 if( pExpr->pRight 764 && sqliteExprResolveIds(pParse, pSrcList, pEList, pExpr->pRight) ){ 765 return 1; 766 } 767 if( pExpr->pList ){ 768 int i; 769 ExprList *pList = pExpr->pList; 770 for(i=0; i<pList->nExpr; i++){ 771 Expr *pArg = pList->a[i].pExpr; 772 if( sqliteExprResolveIds(pParse, pSrcList, pEList, pArg) ){ 773 return 1; 774 } 775 } 776 } 777 } 778 } 779 return 0; 780 } 781 782 /* 783 ** pExpr is a node that defines a function of some kind. It might 784 ** be a syntactic function like "count(x)" or it might be a function 785 ** that implements an operator, like "a LIKE b". 786 ** 787 ** This routine makes *pzName point to the name of the function and 788 ** *pnName hold the number of characters in the function name. 789 */ 790 static void getFunctionName(Expr *pExpr, const char **pzName, int *pnName){ 791 switch( pExpr->op ){ 792 case TK_FUNCTION: { 793 *pzName = pExpr->token.z; 794 *pnName = pExpr->token.n; 795 break; 796 } 797 case TK_LIKE: { 798 *pzName = "like"; 799 *pnName = 4; 800 break; 801 } 802 case TK_GLOB: { 803 *pzName = "glob"; 804 *pnName = 4; 805 break; 806 } 807 default: { 808 *pzName = "can't happen"; 809 *pnName = 12; 810 break; 811 } 812 } 813 } 814 815 /* 816 ** Error check the functions in an expression. Make sure all 817 ** function names are recognized and all functions have the correct 818 ** number of arguments. Leave an error message in pParse->zErrMsg 819 ** if anything is amiss. Return the number of errors. 820 ** 821 ** if pIsAgg is not null and this expression is an aggregate function 822 ** (like count(*) or max(value)) then write a 1 into *pIsAgg. 823 */ 824 int sqliteExprCheck(Parse *pParse, Expr *pExpr, int allowAgg, int *pIsAgg){ 825 int nErr = 0; 826 if( pExpr==0 ) return 0; 827 switch( pExpr->op ){ 828 case TK_GLOB: 829 case TK_LIKE: 830 case TK_FUNCTION: { 831 int n = pExpr->pList ? pExpr->pList->nExpr : 0; /* Number of arguments */ 832 int no_such_func = 0; /* True if no such function exists */ 833 int wrong_num_args = 0; /* True if wrong number of arguments */ 834 int is_agg = 0; /* True if is an aggregate function */ 835 int i; 836 int nId; /* Number of characters in function name */ 837 const char *zId; /* The function name. */ 838 FuncDef *pDef; 839 840 getFunctionName(pExpr, &zId, &nId); 841 pDef = sqliteFindFunction(pParse->db, zId, nId, n, 0); 842 if( pDef==0 ){ 843 pDef = sqliteFindFunction(pParse->db, zId, nId, -1, 0); 844 if( pDef==0 ){ 845 no_such_func = 1; 846 }else{ 847 wrong_num_args = 1; 848 } 849 }else{ 850 is_agg = pDef->xFunc==0; 851 } 852 if( is_agg && !allowAgg ){ 853 sqliteErrorMsg(pParse, "misuse of aggregate function %.*s()", nId, zId); 854 nErr++; 855 is_agg = 0; 856 }else if( no_such_func ){ 857 sqliteErrorMsg(pParse, "no such function: %.*s", nId, zId); 858 nErr++; 859 }else if( wrong_num_args ){ 860 sqliteErrorMsg(pParse,"wrong number of arguments to function %.*s()", 861 nId, zId); 862 nErr++; 863 } 864 if( is_agg ){ 865 pExpr->op = TK_AGG_FUNCTION; 866 if( pIsAgg ) *pIsAgg = 1; 867 } 868 for(i=0; nErr==0 && i<n; i++){ 869 nErr = sqliteExprCheck(pParse, pExpr->pList->a[i].pExpr, 870 allowAgg && !is_agg, pIsAgg); 871 } 872 if( pDef==0 ){ 873 /* Already reported an error */ 874 }else if( pDef->dataType>=0 ){ 875 if( pDef->dataType<n ){ 876 pExpr->dataType = 877 sqliteExprType(pExpr->pList->a[pDef->dataType].pExpr); 878 }else{ 879 pExpr->dataType = SQLITE_SO_NUM; 880 } 881 }else if( pDef->dataType==SQLITE_ARGS ){ 882 pDef->dataType = SQLITE_SO_TEXT; 883 for(i=0; i<n; i++){ 884 if( sqliteExprType(pExpr->pList->a[i].pExpr)==SQLITE_SO_NUM ){ 885 pExpr->dataType = SQLITE_SO_NUM; 886 break; 887 } 888 } 889 }else if( pDef->dataType==SQLITE_NUMERIC ){ 890 pExpr->dataType = SQLITE_SO_NUM; 891 }else{ 892 pExpr->dataType = SQLITE_SO_TEXT; 893 } 894 } 895 /* FALLTHROUGH */ 896 default: { 897 if( pExpr->pLeft ){ 898 nErr = sqliteExprCheck(pParse, pExpr->pLeft, allowAgg, pIsAgg); 899 } 900 if( nErr==0 && pExpr->pRight ){ 901 nErr = sqliteExprCheck(pParse, pExpr->pRight, allowAgg, pIsAgg); 902 } 903 if( nErr==0 && pExpr->pList ){ 904 int n = pExpr->pList->nExpr; 905 int i; 906 for(i=0; nErr==0 && i<n; i++){ 907 Expr *pE2 = pExpr->pList->a[i].pExpr; 908 nErr = sqliteExprCheck(pParse, pE2, allowAgg, pIsAgg); 909 } 910 } 911 break; 912 } 913 } 914 return nErr; 915 } 916 917 /* 918 ** Return either SQLITE_SO_NUM or SQLITE_SO_TEXT to indicate whether the 919 ** given expression should sort as numeric values or as text. 920 ** 921 ** The sqliteExprResolveIds() and sqliteExprCheck() routines must have 922 ** both been called on the expression before it is passed to this routine. 923 */ 924 int sqliteExprType(Expr *p){ 925 if( p==0 ) return SQLITE_SO_NUM; 926 while( p ) switch( p->op ){ 927 case TK_PLUS: 928 case TK_MINUS: 929 case TK_STAR: 930 case TK_SLASH: 931 case TK_AND: 932 case TK_OR: 933 case TK_ISNULL: 934 case TK_NOTNULL: 935 case TK_NOT: 936 case TK_UMINUS: 937 case TK_UPLUS: 938 case TK_BITAND: 939 case TK_BITOR: 940 case TK_BITNOT: 941 case TK_LSHIFT: 942 case TK_RSHIFT: 943 case TK_REM: 944 case TK_INTEGER: 945 case TK_FLOAT: 946 case TK_IN: 947 case TK_BETWEEN: 948 case TK_GLOB: 949 case TK_LIKE: 950 return SQLITE_SO_NUM; 951 952 case TK_STRING: 953 case TK_NULL: 954 case TK_CONCAT: 955 case TK_VARIABLE: 956 return SQLITE_SO_TEXT; 957 958 case TK_LT: 959 case TK_LE: 960 case TK_GT: 961 case TK_GE: 962 case TK_NE: 963 case TK_EQ: 964 if( sqliteExprType(p->pLeft)==SQLITE_SO_NUM ){ 965 return SQLITE_SO_NUM; 966 } 967 p = p->pRight; 968 break; 969 970 case TK_AS: 971 p = p->pLeft; 972 break; 973 974 case TK_COLUMN: 975 case TK_FUNCTION: 976 case TK_AGG_FUNCTION: 977 return p->dataType; 978 979 case TK_SELECT: 980 assert( p->pSelect ); 981 assert( p->pSelect->pEList ); 982 assert( p->pSelect->pEList->nExpr>0 ); 983 p = p->pSelect->pEList->a[0].pExpr; 984 break; 985 986 case TK_CASE: { 987 if( p->pRight && sqliteExprType(p->pRight)==SQLITE_SO_NUM ){ 988 return SQLITE_SO_NUM; 989 } 990 if( p->pList ){ 991 int i; 992 ExprList *pList = p->pList; 993 for(i=1; i<pList->nExpr; i+=2){ 994 if( sqliteExprType(pList->a[i].pExpr)==SQLITE_SO_NUM ){ 995 return SQLITE_SO_NUM; 996 } 997 } 998 } 999 return SQLITE_SO_TEXT; 1000 } 1001 1002 default: 1003 assert( p->op==TK_ABORT ); /* Can't Happen */ 1004 break; 1005 } 1006 return SQLITE_SO_NUM; 1007 } 1008 1009 /* 1010 ** Generate code into the current Vdbe to evaluate the given 1011 ** expression and leave the result on the top of stack. 1012 */ 1013 void sqliteExprCode(Parse *pParse, Expr *pExpr){ 1014 Vdbe *v = pParse->pVdbe; 1015 int op; 1016 if( v==0 || pExpr==0 ) return; 1017 switch( pExpr->op ){ 1018 case TK_PLUS: op = OP_Add; break; 1019 case TK_MINUS: op = OP_Subtract; break; 1020 case TK_STAR: op = OP_Multiply; break; 1021 case TK_SLASH: op = OP_Divide; break; 1022 case TK_AND: op = OP_And; break; 1023 case TK_OR: op = OP_Or; break; 1024 case TK_LT: op = OP_Lt; break; 1025 case TK_LE: op = OP_Le; break; 1026 case TK_GT: op = OP_Gt; break; 1027 case TK_GE: op = OP_Ge; break; 1028 case TK_NE: op = OP_Ne; break; 1029 case TK_EQ: op = OP_Eq; break; 1030 case TK_ISNULL: op = OP_IsNull; break; 1031 case TK_NOTNULL: op = OP_NotNull; break; 1032 case TK_NOT: op = OP_Not; break; 1033 case TK_UMINUS: op = OP_Negative; break; 1034 case TK_BITAND: op = OP_BitAnd; break; 1035 case TK_BITOR: op = OP_BitOr; break; 1036 case TK_BITNOT: op = OP_BitNot; break; 1037 case TK_LSHIFT: op = OP_ShiftLeft; break; 1038 case TK_RSHIFT: op = OP_ShiftRight; break; 1039 case TK_REM: op = OP_Remainder; break; 1040 default: break; 1041 } 1042 switch( pExpr->op ){ 1043 case TK_COLUMN: { 1044 if( pParse->useAgg ){ 1045 sqliteVdbeAddOp(v, OP_AggGet, 0, pExpr->iAgg); 1046 }else if( pExpr->iColumn>=0 ){ 1047 sqliteVdbeAddOp(v, OP_Column, pExpr->iTable, pExpr->iColumn); 1048 }else{ 1049 sqliteVdbeAddOp(v, OP_Recno, pExpr->iTable, 0); 1050 } 1051 break; 1052 } 1053 case TK_STRING: 1054 case TK_FLOAT: 1055 case TK_INTEGER: { 1056 if( pExpr->op==TK_INTEGER && sqliteFitsIn32Bits(pExpr->token.z) ){ 1057 sqliteVdbeAddOp(v, OP_Integer, atoi(pExpr->token.z), 0); 1058 }else{ 1059 sqliteVdbeAddOp(v, OP_String, 0, 0); 1060 } 1061 assert( pExpr->token.z ); 1062 sqliteVdbeChangeP3(v, -1, pExpr->token.z, pExpr->token.n); 1063 sqliteVdbeDequoteP3(v, -1); 1064 break; 1065 } 1066 case TK_NULL: { 1067 sqliteVdbeAddOp(v, OP_String, 0, 0); 1068 break; 1069 } 1070 case TK_VARIABLE: { 1071 sqliteVdbeAddOp(v, OP_Variable, pExpr->iTable, 0); 1072 break; 1073 } 1074 case TK_LT: 1075 case TK_LE: 1076 case TK_GT: 1077 case TK_GE: 1078 case TK_NE: 1079 case TK_EQ: { 1080 if( pParse->db->file_format>=4 && sqliteExprType(pExpr)==SQLITE_SO_TEXT ){ 1081 op += 6; /* Convert numeric opcodes to text opcodes */ 1082 } 1083 } 1084 /* FALLTHROUGH */ 1085 case TK_AND: 1086 case TK_OR: 1087 case TK_PLUS: 1088 case TK_STAR: 1089 case TK_MINUS: 1090 case TK_REM: 1091 case TK_BITAND: 1092 case TK_BITOR: 1093 case TK_SLASH: { 1094 sqliteExprCode(pParse, pExpr->pLeft); 1095 sqliteExprCode(pParse, pExpr->pRight); 1096 sqliteVdbeAddOp(v, op, 0, 0); 1097 break; 1098 } 1099 case TK_LSHIFT: 1100 case TK_RSHIFT: { 1101 sqliteExprCode(pParse, pExpr->pRight); 1102 sqliteExprCode(pParse, pExpr->pLeft); 1103 sqliteVdbeAddOp(v, op, 0, 0); 1104 break; 1105 } 1106 case TK_CONCAT: { 1107 sqliteExprCode(pParse, pExpr->pLeft); 1108 sqliteExprCode(pParse, pExpr->pRight); 1109 sqliteVdbeAddOp(v, OP_Concat, 2, 0); 1110 break; 1111 } 1112 case TK_UMINUS: { 1113 assert( pExpr->pLeft ); 1114 if( pExpr->pLeft->op==TK_FLOAT || pExpr->pLeft->op==TK_INTEGER ){ 1115 Token *p = &pExpr->pLeft->token; 1116 char *z = sqliteMalloc( p->n + 2 ); 1117 sprintf(z, "-%.*s", p->n, p->z); 1118 if( pExpr->pLeft->op==TK_INTEGER && sqliteFitsIn32Bits(z) ){ 1119 sqliteVdbeAddOp(v, OP_Integer, atoi(z), 0); 1120 }else{ 1121 sqliteVdbeAddOp(v, OP_String, 0, 0); 1122 } 1123 sqliteVdbeChangeP3(v, -1, z, p->n+1); 1124 sqliteFree(z); 1125 break; 1126 } 1127 /* Fall through into TK_NOT */ 1128 } 1129 /* FALLTHROUGH */ 1130 case TK_BITNOT: 1131 case TK_NOT: { 1132 sqliteExprCode(pParse, pExpr->pLeft); 1133 sqliteVdbeAddOp(v, op, 0, 0); 1134 break; 1135 } 1136 case TK_ISNULL: 1137 case TK_NOTNULL: { 1138 int dest; 1139 sqliteVdbeAddOp(v, OP_Integer, 1, 0); 1140 sqliteExprCode(pParse, pExpr->pLeft); 1141 dest = sqliteVdbeCurrentAddr(v) + 2; 1142 sqliteVdbeAddOp(v, op, 1, dest); 1143 sqliteVdbeAddOp(v, OP_AddImm, -1, 0); 1144 break; 1145 } 1146 case TK_AGG_FUNCTION: { 1147 sqliteVdbeAddOp(v, OP_AggGet, 0, pExpr->iAgg); 1148 break; 1149 } 1150 case TK_GLOB: 1151 case TK_LIKE: 1152 case TK_FUNCTION: { 1153 ExprList *pList = pExpr->pList; 1154 int nExpr = pList ? pList->nExpr : 0; 1155 FuncDef *pDef; 1156 int nId; 1157 const char *zId; 1158 getFunctionName(pExpr, &zId, &nId); 1159 pDef = sqliteFindFunction(pParse->db, zId, nId, nExpr, 0); 1160 assert( pDef!=0 ); 1161 nExpr = sqliteExprCodeExprList(pParse, pList, pDef->includeTypes); 1162 sqliteVdbeOp3(v, OP_Function, nExpr, 0, (char*)pDef, P3_POINTER); 1163 break; 1164 } 1165 case TK_SELECT: { 1166 sqliteVdbeAddOp(v, OP_MemLoad, pExpr->iColumn, 0); 1167 break; 1168 } 1169 case TK_IN: { 1170 int addr; 1171 sqliteVdbeAddOp(v, OP_Integer, 1, 0); 1172 sqliteExprCode(pParse, pExpr->pLeft); 1173 addr = sqliteVdbeCurrentAddr(v); 1174 sqliteVdbeAddOp(v, OP_NotNull, -1, addr+4); 1175 sqliteVdbeAddOp(v, OP_Pop, 2, 0); 1176 sqliteVdbeAddOp(v, OP_String, 0, 0); 1177 sqliteVdbeAddOp(v, OP_Goto, 0, addr+6); 1178 if( pExpr->pSelect ){ 1179 sqliteVdbeAddOp(v, OP_Found, pExpr->iTable, addr+6); 1180 }else{ 1181 sqliteVdbeAddOp(v, OP_SetFound, pExpr->iTable, addr+6); 1182 } 1183 sqliteVdbeAddOp(v, OP_AddImm, -1, 0); 1184 break; 1185 } 1186 case TK_BETWEEN: { 1187 sqliteExprCode(pParse, pExpr->pLeft); 1188 sqliteVdbeAddOp(v, OP_Dup, 0, 0); 1189 sqliteExprCode(pParse, pExpr->pList->a[0].pExpr); 1190 sqliteVdbeAddOp(v, OP_Ge, 0, 0); 1191 sqliteVdbeAddOp(v, OP_Pull, 1, 0); 1192 sqliteExprCode(pParse, pExpr->pList->a[1].pExpr); 1193 sqliteVdbeAddOp(v, OP_Le, 0, 0); 1194 sqliteVdbeAddOp(v, OP_And, 0, 0); 1195 break; 1196 } 1197 case TK_UPLUS: 1198 case TK_AS: { 1199 sqliteExprCode(pParse, pExpr->pLeft); 1200 break; 1201 } 1202 case TK_CASE: { 1203 int expr_end_label; 1204 int jumpInst; 1205 int addr; 1206 int nExpr; 1207 int i; 1208 1209 assert(pExpr->pList); 1210 assert((pExpr->pList->nExpr % 2) == 0); 1211 assert(pExpr->pList->nExpr > 0); 1212 nExpr = pExpr->pList->nExpr; 1213 expr_end_label = sqliteVdbeMakeLabel(v); 1214 if( pExpr->pLeft ){ 1215 sqliteExprCode(pParse, pExpr->pLeft); 1216 } 1217 for(i=0; i<nExpr; i=i+2){ 1218 sqliteExprCode(pParse, pExpr->pList->a[i].pExpr); 1219 if( pExpr->pLeft ){ 1220 sqliteVdbeAddOp(v, OP_Dup, 1, 1); 1221 jumpInst = sqliteVdbeAddOp(v, OP_Ne, 1, 0); 1222 sqliteVdbeAddOp(v, OP_Pop, 1, 0); 1223 }else{ 1224 jumpInst = sqliteVdbeAddOp(v, OP_IfNot, 1, 0); 1225 } 1226 sqliteExprCode(pParse, pExpr->pList->a[i+1].pExpr); 1227 sqliteVdbeAddOp(v, OP_Goto, 0, expr_end_label); 1228 addr = sqliteVdbeCurrentAddr(v); 1229 sqliteVdbeChangeP2(v, jumpInst, addr); 1230 } 1231 if( pExpr->pLeft ){ 1232 sqliteVdbeAddOp(v, OP_Pop, 1, 0); 1233 } 1234 if( pExpr->pRight ){ 1235 sqliteExprCode(pParse, pExpr->pRight); 1236 }else{ 1237 sqliteVdbeAddOp(v, OP_String, 0, 0); 1238 } 1239 sqliteVdbeResolveLabel(v, expr_end_label); 1240 break; 1241 } 1242 case TK_RAISE: { 1243 if( !pParse->trigStack ){ 1244 sqliteErrorMsg(pParse, 1245 "RAISE() may only be used within a trigger-program"); 1246 pParse->nErr++; 1247 return; 1248 } 1249 if( pExpr->iColumn == OE_Rollback || 1250 pExpr->iColumn == OE_Abort || 1251 pExpr->iColumn == OE_Fail ){ 1252 sqliteVdbeOp3(v, OP_Halt, SQLITE_CONSTRAINT, pExpr->iColumn, 1253 pExpr->token.z, pExpr->token.n); 1254 sqliteVdbeDequoteP3(v, -1); 1255 } else { 1256 assert( pExpr->iColumn == OE_Ignore ); 1257 sqliteVdbeOp3(v, OP_Goto, 0, pParse->trigStack->ignoreJump, 1258 "(IGNORE jump)", 0); 1259 } 1260 } 1261 break; 1262 } 1263 } 1264 1265 /* 1266 ** Generate code that pushes the value of every element of the given 1267 ** expression list onto the stack. If the includeTypes flag is true, 1268 ** then also push a string that is the datatype of each element onto 1269 ** the stack after the value. 1270 ** 1271 ** Return the number of elements pushed onto the stack. 1272 */ 1273 int sqliteExprCodeExprList( 1274 Parse *pParse, /* Parsing context */ 1275 ExprList *pList, /* The expression list to be coded */ 1276 int includeTypes /* TRUE to put datatypes on the stack too */ 1277 ){ 1278 struct ExprList_item *pItem; 1279 int i, n; 1280 Vdbe *v; 1281 if( pList==0 ) return 0; 1282 v = sqliteGetVdbe(pParse); 1283 n = pList->nExpr; 1284 for(pItem=pList->a, i=0; i<n; i++, pItem++){ 1285 sqliteExprCode(pParse, pItem->pExpr); 1286 if( includeTypes ){ 1287 sqliteVdbeOp3(v, OP_String, 0, 0, 1288 sqliteExprType(pItem->pExpr)==SQLITE_SO_NUM ? "numeric" : "text", 1289 P3_STATIC); 1290 } 1291 } 1292 return includeTypes ? n*2 : n; 1293 } 1294 1295 /* 1296 ** Generate code for a boolean expression such that a jump is made 1297 ** to the label "dest" if the expression is true but execution 1298 ** continues straight thru if the expression is false. 1299 ** 1300 ** If the expression evaluates to NULL (neither true nor false), then 1301 ** take the jump if the jumpIfNull flag is true. 1302 */ 1303 void sqliteExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){ 1304 Vdbe *v = pParse->pVdbe; 1305 int op = 0; 1306 if( v==0 || pExpr==0 ) return; 1307 switch( pExpr->op ){ 1308 case TK_LT: op = OP_Lt; break; 1309 case TK_LE: op = OP_Le; break; 1310 case TK_GT: op = OP_Gt; break; 1311 case TK_GE: op = OP_Ge; break; 1312 case TK_NE: op = OP_Ne; break; 1313 case TK_EQ: op = OP_Eq; break; 1314 case TK_ISNULL: op = OP_IsNull; break; 1315 case TK_NOTNULL: op = OP_NotNull; break; 1316 default: break; 1317 } 1318 switch( pExpr->op ){ 1319 case TK_AND: { 1320 int d2 = sqliteVdbeMakeLabel(v); 1321 sqliteExprIfFalse(pParse, pExpr->pLeft, d2, !jumpIfNull); 1322 sqliteExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull); 1323 sqliteVdbeResolveLabel(v, d2); 1324 break; 1325 } 1326 case TK_OR: { 1327 sqliteExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull); 1328 sqliteExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull); 1329 break; 1330 } 1331 case TK_NOT: { 1332 sqliteExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull); 1333 break; 1334 } 1335 case TK_LT: 1336 case TK_LE: 1337 case TK_GT: 1338 case TK_GE: 1339 case TK_NE: 1340 case TK_EQ: { 1341 sqliteExprCode(pParse, pExpr->pLeft); 1342 sqliteExprCode(pParse, pExpr->pRight); 1343 if( pParse->db->file_format>=4 && sqliteExprType(pExpr)==SQLITE_SO_TEXT ){ 1344 op += 6; /* Convert numeric opcodes to text opcodes */ 1345 } 1346 sqliteVdbeAddOp(v, op, jumpIfNull, dest); 1347 break; 1348 } 1349 case TK_ISNULL: 1350 case TK_NOTNULL: { 1351 sqliteExprCode(pParse, pExpr->pLeft); 1352 sqliteVdbeAddOp(v, op, 1, dest); 1353 break; 1354 } 1355 case TK_IN: { 1356 int addr; 1357 sqliteExprCode(pParse, pExpr->pLeft); 1358 addr = sqliteVdbeCurrentAddr(v); 1359 sqliteVdbeAddOp(v, OP_NotNull, -1, addr+3); 1360 sqliteVdbeAddOp(v, OP_Pop, 1, 0); 1361 sqliteVdbeAddOp(v, OP_Goto, 0, jumpIfNull ? dest : addr+4); 1362 if( pExpr->pSelect ){ 1363 sqliteVdbeAddOp(v, OP_Found, pExpr->iTable, dest); 1364 }else{ 1365 sqliteVdbeAddOp(v, OP_SetFound, pExpr->iTable, dest); 1366 } 1367 break; 1368 } 1369 case TK_BETWEEN: { 1370 int addr; 1371 sqliteExprCode(pParse, pExpr->pLeft); 1372 sqliteVdbeAddOp(v, OP_Dup, 0, 0); 1373 sqliteExprCode(pParse, pExpr->pList->a[0].pExpr); 1374 addr = sqliteVdbeAddOp(v, OP_Lt, !jumpIfNull, 0); 1375 sqliteExprCode(pParse, pExpr->pList->a[1].pExpr); 1376 sqliteVdbeAddOp(v, OP_Le, jumpIfNull, dest); 1377 sqliteVdbeAddOp(v, OP_Integer, 0, 0); 1378 sqliteVdbeChangeP2(v, addr, sqliteVdbeCurrentAddr(v)); 1379 sqliteVdbeAddOp(v, OP_Pop, 1, 0); 1380 break; 1381 } 1382 default: { 1383 sqliteExprCode(pParse, pExpr); 1384 sqliteVdbeAddOp(v, OP_If, jumpIfNull, dest); 1385 break; 1386 } 1387 } 1388 } 1389 1390 /* 1391 ** Generate code for a boolean expression such that a jump is made 1392 ** to the label "dest" if the expression is false but execution 1393 ** continues straight thru if the expression is true. 1394 ** 1395 ** If the expression evaluates to NULL (neither true nor false) then 1396 ** jump if jumpIfNull is true or fall through if jumpIfNull is false. 1397 */ 1398 void sqliteExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){ 1399 Vdbe *v = pParse->pVdbe; 1400 int op = 0; 1401 if( v==0 || pExpr==0 ) return; 1402 switch( pExpr->op ){ 1403 case TK_LT: op = OP_Ge; break; 1404 case TK_LE: op = OP_Gt; break; 1405 case TK_GT: op = OP_Le; break; 1406 case TK_GE: op = OP_Lt; break; 1407 case TK_NE: op = OP_Eq; break; 1408 case TK_EQ: op = OP_Ne; break; 1409 case TK_ISNULL: op = OP_NotNull; break; 1410 case TK_NOTNULL: op = OP_IsNull; break; 1411 default: break; 1412 } 1413 switch( pExpr->op ){ 1414 case TK_AND: { 1415 sqliteExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull); 1416 sqliteExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull); 1417 break; 1418 } 1419 case TK_OR: { 1420 int d2 = sqliteVdbeMakeLabel(v); 1421 sqliteExprIfTrue(pParse, pExpr->pLeft, d2, !jumpIfNull); 1422 sqliteExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull); 1423 sqliteVdbeResolveLabel(v, d2); 1424 break; 1425 } 1426 case TK_NOT: { 1427 sqliteExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull); 1428 break; 1429 } 1430 case TK_LT: 1431 case TK_LE: 1432 case TK_GT: 1433 case TK_GE: 1434 case TK_NE: 1435 case TK_EQ: { 1436 if( pParse->db->file_format>=4 && sqliteExprType(pExpr)==SQLITE_SO_TEXT ){ 1437 /* Convert numeric comparison opcodes into text comparison opcodes. 1438 ** This step depends on the fact that the text comparision opcodes are 1439 ** always 6 greater than their corresponding numeric comparison 1440 ** opcodes. 1441 */ 1442 assert( OP_Eq+6 == OP_StrEq ); 1443 op += 6; 1444 } 1445 sqliteExprCode(pParse, pExpr->pLeft); 1446 sqliteExprCode(pParse, pExpr->pRight); 1447 sqliteVdbeAddOp(v, op, jumpIfNull, dest); 1448 break; 1449 } 1450 case TK_ISNULL: 1451 case TK_NOTNULL: { 1452 sqliteExprCode(pParse, pExpr->pLeft); 1453 sqliteVdbeAddOp(v, op, 1, dest); 1454 break; 1455 } 1456 case TK_IN: { 1457 int addr; 1458 sqliteExprCode(pParse, pExpr->pLeft); 1459 addr = sqliteVdbeCurrentAddr(v); 1460 sqliteVdbeAddOp(v, OP_NotNull, -1, addr+3); 1461 sqliteVdbeAddOp(v, OP_Pop, 1, 0); 1462 sqliteVdbeAddOp(v, OP_Goto, 0, jumpIfNull ? dest : addr+4); 1463 if( pExpr->pSelect ){ 1464 sqliteVdbeAddOp(v, OP_NotFound, pExpr->iTable, dest); 1465 }else{ 1466 sqliteVdbeAddOp(v, OP_SetNotFound, pExpr->iTable, dest); 1467 } 1468 break; 1469 } 1470 case TK_BETWEEN: { 1471 int addr; 1472 sqliteExprCode(pParse, pExpr->pLeft); 1473 sqliteVdbeAddOp(v, OP_Dup, 0, 0); 1474 sqliteExprCode(pParse, pExpr->pList->a[0].pExpr); 1475 addr = sqliteVdbeCurrentAddr(v); 1476 sqliteVdbeAddOp(v, OP_Ge, !jumpIfNull, addr+3); 1477 sqliteVdbeAddOp(v, OP_Pop, 1, 0); 1478 sqliteVdbeAddOp(v, OP_Goto, 0, dest); 1479 sqliteExprCode(pParse, pExpr->pList->a[1].pExpr); 1480 sqliteVdbeAddOp(v, OP_Gt, jumpIfNull, dest); 1481 break; 1482 } 1483 default: { 1484 sqliteExprCode(pParse, pExpr); 1485 sqliteVdbeAddOp(v, OP_IfNot, jumpIfNull, dest); 1486 break; 1487 } 1488 } 1489 } 1490 1491 /* 1492 ** Do a deep comparison of two expression trees. Return TRUE (non-zero) 1493 ** if they are identical and return FALSE if they differ in any way. 1494 */ 1495 int sqliteExprCompare(Expr *pA, Expr *pB){ 1496 int i; 1497 if( pA==0 ){ 1498 return pB==0; 1499 }else if( pB==0 ){ 1500 return 0; 1501 } 1502 if( pA->op!=pB->op ) return 0; 1503 if( !sqliteExprCompare(pA->pLeft, pB->pLeft) ) return 0; 1504 if( !sqliteExprCompare(pA->pRight, pB->pRight) ) return 0; 1505 if( pA->pList ){ 1506 if( pB->pList==0 ) return 0; 1507 if( pA->pList->nExpr!=pB->pList->nExpr ) return 0; 1508 for(i=0; i<pA->pList->nExpr; i++){ 1509 if( !sqliteExprCompare(pA->pList->a[i].pExpr, pB->pList->a[i].pExpr) ){ 1510 return 0; 1511 } 1512 } 1513 }else if( pB->pList ){ 1514 return 0; 1515 } 1516 if( pA->pSelect || pB->pSelect ) return 0; 1517 if( pA->iTable!=pB->iTable || pA->iColumn!=pB->iColumn ) return 0; 1518 if( pA->token.z ){ 1519 if( pB->token.z==0 ) return 0; 1520 if( pB->token.n!=pA->token.n ) return 0; 1521 if( sqliteStrNICmp(pA->token.z, pB->token.z, pB->token.n)!=0 ) return 0; 1522 } 1523 return 1; 1524 } 1525 1526 /* 1527 ** Add a new element to the pParse->aAgg[] array and return its index. 1528 */ 1529 static int appendAggInfo(Parse *pParse){ 1530 if( (pParse->nAgg & 0x7)==0 ){ 1531 int amt = pParse->nAgg + 8; 1532 AggExpr *aAgg = sqliteRealloc(pParse->aAgg, amt*sizeof(pParse->aAgg[0])); 1533 if( aAgg==0 ){ 1534 return -1; 1535 } 1536 pParse->aAgg = aAgg; 1537 } 1538 memset(&pParse->aAgg[pParse->nAgg], 0, sizeof(pParse->aAgg[0])); 1539 return pParse->nAgg++; 1540 } 1541 1542 /* 1543 ** Analyze the given expression looking for aggregate functions and 1544 ** for variables that need to be added to the pParse->aAgg[] array. 1545 ** Make additional entries to the pParse->aAgg[] array as necessary. 1546 ** 1547 ** This routine should only be called after the expression has been 1548 ** analyzed by sqliteExprResolveIds() and sqliteExprCheck(). 1549 ** 1550 ** If errors are seen, leave an error message in zErrMsg and return 1551 ** the number of errors. 1552 */ 1553 int sqliteExprAnalyzeAggregates(Parse *pParse, Expr *pExpr){ 1554 int i; 1555 AggExpr *aAgg; 1556 int nErr = 0; 1557 1558 if( pExpr==0 ) return 0; 1559 switch( pExpr->op ){ 1560 case TK_COLUMN: { 1561 aAgg = pParse->aAgg; 1562 for(i=0; i<pParse->nAgg; i++){ 1563 if( aAgg[i].isAgg ) continue; 1564 if( aAgg[i].pExpr->iTable==pExpr->iTable 1565 && aAgg[i].pExpr->iColumn==pExpr->iColumn ){ 1566 break; 1567 } 1568 } 1569 if( i>=pParse->nAgg ){ 1570 i = appendAggInfo(pParse); 1571 if( i<0 ) return 1; 1572 pParse->aAgg[i].isAgg = 0; 1573 pParse->aAgg[i].pExpr = pExpr; 1574 } 1575 pExpr->iAgg = i; 1576 break; 1577 } 1578 case TK_AGG_FUNCTION: { 1579 aAgg = pParse->aAgg; 1580 for(i=0; i<pParse->nAgg; i++){ 1581 if( !aAgg[i].isAgg ) continue; 1582 if( sqliteExprCompare(aAgg[i].pExpr, pExpr) ){ 1583 break; 1584 } 1585 } 1586 if( i>=pParse->nAgg ){ 1587 i = appendAggInfo(pParse); 1588 if( i<0 ) return 1; 1589 pParse->aAgg[i].isAgg = 1; 1590 pParse->aAgg[i].pExpr = pExpr; 1591 pParse->aAgg[i].pFunc = sqliteFindFunction(pParse->db, 1592 pExpr->token.z, pExpr->token.n, 1593 pExpr->pList ? pExpr->pList->nExpr : 0, 0); 1594 } 1595 pExpr->iAgg = i; 1596 break; 1597 } 1598 default: { 1599 if( pExpr->pLeft ){ 1600 nErr = sqliteExprAnalyzeAggregates(pParse, pExpr->pLeft); 1601 } 1602 if( nErr==0 && pExpr->pRight ){ 1603 nErr = sqliteExprAnalyzeAggregates(pParse, pExpr->pRight); 1604 } 1605 if( nErr==0 && pExpr->pList ){ 1606 int n = pExpr->pList->nExpr; 1607 int i; 1608 for(i=0; nErr==0 && i<n; i++){ 1609 nErr = sqliteExprAnalyzeAggregates(pParse, pExpr->pList->a[i].pExpr); 1610 } 1611 } 1612 break; 1613 } 1614 } 1615 return nErr; 1616 } 1617 1618 /* 1619 ** Locate a user function given a name and a number of arguments. 1620 ** Return a pointer to the FuncDef structure that defines that 1621 ** function, or return NULL if the function does not exist. 1622 ** 1623 ** If the createFlag argument is true, then a new (blank) FuncDef 1624 ** structure is created and liked into the "db" structure if a 1625 ** no matching function previously existed. When createFlag is true 1626 ** and the nArg parameter is -1, then only a function that accepts 1627 ** any number of arguments will be returned. 1628 ** 1629 ** If createFlag is false and nArg is -1, then the first valid 1630 ** function found is returned. A function is valid if either xFunc 1631 ** or xStep is non-zero. 1632 */ 1633 FuncDef *sqliteFindFunction( 1634 sqlite *db, /* An open database */ 1635 const char *zName, /* Name of the function. Not null-terminated */ 1636 int nName, /* Number of characters in the name */ 1637 int nArg, /* Number of arguments. -1 means any number */ 1638 int createFlag /* Create new entry if true and does not otherwise exist */ 1639 ){ 1640 FuncDef *pFirst, *p, *pMaybe; 1641 pFirst = p = (FuncDef*)sqliteHashFind(&db->aFunc, zName, nName); 1642 if( p && !createFlag && nArg<0 ){ 1643 while( p && p->xFunc==0 && p->xStep==0 ){ p = p->pNext; } 1644 return p; 1645 } 1646 pMaybe = 0; 1647 while( p && p->nArg!=nArg ){ 1648 if( p->nArg<0 && !createFlag && (p->xFunc || p->xStep) ) pMaybe = p; 1649 p = p->pNext; 1650 } 1651 if( p && !createFlag && p->xFunc==0 && p->xStep==0 ){ 1652 return 0; 1653 } 1654 if( p==0 && pMaybe ){ 1655 assert( createFlag==0 ); 1656 return pMaybe; 1657 } 1658 if( p==0 && createFlag && (p = sqliteMalloc(sizeof(*p)))!=0 ){ 1659 p->nArg = nArg; 1660 p->pNext = pFirst; 1661 p->dataType = pFirst ? pFirst->dataType : SQLITE_NUMERIC; 1662 sqliteHashInsert(&db->aFunc, zName, nName, (void*)p); 1663 } 1664 return p; 1665 } 1666