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