1 /* 2 ** 2008 August 18 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 ** 13 ** This file contains routines used for walking the parser tree and 14 ** resolve all identifiers by associating them with a particular 15 ** table and column. 16 */ 17 #include "sqliteInt.h" 18 19 /* 20 ** Magic table number to mean the EXCLUDED table in an UPSERT statement. 21 */ 22 #define EXCLUDED_TABLE_NUMBER 2 23 24 /* 25 ** Walk the expression tree pExpr and increase the aggregate function 26 ** depth (the Expr.op2 field) by N on every TK_AGG_FUNCTION node. 27 ** This needs to occur when copying a TK_AGG_FUNCTION node from an 28 ** outer query into an inner subquery. 29 ** 30 ** incrAggFunctionDepth(pExpr,n) is the main routine. incrAggDepth(..) 31 ** is a helper function - a callback for the tree walker. 32 ** 33 ** See also the sqlite3WindowExtraAggFuncDepth() routine in window.c 34 */ 35 static int incrAggDepth(Walker *pWalker, Expr *pExpr){ 36 if( pExpr->op==TK_AGG_FUNCTION ) pExpr->op2 += pWalker->u.n; 37 return WRC_Continue; 38 } 39 static void incrAggFunctionDepth(Expr *pExpr, int N){ 40 if( N>0 ){ 41 Walker w; 42 memset(&w, 0, sizeof(w)); 43 w.xExprCallback = incrAggDepth; 44 w.u.n = N; 45 sqlite3WalkExpr(&w, pExpr); 46 } 47 } 48 49 /* 50 ** Turn the pExpr expression into an alias for the iCol-th column of the 51 ** result set in pEList. 52 ** 53 ** If the reference is followed by a COLLATE operator, then make sure 54 ** the COLLATE operator is preserved. For example: 55 ** 56 ** SELECT a+b, c+d FROM t1 ORDER BY 1 COLLATE nocase; 57 ** 58 ** Should be transformed into: 59 ** 60 ** SELECT a+b, c+d FROM t1 ORDER BY (a+b) COLLATE nocase; 61 ** 62 ** The nSubquery parameter specifies how many levels of subquery the 63 ** alias is removed from the original expression. The usual value is 64 ** zero but it might be more if the alias is contained within a subquery 65 ** of the original expression. The Expr.op2 field of TK_AGG_FUNCTION 66 ** structures must be increased by the nSubquery amount. 67 */ 68 static void resolveAlias( 69 Parse *pParse, /* Parsing context */ 70 ExprList *pEList, /* A result set */ 71 int iCol, /* A column in the result set. 0..pEList->nExpr-1 */ 72 Expr *pExpr, /* Transform this into an alias to the result set */ 73 int nSubquery /* Number of subqueries that the label is moving */ 74 ){ 75 Expr *pOrig; /* The iCol-th column of the result set */ 76 Expr *pDup; /* Copy of pOrig */ 77 sqlite3 *db; /* The database connection */ 78 79 assert( iCol>=0 && iCol<pEList->nExpr ); 80 pOrig = pEList->a[iCol].pExpr; 81 assert( pOrig!=0 ); 82 db = pParse->db; 83 pDup = sqlite3ExprDup(db, pOrig, 0); 84 if( db->mallocFailed ){ 85 sqlite3ExprDelete(db, pDup); 86 pDup = 0; 87 }else{ 88 incrAggFunctionDepth(pDup, nSubquery); 89 if( pExpr->op==TK_COLLATE ){ 90 assert( !ExprHasProperty(pExpr, EP_IntValue) ); 91 pDup = sqlite3ExprAddCollateString(pParse, pDup, pExpr->u.zToken); 92 } 93 94 /* Before calling sqlite3ExprDelete(), set the EP_Static flag. This 95 ** prevents ExprDelete() from deleting the Expr structure itself, 96 ** allowing it to be repopulated by the memcpy() on the following line. 97 ** The pExpr->u.zToken might point into memory that will be freed by the 98 ** sqlite3DbFree(db, pDup) on the last line of this block, so be sure to 99 ** make a copy of the token before doing the sqlite3DbFree(). 100 */ 101 ExprSetProperty(pExpr, EP_Static); 102 sqlite3ExprDelete(db, pExpr); 103 memcpy(pExpr, pDup, sizeof(*pExpr)); 104 if( !ExprHasProperty(pExpr, EP_IntValue) && pExpr->u.zToken!=0 ){ 105 assert( (pExpr->flags & (EP_Reduced|EP_TokenOnly))==0 ); 106 pExpr->u.zToken = sqlite3DbStrDup(db, pExpr->u.zToken); 107 pExpr->flags |= EP_MemToken; 108 } 109 if( ExprHasProperty(pExpr, EP_WinFunc) ){ 110 if( ALWAYS(pExpr->y.pWin!=0) ){ 111 pExpr->y.pWin->pOwner = pExpr; 112 } 113 } 114 sqlite3DbFree(db, pDup); 115 } 116 } 117 118 119 /* 120 ** Return TRUE if the name zCol occurs anywhere in the USING clause. 121 ** 122 ** Return FALSE if the USING clause is NULL or if it does not contain 123 ** zCol. 124 */ 125 static int nameInUsingClause(IdList *pUsing, const char *zCol){ 126 int k; 127 assert( pUsing!=0 ); 128 for(k=0; k<pUsing->nId; k++){ 129 if( sqlite3StrICmp(pUsing->a[k].zName, zCol)==0 ) return 1; 130 } 131 return 0; 132 } 133 134 /* 135 ** Subqueries stores the original database, table and column names for their 136 ** result sets in ExprList.a[].zSpan, in the form "DATABASE.TABLE.COLUMN". 137 ** Check to see if the zSpan given to this routine matches the zDb, zTab, 138 ** and zCol. If any of zDb, zTab, and zCol are NULL then those fields will 139 ** match anything. 140 */ 141 int sqlite3MatchEName( 142 const struct ExprList_item *pItem, 143 const char *zCol, 144 const char *zTab, 145 const char *zDb 146 ){ 147 int n; 148 const char *zSpan; 149 if( pItem->eEName!=ENAME_TAB ) return 0; 150 zSpan = pItem->zEName; 151 for(n=0; ALWAYS(zSpan[n]) && zSpan[n]!='.'; n++){} 152 if( zDb && (sqlite3StrNICmp(zSpan, zDb, n)!=0 || zDb[n]!=0) ){ 153 return 0; 154 } 155 zSpan += n+1; 156 for(n=0; ALWAYS(zSpan[n]) && zSpan[n]!='.'; n++){} 157 if( zTab && (sqlite3StrNICmp(zSpan, zTab, n)!=0 || zTab[n]!=0) ){ 158 return 0; 159 } 160 zSpan += n+1; 161 if( zCol && sqlite3StrICmp(zSpan, zCol)!=0 ){ 162 return 0; 163 } 164 return 1; 165 } 166 167 /* 168 ** Return TRUE if the double-quoted string mis-feature should be supported. 169 */ 170 static int areDoubleQuotedStringsEnabled(sqlite3 *db, NameContext *pTopNC){ 171 if( db->init.busy ) return 1; /* Always support for legacy schemas */ 172 if( pTopNC->ncFlags & NC_IsDDL ){ 173 /* Currently parsing a DDL statement */ 174 if( sqlite3WritableSchema(db) && (db->flags & SQLITE_DqsDML)!=0 ){ 175 return 1; 176 } 177 return (db->flags & SQLITE_DqsDDL)!=0; 178 }else{ 179 /* Currently parsing a DML statement */ 180 return (db->flags & SQLITE_DqsDML)!=0; 181 } 182 } 183 184 /* 185 ** The argument is guaranteed to be a non-NULL Expr node of type TK_COLUMN. 186 ** return the appropriate colUsed mask. 187 */ 188 Bitmask sqlite3ExprColUsed(Expr *pExpr){ 189 int n; 190 Table *pExTab; 191 192 n = pExpr->iColumn; 193 assert( ExprUseYTab(pExpr) ); 194 pExTab = pExpr->y.pTab; 195 assert( pExTab!=0 ); 196 if( (pExTab->tabFlags & TF_HasGenerated)!=0 197 && (pExTab->aCol[n].colFlags & COLFLAG_GENERATED)!=0 198 ){ 199 testcase( pExTab->nCol==BMS-1 ); 200 testcase( pExTab->nCol==BMS ); 201 return pExTab->nCol>=BMS ? ALLBITS : MASKBIT(pExTab->nCol)-1; 202 }else{ 203 testcase( n==BMS-1 ); 204 testcase( n==BMS ); 205 if( n>=BMS ) n = BMS-1; 206 return ((Bitmask)1)<<n; 207 } 208 } 209 210 /* 211 ** Given the name of a column of the form X.Y.Z or Y.Z or just Z, look up 212 ** that name in the set of source tables in pSrcList and make the pExpr 213 ** expression node refer back to that source column. The following changes 214 ** are made to pExpr: 215 ** 216 ** pExpr->iDb Set the index in db->aDb[] of the database X 217 ** (even if X is implied). 218 ** pExpr->iTable Set to the cursor number for the table obtained 219 ** from pSrcList. 220 ** pExpr->y.pTab Points to the Table structure of X.Y (even if 221 ** X and/or Y are implied.) 222 ** pExpr->iColumn Set to the column number within the table. 223 ** pExpr->op Set to TK_COLUMN. 224 ** pExpr->pLeft Any expression this points to is deleted 225 ** pExpr->pRight Any expression this points to is deleted. 226 ** 227 ** The zDb variable is the name of the database (the "X"). This value may be 228 ** NULL meaning that name is of the form Y.Z or Z. Any available database 229 ** can be used. The zTable variable is the name of the table (the "Y"). This 230 ** value can be NULL if zDb is also NULL. If zTable is NULL it 231 ** means that the form of the name is Z and that columns from any table 232 ** can be used. 233 ** 234 ** If the name cannot be resolved unambiguously, leave an error message 235 ** in pParse and return WRC_Abort. Return WRC_Prune on success. 236 */ 237 static int lookupName( 238 Parse *pParse, /* The parsing context */ 239 const char *zDb, /* Name of the database containing table, or NULL */ 240 const char *zTab, /* Name of table containing column, or NULL */ 241 const char *zCol, /* Name of the column. */ 242 NameContext *pNC, /* The name context used to resolve the name */ 243 Expr *pExpr /* Make this EXPR node point to the selected column */ 244 ){ 245 int i, j; /* Loop counters */ 246 int cnt = 0; /* Number of matching column names */ 247 int cntTab = 0; /* Number of matching table names */ 248 int nSubquery = 0; /* How many levels of subquery */ 249 sqlite3 *db = pParse->db; /* The database connection */ 250 SrcItem *pItem; /* Use for looping over pSrcList items */ 251 SrcItem *pMatch = 0; /* The matching pSrcList item */ 252 NameContext *pTopNC = pNC; /* First namecontext in the list */ 253 Schema *pSchema = 0; /* Schema of the expression */ 254 int eNewExprOp = TK_COLUMN; /* New value for pExpr->op on success */ 255 Table *pTab = 0; /* Table hold the row */ 256 Column *pCol; /* A column of pTab */ 257 258 assert( pNC ); /* the name context cannot be NULL. */ 259 assert( zCol ); /* The Z in X.Y.Z cannot be NULL */ 260 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) ); 261 262 /* Initialize the node to no-match */ 263 pExpr->iTable = -1; 264 ExprSetVVAProperty(pExpr, EP_NoReduce); 265 266 /* Translate the schema name in zDb into a pointer to the corresponding 267 ** schema. If not found, pSchema will remain NULL and nothing will match 268 ** resulting in an appropriate error message toward the end of this routine 269 */ 270 if( zDb ){ 271 testcase( pNC->ncFlags & NC_PartIdx ); 272 testcase( pNC->ncFlags & NC_IsCheck ); 273 if( (pNC->ncFlags & (NC_PartIdx|NC_IsCheck))!=0 ){ 274 /* Silently ignore database qualifiers inside CHECK constraints and 275 ** partial indices. Do not raise errors because that might break 276 ** legacy and because it does not hurt anything to just ignore the 277 ** database name. */ 278 zDb = 0; 279 }else{ 280 for(i=0; i<db->nDb; i++){ 281 assert( db->aDb[i].zDbSName ); 282 if( sqlite3StrICmp(db->aDb[i].zDbSName,zDb)==0 ){ 283 pSchema = db->aDb[i].pSchema; 284 break; 285 } 286 } 287 if( i==db->nDb && sqlite3StrICmp("main", zDb)==0 ){ 288 /* This branch is taken when the main database has been renamed 289 ** using SQLITE_DBCONFIG_MAINDBNAME. */ 290 pSchema = db->aDb[0].pSchema; 291 zDb = db->aDb[0].zDbSName; 292 } 293 } 294 } 295 296 /* Start at the inner-most context and move outward until a match is found */ 297 assert( pNC && cnt==0 ); 298 do{ 299 ExprList *pEList; 300 SrcList *pSrcList = pNC->pSrcList; 301 302 if( pSrcList ){ 303 for(i=0, pItem=pSrcList->a; i<pSrcList->nSrc; i++, pItem++){ 304 u8 hCol; 305 pTab = pItem->pTab; 306 assert( pTab!=0 && pTab->zName!=0 ); 307 assert( pTab->nCol>0 || pParse->nErr ); 308 if( pItem->pSelect && (pItem->pSelect->selFlags & SF_NestedFrom)!=0 ){ 309 int hit = 0; 310 pEList = pItem->pSelect->pEList; 311 for(j=0; j<pEList->nExpr; j++){ 312 if( sqlite3MatchEName(&pEList->a[j], zCol, zTab, zDb) ){ 313 cnt++; 314 cntTab = 2; 315 pMatch = pItem; 316 pExpr->iColumn = j; 317 hit = 1; 318 } 319 } 320 if( hit || zTab==0 ) continue; 321 } 322 if( zDb ){ 323 if( pTab->pSchema!=pSchema ) continue; 324 if( pSchema==0 && strcmp(zDb,"*")!=0 ) continue; 325 } 326 if( zTab ){ 327 const char *zTabName = pItem->zAlias ? pItem->zAlias : pTab->zName; 328 assert( zTabName!=0 ); 329 if( sqlite3StrICmp(zTabName, zTab)!=0 ){ 330 continue; 331 } 332 assert( ExprUseYTab(pExpr) ); 333 if( IN_RENAME_OBJECT && pItem->zAlias ){ 334 sqlite3RenameTokenRemap(pParse, 0, (void*)&pExpr->y.pTab); 335 } 336 } 337 hCol = sqlite3StrIHash(zCol); 338 for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){ 339 if( pCol->hName==hCol 340 && sqlite3StrICmp(pCol->zCnName, zCol)==0 341 ){ 342 /* If there has been exactly one prior match and this match 343 ** is for the right-hand table of a NATURAL JOIN or is in a 344 ** USING clause, then skip this match. 345 */ 346 if( cnt==1 ){ 347 if( pItem->fg.jointype & JT_NATURAL ) continue; 348 if( pItem->fg.isUsing 349 && nameInUsingClause(pItem->u3.pUsing, zCol) 350 ){ 351 continue; 352 } 353 } 354 cnt++; 355 pMatch = pItem; 356 /* Substitute the rowid (column -1) for the INTEGER PRIMARY KEY */ 357 pExpr->iColumn = j==pTab->iPKey ? -1 : (i16)j; 358 break; 359 } 360 } 361 if( 0==cnt && VisibleRowid(pTab) ){ 362 cntTab++; 363 pMatch = pItem; 364 } 365 } 366 if( pMatch ){ 367 pExpr->iTable = pMatch->iCursor; 368 assert( ExprUseYTab(pExpr) ); 369 pExpr->y.pTab = pMatch->pTab; 370 /* RIGHT JOIN not (yet) supported */ 371 assert( (pMatch->fg.jointype & JT_RIGHT)==0 ); 372 if( (pMatch->fg.jointype & JT_LEFT)!=0 ){ 373 ExprSetProperty(pExpr, EP_CanBeNull); 374 } 375 pSchema = pExpr->y.pTab->pSchema; 376 } 377 } /* if( pSrcList ) */ 378 379 #if !defined(SQLITE_OMIT_TRIGGER) || !defined(SQLITE_OMIT_UPSERT) 380 /* If we have not already resolved the name, then maybe 381 ** it is a new.* or old.* trigger argument reference. Or 382 ** maybe it is an excluded.* from an upsert. Or maybe it is 383 ** a reference in the RETURNING clause to a table being modified. 384 */ 385 if( cnt==0 && zDb==0 ){ 386 pTab = 0; 387 #ifndef SQLITE_OMIT_TRIGGER 388 if( pParse->pTriggerTab!=0 ){ 389 int op = pParse->eTriggerOp; 390 assert( op==TK_DELETE || op==TK_UPDATE || op==TK_INSERT ); 391 if( pParse->bReturning ){ 392 if( (pNC->ncFlags & NC_UBaseReg)!=0 393 && (zTab==0 || sqlite3StrICmp(zTab,pParse->pTriggerTab->zName)==0) 394 ){ 395 pExpr->iTable = op!=TK_DELETE; 396 pTab = pParse->pTriggerTab; 397 } 398 }else if( op!=TK_DELETE && zTab && sqlite3StrICmp("new",zTab) == 0 ){ 399 pExpr->iTable = 1; 400 pTab = pParse->pTriggerTab; 401 }else if( op!=TK_INSERT && zTab && sqlite3StrICmp("old",zTab)==0 ){ 402 pExpr->iTable = 0; 403 pTab = pParse->pTriggerTab; 404 } 405 } 406 #endif /* SQLITE_OMIT_TRIGGER */ 407 #ifndef SQLITE_OMIT_UPSERT 408 if( (pNC->ncFlags & NC_UUpsert)!=0 && zTab!=0 ){ 409 Upsert *pUpsert = pNC->uNC.pUpsert; 410 if( pUpsert && sqlite3StrICmp("excluded",zTab)==0 ){ 411 pTab = pUpsert->pUpsertSrc->a[0].pTab; 412 pExpr->iTable = EXCLUDED_TABLE_NUMBER; 413 } 414 } 415 #endif /* SQLITE_OMIT_UPSERT */ 416 417 if( pTab ){ 418 int iCol; 419 u8 hCol = sqlite3StrIHash(zCol); 420 pSchema = pTab->pSchema; 421 cntTab++; 422 for(iCol=0, pCol=pTab->aCol; iCol<pTab->nCol; iCol++, pCol++){ 423 if( pCol->hName==hCol 424 && sqlite3StrICmp(pCol->zCnName, zCol)==0 425 ){ 426 if( iCol==pTab->iPKey ){ 427 iCol = -1; 428 } 429 break; 430 } 431 } 432 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && VisibleRowid(pTab) ){ 433 /* IMP: R-51414-32910 */ 434 iCol = -1; 435 } 436 if( iCol<pTab->nCol ){ 437 cnt++; 438 pMatch = 0; 439 #ifndef SQLITE_OMIT_UPSERT 440 if( pExpr->iTable==EXCLUDED_TABLE_NUMBER ){ 441 testcase( iCol==(-1) ); 442 assert( ExprUseYTab(pExpr) ); 443 if( IN_RENAME_OBJECT ){ 444 pExpr->iColumn = iCol; 445 pExpr->y.pTab = pTab; 446 eNewExprOp = TK_COLUMN; 447 }else{ 448 pExpr->iTable = pNC->uNC.pUpsert->regData + 449 sqlite3TableColumnToStorage(pTab, iCol); 450 eNewExprOp = TK_REGISTER; 451 } 452 }else 453 #endif /* SQLITE_OMIT_UPSERT */ 454 { 455 assert( ExprUseYTab(pExpr) ); 456 pExpr->y.pTab = pTab; 457 if( pParse->bReturning ){ 458 eNewExprOp = TK_REGISTER; 459 pExpr->op2 = TK_COLUMN; 460 pExpr->iTable = pNC->uNC.iBaseReg + (pTab->nCol+1)*pExpr->iTable + 461 sqlite3TableColumnToStorage(pTab, iCol) + 1; 462 }else{ 463 pExpr->iColumn = (i16)iCol; 464 eNewExprOp = TK_TRIGGER; 465 #ifndef SQLITE_OMIT_TRIGGER 466 if( iCol<0 ){ 467 pExpr->affExpr = SQLITE_AFF_INTEGER; 468 }else if( pExpr->iTable==0 ){ 469 testcase( iCol==31 ); 470 testcase( iCol==32 ); 471 pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol)); 472 }else{ 473 testcase( iCol==31 ); 474 testcase( iCol==32 ); 475 pParse->newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol)); 476 } 477 #endif /* SQLITE_OMIT_TRIGGER */ 478 } 479 } 480 } 481 } 482 } 483 #endif /* !defined(SQLITE_OMIT_TRIGGER) || !defined(SQLITE_OMIT_UPSERT) */ 484 485 /* 486 ** Perhaps the name is a reference to the ROWID 487 */ 488 if( cnt==0 489 && cntTab==1 490 && pMatch 491 && (pNC->ncFlags & (NC_IdxExpr|NC_GenCol))==0 492 && sqlite3IsRowid(zCol) 493 && ALWAYS(VisibleRowid(pMatch->pTab)) 494 ){ 495 cnt = 1; 496 pExpr->iColumn = -1; 497 pExpr->affExpr = SQLITE_AFF_INTEGER; 498 } 499 500 /* 501 ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z 502 ** might refer to an result-set alias. This happens, for example, when 503 ** we are resolving names in the WHERE clause of the following command: 504 ** 505 ** SELECT a+b AS x FROM table WHERE x<10; 506 ** 507 ** In cases like this, replace pExpr with a copy of the expression that 508 ** forms the result set entry ("a+b" in the example) and return immediately. 509 ** Note that the expression in the result set should have already been 510 ** resolved by the time the WHERE clause is resolved. 511 ** 512 ** The ability to use an output result-set column in the WHERE, GROUP BY, 513 ** or HAVING clauses, or as part of a larger expression in the ORDER BY 514 ** clause is not standard SQL. This is a (goofy) SQLite extension, that 515 ** is supported for backwards compatibility only. Hence, we issue a warning 516 ** on sqlite3_log() whenever the capability is used. 517 */ 518 if( cnt==0 519 && (pNC->ncFlags & NC_UEList)!=0 520 && zTab==0 521 ){ 522 pEList = pNC->uNC.pEList; 523 assert( pEList!=0 ); 524 for(j=0; j<pEList->nExpr; j++){ 525 char *zAs = pEList->a[j].zEName; 526 if( pEList->a[j].eEName==ENAME_NAME 527 && sqlite3_stricmp(zAs, zCol)==0 528 ){ 529 Expr *pOrig; 530 assert( pExpr->pLeft==0 && pExpr->pRight==0 ); 531 assert( ExprUseXList(pExpr)==0 || pExpr->x.pList==0 ); 532 assert( ExprUseXSelect(pExpr)==0 || pExpr->x.pSelect==0 ); 533 pOrig = pEList->a[j].pExpr; 534 if( (pNC->ncFlags&NC_AllowAgg)==0 && ExprHasProperty(pOrig, EP_Agg) ){ 535 sqlite3ErrorMsg(pParse, "misuse of aliased aggregate %s", zAs); 536 return WRC_Abort; 537 } 538 if( ExprHasProperty(pOrig, EP_Win) 539 && ((pNC->ncFlags&NC_AllowWin)==0 || pNC!=pTopNC ) 540 ){ 541 sqlite3ErrorMsg(pParse, "misuse of aliased window function %s",zAs); 542 return WRC_Abort; 543 } 544 if( sqlite3ExprVectorSize(pOrig)!=1 ){ 545 sqlite3ErrorMsg(pParse, "row value misused"); 546 return WRC_Abort; 547 } 548 resolveAlias(pParse, pEList, j, pExpr, nSubquery); 549 cnt = 1; 550 pMatch = 0; 551 assert( zTab==0 && zDb==0 ); 552 if( IN_RENAME_OBJECT ){ 553 sqlite3RenameTokenRemap(pParse, 0, (void*)pExpr); 554 } 555 goto lookupname_end; 556 } 557 } 558 } 559 560 /* Advance to the next name context. The loop will exit when either 561 ** we have a match (cnt>0) or when we run out of name contexts. 562 */ 563 if( cnt ) break; 564 pNC = pNC->pNext; 565 nSubquery++; 566 }while( pNC ); 567 568 569 /* 570 ** If X and Y are NULL (in other words if only the column name Z is 571 ** supplied) and the value of Z is enclosed in double-quotes, then 572 ** Z is a string literal if it doesn't match any column names. In that 573 ** case, we need to return right away and not make any changes to 574 ** pExpr. 575 ** 576 ** Because no reference was made to outer contexts, the pNC->nRef 577 ** fields are not changed in any context. 578 */ 579 if( cnt==0 && zTab==0 ){ 580 assert( pExpr->op==TK_ID ); 581 if( ExprHasProperty(pExpr,EP_DblQuoted) 582 && areDoubleQuotedStringsEnabled(db, pTopNC) 583 ){ 584 /* If a double-quoted identifier does not match any known column name, 585 ** then treat it as a string. 586 ** 587 ** This hack was added in the early days of SQLite in a misguided attempt 588 ** to be compatible with MySQL 3.x, which used double-quotes for strings. 589 ** I now sorely regret putting in this hack. The effect of this hack is 590 ** that misspelled identifier names are silently converted into strings 591 ** rather than causing an error, to the frustration of countless 592 ** programmers. To all those frustrated programmers, my apologies. 593 ** 594 ** Someday, I hope to get rid of this hack. Unfortunately there is 595 ** a huge amount of legacy SQL that uses it. So for now, we just 596 ** issue a warning. 597 */ 598 sqlite3_log(SQLITE_WARNING, 599 "double-quoted string literal: \"%w\"", zCol); 600 #ifdef SQLITE_ENABLE_NORMALIZE 601 sqlite3VdbeAddDblquoteStr(db, pParse->pVdbe, zCol); 602 #endif 603 pExpr->op = TK_STRING; 604 memset(&pExpr->y, 0, sizeof(pExpr->y)); 605 return WRC_Prune; 606 } 607 if( sqlite3ExprIdToTrueFalse(pExpr) ){ 608 return WRC_Prune; 609 } 610 } 611 612 /* 613 ** cnt==0 means there was not match. cnt>1 means there were two or 614 ** more matches. Either way, we have an error. 615 */ 616 if( cnt!=1 ){ 617 const char *zErr; 618 zErr = cnt==0 ? "no such column" : "ambiguous column name"; 619 if( zDb ){ 620 sqlite3ErrorMsg(pParse, "%s: %s.%s.%s", zErr, zDb, zTab, zCol); 621 }else if( zTab ){ 622 sqlite3ErrorMsg(pParse, "%s: %s.%s", zErr, zTab, zCol); 623 }else{ 624 sqlite3ErrorMsg(pParse, "%s: %s", zErr, zCol); 625 } 626 sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr); 627 pParse->checkSchema = 1; 628 pTopNC->nNcErr++; 629 } 630 631 /* If a column from a table in pSrcList is referenced, then record 632 ** this fact in the pSrcList.a[].colUsed bitmask. Column 0 causes 633 ** bit 0 to be set. Column 1 sets bit 1. And so forth. Bit 63 is 634 ** set if the 63rd or any subsequent column is used. 635 ** 636 ** The colUsed mask is an optimization used to help determine if an 637 ** index is a covering index. The correct answer is still obtained 638 ** if the mask contains extra set bits. However, it is important to 639 ** avoid setting bits beyond the maximum column number of the table. 640 ** (See ticket [b92e5e8ec2cdbaa1]). 641 ** 642 ** If a generated column is referenced, set bits for every column 643 ** of the table. 644 */ 645 if( pExpr->iColumn>=0 && pMatch!=0 ){ 646 pMatch->colUsed |= sqlite3ExprColUsed(pExpr); 647 } 648 649 /* Clean up and return 650 */ 651 if( !ExprHasProperty(pExpr,(EP_TokenOnly|EP_Leaf)) ){ 652 sqlite3ExprDelete(db, pExpr->pLeft); 653 pExpr->pLeft = 0; 654 sqlite3ExprDelete(db, pExpr->pRight); 655 pExpr->pRight = 0; 656 } 657 pExpr->op = eNewExprOp; 658 ExprSetProperty(pExpr, EP_Leaf); 659 lookupname_end: 660 if( cnt==1 ){ 661 assert( pNC!=0 ); 662 #ifndef SQLITE_OMIT_AUTHORIZATION 663 if( pParse->db->xAuth 664 && (pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER) 665 ){ 666 sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList); 667 } 668 #endif 669 /* Increment the nRef value on all name contexts from TopNC up to 670 ** the point where the name matched. */ 671 for(;;){ 672 assert( pTopNC!=0 ); 673 pTopNC->nRef++; 674 if( pTopNC==pNC ) break; 675 pTopNC = pTopNC->pNext; 676 } 677 return WRC_Prune; 678 } else { 679 return WRC_Abort; 680 } 681 } 682 683 /* 684 ** Allocate and return a pointer to an expression to load the column iCol 685 ** from datasource iSrc in SrcList pSrc. 686 */ 687 Expr *sqlite3CreateColumnExpr(sqlite3 *db, SrcList *pSrc, int iSrc, int iCol){ 688 Expr *p = sqlite3ExprAlloc(db, TK_COLUMN, 0, 0); 689 if( p ){ 690 SrcItem *pItem = &pSrc->a[iSrc]; 691 Table *pTab; 692 assert( ExprUseYTab(p) ); 693 pTab = p->y.pTab = pItem->pTab; 694 p->iTable = pItem->iCursor; 695 if( p->y.pTab->iPKey==iCol ){ 696 p->iColumn = -1; 697 }else{ 698 p->iColumn = (ynVar)iCol; 699 if( (pTab->tabFlags & TF_HasGenerated)!=0 700 && (pTab->aCol[iCol].colFlags & COLFLAG_GENERATED)!=0 701 ){ 702 testcase( pTab->nCol==63 ); 703 testcase( pTab->nCol==64 ); 704 pItem->colUsed = pTab->nCol>=64 ? ALLBITS : MASKBIT(pTab->nCol)-1; 705 }else{ 706 testcase( iCol==BMS ); 707 testcase( iCol==BMS-1 ); 708 pItem->colUsed |= ((Bitmask)1)<<(iCol>=BMS ? BMS-1 : iCol); 709 } 710 } 711 } 712 return p; 713 } 714 715 /* 716 ** Report an error that an expression is not valid for some set of 717 ** pNC->ncFlags values determined by validMask. 718 ** 719 ** static void notValid( 720 ** Parse *pParse, // Leave error message here 721 ** NameContext *pNC, // The name context 722 ** const char *zMsg, // Type of error 723 ** int validMask, // Set of contexts for which prohibited 724 ** Expr *pExpr // Invalidate this expression on error 725 ** ){...} 726 ** 727 ** As an optimization, since the conditional is almost always false 728 ** (because errors are rare), the conditional is moved outside of the 729 ** function call using a macro. 730 */ 731 static void notValidImpl( 732 Parse *pParse, /* Leave error message here */ 733 NameContext *pNC, /* The name context */ 734 const char *zMsg, /* Type of error */ 735 Expr *pExpr, /* Invalidate this expression on error */ 736 Expr *pError /* Associate error with this expression */ 737 ){ 738 const char *zIn = "partial index WHERE clauses"; 739 if( pNC->ncFlags & NC_IdxExpr ) zIn = "index expressions"; 740 #ifndef SQLITE_OMIT_CHECK 741 else if( pNC->ncFlags & NC_IsCheck ) zIn = "CHECK constraints"; 742 #endif 743 #ifndef SQLITE_OMIT_GENERATED_COLUMNS 744 else if( pNC->ncFlags & NC_GenCol ) zIn = "generated columns"; 745 #endif 746 sqlite3ErrorMsg(pParse, "%s prohibited in %s", zMsg, zIn); 747 if( pExpr ) pExpr->op = TK_NULL; 748 sqlite3RecordErrorOffsetOfExpr(pParse->db, pError); 749 } 750 #define sqlite3ResolveNotValid(P,N,M,X,E,R) \ 751 assert( ((X)&~(NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol))==0 ); \ 752 if( ((N)->ncFlags & (X))!=0 ) notValidImpl(P,N,M,E,R); 753 754 /* 755 ** Expression p should encode a floating point value between 1.0 and 0.0. 756 ** Return 1024 times this value. Or return -1 if p is not a floating point 757 ** value between 1.0 and 0.0. 758 */ 759 static int exprProbability(Expr *p){ 760 double r = -1.0; 761 if( p->op!=TK_FLOAT ) return -1; 762 assert( !ExprHasProperty(p, EP_IntValue) ); 763 sqlite3AtoF(p->u.zToken, &r, sqlite3Strlen30(p->u.zToken), SQLITE_UTF8); 764 assert( r>=0.0 ); 765 if( r>1.0 ) return -1; 766 return (int)(r*134217728.0); 767 } 768 769 /* 770 ** This routine is callback for sqlite3WalkExpr(). 771 ** 772 ** Resolve symbolic names into TK_COLUMN operators for the current 773 ** node in the expression tree. Return 0 to continue the search down 774 ** the tree or 2 to abort the tree walk. 775 ** 776 ** This routine also does error checking and name resolution for 777 ** function names. The operator for aggregate functions is changed 778 ** to TK_AGG_FUNCTION. 779 */ 780 static int resolveExprStep(Walker *pWalker, Expr *pExpr){ 781 NameContext *pNC; 782 Parse *pParse; 783 784 pNC = pWalker->u.pNC; 785 assert( pNC!=0 ); 786 pParse = pNC->pParse; 787 assert( pParse==pWalker->pParse ); 788 789 #ifndef NDEBUG 790 if( pNC->pSrcList && pNC->pSrcList->nAlloc>0 ){ 791 SrcList *pSrcList = pNC->pSrcList; 792 int i; 793 for(i=0; i<pNC->pSrcList->nSrc; i++){ 794 assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursor<pParse->nTab); 795 } 796 } 797 #endif 798 switch( pExpr->op ){ 799 800 /* The special operator TK_ROW means use the rowid for the first 801 ** column in the FROM clause. This is used by the LIMIT and ORDER BY 802 ** clause processing on UPDATE and DELETE statements, and by 803 ** UPDATE ... FROM statement processing. 804 */ 805 case TK_ROW: { 806 SrcList *pSrcList = pNC->pSrcList; 807 SrcItem *pItem; 808 assert( pSrcList && pSrcList->nSrc>=1 ); 809 pItem = pSrcList->a; 810 pExpr->op = TK_COLUMN; 811 assert( ExprUseYTab(pExpr) ); 812 pExpr->y.pTab = pItem->pTab; 813 pExpr->iTable = pItem->iCursor; 814 pExpr->iColumn--; 815 pExpr->affExpr = SQLITE_AFF_INTEGER; 816 break; 817 } 818 819 /* An optimization: Attempt to convert 820 ** 821 ** "expr IS NOT NULL" --> "TRUE" 822 ** "expr IS NULL" --> "FALSE" 823 ** 824 ** if we can prove that "expr" is never NULL. Call this the 825 ** "NOT NULL strength reduction optimization". 826 ** 827 ** If this optimization occurs, also restore the NameContext ref-counts 828 ** to the state they where in before the "column" LHS expression was 829 ** resolved. This prevents "column" from being counted as having been 830 ** referenced, which might prevent a SELECT from being erroneously 831 ** marked as correlated. 832 */ 833 case TK_NOTNULL: 834 case TK_ISNULL: { 835 int anRef[8]; 836 NameContext *p; 837 int i; 838 for(i=0, p=pNC; p && i<ArraySize(anRef); p=p->pNext, i++){ 839 anRef[i] = p->nRef; 840 } 841 sqlite3WalkExpr(pWalker, pExpr->pLeft); 842 if( 0==sqlite3ExprCanBeNull(pExpr->pLeft) && !IN_RENAME_OBJECT ){ 843 testcase( ExprHasProperty(pExpr, EP_FromJoin) ); 844 assert( !ExprHasProperty(pExpr, EP_IntValue) ); 845 if( pExpr->op==TK_NOTNULL ){ 846 pExpr->u.zToken = "true"; 847 ExprSetProperty(pExpr, EP_IsTrue); 848 }else{ 849 pExpr->u.zToken = "false"; 850 ExprSetProperty(pExpr, EP_IsFalse); 851 } 852 pExpr->op = TK_TRUEFALSE; 853 for(i=0, p=pNC; p && i<ArraySize(anRef); p=p->pNext, i++){ 854 p->nRef = anRef[i]; 855 } 856 sqlite3ExprDelete(pParse->db, pExpr->pLeft); 857 pExpr->pLeft = 0; 858 } 859 return WRC_Prune; 860 } 861 862 /* A column name: ID 863 ** Or table name and column name: ID.ID 864 ** Or a database, table and column: ID.ID.ID 865 ** 866 ** The TK_ID and TK_OUT cases are combined so that there will only 867 ** be one call to lookupName(). Then the compiler will in-line 868 ** lookupName() for a size reduction and performance increase. 869 */ 870 case TK_ID: 871 case TK_DOT: { 872 const char *zColumn; 873 const char *zTable; 874 const char *zDb; 875 Expr *pRight; 876 877 if( pExpr->op==TK_ID ){ 878 zDb = 0; 879 zTable = 0; 880 assert( !ExprHasProperty(pExpr, EP_IntValue) ); 881 zColumn = pExpr->u.zToken; 882 }else{ 883 Expr *pLeft = pExpr->pLeft; 884 testcase( pNC->ncFlags & NC_IdxExpr ); 885 testcase( pNC->ncFlags & NC_GenCol ); 886 sqlite3ResolveNotValid(pParse, pNC, "the \".\" operator", 887 NC_IdxExpr|NC_GenCol, 0, pExpr); 888 pRight = pExpr->pRight; 889 if( pRight->op==TK_ID ){ 890 zDb = 0; 891 }else{ 892 assert( pRight->op==TK_DOT ); 893 assert( !ExprHasProperty(pRight, EP_IntValue) ); 894 zDb = pLeft->u.zToken; 895 pLeft = pRight->pLeft; 896 pRight = pRight->pRight; 897 } 898 assert( ExprUseUToken(pLeft) && ExprUseUToken(pRight) ); 899 zTable = pLeft->u.zToken; 900 zColumn = pRight->u.zToken; 901 assert( ExprUseYTab(pExpr) ); 902 if( IN_RENAME_OBJECT ){ 903 sqlite3RenameTokenRemap(pParse, (void*)pExpr, (void*)pRight); 904 sqlite3RenameTokenRemap(pParse, (void*)&pExpr->y.pTab, (void*)pLeft); 905 } 906 } 907 return lookupName(pParse, zDb, zTable, zColumn, pNC, pExpr); 908 } 909 910 /* Resolve function names 911 */ 912 case TK_FUNCTION: { 913 ExprList *pList = pExpr->x.pList; /* The argument list */ 914 int n = pList ? pList->nExpr : 0; /* Number of arguments */ 915 int no_such_func = 0; /* True if no such function exists */ 916 int wrong_num_args = 0; /* True if wrong number of arguments */ 917 int is_agg = 0; /* True if is an aggregate function */ 918 const char *zId; /* The function name. */ 919 FuncDef *pDef; /* Information about the function */ 920 u8 enc = ENC(pParse->db); /* The database encoding */ 921 int savedAllowFlags = (pNC->ncFlags & (NC_AllowAgg | NC_AllowWin)); 922 #ifndef SQLITE_OMIT_WINDOWFUNC 923 Window *pWin = (IsWindowFunc(pExpr) ? pExpr->y.pWin : 0); 924 #endif 925 assert( !ExprHasProperty(pExpr, EP_xIsSelect|EP_IntValue) ); 926 zId = pExpr->u.zToken; 927 pDef = sqlite3FindFunction(pParse->db, zId, n, enc, 0); 928 if( pDef==0 ){ 929 pDef = sqlite3FindFunction(pParse->db, zId, -2, enc, 0); 930 if( pDef==0 ){ 931 no_such_func = 1; 932 }else{ 933 wrong_num_args = 1; 934 } 935 }else{ 936 is_agg = pDef->xFinalize!=0; 937 if( pDef->funcFlags & SQLITE_FUNC_UNLIKELY ){ 938 ExprSetProperty(pExpr, EP_Unlikely); 939 if( n==2 ){ 940 pExpr->iTable = exprProbability(pList->a[1].pExpr); 941 if( pExpr->iTable<0 ){ 942 sqlite3ErrorMsg(pParse, 943 "second argument to %#T() must be a " 944 "constant between 0.0 and 1.0", pExpr); 945 pNC->nNcErr++; 946 } 947 }else{ 948 /* EVIDENCE-OF: R-61304-29449 The unlikely(X) function is 949 ** equivalent to likelihood(X, 0.0625). 950 ** EVIDENCE-OF: R-01283-11636 The unlikely(X) function is 951 ** short-hand for likelihood(X,0.0625). 952 ** EVIDENCE-OF: R-36850-34127 The likely(X) function is short-hand 953 ** for likelihood(X,0.9375). 954 ** EVIDENCE-OF: R-53436-40973 The likely(X) function is equivalent 955 ** to likelihood(X,0.9375). */ 956 /* TUNING: unlikely() probability is 0.0625. likely() is 0.9375 */ 957 pExpr->iTable = pDef->zName[0]=='u' ? 8388608 : 125829120; 958 } 959 } 960 #ifndef SQLITE_OMIT_AUTHORIZATION 961 { 962 int auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0,pDef->zName,0); 963 if( auth!=SQLITE_OK ){ 964 if( auth==SQLITE_DENY ){ 965 sqlite3ErrorMsg(pParse, "not authorized to use function: %#T", 966 pExpr); 967 pNC->nNcErr++; 968 } 969 pExpr->op = TK_NULL; 970 return WRC_Prune; 971 } 972 } 973 #endif 974 if( pDef->funcFlags & (SQLITE_FUNC_CONSTANT|SQLITE_FUNC_SLOCHNG) ){ 975 /* For the purposes of the EP_ConstFunc flag, date and time 976 ** functions and other functions that change slowly are considered 977 ** constant because they are constant for the duration of one query. 978 ** This allows them to be factored out of inner loops. */ 979 ExprSetProperty(pExpr,EP_ConstFunc); 980 } 981 if( (pDef->funcFlags & SQLITE_FUNC_CONSTANT)==0 ){ 982 /* Clearly non-deterministic functions like random(), but also 983 ** date/time functions that use 'now', and other functions like 984 ** sqlite_version() that might change over time cannot be used 985 ** in an index or generated column. Curiously, they can be used 986 ** in a CHECK constraint. SQLServer, MySQL, and PostgreSQL all 987 ** all this. */ 988 sqlite3ResolveNotValid(pParse, pNC, "non-deterministic functions", 989 NC_IdxExpr|NC_PartIdx|NC_GenCol, 0, pExpr); 990 }else{ 991 assert( (NC_SelfRef & 0xff)==NC_SelfRef ); /* Must fit in 8 bits */ 992 pExpr->op2 = pNC->ncFlags & NC_SelfRef; 993 if( pNC->ncFlags & NC_FromDDL ) ExprSetProperty(pExpr, EP_FromDDL); 994 } 995 if( (pDef->funcFlags & SQLITE_FUNC_INTERNAL)!=0 996 && pParse->nested==0 997 && (pParse->db->mDbFlags & DBFLAG_InternalFunc)==0 998 ){ 999 /* Internal-use-only functions are disallowed unless the 1000 ** SQL is being compiled using sqlite3NestedParse() or 1001 ** the SQLITE_TESTCTRL_INTERNAL_FUNCTIONS test-control has be 1002 ** used to activate internal functions for testing purposes */ 1003 no_such_func = 1; 1004 pDef = 0; 1005 }else 1006 if( (pDef->funcFlags & (SQLITE_FUNC_DIRECT|SQLITE_FUNC_UNSAFE))!=0 1007 && !IN_RENAME_OBJECT 1008 ){ 1009 sqlite3ExprFunctionUsable(pParse, pExpr, pDef); 1010 } 1011 } 1012 1013 if( 0==IN_RENAME_OBJECT ){ 1014 #ifndef SQLITE_OMIT_WINDOWFUNC 1015 assert( is_agg==0 || (pDef->funcFlags & SQLITE_FUNC_MINMAX) 1016 || (pDef->xValue==0 && pDef->xInverse==0) 1017 || (pDef->xValue && pDef->xInverse && pDef->xSFunc && pDef->xFinalize) 1018 ); 1019 if( pDef && pDef->xValue==0 && pWin ){ 1020 sqlite3ErrorMsg(pParse, 1021 "%#T() may not be used as a window function", pExpr 1022 ); 1023 pNC->nNcErr++; 1024 }else if( 1025 (is_agg && (pNC->ncFlags & NC_AllowAgg)==0) 1026 || (is_agg && (pDef->funcFlags&SQLITE_FUNC_WINDOW) && !pWin) 1027 || (is_agg && pWin && (pNC->ncFlags & NC_AllowWin)==0) 1028 ){ 1029 const char *zType; 1030 if( (pDef->funcFlags & SQLITE_FUNC_WINDOW) || pWin ){ 1031 zType = "window"; 1032 }else{ 1033 zType = "aggregate"; 1034 } 1035 sqlite3ErrorMsg(pParse, "misuse of %s function %#T()",zType,pExpr); 1036 pNC->nNcErr++; 1037 is_agg = 0; 1038 } 1039 #else 1040 if( (is_agg && (pNC->ncFlags & NC_AllowAgg)==0) ){ 1041 sqlite3ErrorMsg(pParse,"misuse of aggregate function %#T()",pExpr); 1042 pNC->nNcErr++; 1043 is_agg = 0; 1044 } 1045 #endif 1046 else if( no_such_func && pParse->db->init.busy==0 1047 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION 1048 && pParse->explain==0 1049 #endif 1050 ){ 1051 sqlite3ErrorMsg(pParse, "no such function: %#T", pExpr); 1052 pNC->nNcErr++; 1053 }else if( wrong_num_args ){ 1054 sqlite3ErrorMsg(pParse,"wrong number of arguments to function %#T()", 1055 pExpr); 1056 pNC->nNcErr++; 1057 } 1058 #ifndef SQLITE_OMIT_WINDOWFUNC 1059 else if( is_agg==0 && ExprHasProperty(pExpr, EP_WinFunc) ){ 1060 sqlite3ErrorMsg(pParse, 1061 "FILTER may not be used with non-aggregate %#T()", 1062 pExpr 1063 ); 1064 pNC->nNcErr++; 1065 } 1066 #endif 1067 if( is_agg ){ 1068 /* Window functions may not be arguments of aggregate functions. 1069 ** Or arguments of other window functions. But aggregate functions 1070 ** may be arguments for window functions. */ 1071 #ifndef SQLITE_OMIT_WINDOWFUNC 1072 pNC->ncFlags &= ~(NC_AllowWin | (!pWin ? NC_AllowAgg : 0)); 1073 #else 1074 pNC->ncFlags &= ~NC_AllowAgg; 1075 #endif 1076 } 1077 } 1078 #ifndef SQLITE_OMIT_WINDOWFUNC 1079 else if( ExprHasProperty(pExpr, EP_WinFunc) ){ 1080 is_agg = 1; 1081 } 1082 #endif 1083 sqlite3WalkExprList(pWalker, pList); 1084 if( is_agg ){ 1085 #ifndef SQLITE_OMIT_WINDOWFUNC 1086 if( pWin ){ 1087 Select *pSel = pNC->pWinSelect; 1088 assert( pWin==0 || (ExprUseYWin(pExpr) && pWin==pExpr->y.pWin) ); 1089 if( IN_RENAME_OBJECT==0 ){ 1090 sqlite3WindowUpdate(pParse, pSel ? pSel->pWinDefn : 0, pWin, pDef); 1091 if( pParse->db->mallocFailed ) break; 1092 } 1093 sqlite3WalkExprList(pWalker, pWin->pPartition); 1094 sqlite3WalkExprList(pWalker, pWin->pOrderBy); 1095 sqlite3WalkExpr(pWalker, pWin->pFilter); 1096 sqlite3WindowLink(pSel, pWin); 1097 pNC->ncFlags |= NC_HasWin; 1098 }else 1099 #endif /* SQLITE_OMIT_WINDOWFUNC */ 1100 { 1101 NameContext *pNC2; /* For looping up thru outer contexts */ 1102 pExpr->op = TK_AGG_FUNCTION; 1103 pExpr->op2 = 0; 1104 #ifndef SQLITE_OMIT_WINDOWFUNC 1105 if( ExprHasProperty(pExpr, EP_WinFunc) ){ 1106 sqlite3WalkExpr(pWalker, pExpr->y.pWin->pFilter); 1107 } 1108 #endif 1109 pNC2 = pNC; 1110 while( pNC2 1111 && sqlite3ReferencesSrcList(pParse, pExpr, pNC2->pSrcList)==0 1112 ){ 1113 pExpr->op2++; 1114 pNC2 = pNC2->pNext; 1115 } 1116 assert( pDef!=0 || IN_RENAME_OBJECT ); 1117 if( pNC2 && pDef ){ 1118 assert( SQLITE_FUNC_MINMAX==NC_MinMaxAgg ); 1119 assert( SQLITE_FUNC_ANYORDER==NC_OrderAgg ); 1120 testcase( (pDef->funcFlags & SQLITE_FUNC_MINMAX)!=0 ); 1121 testcase( (pDef->funcFlags & SQLITE_FUNC_ANYORDER)!=0 ); 1122 pNC2->ncFlags |= NC_HasAgg 1123 | ((pDef->funcFlags^SQLITE_FUNC_ANYORDER) 1124 & (SQLITE_FUNC_MINMAX|SQLITE_FUNC_ANYORDER)); 1125 } 1126 } 1127 pNC->ncFlags |= savedAllowFlags; 1128 } 1129 /* FIX ME: Compute pExpr->affinity based on the expected return 1130 ** type of the function 1131 */ 1132 return WRC_Prune; 1133 } 1134 #ifndef SQLITE_OMIT_SUBQUERY 1135 case TK_SELECT: 1136 case TK_EXISTS: testcase( pExpr->op==TK_EXISTS ); 1137 #endif 1138 case TK_IN: { 1139 testcase( pExpr->op==TK_IN ); 1140 if( ExprUseXSelect(pExpr) ){ 1141 int nRef = pNC->nRef; 1142 testcase( pNC->ncFlags & NC_IsCheck ); 1143 testcase( pNC->ncFlags & NC_PartIdx ); 1144 testcase( pNC->ncFlags & NC_IdxExpr ); 1145 testcase( pNC->ncFlags & NC_GenCol ); 1146 if( pNC->ncFlags & NC_SelfRef ){ 1147 notValidImpl(pParse, pNC, "subqueries", pExpr, pExpr); 1148 }else{ 1149 sqlite3WalkSelect(pWalker, pExpr->x.pSelect); 1150 } 1151 assert( pNC->nRef>=nRef ); 1152 if( nRef!=pNC->nRef ){ 1153 ExprSetProperty(pExpr, EP_VarSelect); 1154 pNC->ncFlags |= NC_VarSelect; 1155 } 1156 } 1157 break; 1158 } 1159 case TK_VARIABLE: { 1160 testcase( pNC->ncFlags & NC_IsCheck ); 1161 testcase( pNC->ncFlags & NC_PartIdx ); 1162 testcase( pNC->ncFlags & NC_IdxExpr ); 1163 testcase( pNC->ncFlags & NC_GenCol ); 1164 sqlite3ResolveNotValid(pParse, pNC, "parameters", 1165 NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol, pExpr, pExpr); 1166 break; 1167 } 1168 case TK_IS: 1169 case TK_ISNOT: { 1170 Expr *pRight = sqlite3ExprSkipCollateAndLikely(pExpr->pRight); 1171 assert( !ExprHasProperty(pExpr, EP_Reduced) ); 1172 /* Handle special cases of "x IS TRUE", "x IS FALSE", "x IS NOT TRUE", 1173 ** and "x IS NOT FALSE". */ 1174 if( ALWAYS(pRight) && (pRight->op==TK_ID || pRight->op==TK_TRUEFALSE) ){ 1175 int rc = resolveExprStep(pWalker, pRight); 1176 if( rc==WRC_Abort ) return WRC_Abort; 1177 if( pRight->op==TK_TRUEFALSE ){ 1178 pExpr->op2 = pExpr->op; 1179 pExpr->op = TK_TRUTH; 1180 return WRC_Continue; 1181 } 1182 } 1183 /* no break */ deliberate_fall_through 1184 } 1185 case TK_BETWEEN: 1186 case TK_EQ: 1187 case TK_NE: 1188 case TK_LT: 1189 case TK_LE: 1190 case TK_GT: 1191 case TK_GE: { 1192 int nLeft, nRight; 1193 if( pParse->db->mallocFailed ) break; 1194 assert( pExpr->pLeft!=0 ); 1195 nLeft = sqlite3ExprVectorSize(pExpr->pLeft); 1196 if( pExpr->op==TK_BETWEEN ){ 1197 assert( ExprUseXList(pExpr) ); 1198 nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[0].pExpr); 1199 if( nRight==nLeft ){ 1200 nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[1].pExpr); 1201 } 1202 }else{ 1203 assert( pExpr->pRight!=0 ); 1204 nRight = sqlite3ExprVectorSize(pExpr->pRight); 1205 } 1206 if( nLeft!=nRight ){ 1207 testcase( pExpr->op==TK_EQ ); 1208 testcase( pExpr->op==TK_NE ); 1209 testcase( pExpr->op==TK_LT ); 1210 testcase( pExpr->op==TK_LE ); 1211 testcase( pExpr->op==TK_GT ); 1212 testcase( pExpr->op==TK_GE ); 1213 testcase( pExpr->op==TK_IS ); 1214 testcase( pExpr->op==TK_ISNOT ); 1215 testcase( pExpr->op==TK_BETWEEN ); 1216 sqlite3ErrorMsg(pParse, "row value misused"); 1217 sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr); 1218 } 1219 break; 1220 } 1221 } 1222 assert( pParse->db->mallocFailed==0 || pParse->nErr!=0 ); 1223 return pParse->nErr ? WRC_Abort : WRC_Continue; 1224 } 1225 1226 /* 1227 ** pEList is a list of expressions which are really the result set of the 1228 ** a SELECT statement. pE is a term in an ORDER BY or GROUP BY clause. 1229 ** This routine checks to see if pE is a simple identifier which corresponds 1230 ** to the AS-name of one of the terms of the expression list. If it is, 1231 ** this routine return an integer between 1 and N where N is the number of 1232 ** elements in pEList, corresponding to the matching entry. If there is 1233 ** no match, or if pE is not a simple identifier, then this routine 1234 ** return 0. 1235 ** 1236 ** pEList has been resolved. pE has not. 1237 */ 1238 static int resolveAsName( 1239 Parse *pParse, /* Parsing context for error messages */ 1240 ExprList *pEList, /* List of expressions to scan */ 1241 Expr *pE /* Expression we are trying to match */ 1242 ){ 1243 int i; /* Loop counter */ 1244 1245 UNUSED_PARAMETER(pParse); 1246 1247 if( pE->op==TK_ID ){ 1248 const char *zCol; 1249 assert( !ExprHasProperty(pE, EP_IntValue) ); 1250 zCol = pE->u.zToken; 1251 for(i=0; i<pEList->nExpr; i++){ 1252 if( pEList->a[i].eEName==ENAME_NAME 1253 && sqlite3_stricmp(pEList->a[i].zEName, zCol)==0 1254 ){ 1255 return i+1; 1256 } 1257 } 1258 } 1259 return 0; 1260 } 1261 1262 /* 1263 ** pE is a pointer to an expression which is a single term in the 1264 ** ORDER BY of a compound SELECT. The expression has not been 1265 ** name resolved. 1266 ** 1267 ** At the point this routine is called, we already know that the 1268 ** ORDER BY term is not an integer index into the result set. That 1269 ** case is handled by the calling routine. 1270 ** 1271 ** Attempt to match pE against result set columns in the left-most 1272 ** SELECT statement. Return the index i of the matching column, 1273 ** as an indication to the caller that it should sort by the i-th column. 1274 ** The left-most column is 1. In other words, the value returned is the 1275 ** same integer value that would be used in the SQL statement to indicate 1276 ** the column. 1277 ** 1278 ** If there is no match, return 0. Return -1 if an error occurs. 1279 */ 1280 static int resolveOrderByTermToExprList( 1281 Parse *pParse, /* Parsing context for error messages */ 1282 Select *pSelect, /* The SELECT statement with the ORDER BY clause */ 1283 Expr *pE /* The specific ORDER BY term */ 1284 ){ 1285 int i; /* Loop counter */ 1286 ExprList *pEList; /* The columns of the result set */ 1287 NameContext nc; /* Name context for resolving pE */ 1288 sqlite3 *db; /* Database connection */ 1289 int rc; /* Return code from subprocedures */ 1290 u8 savedSuppErr; /* Saved value of db->suppressErr */ 1291 1292 assert( sqlite3ExprIsInteger(pE, &i)==0 ); 1293 pEList = pSelect->pEList; 1294 1295 /* Resolve all names in the ORDER BY term expression 1296 */ 1297 memset(&nc, 0, sizeof(nc)); 1298 nc.pParse = pParse; 1299 nc.pSrcList = pSelect->pSrc; 1300 nc.uNC.pEList = pEList; 1301 nc.ncFlags = NC_AllowAgg|NC_UEList|NC_NoSelect; 1302 nc.nNcErr = 0; 1303 db = pParse->db; 1304 savedSuppErr = db->suppressErr; 1305 db->suppressErr = 1; 1306 rc = sqlite3ResolveExprNames(&nc, pE); 1307 db->suppressErr = savedSuppErr; 1308 if( rc ) return 0; 1309 1310 /* Try to match the ORDER BY expression against an expression 1311 ** in the result set. Return an 1-based index of the matching 1312 ** result-set entry. 1313 */ 1314 for(i=0; i<pEList->nExpr; i++){ 1315 if( sqlite3ExprCompare(0, pEList->a[i].pExpr, pE, -1)<2 ){ 1316 return i+1; 1317 } 1318 } 1319 1320 /* If no match, return 0. */ 1321 return 0; 1322 } 1323 1324 /* 1325 ** Generate an ORDER BY or GROUP BY term out-of-range error. 1326 */ 1327 static void resolveOutOfRangeError( 1328 Parse *pParse, /* The error context into which to write the error */ 1329 const char *zType, /* "ORDER" or "GROUP" */ 1330 int i, /* The index (1-based) of the term out of range */ 1331 int mx, /* Largest permissible value of i */ 1332 Expr *pError /* Associate the error with the expression */ 1333 ){ 1334 sqlite3ErrorMsg(pParse, 1335 "%r %s BY term out of range - should be " 1336 "between 1 and %d", i, zType, mx); 1337 sqlite3RecordErrorOffsetOfExpr(pParse->db, pError); 1338 } 1339 1340 /* 1341 ** Analyze the ORDER BY clause in a compound SELECT statement. Modify 1342 ** each term of the ORDER BY clause is a constant integer between 1 1343 ** and N where N is the number of columns in the compound SELECT. 1344 ** 1345 ** ORDER BY terms that are already an integer between 1 and N are 1346 ** unmodified. ORDER BY terms that are integers outside the range of 1347 ** 1 through N generate an error. ORDER BY terms that are expressions 1348 ** are matched against result set expressions of compound SELECT 1349 ** beginning with the left-most SELECT and working toward the right. 1350 ** At the first match, the ORDER BY expression is transformed into 1351 ** the integer column number. 1352 ** 1353 ** Return the number of errors seen. 1354 */ 1355 static int resolveCompoundOrderBy( 1356 Parse *pParse, /* Parsing context. Leave error messages here */ 1357 Select *pSelect /* The SELECT statement containing the ORDER BY */ 1358 ){ 1359 int i; 1360 ExprList *pOrderBy; 1361 ExprList *pEList; 1362 sqlite3 *db; 1363 int moreToDo = 1; 1364 1365 pOrderBy = pSelect->pOrderBy; 1366 if( pOrderBy==0 ) return 0; 1367 db = pParse->db; 1368 if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){ 1369 sqlite3ErrorMsg(pParse, "too many terms in ORDER BY clause"); 1370 return 1; 1371 } 1372 for(i=0; i<pOrderBy->nExpr; i++){ 1373 pOrderBy->a[i].done = 0; 1374 } 1375 pSelect->pNext = 0; 1376 while( pSelect->pPrior ){ 1377 pSelect->pPrior->pNext = pSelect; 1378 pSelect = pSelect->pPrior; 1379 } 1380 while( pSelect && moreToDo ){ 1381 struct ExprList_item *pItem; 1382 moreToDo = 0; 1383 pEList = pSelect->pEList; 1384 assert( pEList!=0 ); 1385 for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){ 1386 int iCol = -1; 1387 Expr *pE, *pDup; 1388 if( pItem->done ) continue; 1389 pE = sqlite3ExprSkipCollateAndLikely(pItem->pExpr); 1390 if( NEVER(pE==0) ) continue; 1391 if( sqlite3ExprIsInteger(pE, &iCol) ){ 1392 if( iCol<=0 || iCol>pEList->nExpr ){ 1393 resolveOutOfRangeError(pParse, "ORDER", i+1, pEList->nExpr, pE); 1394 return 1; 1395 } 1396 }else{ 1397 iCol = resolveAsName(pParse, pEList, pE); 1398 if( iCol==0 ){ 1399 /* Now test if expression pE matches one of the values returned 1400 ** by pSelect. In the usual case this is done by duplicating the 1401 ** expression, resolving any symbols in it, and then comparing 1402 ** it against each expression returned by the SELECT statement. 1403 ** Once the comparisons are finished, the duplicate expression 1404 ** is deleted. 1405 ** 1406 ** If this is running as part of an ALTER TABLE operation and 1407 ** the symbols resolve successfully, also resolve the symbols in the 1408 ** actual expression. This allows the code in alter.c to modify 1409 ** column references within the ORDER BY expression as required. */ 1410 pDup = sqlite3ExprDup(db, pE, 0); 1411 if( !db->mallocFailed ){ 1412 assert(pDup); 1413 iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup); 1414 if( IN_RENAME_OBJECT && iCol>0 ){ 1415 resolveOrderByTermToExprList(pParse, pSelect, pE); 1416 } 1417 } 1418 sqlite3ExprDelete(db, pDup); 1419 } 1420 } 1421 if( iCol>0 ){ 1422 /* Convert the ORDER BY term into an integer column number iCol, 1423 ** taking care to preserve the COLLATE clause if it exists. */ 1424 if( !IN_RENAME_OBJECT ){ 1425 Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0); 1426 if( pNew==0 ) return 1; 1427 pNew->flags |= EP_IntValue; 1428 pNew->u.iValue = iCol; 1429 if( pItem->pExpr==pE ){ 1430 pItem->pExpr = pNew; 1431 }else{ 1432 Expr *pParent = pItem->pExpr; 1433 assert( pParent->op==TK_COLLATE ); 1434 while( pParent->pLeft->op==TK_COLLATE ) pParent = pParent->pLeft; 1435 assert( pParent->pLeft==pE ); 1436 pParent->pLeft = pNew; 1437 } 1438 sqlite3ExprDelete(db, pE); 1439 pItem->u.x.iOrderByCol = (u16)iCol; 1440 } 1441 pItem->done = 1; 1442 }else{ 1443 moreToDo = 1; 1444 } 1445 } 1446 pSelect = pSelect->pNext; 1447 } 1448 for(i=0; i<pOrderBy->nExpr; i++){ 1449 if( pOrderBy->a[i].done==0 ){ 1450 sqlite3ErrorMsg(pParse, "%r ORDER BY term does not match any " 1451 "column in the result set", i+1); 1452 return 1; 1453 } 1454 } 1455 return 0; 1456 } 1457 1458 /* 1459 ** Check every term in the ORDER BY or GROUP BY clause pOrderBy of 1460 ** the SELECT statement pSelect. If any term is reference to a 1461 ** result set expression (as determined by the ExprList.a.u.x.iOrderByCol 1462 ** field) then convert that term into a copy of the corresponding result set 1463 ** column. 1464 ** 1465 ** If any errors are detected, add an error message to pParse and 1466 ** return non-zero. Return zero if no errors are seen. 1467 */ 1468 int sqlite3ResolveOrderGroupBy( 1469 Parse *pParse, /* Parsing context. Leave error messages here */ 1470 Select *pSelect, /* The SELECT statement containing the clause */ 1471 ExprList *pOrderBy, /* The ORDER BY or GROUP BY clause to be processed */ 1472 const char *zType /* "ORDER" or "GROUP" */ 1473 ){ 1474 int i; 1475 sqlite3 *db = pParse->db; 1476 ExprList *pEList; 1477 struct ExprList_item *pItem; 1478 1479 if( pOrderBy==0 || pParse->db->mallocFailed || IN_RENAME_OBJECT ) return 0; 1480 if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){ 1481 sqlite3ErrorMsg(pParse, "too many terms in %s BY clause", zType); 1482 return 1; 1483 } 1484 pEList = pSelect->pEList; 1485 assert( pEList!=0 ); /* sqlite3SelectNew() guarantees this */ 1486 for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){ 1487 if( pItem->u.x.iOrderByCol ){ 1488 if( pItem->u.x.iOrderByCol>pEList->nExpr ){ 1489 resolveOutOfRangeError(pParse, zType, i+1, pEList->nExpr, 0); 1490 return 1; 1491 } 1492 resolveAlias(pParse, pEList, pItem->u.x.iOrderByCol-1, pItem->pExpr,0); 1493 } 1494 } 1495 return 0; 1496 } 1497 1498 #ifndef SQLITE_OMIT_WINDOWFUNC 1499 /* 1500 ** Walker callback for windowRemoveExprFromSelect(). 1501 */ 1502 static int resolveRemoveWindowsCb(Walker *pWalker, Expr *pExpr){ 1503 UNUSED_PARAMETER(pWalker); 1504 if( ExprHasProperty(pExpr, EP_WinFunc) ){ 1505 Window *pWin = pExpr->y.pWin; 1506 sqlite3WindowUnlinkFromSelect(pWin); 1507 } 1508 return WRC_Continue; 1509 } 1510 1511 /* 1512 ** Remove any Window objects owned by the expression pExpr from the 1513 ** Select.pWin list of Select object pSelect. 1514 */ 1515 static void windowRemoveExprFromSelect(Select *pSelect, Expr *pExpr){ 1516 if( pSelect->pWin ){ 1517 Walker sWalker; 1518 memset(&sWalker, 0, sizeof(Walker)); 1519 sWalker.xExprCallback = resolveRemoveWindowsCb; 1520 sWalker.u.pSelect = pSelect; 1521 sqlite3WalkExpr(&sWalker, pExpr); 1522 } 1523 } 1524 #else 1525 # define windowRemoveExprFromSelect(a, b) 1526 #endif /* SQLITE_OMIT_WINDOWFUNC */ 1527 1528 /* 1529 ** pOrderBy is an ORDER BY or GROUP BY clause in SELECT statement pSelect. 1530 ** The Name context of the SELECT statement is pNC. zType is either 1531 ** "ORDER" or "GROUP" depending on which type of clause pOrderBy is. 1532 ** 1533 ** This routine resolves each term of the clause into an expression. 1534 ** If the order-by term is an integer I between 1 and N (where N is the 1535 ** number of columns in the result set of the SELECT) then the expression 1536 ** in the resolution is a copy of the I-th result-set expression. If 1537 ** the order-by term is an identifier that corresponds to the AS-name of 1538 ** a result-set expression, then the term resolves to a copy of the 1539 ** result-set expression. Otherwise, the expression is resolved in 1540 ** the usual way - using sqlite3ResolveExprNames(). 1541 ** 1542 ** This routine returns the number of errors. If errors occur, then 1543 ** an appropriate error message might be left in pParse. (OOM errors 1544 ** excepted.) 1545 */ 1546 static int resolveOrderGroupBy( 1547 NameContext *pNC, /* The name context of the SELECT statement */ 1548 Select *pSelect, /* The SELECT statement holding pOrderBy */ 1549 ExprList *pOrderBy, /* An ORDER BY or GROUP BY clause to resolve */ 1550 const char *zType /* Either "ORDER" or "GROUP", as appropriate */ 1551 ){ 1552 int i, j; /* Loop counters */ 1553 int iCol; /* Column number */ 1554 struct ExprList_item *pItem; /* A term of the ORDER BY clause */ 1555 Parse *pParse; /* Parsing context */ 1556 int nResult; /* Number of terms in the result set */ 1557 1558 assert( pOrderBy!=0 ); 1559 nResult = pSelect->pEList->nExpr; 1560 pParse = pNC->pParse; 1561 for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){ 1562 Expr *pE = pItem->pExpr; 1563 Expr *pE2 = sqlite3ExprSkipCollateAndLikely(pE); 1564 if( NEVER(pE2==0) ) continue; 1565 if( zType[0]!='G' ){ 1566 iCol = resolveAsName(pParse, pSelect->pEList, pE2); 1567 if( iCol>0 ){ 1568 /* If an AS-name match is found, mark this ORDER BY column as being 1569 ** a copy of the iCol-th result-set column. The subsequent call to 1570 ** sqlite3ResolveOrderGroupBy() will convert the expression to a 1571 ** copy of the iCol-th result-set expression. */ 1572 pItem->u.x.iOrderByCol = (u16)iCol; 1573 continue; 1574 } 1575 } 1576 if( sqlite3ExprIsInteger(pE2, &iCol) ){ 1577 /* The ORDER BY term is an integer constant. Again, set the column 1578 ** number so that sqlite3ResolveOrderGroupBy() will convert the 1579 ** order-by term to a copy of the result-set expression */ 1580 if( iCol<1 || iCol>0xffff ){ 1581 resolveOutOfRangeError(pParse, zType, i+1, nResult, pE2); 1582 return 1; 1583 } 1584 pItem->u.x.iOrderByCol = (u16)iCol; 1585 continue; 1586 } 1587 1588 /* Otherwise, treat the ORDER BY term as an ordinary expression */ 1589 pItem->u.x.iOrderByCol = 0; 1590 if( sqlite3ResolveExprNames(pNC, pE) ){ 1591 return 1; 1592 } 1593 for(j=0; j<pSelect->pEList->nExpr; j++){ 1594 if( sqlite3ExprCompare(0, pE, pSelect->pEList->a[j].pExpr, -1)==0 ){ 1595 /* Since this expresion is being changed into a reference 1596 ** to an identical expression in the result set, remove all Window 1597 ** objects belonging to the expression from the Select.pWin list. */ 1598 windowRemoveExprFromSelect(pSelect, pE); 1599 pItem->u.x.iOrderByCol = j+1; 1600 } 1601 } 1602 } 1603 return sqlite3ResolveOrderGroupBy(pParse, pSelect, pOrderBy, zType); 1604 } 1605 1606 /* 1607 ** Resolve names in the SELECT statement p and all of its descendants. 1608 */ 1609 static int resolveSelectStep(Walker *pWalker, Select *p){ 1610 NameContext *pOuterNC; /* Context that contains this SELECT */ 1611 NameContext sNC; /* Name context of this SELECT */ 1612 int isCompound; /* True if p is a compound select */ 1613 int nCompound; /* Number of compound terms processed so far */ 1614 Parse *pParse; /* Parsing context */ 1615 int i; /* Loop counter */ 1616 ExprList *pGroupBy; /* The GROUP BY clause */ 1617 Select *pLeftmost; /* Left-most of SELECT of a compound */ 1618 sqlite3 *db; /* Database connection */ 1619 1620 1621 assert( p!=0 ); 1622 if( p->selFlags & SF_Resolved ){ 1623 return WRC_Prune; 1624 } 1625 pOuterNC = pWalker->u.pNC; 1626 pParse = pWalker->pParse; 1627 db = pParse->db; 1628 1629 /* Normally sqlite3SelectExpand() will be called first and will have 1630 ** already expanded this SELECT. However, if this is a subquery within 1631 ** an expression, sqlite3ResolveExprNames() will be called without a 1632 ** prior call to sqlite3SelectExpand(). When that happens, let 1633 ** sqlite3SelectPrep() do all of the processing for this SELECT. 1634 ** sqlite3SelectPrep() will invoke both sqlite3SelectExpand() and 1635 ** this routine in the correct order. 1636 */ 1637 if( (p->selFlags & SF_Expanded)==0 ){ 1638 sqlite3SelectPrep(pParse, p, pOuterNC); 1639 return pParse->nErr ? WRC_Abort : WRC_Prune; 1640 } 1641 1642 isCompound = p->pPrior!=0; 1643 nCompound = 0; 1644 pLeftmost = p; 1645 while( p ){ 1646 assert( (p->selFlags & SF_Expanded)!=0 ); 1647 assert( (p->selFlags & SF_Resolved)==0 ); 1648 assert( db->suppressErr==0 ); /* SF_Resolved not set if errors suppressed */ 1649 p->selFlags |= SF_Resolved; 1650 1651 1652 /* Resolve the expressions in the LIMIT and OFFSET clauses. These 1653 ** are not allowed to refer to any names, so pass an empty NameContext. 1654 */ 1655 memset(&sNC, 0, sizeof(sNC)); 1656 sNC.pParse = pParse; 1657 sNC.pWinSelect = p; 1658 if( sqlite3ResolveExprNames(&sNC, p->pLimit) ){ 1659 return WRC_Abort; 1660 } 1661 1662 /* If the SF_Converted flags is set, then this Select object was 1663 ** was created by the convertCompoundSelectToSubquery() function. 1664 ** In this case the ORDER BY clause (p->pOrderBy) should be resolved 1665 ** as if it were part of the sub-query, not the parent. This block 1666 ** moves the pOrderBy down to the sub-query. It will be moved back 1667 ** after the names have been resolved. */ 1668 if( p->selFlags & SF_Converted ){ 1669 Select *pSub = p->pSrc->a[0].pSelect; 1670 assert( p->pSrc->nSrc==1 && p->pOrderBy ); 1671 assert( pSub->pPrior && pSub->pOrderBy==0 ); 1672 pSub->pOrderBy = p->pOrderBy; 1673 p->pOrderBy = 0; 1674 } 1675 1676 /* Recursively resolve names in all subqueries in the FROM clause 1677 */ 1678 for(i=0; i<p->pSrc->nSrc; i++){ 1679 SrcItem *pItem = &p->pSrc->a[i]; 1680 if( pItem->pSelect && (pItem->pSelect->selFlags & SF_Resolved)==0 ){ 1681 int nRef = pOuterNC ? pOuterNC->nRef : 0; 1682 const char *zSavedContext = pParse->zAuthContext; 1683 1684 if( pItem->zName ) pParse->zAuthContext = pItem->zName; 1685 sqlite3ResolveSelectNames(pParse, pItem->pSelect, pOuterNC); 1686 pParse->zAuthContext = zSavedContext; 1687 if( pParse->nErr ) return WRC_Abort; 1688 assert( db->mallocFailed==0 ); 1689 1690 /* If the number of references to the outer context changed when 1691 ** expressions in the sub-select were resolved, the sub-select 1692 ** is correlated. It is not required to check the refcount on any 1693 ** but the innermost outer context object, as lookupName() increments 1694 ** the refcount on all contexts between the current one and the 1695 ** context containing the column when it resolves a name. */ 1696 if( pOuterNC ){ 1697 assert( pItem->fg.isCorrelated==0 && pOuterNC->nRef>=nRef ); 1698 pItem->fg.isCorrelated = (pOuterNC->nRef>nRef); 1699 } 1700 } 1701 } 1702 1703 /* Set up the local name-context to pass to sqlite3ResolveExprNames() to 1704 ** resolve the result-set expression list. 1705 */ 1706 sNC.ncFlags = NC_AllowAgg|NC_AllowWin; 1707 sNC.pSrcList = p->pSrc; 1708 sNC.pNext = pOuterNC; 1709 1710 /* Resolve names in the result set. */ 1711 if( sqlite3ResolveExprListNames(&sNC, p->pEList) ) return WRC_Abort; 1712 sNC.ncFlags &= ~NC_AllowWin; 1713 1714 /* If there are no aggregate functions in the result-set, and no GROUP BY 1715 ** expression, do not allow aggregates in any of the other expressions. 1716 */ 1717 assert( (p->selFlags & SF_Aggregate)==0 ); 1718 pGroupBy = p->pGroupBy; 1719 if( pGroupBy || (sNC.ncFlags & NC_HasAgg)!=0 ){ 1720 assert( NC_MinMaxAgg==SF_MinMaxAgg ); 1721 assert( NC_OrderAgg==SF_OrderByReqd ); 1722 p->selFlags |= SF_Aggregate | (sNC.ncFlags&(NC_MinMaxAgg|NC_OrderAgg)); 1723 }else{ 1724 sNC.ncFlags &= ~NC_AllowAgg; 1725 } 1726 1727 /* Add the output column list to the name-context before parsing the 1728 ** other expressions in the SELECT statement. This is so that 1729 ** expressions in the WHERE clause (etc.) can refer to expressions by 1730 ** aliases in the result set. 1731 ** 1732 ** Minor point: If this is the case, then the expression will be 1733 ** re-evaluated for each reference to it. 1734 */ 1735 assert( (sNC.ncFlags & (NC_UAggInfo|NC_UUpsert|NC_UBaseReg))==0 ); 1736 sNC.uNC.pEList = p->pEList; 1737 sNC.ncFlags |= NC_UEList; 1738 if( p->pHaving ){ 1739 if( !pGroupBy ){ 1740 sqlite3ErrorMsg(pParse, "a GROUP BY clause is required before HAVING"); 1741 return WRC_Abort; 1742 } 1743 if( sqlite3ResolveExprNames(&sNC, p->pHaving) ) return WRC_Abort; 1744 } 1745 if( sqlite3ResolveExprNames(&sNC, p->pWhere) ) return WRC_Abort; 1746 1747 /* Resolve names in table-valued-function arguments */ 1748 for(i=0; i<p->pSrc->nSrc; i++){ 1749 SrcItem *pItem = &p->pSrc->a[i]; 1750 if( pItem->fg.isTabFunc 1751 && sqlite3ResolveExprListNames(&sNC, pItem->u1.pFuncArg) 1752 ){ 1753 return WRC_Abort; 1754 } 1755 } 1756 1757 #ifndef SQLITE_OMIT_WINDOWFUNC 1758 if( IN_RENAME_OBJECT ){ 1759 Window *pWin; 1760 for(pWin=p->pWinDefn; pWin; pWin=pWin->pNextWin){ 1761 if( sqlite3ResolveExprListNames(&sNC, pWin->pOrderBy) 1762 || sqlite3ResolveExprListNames(&sNC, pWin->pPartition) 1763 ){ 1764 return WRC_Abort; 1765 } 1766 } 1767 } 1768 #endif 1769 1770 /* The ORDER BY and GROUP BY clauses may not refer to terms in 1771 ** outer queries 1772 */ 1773 sNC.pNext = 0; 1774 sNC.ncFlags |= NC_AllowAgg|NC_AllowWin; 1775 1776 /* If this is a converted compound query, move the ORDER BY clause from 1777 ** the sub-query back to the parent query. At this point each term 1778 ** within the ORDER BY clause has been transformed to an integer value. 1779 ** These integers will be replaced by copies of the corresponding result 1780 ** set expressions by the call to resolveOrderGroupBy() below. */ 1781 if( p->selFlags & SF_Converted ){ 1782 Select *pSub = p->pSrc->a[0].pSelect; 1783 p->pOrderBy = pSub->pOrderBy; 1784 pSub->pOrderBy = 0; 1785 } 1786 1787 /* Process the ORDER BY clause for singleton SELECT statements. 1788 ** The ORDER BY clause for compounds SELECT statements is handled 1789 ** below, after all of the result-sets for all of the elements of 1790 ** the compound have been resolved. 1791 ** 1792 ** If there is an ORDER BY clause on a term of a compound-select other 1793 ** than the right-most term, then that is a syntax error. But the error 1794 ** is not detected until much later, and so we need to go ahead and 1795 ** resolve those symbols on the incorrect ORDER BY for consistency. 1796 */ 1797 if( p->pOrderBy!=0 1798 && isCompound<=nCompound /* Defer right-most ORDER BY of a compound */ 1799 && resolveOrderGroupBy(&sNC, p, p->pOrderBy, "ORDER") 1800 ){ 1801 return WRC_Abort; 1802 } 1803 if( db->mallocFailed ){ 1804 return WRC_Abort; 1805 } 1806 sNC.ncFlags &= ~NC_AllowWin; 1807 1808 /* Resolve the GROUP BY clause. At the same time, make sure 1809 ** the GROUP BY clause does not contain aggregate functions. 1810 */ 1811 if( pGroupBy ){ 1812 struct ExprList_item *pItem; 1813 1814 if( resolveOrderGroupBy(&sNC, p, pGroupBy, "GROUP") || db->mallocFailed ){ 1815 return WRC_Abort; 1816 } 1817 for(i=0, pItem=pGroupBy->a; i<pGroupBy->nExpr; i++, pItem++){ 1818 if( ExprHasProperty(pItem->pExpr, EP_Agg) ){ 1819 sqlite3ErrorMsg(pParse, "aggregate functions are not allowed in " 1820 "the GROUP BY clause"); 1821 return WRC_Abort; 1822 } 1823 } 1824 } 1825 1826 /* If this is part of a compound SELECT, check that it has the right 1827 ** number of expressions in the select list. */ 1828 if( p->pNext && p->pEList->nExpr!=p->pNext->pEList->nExpr ){ 1829 sqlite3SelectWrongNumTermsError(pParse, p->pNext); 1830 return WRC_Abort; 1831 } 1832 1833 /* Advance to the next term of the compound 1834 */ 1835 p = p->pPrior; 1836 nCompound++; 1837 } 1838 1839 /* Resolve the ORDER BY on a compound SELECT after all terms of 1840 ** the compound have been resolved. 1841 */ 1842 if( isCompound && resolveCompoundOrderBy(pParse, pLeftmost) ){ 1843 return WRC_Abort; 1844 } 1845 1846 return WRC_Prune; 1847 } 1848 1849 /* 1850 ** This routine walks an expression tree and resolves references to 1851 ** table columns and result-set columns. At the same time, do error 1852 ** checking on function usage and set a flag if any aggregate functions 1853 ** are seen. 1854 ** 1855 ** To resolve table columns references we look for nodes (or subtrees) of the 1856 ** form X.Y.Z or Y.Z or just Z where 1857 ** 1858 ** X: The name of a database. Ex: "main" or "temp" or 1859 ** the symbolic name assigned to an ATTACH-ed database. 1860 ** 1861 ** Y: The name of a table in a FROM clause. Or in a trigger 1862 ** one of the special names "old" or "new". 1863 ** 1864 ** Z: The name of a column in table Y. 1865 ** 1866 ** The node at the root of the subtree is modified as follows: 1867 ** 1868 ** Expr.op Changed to TK_COLUMN 1869 ** Expr.pTab Points to the Table object for X.Y 1870 ** Expr.iColumn The column index in X.Y. -1 for the rowid. 1871 ** Expr.iTable The VDBE cursor number for X.Y 1872 ** 1873 ** 1874 ** To resolve result-set references, look for expression nodes of the 1875 ** form Z (with no X and Y prefix) where the Z matches the right-hand 1876 ** size of an AS clause in the result-set of a SELECT. The Z expression 1877 ** is replaced by a copy of the left-hand side of the result-set expression. 1878 ** Table-name and function resolution occurs on the substituted expression 1879 ** tree. For example, in: 1880 ** 1881 ** SELECT a+b AS x, c+d AS y FROM t1 ORDER BY x; 1882 ** 1883 ** The "x" term of the order by is replaced by "a+b" to render: 1884 ** 1885 ** SELECT a+b AS x, c+d AS y FROM t1 ORDER BY a+b; 1886 ** 1887 ** Function calls are checked to make sure that the function is 1888 ** defined and that the correct number of arguments are specified. 1889 ** If the function is an aggregate function, then the NC_HasAgg flag is 1890 ** set and the opcode is changed from TK_FUNCTION to TK_AGG_FUNCTION. 1891 ** If an expression contains aggregate functions then the EP_Agg 1892 ** property on the expression is set. 1893 ** 1894 ** An error message is left in pParse if anything is amiss. The number 1895 ** if errors is returned. 1896 */ 1897 int sqlite3ResolveExprNames( 1898 NameContext *pNC, /* Namespace to resolve expressions in. */ 1899 Expr *pExpr /* The expression to be analyzed. */ 1900 ){ 1901 int savedHasAgg; 1902 Walker w; 1903 1904 if( pExpr==0 ) return SQLITE_OK; 1905 savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg); 1906 pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg); 1907 w.pParse = pNC->pParse; 1908 w.xExprCallback = resolveExprStep; 1909 w.xSelectCallback = (pNC->ncFlags & NC_NoSelect) ? 0 : resolveSelectStep; 1910 w.xSelectCallback2 = 0; 1911 w.u.pNC = pNC; 1912 #if SQLITE_MAX_EXPR_DEPTH>0 1913 w.pParse->nHeight += pExpr->nHeight; 1914 if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){ 1915 return SQLITE_ERROR; 1916 } 1917 #endif 1918 sqlite3WalkExpr(&w, pExpr); 1919 #if SQLITE_MAX_EXPR_DEPTH>0 1920 w.pParse->nHeight -= pExpr->nHeight; 1921 #endif 1922 assert( EP_Agg==NC_HasAgg ); 1923 assert( EP_Win==NC_HasWin ); 1924 testcase( pNC->ncFlags & NC_HasAgg ); 1925 testcase( pNC->ncFlags & NC_HasWin ); 1926 ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) ); 1927 pNC->ncFlags |= savedHasAgg; 1928 return pNC->nNcErr>0 || w.pParse->nErr>0; 1929 } 1930 1931 /* 1932 ** Resolve all names for all expression in an expression list. This is 1933 ** just like sqlite3ResolveExprNames() except that it works for an expression 1934 ** list rather than a single expression. 1935 */ 1936 int sqlite3ResolveExprListNames( 1937 NameContext *pNC, /* Namespace to resolve expressions in. */ 1938 ExprList *pList /* The expression list to be analyzed. */ 1939 ){ 1940 int i; 1941 int savedHasAgg = 0; 1942 Walker w; 1943 if( pList==0 ) return WRC_Continue; 1944 w.pParse = pNC->pParse; 1945 w.xExprCallback = resolveExprStep; 1946 w.xSelectCallback = resolveSelectStep; 1947 w.xSelectCallback2 = 0; 1948 w.u.pNC = pNC; 1949 savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg); 1950 pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg); 1951 for(i=0; i<pList->nExpr; i++){ 1952 Expr *pExpr = pList->a[i].pExpr; 1953 if( pExpr==0 ) continue; 1954 #if SQLITE_MAX_EXPR_DEPTH>0 1955 w.pParse->nHeight += pExpr->nHeight; 1956 if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){ 1957 return WRC_Abort; 1958 } 1959 #endif 1960 sqlite3WalkExpr(&w, pExpr); 1961 #if SQLITE_MAX_EXPR_DEPTH>0 1962 w.pParse->nHeight -= pExpr->nHeight; 1963 #endif 1964 assert( EP_Agg==NC_HasAgg ); 1965 assert( EP_Win==NC_HasWin ); 1966 testcase( pNC->ncFlags & NC_HasAgg ); 1967 testcase( pNC->ncFlags & NC_HasWin ); 1968 if( pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg) ){ 1969 ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) ); 1970 savedHasAgg |= pNC->ncFlags & 1971 (NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg); 1972 pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg); 1973 } 1974 if( w.pParse->nErr>0 ) return WRC_Abort; 1975 } 1976 pNC->ncFlags |= savedHasAgg; 1977 return WRC_Continue; 1978 } 1979 1980 /* 1981 ** Resolve all names in all expressions of a SELECT and in all 1982 ** decendents of the SELECT, including compounds off of p->pPrior, 1983 ** subqueries in expressions, and subqueries used as FROM clause 1984 ** terms. 1985 ** 1986 ** See sqlite3ResolveExprNames() for a description of the kinds of 1987 ** transformations that occur. 1988 ** 1989 ** All SELECT statements should have been expanded using 1990 ** sqlite3SelectExpand() prior to invoking this routine. 1991 */ 1992 void sqlite3ResolveSelectNames( 1993 Parse *pParse, /* The parser context */ 1994 Select *p, /* The SELECT statement being coded. */ 1995 NameContext *pOuterNC /* Name context for parent SELECT statement */ 1996 ){ 1997 Walker w; 1998 1999 assert( p!=0 ); 2000 w.xExprCallback = resolveExprStep; 2001 w.xSelectCallback = resolveSelectStep; 2002 w.xSelectCallback2 = 0; 2003 w.pParse = pParse; 2004 w.u.pNC = pOuterNC; 2005 sqlite3WalkSelect(&w, p); 2006 } 2007 2008 /* 2009 ** Resolve names in expressions that can only reference a single table 2010 ** or which cannot reference any tables at all. Examples: 2011 ** 2012 ** "type" flag 2013 ** ------------ 2014 ** (1) CHECK constraints NC_IsCheck 2015 ** (2) WHERE clauses on partial indices NC_PartIdx 2016 ** (3) Expressions in indexes on expressions NC_IdxExpr 2017 ** (4) Expression arguments to VACUUM INTO. 0 2018 ** (5) GENERATED ALWAYS as expressions NC_GenCol 2019 ** 2020 ** In all cases except (4), the Expr.iTable value for Expr.op==TK_COLUMN 2021 ** nodes of the expression is set to -1 and the Expr.iColumn value is 2022 ** set to the column number. In case (4), TK_COLUMN nodes cause an error. 2023 ** 2024 ** Any errors cause an error message to be set in pParse. 2025 */ 2026 int sqlite3ResolveSelfReference( 2027 Parse *pParse, /* Parsing context */ 2028 Table *pTab, /* The table being referenced, or NULL */ 2029 int type, /* NC_IsCheck, NC_PartIdx, NC_IdxExpr, NC_GenCol, or 0 */ 2030 Expr *pExpr, /* Expression to resolve. May be NULL. */ 2031 ExprList *pList /* Expression list to resolve. May be NULL. */ 2032 ){ 2033 SrcList sSrc; /* Fake SrcList for pParse->pNewTable */ 2034 NameContext sNC; /* Name context for pParse->pNewTable */ 2035 int rc; 2036 2037 assert( type==0 || pTab!=0 ); 2038 assert( type==NC_IsCheck || type==NC_PartIdx || type==NC_IdxExpr 2039 || type==NC_GenCol || pTab==0 ); 2040 memset(&sNC, 0, sizeof(sNC)); 2041 memset(&sSrc, 0, sizeof(sSrc)); 2042 if( pTab ){ 2043 sSrc.nSrc = 1; 2044 sSrc.a[0].zName = pTab->zName; 2045 sSrc.a[0].pTab = pTab; 2046 sSrc.a[0].iCursor = -1; 2047 if( pTab->pSchema!=pParse->db->aDb[1].pSchema ){ 2048 /* Cause EP_FromDDL to be set on TK_FUNCTION nodes of non-TEMP 2049 ** schema elements */ 2050 type |= NC_FromDDL; 2051 } 2052 } 2053 sNC.pParse = pParse; 2054 sNC.pSrcList = &sSrc; 2055 sNC.ncFlags = type | NC_IsDDL; 2056 if( (rc = sqlite3ResolveExprNames(&sNC, pExpr))!=SQLITE_OK ) return rc; 2057 if( pList ) rc = sqlite3ResolveExprListNames(&sNC, pList); 2058 return rc; 2059 } 2060