| OLD | NEW |
|---|
| (Empty) |
| 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 #include <stdlib.h> | |
| 19 #include <string.h> | |
| 20 | |
| 21 /* | |
| 22 ** Walk the expression tree pExpr and increase the aggregate function | |
| 23 ** depth (the Expr.op2 field) by N on every TK_AGG_FUNCTION node. | |
| 24 ** This needs to occur when copying a TK_AGG_FUNCTION node from an | |
| 25 ** outer query into an inner subquery. | |
| 26 ** | |
| 27 ** incrAggFunctionDepth(pExpr,n) is the main routine. incrAggDepth(..) | |
| 28 ** is a helper function - a callback for the tree walker. | |
| 29 */ | |
| 30 static int incrAggDepth(Walker *pWalker, Expr *pExpr){ | |
| 31 if( pExpr->op==TK_AGG_FUNCTION ) pExpr->op2 += pWalker->u.i; | |
| 32 return WRC_Continue; | |
| 33 } | |
| 34 static void incrAggFunctionDepth(Expr *pExpr, int N){ | |
| 35 if( N>0 ){ | |
| 36 Walker w; | |
| 37 memset(&w, 0, sizeof(w)); | |
| 38 w.xExprCallback = incrAggDepth; | |
| 39 w.u.i = N; | |
| 40 sqlite3WalkExpr(&w, pExpr); | |
| 41 } | |
| 42 } | |
| 43 | |
| 44 /* | |
| 45 ** Turn the pExpr expression into an alias for the iCol-th column of the | |
| 46 ** result set in pEList. | |
| 47 ** | |
| 48 ** If the result set column is a simple column reference, then this routine | |
| 49 ** makes an exact copy. But for any other kind of expression, this | |
| 50 ** routine make a copy of the result set column as the argument to the | |
| 51 ** TK_AS operator. The TK_AS operator causes the expression to be | |
| 52 ** evaluated just once and then reused for each alias. | |
| 53 ** | |
| 54 ** The reason for suppressing the TK_AS term when the expression is a simple | |
| 55 ** column reference is so that the column reference will be recognized as | |
| 56 ** usable by indices within the WHERE clause processing logic. | |
| 57 ** | |
| 58 ** The TK_AS operator is inhibited if zType[0]=='G'. This means | |
| 59 ** that in a GROUP BY clause, the expression is evaluated twice. Hence: | |
| 60 ** | |
| 61 ** SELECT random()%5 AS x, count(*) FROM tab GROUP BY x | |
| 62 ** | |
| 63 ** Is equivalent to: | |
| 64 ** | |
| 65 ** SELECT random()%5 AS x, count(*) FROM tab GROUP BY random()%5 | |
| 66 ** | |
| 67 ** The result of random()%5 in the GROUP BY clause is probably different | |
| 68 ** from the result in the result-set. On the other hand Standard SQL does | |
| 69 ** not allow the GROUP BY clause to contain references to result-set columns. | |
| 70 ** So this should never come up in well-formed queries. | |
| 71 ** | |
| 72 ** If the reference is followed by a COLLATE operator, then make sure | |
| 73 ** the COLLATE operator is preserved. For example: | |
| 74 ** | |
| 75 ** SELECT a+b, c+d FROM t1 ORDER BY 1 COLLATE nocase; | |
| 76 ** | |
| 77 ** Should be transformed into: | |
| 78 ** | |
| 79 ** SELECT a+b, c+d FROM t1 ORDER BY (a+b) COLLATE nocase; | |
| 80 ** | |
| 81 ** The nSubquery parameter specifies how many levels of subquery the | |
| 82 ** alias is removed from the original expression. The usually value is | |
| 83 ** zero but it might be more if the alias is contained within a subquery | |
| 84 ** of the original expression. The Expr.op2 field of TK_AGG_FUNCTION | |
| 85 ** structures must be increased by the nSubquery amount. | |
| 86 */ | |
| 87 static void resolveAlias( | |
| 88 Parse *pParse, /* Parsing context */ | |
| 89 ExprList *pEList, /* A result set */ | |
| 90 int iCol, /* A column in the result set. 0..pEList->nExpr-1 */ | |
| 91 Expr *pExpr, /* Transform this into an alias to the result set */ | |
| 92 const char *zType, /* "GROUP" or "ORDER" or "" */ | |
| 93 int nSubquery /* Number of subqueries that the label is moving */ | |
| 94 ){ | |
| 95 Expr *pOrig; /* The iCol-th column of the result set */ | |
| 96 Expr *pDup; /* Copy of pOrig */ | |
| 97 sqlite3 *db; /* The database connection */ | |
| 98 | |
| 99 assert( iCol>=0 && iCol<pEList->nExpr ); | |
| 100 pOrig = pEList->a[iCol].pExpr; | |
| 101 assert( pOrig!=0 ); | |
| 102 assert( pOrig->flags & EP_Resolved ); | |
| 103 db = pParse->db; | |
| 104 pDup = sqlite3ExprDup(db, pOrig, 0); | |
| 105 if( pDup==0 ) return; | |
| 106 if( pOrig->op!=TK_COLUMN && zType[0]!='G' ){ | |
| 107 incrAggFunctionDepth(pDup, nSubquery); | |
| 108 pDup = sqlite3PExpr(pParse, TK_AS, pDup, 0, 0); | |
| 109 if( pDup==0 ) return; | |
| 110 ExprSetProperty(pDup, EP_Skip); | |
| 111 if( pEList->a[iCol].u.x.iAlias==0 ){ | |
| 112 pEList->a[iCol].u.x.iAlias = (u16)(++pParse->nAlias); | |
| 113 } | |
| 114 pDup->iTable = pEList->a[iCol].u.x.iAlias; | |
| 115 } | |
| 116 if( pExpr->op==TK_COLLATE ){ | |
| 117 pDup = sqlite3ExprAddCollateString(pParse, pDup, pExpr->u.zToken); | |
| 118 } | |
| 119 | |
| 120 /* Before calling sqlite3ExprDelete(), set the EP_Static flag. This | |
| 121 ** prevents ExprDelete() from deleting the Expr structure itself, | |
| 122 ** allowing it to be repopulated by the memcpy() on the following line. | |
| 123 ** The pExpr->u.zToken might point into memory that will be freed by the | |
| 124 ** sqlite3DbFree(db, pDup) on the last line of this block, so be sure to | |
| 125 ** make a copy of the token before doing the sqlite3DbFree(). | |
| 126 */ | |
| 127 ExprSetProperty(pExpr, EP_Static); | |
| 128 sqlite3ExprDelete(db, pExpr); | |
| 129 memcpy(pExpr, pDup, sizeof(*pExpr)); | |
| 130 if( !ExprHasProperty(pExpr, EP_IntValue) && pExpr->u.zToken!=0 ){ | |
| 131 assert( (pExpr->flags & (EP_Reduced|EP_TokenOnly))==0 ); | |
| 132 pExpr->u.zToken = sqlite3DbStrDup(db, pExpr->u.zToken); | |
| 133 pExpr->flags |= EP_MemToken; | |
| 134 } | |
| 135 sqlite3DbFree(db, pDup); | |
| 136 } | |
| 137 | |
| 138 | |
| 139 /* | |
| 140 ** Return TRUE if the name zCol occurs anywhere in the USING clause. | |
| 141 ** | |
| 142 ** Return FALSE if the USING clause is NULL or if it does not contain | |
| 143 ** zCol. | |
| 144 */ | |
| 145 static int nameInUsingClause(IdList *pUsing, const char *zCol){ | |
| 146 if( pUsing ){ | |
| 147 int k; | |
| 148 for(k=0; k<pUsing->nId; k++){ | |
| 149 if( sqlite3StrICmp(pUsing->a[k].zName, zCol)==0 ) return 1; | |
| 150 } | |
| 151 } | |
| 152 return 0; | |
| 153 } | |
| 154 | |
| 155 /* | |
| 156 ** Subqueries stores the original database, table and column names for their | |
| 157 ** result sets in ExprList.a[].zSpan, in the form "DATABASE.TABLE.COLUMN". | |
| 158 ** Check to see if the zSpan given to this routine matches the zDb, zTab, | |
| 159 ** and zCol. If any of zDb, zTab, and zCol are NULL then those fields will | |
| 160 ** match anything. | |
| 161 */ | |
| 162 int sqlite3MatchSpanName( | |
| 163 const char *zSpan, | |
| 164 const char *zCol, | |
| 165 const char *zTab, | |
| 166 const char *zDb | |
| 167 ){ | |
| 168 int n; | |
| 169 for(n=0; ALWAYS(zSpan[n]) && zSpan[n]!='.'; n++){} | |
| 170 if( zDb && (sqlite3StrNICmp(zSpan, zDb, n)!=0 || zDb[n]!=0) ){ | |
| 171 return 0; | |
| 172 } | |
| 173 zSpan += n+1; | |
| 174 for(n=0; ALWAYS(zSpan[n]) && zSpan[n]!='.'; n++){} | |
| 175 if( zTab && (sqlite3StrNICmp(zSpan, zTab, n)!=0 || zTab[n]!=0) ){ | |
| 176 return 0; | |
| 177 } | |
| 178 zSpan += n+1; | |
| 179 if( zCol && sqlite3StrICmp(zSpan, zCol)!=0 ){ | |
| 180 return 0; | |
| 181 } | |
| 182 return 1; | |
| 183 } | |
| 184 | |
| 185 /* | |
| 186 ** Given the name of a column of the form X.Y.Z or Y.Z or just Z, look up | |
| 187 ** that name in the set of source tables in pSrcList and make the pExpr | |
| 188 ** expression node refer back to that source column. The following changes | |
| 189 ** are made to pExpr: | |
| 190 ** | |
| 191 ** pExpr->iDb Set the index in db->aDb[] of the database X | |
| 192 ** (even if X is implied). | |
| 193 ** pExpr->iTable Set to the cursor number for the table obtained | |
| 194 ** from pSrcList. | |
| 195 ** pExpr->pTab Points to the Table structure of X.Y (even if | |
| 196 ** X and/or Y are implied.) | |
| 197 ** pExpr->iColumn Set to the column number within the table. | |
| 198 ** pExpr->op Set to TK_COLUMN. | |
| 199 ** pExpr->pLeft Any expression this points to is deleted | |
| 200 ** pExpr->pRight Any expression this points to is deleted. | |
| 201 ** | |
| 202 ** The zDb variable is the name of the database (the "X"). This value may be | |
| 203 ** NULL meaning that name is of the form Y.Z or Z. Any available database | |
| 204 ** can be used. The zTable variable is the name of the table (the "Y"). This | |
| 205 ** value can be NULL if zDb is also NULL. If zTable is NULL it | |
| 206 ** means that the form of the name is Z and that columns from any table | |
| 207 ** can be used. | |
| 208 ** | |
| 209 ** If the name cannot be resolved unambiguously, leave an error message | |
| 210 ** in pParse and return WRC_Abort. Return WRC_Prune on success. | |
| 211 */ | |
| 212 static int lookupName( | |
| 213 Parse *pParse, /* The parsing context */ | |
| 214 const char *zDb, /* Name of the database containing table, or NULL */ | |
| 215 const char *zTab, /* Name of table containing column, or NULL */ | |
| 216 const char *zCol, /* Name of the column. */ | |
| 217 NameContext *pNC, /* The name context used to resolve the name */ | |
| 218 Expr *pExpr /* Make this EXPR node point to the selected column */ | |
| 219 ){ | |
| 220 int i, j; /* Loop counters */ | |
| 221 int cnt = 0; /* Number of matching column names */ | |
| 222 int cntTab = 0; /* Number of matching table names */ | |
| 223 int nSubquery = 0; /* How many levels of subquery */ | |
| 224 sqlite3 *db = pParse->db; /* The database connection */ | |
| 225 struct SrcList_item *pItem; /* Use for looping over pSrcList items */ | |
| 226 struct SrcList_item *pMatch = 0; /* The matching pSrcList item */ | |
| 227 NameContext *pTopNC = pNC; /* First namecontext in the list */ | |
| 228 Schema *pSchema = 0; /* Schema of the expression */ | |
| 229 int isTrigger = 0; /* True if resolved to a trigger column */ | |
| 230 Table *pTab = 0; /* Table hold the row */ | |
| 231 Column *pCol; /* A column of pTab */ | |
| 232 | |
| 233 assert( pNC ); /* the name context cannot be NULL. */ | |
| 234 assert( zCol ); /* The Z in X.Y.Z cannot be NULL */ | |
| 235 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) ); | |
| 236 | |
| 237 /* Initialize the node to no-match */ | |
| 238 pExpr->iTable = -1; | |
| 239 pExpr->pTab = 0; | |
| 240 ExprSetVVAProperty(pExpr, EP_NoReduce); | |
| 241 | |
| 242 /* Translate the schema name in zDb into a pointer to the corresponding | |
| 243 ** schema. If not found, pSchema will remain NULL and nothing will match | |
| 244 ** resulting in an appropriate error message toward the end of this routine | |
| 245 */ | |
| 246 if( zDb ){ | |
| 247 testcase( pNC->ncFlags & NC_PartIdx ); | |
| 248 testcase( pNC->ncFlags & NC_IsCheck ); | |
| 249 if( (pNC->ncFlags & (NC_PartIdx|NC_IsCheck))!=0 ){ | |
| 250 /* Silently ignore database qualifiers inside CHECK constraints and partia
l | |
| 251 ** indices. Do not raise errors because that might break legacy and | |
| 252 ** because it does not hurt anything to just ignore the database name. */ | |
| 253 zDb = 0; | |
| 254 }else{ | |
| 255 for(i=0; i<db->nDb; i++){ | |
| 256 assert( db->aDb[i].zName ); | |
| 257 if( sqlite3StrICmp(db->aDb[i].zName,zDb)==0 ){ | |
| 258 pSchema = db->aDb[i].pSchema; | |
| 259 break; | |
| 260 } | |
| 261 } | |
| 262 } | |
| 263 } | |
| 264 | |
| 265 /* Start at the inner-most context and move outward until a match is found */ | |
| 266 while( pNC && cnt==0 ){ | |
| 267 ExprList *pEList; | |
| 268 SrcList *pSrcList = pNC->pSrcList; | |
| 269 | |
| 270 if( pSrcList ){ | |
| 271 for(i=0, pItem=pSrcList->a; i<pSrcList->nSrc; i++, pItem++){ | |
| 272 pTab = pItem->pTab; | |
| 273 assert( pTab!=0 && pTab->zName!=0 ); | |
| 274 assert( pTab->nCol>0 ); | |
| 275 if( pItem->pSelect && (pItem->pSelect->selFlags & SF_NestedFrom)!=0 ){ | |
| 276 int hit = 0; | |
| 277 pEList = pItem->pSelect->pEList; | |
| 278 for(j=0; j<pEList->nExpr; j++){ | |
| 279 if( sqlite3MatchSpanName(pEList->a[j].zSpan, zCol, zTab, zDb) ){ | |
| 280 cnt++; | |
| 281 cntTab = 2; | |
| 282 pMatch = pItem; | |
| 283 pExpr->iColumn = j; | |
| 284 hit = 1; | |
| 285 } | |
| 286 } | |
| 287 if( hit || zTab==0 ) continue; | |
| 288 } | |
| 289 if( zDb && pTab->pSchema!=pSchema ){ | |
| 290 continue; | |
| 291 } | |
| 292 if( zTab ){ | |
| 293 const char *zTabName = pItem->zAlias ? pItem->zAlias : pTab->zName; | |
| 294 assert( zTabName!=0 ); | |
| 295 if( sqlite3StrICmp(zTabName, zTab)!=0 ){ | |
| 296 continue; | |
| 297 } | |
| 298 } | |
| 299 if( 0==(cntTab++) ){ | |
| 300 pMatch = pItem; | |
| 301 } | |
| 302 for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){ | |
| 303 if( sqlite3StrICmp(pCol->zName, zCol)==0 ){ | |
| 304 /* If there has been exactly one prior match and this match | |
| 305 ** is for the right-hand table of a NATURAL JOIN or is in a | |
| 306 ** USING clause, then skip this match. | |
| 307 */ | |
| 308 if( cnt==1 ){ | |
| 309 if( pItem->jointype & JT_NATURAL ) continue; | |
| 310 if( nameInUsingClause(pItem->pUsing, zCol) ) continue; | |
| 311 } | |
| 312 cnt++; | |
| 313 pMatch = pItem; | |
| 314 /* Substitute the rowid (column -1) for the INTEGER PRIMARY KEY */ | |
| 315 pExpr->iColumn = j==pTab->iPKey ? -1 : (i16)j; | |
| 316 break; | |
| 317 } | |
| 318 } | |
| 319 } | |
| 320 if( pMatch ){ | |
| 321 pExpr->iTable = pMatch->iCursor; | |
| 322 pExpr->pTab = pMatch->pTab; | |
| 323 assert( (pMatch->jointype & JT_RIGHT)==0 ); /* RIGHT JOIN not (yet) supp
orted */ | |
| 324 if( (pMatch->jointype & JT_LEFT)!=0 ){ | |
| 325 ExprSetProperty(pExpr, EP_CanBeNull); | |
| 326 } | |
| 327 pSchema = pExpr->pTab->pSchema; | |
| 328 } | |
| 329 } /* if( pSrcList ) */ | |
| 330 | |
| 331 #ifndef SQLITE_OMIT_TRIGGER | |
| 332 /* If we have not already resolved the name, then maybe | |
| 333 ** it is a new.* or old.* trigger argument reference | |
| 334 */ | |
| 335 if( zDb==0 && zTab!=0 && cntTab==0 && pParse->pTriggerTab!=0 ){ | |
| 336 int op = pParse->eTriggerOp; | |
| 337 assert( op==TK_DELETE || op==TK_UPDATE || op==TK_INSERT ); | |
| 338 if( op!=TK_DELETE && sqlite3StrICmp("new",zTab) == 0 ){ | |
| 339 pExpr->iTable = 1; | |
| 340 pTab = pParse->pTriggerTab; | |
| 341 }else if( op!=TK_INSERT && sqlite3StrICmp("old",zTab)==0 ){ | |
| 342 pExpr->iTable = 0; | |
| 343 pTab = pParse->pTriggerTab; | |
| 344 }else{ | |
| 345 pTab = 0; | |
| 346 } | |
| 347 | |
| 348 if( pTab ){ | |
| 349 int iCol; | |
| 350 pSchema = pTab->pSchema; | |
| 351 cntTab++; | |
| 352 for(iCol=0, pCol=pTab->aCol; iCol<pTab->nCol; iCol++, pCol++){ | |
| 353 if( sqlite3StrICmp(pCol->zName, zCol)==0 ){ | |
| 354 if( iCol==pTab->iPKey ){ | |
| 355 iCol = -1; | |
| 356 } | |
| 357 break; | |
| 358 } | |
| 359 } | |
| 360 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && HasRowid(pTab) ){ | |
| 361 /* IMP: R-51414-32910 */ | |
| 362 /* IMP: R-44911-55124 */ | |
| 363 iCol = -1; | |
| 364 } | |
| 365 if( iCol<pTab->nCol ){ | |
| 366 cnt++; | |
| 367 if( iCol<0 ){ | |
| 368 pExpr->affinity = SQLITE_AFF_INTEGER; | |
| 369 }else if( pExpr->iTable==0 ){ | |
| 370 testcase( iCol==31 ); | |
| 371 testcase( iCol==32 ); | |
| 372 pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol)); | |
| 373 }else{ | |
| 374 testcase( iCol==31 ); | |
| 375 testcase( iCol==32 ); | |
| 376 pParse->newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol)); | |
| 377 } | |
| 378 pExpr->iColumn = (i16)iCol; | |
| 379 pExpr->pTab = pTab; | |
| 380 isTrigger = 1; | |
| 381 } | |
| 382 } | |
| 383 } | |
| 384 #endif /* !defined(SQLITE_OMIT_TRIGGER) */ | |
| 385 | |
| 386 /* | |
| 387 ** Perhaps the name is a reference to the ROWID | |
| 388 */ | |
| 389 if( cnt==0 && cntTab==1 && pMatch && sqlite3IsRowid(zCol) | |
| 390 && HasRowid(pMatch->pTab) ){ | |
| 391 cnt = 1; | |
| 392 pExpr->iColumn = -1; /* IMP: R-44911-55124 */ | |
| 393 pExpr->affinity = SQLITE_AFF_INTEGER; | |
| 394 } | |
| 395 | |
| 396 /* | |
| 397 ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z | |
| 398 ** might refer to an result-set alias. This happens, for example, when | |
| 399 ** we are resolving names in the WHERE clause of the following command: | |
| 400 ** | |
| 401 ** SELECT a+b AS x FROM table WHERE x<10; | |
| 402 ** | |
| 403 ** In cases like this, replace pExpr with a copy of the expression that | |
| 404 ** forms the result set entry ("a+b" in the example) and return immediately. | |
| 405 ** Note that the expression in the result set should have already been | |
| 406 ** resolved by the time the WHERE clause is resolved. | |
| 407 ** | |
| 408 ** The ability to use an output result-set column in the WHERE, GROUP BY, | |
| 409 ** or HAVING clauses, or as part of a larger expression in the ORDRE BY | |
| 410 ** clause is not standard SQL. This is a (goofy) SQLite extension, that | |
| 411 ** is supported for backwards compatibility only. TO DO: Issue a warning | |
| 412 ** on sqlite3_log() whenever the capability is used. | |
| 413 */ | |
| 414 if( (pEList = pNC->pEList)!=0 | |
| 415 && zTab==0 | |
| 416 && cnt==0 | |
| 417 ){ | |
| 418 for(j=0; j<pEList->nExpr; j++){ | |
| 419 char *zAs = pEList->a[j].zName; | |
| 420 if( zAs!=0 && sqlite3StrICmp(zAs, zCol)==0 ){ | |
| 421 Expr *pOrig; | |
| 422 assert( pExpr->pLeft==0 && pExpr->pRight==0 ); | |
| 423 assert( pExpr->x.pList==0 ); | |
| 424 assert( pExpr->x.pSelect==0 ); | |
| 425 pOrig = pEList->a[j].pExpr; | |
| 426 if( (pNC->ncFlags&NC_AllowAgg)==0 && ExprHasProperty(pOrig, EP_Agg) ){ | |
| 427 sqlite3ErrorMsg(pParse, "misuse of aliased aggregate %s", zAs); | |
| 428 return WRC_Abort; | |
| 429 } | |
| 430 resolveAlias(pParse, pEList, j, pExpr, "", nSubquery); | |
| 431 cnt = 1; | |
| 432 pMatch = 0; | |
| 433 assert( zTab==0 && zDb==0 ); | |
| 434 goto lookupname_end; | |
| 435 } | |
| 436 } | |
| 437 } | |
| 438 | |
| 439 /* Advance to the next name context. The loop will exit when either | |
| 440 ** we have a match (cnt>0) or when we run out of name contexts. | |
| 441 */ | |
| 442 if( cnt==0 ){ | |
| 443 pNC = pNC->pNext; | |
| 444 nSubquery++; | |
| 445 } | |
| 446 } | |
| 447 | |
| 448 /* | |
| 449 ** If X and Y are NULL (in other words if only the column name Z is | |
| 450 ** supplied) and the value of Z is enclosed in double-quotes, then | |
| 451 ** Z is a string literal if it doesn't match any column names. In that | |
| 452 ** case, we need to return right away and not make any changes to | |
| 453 ** pExpr. | |
| 454 ** | |
| 455 ** Because no reference was made to outer contexts, the pNC->nRef | |
| 456 ** fields are not changed in any context. | |
| 457 */ | |
| 458 if( cnt==0 && zTab==0 && ExprHasProperty(pExpr,EP_DblQuoted) ){ | |
| 459 pExpr->op = TK_STRING; | |
| 460 pExpr->pTab = 0; | |
| 461 return WRC_Prune; | |
| 462 } | |
| 463 | |
| 464 /* | |
| 465 ** cnt==0 means there was not match. cnt>1 means there were two or | |
| 466 ** more matches. Either way, we have an error. | |
| 467 */ | |
| 468 if( cnt!=1 ){ | |
| 469 const char *zErr; | |
| 470 zErr = cnt==0 ? "no such column" : "ambiguous column name"; | |
| 471 if( zDb ){ | |
| 472 sqlite3ErrorMsg(pParse, "%s: %s.%s.%s", zErr, zDb, zTab, zCol); | |
| 473 }else if( zTab ){ | |
| 474 sqlite3ErrorMsg(pParse, "%s: %s.%s", zErr, zTab, zCol); | |
| 475 }else{ | |
| 476 sqlite3ErrorMsg(pParse, "%s: %s", zErr, zCol); | |
| 477 } | |
| 478 pParse->checkSchema = 1; | |
| 479 pTopNC->nErr++; | |
| 480 } | |
| 481 | |
| 482 /* If a column from a table in pSrcList is referenced, then record | |
| 483 ** this fact in the pSrcList.a[].colUsed bitmask. Column 0 causes | |
| 484 ** bit 0 to be set. Column 1 sets bit 1. And so forth. If the | |
| 485 ** column number is greater than the number of bits in the bitmask | |
| 486 ** then set the high-order bit of the bitmask. | |
| 487 */ | |
| 488 if( pExpr->iColumn>=0 && pMatch!=0 ){ | |
| 489 int n = pExpr->iColumn; | |
| 490 testcase( n==BMS-1 ); | |
| 491 if( n>=BMS ){ | |
| 492 n = BMS-1; | |
| 493 } | |
| 494 assert( pMatch->iCursor==pExpr->iTable ); | |
| 495 pMatch->colUsed |= ((Bitmask)1)<<n; | |
| 496 } | |
| 497 | |
| 498 /* Clean up and return | |
| 499 */ | |
| 500 sqlite3ExprDelete(db, pExpr->pLeft); | |
| 501 pExpr->pLeft = 0; | |
| 502 sqlite3ExprDelete(db, pExpr->pRight); | |
| 503 pExpr->pRight = 0; | |
| 504 pExpr->op = (isTrigger ? TK_TRIGGER : TK_COLUMN); | |
| 505 lookupname_end: | |
| 506 if( cnt==1 ){ | |
| 507 assert( pNC!=0 ); | |
| 508 if( pExpr->op!=TK_AS ){ | |
| 509 sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList); | |
| 510 } | |
| 511 /* Increment the nRef value on all name contexts from TopNC up to | |
| 512 ** the point where the name matched. */ | |
| 513 for(;;){ | |
| 514 assert( pTopNC!=0 ); | |
| 515 pTopNC->nRef++; | |
| 516 if( pTopNC==pNC ) break; | |
| 517 pTopNC = pTopNC->pNext; | |
| 518 } | |
| 519 return WRC_Prune; | |
| 520 } else { | |
| 521 return WRC_Abort; | |
| 522 } | |
| 523 } | |
| 524 | |
| 525 /* | |
| 526 ** Allocate and return a pointer to an expression to load the column iCol | |
| 527 ** from datasource iSrc in SrcList pSrc. | |
| 528 */ | |
| 529 Expr *sqlite3CreateColumnExpr(sqlite3 *db, SrcList *pSrc, int iSrc, int iCol){ | |
| 530 Expr *p = sqlite3ExprAlloc(db, TK_COLUMN, 0, 0); | |
| 531 if( p ){ | |
| 532 struct SrcList_item *pItem = &pSrc->a[iSrc]; | |
| 533 p->pTab = pItem->pTab; | |
| 534 p->iTable = pItem->iCursor; | |
| 535 if( p->pTab->iPKey==iCol ){ | |
| 536 p->iColumn = -1; | |
| 537 }else{ | |
| 538 p->iColumn = (ynVar)iCol; | |
| 539 testcase( iCol==BMS ); | |
| 540 testcase( iCol==BMS-1 ); | |
| 541 pItem->colUsed |= ((Bitmask)1)<<(iCol>=BMS ? BMS-1 : iCol); | |
| 542 } | |
| 543 ExprSetProperty(p, EP_Resolved); | |
| 544 } | |
| 545 return p; | |
| 546 } | |
| 547 | |
| 548 /* | |
| 549 ** Report an error that an expression is not valid for a partial index WHERE | |
| 550 ** clause. | |
| 551 */ | |
| 552 static void notValidPartIdxWhere( | |
| 553 Parse *pParse, /* Leave error message here */ | |
| 554 NameContext *pNC, /* The name context */ | |
| 555 const char *zMsg /* Type of error */ | |
| 556 ){ | |
| 557 if( (pNC->ncFlags & NC_PartIdx)!=0 ){ | |
| 558 sqlite3ErrorMsg(pParse, "%s prohibited in partial index WHERE clauses", | |
| 559 zMsg); | |
| 560 } | |
| 561 } | |
| 562 | |
| 563 #ifndef SQLITE_OMIT_CHECK | |
| 564 /* | |
| 565 ** Report an error that an expression is not valid for a CHECK constraint. | |
| 566 */ | |
| 567 static void notValidCheckConstraint( | |
| 568 Parse *pParse, /* Leave error message here */ | |
| 569 NameContext *pNC, /* The name context */ | |
| 570 const char *zMsg /* Type of error */ | |
| 571 ){ | |
| 572 if( (pNC->ncFlags & NC_IsCheck)!=0 ){ | |
| 573 sqlite3ErrorMsg(pParse,"%s prohibited in CHECK constraints", zMsg); | |
| 574 } | |
| 575 } | |
| 576 #else | |
| 577 # define notValidCheckConstraint(P,N,M) | |
| 578 #endif | |
| 579 | |
| 580 /* | |
| 581 ** Expression p should encode a floating point value between 1.0 and 0.0. | |
| 582 ** Return 1024 times this value. Or return -1 if p is not a floating point | |
| 583 ** value between 1.0 and 0.0. | |
| 584 */ | |
| 585 static int exprProbability(Expr *p){ | |
| 586 double r = -1.0; | |
| 587 if( p->op!=TK_FLOAT ) return -1; | |
| 588 sqlite3AtoF(p->u.zToken, &r, sqlite3Strlen30(p->u.zToken), SQLITE_UTF8); | |
| 589 assert( r>=0.0 ); | |
| 590 if( r>1.0 ) return -1; | |
| 591 return (int)(r*1000.0); | |
| 592 } | |
| 593 | |
| 594 /* | |
| 595 ** This routine is callback for sqlite3WalkExpr(). | |
| 596 ** | |
| 597 ** Resolve symbolic names into TK_COLUMN operators for the current | |
| 598 ** node in the expression tree. Return 0 to continue the search down | |
| 599 ** the tree or 2 to abort the tree walk. | |
| 600 ** | |
| 601 ** This routine also does error checking and name resolution for | |
| 602 ** function names. The operator for aggregate functions is changed | |
| 603 ** to TK_AGG_FUNCTION. | |
| 604 */ | |
| 605 static int resolveExprStep(Walker *pWalker, Expr *pExpr){ | |
| 606 NameContext *pNC; | |
| 607 Parse *pParse; | |
| 608 | |
| 609 pNC = pWalker->u.pNC; | |
| 610 assert( pNC!=0 ); | |
| 611 pParse = pNC->pParse; | |
| 612 assert( pParse==pWalker->pParse ); | |
| 613 | |
| 614 if( ExprHasProperty(pExpr, EP_Resolved) ) return WRC_Prune; | |
| 615 ExprSetProperty(pExpr, EP_Resolved); | |
| 616 #ifndef NDEBUG | |
| 617 if( pNC->pSrcList && pNC->pSrcList->nAlloc>0 ){ | |
| 618 SrcList *pSrcList = pNC->pSrcList; | |
| 619 int i; | |
| 620 for(i=0; i<pNC->pSrcList->nSrc; i++){ | |
| 621 assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursor<pParse->nTab); | |
| 622 } | |
| 623 } | |
| 624 #endif | |
| 625 switch( pExpr->op ){ | |
| 626 | |
| 627 #if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY) | |
| 628 /* The special operator TK_ROW means use the rowid for the first | |
| 629 ** column in the FROM clause. This is used by the LIMIT and ORDER BY | |
| 630 ** clause processing on UPDATE and DELETE statements. | |
| 631 */ | |
| 632 case TK_ROW: { | |
| 633 SrcList *pSrcList = pNC->pSrcList; | |
| 634 struct SrcList_item *pItem; | |
| 635 assert( pSrcList && pSrcList->nSrc==1 ); | |
| 636 pItem = pSrcList->a; | |
| 637 pExpr->op = TK_COLUMN; | |
| 638 pExpr->pTab = pItem->pTab; | |
| 639 pExpr->iTable = pItem->iCursor; | |
| 640 pExpr->iColumn = -1; | |
| 641 pExpr->affinity = SQLITE_AFF_INTEGER; | |
| 642 break; | |
| 643 } | |
| 644 #endif /* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUB
QUERY) */ | |
| 645 | |
| 646 /* A lone identifier is the name of a column. | |
| 647 */ | |
| 648 case TK_ID: { | |
| 649 return lookupName(pParse, 0, 0, pExpr->u.zToken, pNC, pExpr); | |
| 650 } | |
| 651 | |
| 652 /* A table name and column name: ID.ID | |
| 653 ** Or a database, table and column: ID.ID.ID | |
| 654 */ | |
| 655 case TK_DOT: { | |
| 656 const char *zColumn; | |
| 657 const char *zTable; | |
| 658 const char *zDb; | |
| 659 Expr *pRight; | |
| 660 | |
| 661 /* if( pSrcList==0 ) break; */ | |
| 662 pRight = pExpr->pRight; | |
| 663 if( pRight->op==TK_ID ){ | |
| 664 zDb = 0; | |
| 665 zTable = pExpr->pLeft->u.zToken; | |
| 666 zColumn = pRight->u.zToken; | |
| 667 }else{ | |
| 668 assert( pRight->op==TK_DOT ); | |
| 669 zDb = pExpr->pLeft->u.zToken; | |
| 670 zTable = pRight->pLeft->u.zToken; | |
| 671 zColumn = pRight->pRight->u.zToken; | |
| 672 } | |
| 673 return lookupName(pParse, zDb, zTable, zColumn, pNC, pExpr); | |
| 674 } | |
| 675 | |
| 676 /* Resolve function names | |
| 677 */ | |
| 678 case TK_FUNCTION: { | |
| 679 ExprList *pList = pExpr->x.pList; /* The argument list */ | |
| 680 int n = pList ? pList->nExpr : 0; /* Number of arguments */ | |
| 681 int no_such_func = 0; /* True if no such function exists */ | |
| 682 int wrong_num_args = 0; /* True if wrong number of arguments */ | |
| 683 int is_agg = 0; /* True if is an aggregate function */ | |
| 684 int auth; /* Authorization to use the function */ | |
| 685 int nId; /* Number of characters in function name */ | |
| 686 const char *zId; /* The function name. */ | |
| 687 FuncDef *pDef; /* Information about the function */ | |
| 688 u8 enc = ENC(pParse->db); /* The database encoding */ | |
| 689 | |
| 690 assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); | |
| 691 notValidPartIdxWhere(pParse, pNC, "functions"); | |
| 692 zId = pExpr->u.zToken; | |
| 693 nId = sqlite3Strlen30(zId); | |
| 694 pDef = sqlite3FindFunction(pParse->db, zId, nId, n, enc, 0); | |
| 695 if( pDef==0 ){ | |
| 696 pDef = sqlite3FindFunction(pParse->db, zId, nId, -2, enc, 0); | |
| 697 if( pDef==0 ){ | |
| 698 no_such_func = 1; | |
| 699 }else{ | |
| 700 wrong_num_args = 1; | |
| 701 } | |
| 702 }else{ | |
| 703 is_agg = pDef->xFunc==0; | |
| 704 if( pDef->funcFlags & SQLITE_FUNC_UNLIKELY ){ | |
| 705 ExprSetProperty(pExpr, EP_Unlikely|EP_Skip); | |
| 706 if( n==2 ){ | |
| 707 pExpr->iTable = exprProbability(pList->a[1].pExpr); | |
| 708 if( pExpr->iTable<0 ){ | |
| 709 sqlite3ErrorMsg(pParse, "second argument to likelihood() must be a
" | |
| 710 "constant between 0.0 and 1.0"); | |
| 711 pNC->nErr++; | |
| 712 } | |
| 713 }else{ | |
| 714 /* EVIDENCE-OF: R-61304-29449 The unlikely(X) function is equivalent
to | |
| 715 ** likelihood(X, 0.0625). | |
| 716 ** EVIDENCE-OF: R-01283-11636 The unlikely(X) function is short-hand
for | |
| 717 ** likelihood(X,0.0625). | |
| 718 ** EVIDENCE-OF: R-36850-34127 The likely(X) function is short-hand f
or | |
| 719 ** likelihood(X,0.9375). | |
| 720 ** EVIDENCE-OF: R-53436-40973 The likely(X) function is equivalent t
o | |
| 721 ** likelihood(X,0.9375). */ | |
| 722 /* TUNING: unlikely() probability is 0.0625. likely() is 0.9375 */ | |
| 723 pExpr->iTable = pDef->zName[0]=='u' ? 62 : 938; | |
| 724 } | |
| 725 } | |
| 726 #ifndef SQLITE_OMIT_AUTHORIZATION | |
| 727 auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0, pDef->zName, 0); | |
| 728 if( auth!=SQLITE_OK ){ | |
| 729 if( auth==SQLITE_DENY ){ | |
| 730 sqlite3ErrorMsg(pParse, "not authorized to use function: %s", | |
| 731 pDef->zName); | |
| 732 pNC->nErr++; | |
| 733 } | |
| 734 pExpr->op = TK_NULL; | |
| 735 return WRC_Prune; | |
| 736 } | |
| 737 #endif | |
| 738 if( pDef->funcFlags & SQLITE_FUNC_CONSTANT ) ExprSetProperty(pExpr,EP_Co
nstant); | |
| 739 } | |
| 740 if( is_agg && (pNC->ncFlags & NC_AllowAgg)==0 ){ | |
| 741 sqlite3ErrorMsg(pParse, "misuse of aggregate function %.*s()", nId,zId); | |
| 742 pNC->nErr++; | |
| 743 is_agg = 0; | |
| 744 }else if( no_such_func && pParse->db->init.busy==0 ){ | |
| 745 sqlite3ErrorMsg(pParse, "no such function: %.*s", nId, zId); | |
| 746 pNC->nErr++; | |
| 747 }else if( wrong_num_args ){ | |
| 748 sqlite3ErrorMsg(pParse,"wrong number of arguments to function %.*s()", | |
| 749 nId, zId); | |
| 750 pNC->nErr++; | |
| 751 } | |
| 752 if( is_agg ) pNC->ncFlags &= ~NC_AllowAgg; | |
| 753 sqlite3WalkExprList(pWalker, pList); | |
| 754 if( is_agg ){ | |
| 755 NameContext *pNC2 = pNC; | |
| 756 pExpr->op = TK_AGG_FUNCTION; | |
| 757 pExpr->op2 = 0; | |
| 758 while( pNC2 && !sqlite3FunctionUsesThisSrc(pExpr, pNC2->pSrcList) ){ | |
| 759 pExpr->op2++; | |
| 760 pNC2 = pNC2->pNext; | |
| 761 } | |
| 762 assert( pDef!=0 ); | |
| 763 if( pNC2 ){ | |
| 764 assert( SQLITE_FUNC_MINMAX==NC_MinMaxAgg ); | |
| 765 testcase( (pDef->funcFlags & SQLITE_FUNC_MINMAX)!=0 ); | |
| 766 pNC2->ncFlags |= NC_HasAgg | (pDef->funcFlags & SQLITE_FUNC_MINMAX); | |
| 767 | |
| 768 } | |
| 769 pNC->ncFlags |= NC_AllowAgg; | |
| 770 } | |
| 771 /* FIX ME: Compute pExpr->affinity based on the expected return | |
| 772 ** type of the function | |
| 773 */ | |
| 774 return WRC_Prune; | |
| 775 } | |
| 776 #ifndef SQLITE_OMIT_SUBQUERY | |
| 777 case TK_SELECT: | |
| 778 case TK_EXISTS: testcase( pExpr->op==TK_EXISTS ); | |
| 779 #endif | |
| 780 case TK_IN: { | |
| 781 testcase( pExpr->op==TK_IN ); | |
| 782 if( ExprHasProperty(pExpr, EP_xIsSelect) ){ | |
| 783 int nRef = pNC->nRef; | |
| 784 notValidCheckConstraint(pParse, pNC, "subqueries"); | |
| 785 notValidPartIdxWhere(pParse, pNC, "subqueries"); | |
| 786 sqlite3WalkSelect(pWalker, pExpr->x.pSelect); | |
| 787 assert( pNC->nRef>=nRef ); | |
| 788 if( nRef!=pNC->nRef ){ | |
| 789 ExprSetProperty(pExpr, EP_VarSelect); | |
| 790 } | |
| 791 } | |
| 792 break; | |
| 793 } | |
| 794 case TK_VARIABLE: { | |
| 795 notValidCheckConstraint(pParse, pNC, "parameters"); | |
| 796 notValidPartIdxWhere(pParse, pNC, "parameters"); | |
| 797 break; | |
| 798 } | |
| 799 } | |
| 800 return (pParse->nErr || pParse->db->mallocFailed) ? WRC_Abort : WRC_Continue; | |
| 801 } | |
| 802 | |
| 803 /* | |
| 804 ** pEList is a list of expressions which are really the result set of the | |
| 805 ** a SELECT statement. pE is a term in an ORDER BY or GROUP BY clause. | |
| 806 ** This routine checks to see if pE is a simple identifier which corresponds | |
| 807 ** to the AS-name of one of the terms of the expression list. If it is, | |
| 808 ** this routine return an integer between 1 and N where N is the number of | |
| 809 ** elements in pEList, corresponding to the matching entry. If there is | |
| 810 ** no match, or if pE is not a simple identifier, then this routine | |
| 811 ** return 0. | |
| 812 ** | |
| 813 ** pEList has been resolved. pE has not. | |
| 814 */ | |
| 815 static int resolveAsName( | |
| 816 Parse *pParse, /* Parsing context for error messages */ | |
| 817 ExprList *pEList, /* List of expressions to scan */ | |
| 818 Expr *pE /* Expression we are trying to match */ | |
| 819 ){ | |
| 820 int i; /* Loop counter */ | |
| 821 | |
| 822 UNUSED_PARAMETER(pParse); | |
| 823 | |
| 824 if( pE->op==TK_ID ){ | |
| 825 char *zCol = pE->u.zToken; | |
| 826 for(i=0; i<pEList->nExpr; i++){ | |
| 827 char *zAs = pEList->a[i].zName; | |
| 828 if( zAs!=0 && sqlite3StrICmp(zAs, zCol)==0 ){ | |
| 829 return i+1; | |
| 830 } | |
| 831 } | |
| 832 } | |
| 833 return 0; | |
| 834 } | |
| 835 | |
| 836 /* | |
| 837 ** pE is a pointer to an expression which is a single term in the | |
| 838 ** ORDER BY of a compound SELECT. The expression has not been | |
| 839 ** name resolved. | |
| 840 ** | |
| 841 ** At the point this routine is called, we already know that the | |
| 842 ** ORDER BY term is not an integer index into the result set. That | |
| 843 ** case is handled by the calling routine. | |
| 844 ** | |
| 845 ** Attempt to match pE against result set columns in the left-most | |
| 846 ** SELECT statement. Return the index i of the matching column, | |
| 847 ** as an indication to the caller that it should sort by the i-th column. | |
| 848 ** The left-most column is 1. In other words, the value returned is the | |
| 849 ** same integer value that would be used in the SQL statement to indicate | |
| 850 ** the column. | |
| 851 ** | |
| 852 ** If there is no match, return 0. Return -1 if an error occurs. | |
| 853 */ | |
| 854 static int resolveOrderByTermToExprList( | |
| 855 Parse *pParse, /* Parsing context for error messages */ | |
| 856 Select *pSelect, /* The SELECT statement with the ORDER BY clause */ | |
| 857 Expr *pE /* The specific ORDER BY term */ | |
| 858 ){ | |
| 859 int i; /* Loop counter */ | |
| 860 ExprList *pEList; /* The columns of the result set */ | |
| 861 NameContext nc; /* Name context for resolving pE */ | |
| 862 sqlite3 *db; /* Database connection */ | |
| 863 int rc; /* Return code from subprocedures */ | |
| 864 u8 savedSuppErr; /* Saved value of db->suppressErr */ | |
| 865 | |
| 866 assert( sqlite3ExprIsInteger(pE, &i)==0 ); | |
| 867 pEList = pSelect->pEList; | |
| 868 | |
| 869 /* Resolve all names in the ORDER BY term expression | |
| 870 */ | |
| 871 memset(&nc, 0, sizeof(nc)); | |
| 872 nc.pParse = pParse; | |
| 873 nc.pSrcList = pSelect->pSrc; | |
| 874 nc.pEList = pEList; | |
| 875 nc.ncFlags = NC_AllowAgg; | |
| 876 nc.nErr = 0; | |
| 877 db = pParse->db; | |
| 878 savedSuppErr = db->suppressErr; | |
| 879 db->suppressErr = 1; | |
| 880 rc = sqlite3ResolveExprNames(&nc, pE); | |
| 881 db->suppressErr = savedSuppErr; | |
| 882 if( rc ) return 0; | |
| 883 | |
| 884 /* Try to match the ORDER BY expression against an expression | |
| 885 ** in the result set. Return an 1-based index of the matching | |
| 886 ** result-set entry. | |
| 887 */ | |
| 888 for(i=0; i<pEList->nExpr; i++){ | |
| 889 if( sqlite3ExprCompare(pEList->a[i].pExpr, pE, -1)<2 ){ | |
| 890 return i+1; | |
| 891 } | |
| 892 } | |
| 893 | |
| 894 /* If no match, return 0. */ | |
| 895 return 0; | |
| 896 } | |
| 897 | |
| 898 /* | |
| 899 ** Generate an ORDER BY or GROUP BY term out-of-range error. | |
| 900 */ | |
| 901 static void resolveOutOfRangeError( | |
| 902 Parse *pParse, /* The error context into which to write the error */ | |
| 903 const char *zType, /* "ORDER" or "GROUP" */ | |
| 904 int i, /* The index (1-based) of the term out of range */ | |
| 905 int mx /* Largest permissible value of i */ | |
| 906 ){ | |
| 907 sqlite3ErrorMsg(pParse, | |
| 908 "%r %s BY term out of range - should be " | |
| 909 "between 1 and %d", i, zType, mx); | |
| 910 } | |
| 911 | |
| 912 /* | |
| 913 ** Analyze the ORDER BY clause in a compound SELECT statement. Modify | |
| 914 ** each term of the ORDER BY clause is a constant integer between 1 | |
| 915 ** and N where N is the number of columns in the compound SELECT. | |
| 916 ** | |
| 917 ** ORDER BY terms that are already an integer between 1 and N are | |
| 918 ** unmodified. ORDER BY terms that are integers outside the range of | |
| 919 ** 1 through N generate an error. ORDER BY terms that are expressions | |
| 920 ** are matched against result set expressions of compound SELECT | |
| 921 ** beginning with the left-most SELECT and working toward the right. | |
| 922 ** At the first match, the ORDER BY expression is transformed into | |
| 923 ** the integer column number. | |
| 924 ** | |
| 925 ** Return the number of errors seen. | |
| 926 */ | |
| 927 static int resolveCompoundOrderBy( | |
| 928 Parse *pParse, /* Parsing context. Leave error messages here */ | |
| 929 Select *pSelect /* The SELECT statement containing the ORDER BY */ | |
| 930 ){ | |
| 931 int i; | |
| 932 ExprList *pOrderBy; | |
| 933 ExprList *pEList; | |
| 934 sqlite3 *db; | |
| 935 int moreToDo = 1; | |
| 936 | |
| 937 pOrderBy = pSelect->pOrderBy; | |
| 938 if( pOrderBy==0 ) return 0; | |
| 939 db = pParse->db; | |
| 940 #if SQLITE_MAX_COLUMN | |
| 941 if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){ | |
| 942 sqlite3ErrorMsg(pParse, "too many terms in ORDER BY clause"); | |
| 943 return 1; | |
| 944 } | |
| 945 #endif | |
| 946 for(i=0; i<pOrderBy->nExpr; i++){ | |
| 947 pOrderBy->a[i].done = 0; | |
| 948 } | |
| 949 pSelect->pNext = 0; | |
| 950 while( pSelect->pPrior ){ | |
| 951 pSelect->pPrior->pNext = pSelect; | |
| 952 pSelect = pSelect->pPrior; | |
| 953 } | |
| 954 while( pSelect && moreToDo ){ | |
| 955 struct ExprList_item *pItem; | |
| 956 moreToDo = 0; | |
| 957 pEList = pSelect->pEList; | |
| 958 assert( pEList!=0 ); | |
| 959 for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){ | |
| 960 int iCol = -1; | |
| 961 Expr *pE, *pDup; | |
| 962 if( pItem->done ) continue; | |
| 963 pE = sqlite3ExprSkipCollate(pItem->pExpr); | |
| 964 if( sqlite3ExprIsInteger(pE, &iCol) ){ | |
| 965 if( iCol<=0 || iCol>pEList->nExpr ){ | |
| 966 resolveOutOfRangeError(pParse, "ORDER", i+1, pEList->nExpr); | |
| 967 return 1; | |
| 968 } | |
| 969 }else{ | |
| 970 iCol = resolveAsName(pParse, pEList, pE); | |
| 971 if( iCol==0 ){ | |
| 972 pDup = sqlite3ExprDup(db, pE, 0); | |
| 973 if( !db->mallocFailed ){ | |
| 974 assert(pDup); | |
| 975 iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup); | |
| 976 } | |
| 977 sqlite3ExprDelete(db, pDup); | |
| 978 } | |
| 979 } | |
| 980 if( iCol>0 ){ | |
| 981 /* Convert the ORDER BY term into an integer column number iCol, | |
| 982 ** taking care to preserve the COLLATE clause if it exists */ | |
| 983 Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0); | |
| 984 if( pNew==0 ) return 1; | |
| 985 pNew->flags |= EP_IntValue; | |
| 986 pNew->u.iValue = iCol; | |
| 987 if( pItem->pExpr==pE ){ | |
| 988 pItem->pExpr = pNew; | |
| 989 }else{ | |
| 990 assert( pItem->pExpr->op==TK_COLLATE ); | |
| 991 assert( pItem->pExpr->pLeft==pE ); | |
| 992 pItem->pExpr->pLeft = pNew; | |
| 993 } | |
| 994 sqlite3ExprDelete(db, pE); | |
| 995 pItem->u.x.iOrderByCol = (u16)iCol; | |
| 996 pItem->done = 1; | |
| 997 }else{ | |
| 998 moreToDo = 1; | |
| 999 } | |
| 1000 } | |
| 1001 pSelect = pSelect->pNext; | |
| 1002 } | |
| 1003 for(i=0; i<pOrderBy->nExpr; i++){ | |
| 1004 if( pOrderBy->a[i].done==0 ){ | |
| 1005 sqlite3ErrorMsg(pParse, "%r ORDER BY term does not match any " | |
| 1006 "column in the result set", i+1); | |
| 1007 return 1; | |
| 1008 } | |
| 1009 } | |
| 1010 return 0; | |
| 1011 } | |
| 1012 | |
| 1013 /* | |
| 1014 ** Check every term in the ORDER BY or GROUP BY clause pOrderBy of | |
| 1015 ** the SELECT statement pSelect. If any term is reference to a | |
| 1016 ** result set expression (as determined by the ExprList.a.u.x.iOrderByCol | |
| 1017 ** field) then convert that term into a copy of the corresponding result set | |
| 1018 ** column. | |
| 1019 ** | |
| 1020 ** If any errors are detected, add an error message to pParse and | |
| 1021 ** return non-zero. Return zero if no errors are seen. | |
| 1022 */ | |
| 1023 int sqlite3ResolveOrderGroupBy( | |
| 1024 Parse *pParse, /* Parsing context. Leave error messages here */ | |
| 1025 Select *pSelect, /* The SELECT statement containing the clause */ | |
| 1026 ExprList *pOrderBy, /* The ORDER BY or GROUP BY clause to be processed */ | |
| 1027 const char *zType /* "ORDER" or "GROUP" */ | |
| 1028 ){ | |
| 1029 int i; | |
| 1030 sqlite3 *db = pParse->db; | |
| 1031 ExprList *pEList; | |
| 1032 struct ExprList_item *pItem; | |
| 1033 | |
| 1034 if( pOrderBy==0 || pParse->db->mallocFailed ) return 0; | |
| 1035 #if SQLITE_MAX_COLUMN | |
| 1036 if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){ | |
| 1037 sqlite3ErrorMsg(pParse, "too many terms in %s BY clause", zType); | |
| 1038 return 1; | |
| 1039 } | |
| 1040 #endif | |
| 1041 pEList = pSelect->pEList; | |
| 1042 assert( pEList!=0 ); /* sqlite3SelectNew() guarantees this */ | |
| 1043 for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){ | |
| 1044 if( pItem->u.x.iOrderByCol ){ | |
| 1045 if( pItem->u.x.iOrderByCol>pEList->nExpr ){ | |
| 1046 resolveOutOfRangeError(pParse, zType, i+1, pEList->nExpr); | |
| 1047 return 1; | |
| 1048 } | |
| 1049 resolveAlias(pParse, pEList, pItem->u.x.iOrderByCol-1, pItem->pExpr, zType
,0); | |
| 1050 } | |
| 1051 } | |
| 1052 return 0; | |
| 1053 } | |
| 1054 | |
| 1055 /* | |
| 1056 ** pOrderBy is an ORDER BY or GROUP BY clause in SELECT statement pSelect. | |
| 1057 ** The Name context of the SELECT statement is pNC. zType is either | |
| 1058 ** "ORDER" or "GROUP" depending on which type of clause pOrderBy is. | |
| 1059 ** | |
| 1060 ** This routine resolves each term of the clause into an expression. | |
| 1061 ** If the order-by term is an integer I between 1 and N (where N is the | |
| 1062 ** number of columns in the result set of the SELECT) then the expression | |
| 1063 ** in the resolution is a copy of the I-th result-set expression. If | |
| 1064 ** the order-by term is an identifier that corresponds to the AS-name of | |
| 1065 ** a result-set expression, then the term resolves to a copy of the | |
| 1066 ** result-set expression. Otherwise, the expression is resolved in | |
| 1067 ** the usual way - using sqlite3ResolveExprNames(). | |
| 1068 ** | |
| 1069 ** This routine returns the number of errors. If errors occur, then | |
| 1070 ** an appropriate error message might be left in pParse. (OOM errors | |
| 1071 ** excepted.) | |
| 1072 */ | |
| 1073 static int resolveOrderGroupBy( | |
| 1074 NameContext *pNC, /* The name context of the SELECT statement */ | |
| 1075 Select *pSelect, /* The SELECT statement holding pOrderBy */ | |
| 1076 ExprList *pOrderBy, /* An ORDER BY or GROUP BY clause to resolve */ | |
| 1077 const char *zType /* Either "ORDER" or "GROUP", as appropriate */ | |
| 1078 ){ | |
| 1079 int i, j; /* Loop counters */ | |
| 1080 int iCol; /* Column number */ | |
| 1081 struct ExprList_item *pItem; /* A term of the ORDER BY clause */ | |
| 1082 Parse *pParse; /* Parsing context */ | |
| 1083 int nResult; /* Number of terms in the result set */ | |
| 1084 | |
| 1085 if( pOrderBy==0 ) return 0; | |
| 1086 nResult = pSelect->pEList->nExpr; | |
| 1087 pParse = pNC->pParse; | |
| 1088 for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){ | |
| 1089 Expr *pE = pItem->pExpr; | |
| 1090 Expr *pE2 = sqlite3ExprSkipCollate(pE); | |
| 1091 if( zType[0]!='G' ){ | |
| 1092 iCol = resolveAsName(pParse, pSelect->pEList, pE2); | |
| 1093 if( iCol>0 ){ | |
| 1094 /* If an AS-name match is found, mark this ORDER BY column as being | |
| 1095 ** a copy of the iCol-th result-set column. The subsequent call to | |
| 1096 ** sqlite3ResolveOrderGroupBy() will convert the expression to a | |
| 1097 ** copy of the iCol-th result-set expression. */ | |
| 1098 pItem->u.x.iOrderByCol = (u16)iCol; | |
| 1099 continue; | |
| 1100 } | |
| 1101 } | |
| 1102 if( sqlite3ExprIsInteger(pE2, &iCol) ){ | |
| 1103 /* The ORDER BY term is an integer constant. Again, set the column | |
| 1104 ** number so that sqlite3ResolveOrderGroupBy() will convert the | |
| 1105 ** order-by term to a copy of the result-set expression */ | |
| 1106 if( iCol<1 || iCol>0xffff ){ | |
| 1107 resolveOutOfRangeError(pParse, zType, i+1, nResult); | |
| 1108 return 1; | |
| 1109 } | |
| 1110 pItem->u.x.iOrderByCol = (u16)iCol; | |
| 1111 continue; | |
| 1112 } | |
| 1113 | |
| 1114 /* Otherwise, treat the ORDER BY term as an ordinary expression */ | |
| 1115 pItem->u.x.iOrderByCol = 0; | |
| 1116 if( sqlite3ResolveExprNames(pNC, pE) ){ | |
| 1117 return 1; | |
| 1118 } | |
| 1119 for(j=0; j<pSelect->pEList->nExpr; j++){ | |
| 1120 if( sqlite3ExprCompare(pE, pSelect->pEList->a[j].pExpr, -1)==0 ){ | |
| 1121 pItem->u.x.iOrderByCol = j+1; | |
| 1122 } | |
| 1123 } | |
| 1124 } | |
| 1125 return sqlite3ResolveOrderGroupBy(pParse, pSelect, pOrderBy, zType); | |
| 1126 } | |
| 1127 | |
| 1128 /* | |
| 1129 ** Resolve names in the SELECT statement p and all of its descendants. | |
| 1130 */ | |
| 1131 static int resolveSelectStep(Walker *pWalker, Select *p){ | |
| 1132 NameContext *pOuterNC; /* Context that contains this SELECT */ | |
| 1133 NameContext sNC; /* Name context of this SELECT */ | |
| 1134 int isCompound; /* True if p is a compound select */ | |
| 1135 int nCompound; /* Number of compound terms processed so far */ | |
| 1136 Parse *pParse; /* Parsing context */ | |
| 1137 ExprList *pEList; /* Result set expression list */ | |
| 1138 int i; /* Loop counter */ | |
| 1139 ExprList *pGroupBy; /* The GROUP BY clause */ | |
| 1140 Select *pLeftmost; /* Left-most of SELECT of a compound */ | |
| 1141 sqlite3 *db; /* Database connection */ | |
| 1142 | |
| 1143 | |
| 1144 assert( p!=0 ); | |
| 1145 if( p->selFlags & SF_Resolved ){ | |
| 1146 return WRC_Prune; | |
| 1147 } | |
| 1148 pOuterNC = pWalker->u.pNC; | |
| 1149 pParse = pWalker->pParse; | |
| 1150 db = pParse->db; | |
| 1151 | |
| 1152 /* Normally sqlite3SelectExpand() will be called first and will have | |
| 1153 ** already expanded this SELECT. However, if this is a subquery within | |
| 1154 ** an expression, sqlite3ResolveExprNames() will be called without a | |
| 1155 ** prior call to sqlite3SelectExpand(). When that happens, let | |
| 1156 ** sqlite3SelectPrep() do all of the processing for this SELECT. | |
| 1157 ** sqlite3SelectPrep() will invoke both sqlite3SelectExpand() and | |
| 1158 ** this routine in the correct order. | |
| 1159 */ | |
| 1160 if( (p->selFlags & SF_Expanded)==0 ){ | |
| 1161 sqlite3SelectPrep(pParse, p, pOuterNC); | |
| 1162 return (pParse->nErr || db->mallocFailed) ? WRC_Abort : WRC_Prune; | |
| 1163 } | |
| 1164 | |
| 1165 isCompound = p->pPrior!=0; | |
| 1166 nCompound = 0; | |
| 1167 pLeftmost = p; | |
| 1168 while( p ){ | |
| 1169 assert( (p->selFlags & SF_Expanded)!=0 ); | |
| 1170 assert( (p->selFlags & SF_Resolved)==0 ); | |
| 1171 p->selFlags |= SF_Resolved; | |
| 1172 | |
| 1173 /* Resolve the expressions in the LIMIT and OFFSET clauses. These | |
| 1174 ** are not allowed to refer to any names, so pass an empty NameContext. | |
| 1175 */ | |
| 1176 memset(&sNC, 0, sizeof(sNC)); | |
| 1177 sNC.pParse = pParse; | |
| 1178 if( sqlite3ResolveExprNames(&sNC, p->pLimit) || | |
| 1179 sqlite3ResolveExprNames(&sNC, p->pOffset) ){ | |
| 1180 return WRC_Abort; | |
| 1181 } | |
| 1182 | |
| 1183 /* Recursively resolve names in all subqueries | |
| 1184 */ | |
| 1185 for(i=0; i<p->pSrc->nSrc; i++){ | |
| 1186 struct SrcList_item *pItem = &p->pSrc->a[i]; | |
| 1187 if( pItem->pSelect ){ | |
| 1188 NameContext *pNC; /* Used to iterate name contexts */ | |
| 1189 int nRef = 0; /* Refcount for pOuterNC and outer contexts */ | |
| 1190 const char *zSavedContext = pParse->zAuthContext; | |
| 1191 | |
| 1192 /* Count the total number of references to pOuterNC and all of its | |
| 1193 ** parent contexts. After resolving references to expressions in | |
| 1194 ** pItem->pSelect, check if this value has changed. If so, then | |
| 1195 ** SELECT statement pItem->pSelect must be correlated. Set the | |
| 1196 ** pItem->isCorrelated flag if this is the case. */ | |
| 1197 for(pNC=pOuterNC; pNC; pNC=pNC->pNext) nRef += pNC->nRef; | |
| 1198 | |
| 1199 if( pItem->zName ) pParse->zAuthContext = pItem->zName; | |
| 1200 sqlite3ResolveSelectNames(pParse, pItem->pSelect, pOuterNC); | |
| 1201 pParse->zAuthContext = zSavedContext; | |
| 1202 if( pParse->nErr || db->mallocFailed ) return WRC_Abort; | |
| 1203 | |
| 1204 for(pNC=pOuterNC; pNC; pNC=pNC->pNext) nRef -= pNC->nRef; | |
| 1205 assert( pItem->isCorrelated==0 && nRef<=0 ); | |
| 1206 pItem->isCorrelated = (nRef!=0); | |
| 1207 } | |
| 1208 } | |
| 1209 | |
| 1210 /* Set up the local name-context to pass to sqlite3ResolveExprNames() to | |
| 1211 ** resolve the result-set expression list. | |
| 1212 */ | |
| 1213 sNC.ncFlags = NC_AllowAgg; | |
| 1214 sNC.pSrcList = p->pSrc; | |
| 1215 sNC.pNext = pOuterNC; | |
| 1216 | |
| 1217 /* Resolve names in the result set. */ | |
| 1218 pEList = p->pEList; | |
| 1219 assert( pEList!=0 ); | |
| 1220 for(i=0; i<pEList->nExpr; i++){ | |
| 1221 Expr *pX = pEList->a[i].pExpr; | |
| 1222 if( sqlite3ResolveExprNames(&sNC, pX) ){ | |
| 1223 return WRC_Abort; | |
| 1224 } | |
| 1225 } | |
| 1226 | |
| 1227 /* If there are no aggregate functions in the result-set, and no GROUP BY | |
| 1228 ** expression, do not allow aggregates in any of the other expressions. | |
| 1229 */ | |
| 1230 assert( (p->selFlags & SF_Aggregate)==0 ); | |
| 1231 pGroupBy = p->pGroupBy; | |
| 1232 if( pGroupBy || (sNC.ncFlags & NC_HasAgg)!=0 ){ | |
| 1233 assert( NC_MinMaxAgg==SF_MinMaxAgg ); | |
| 1234 p->selFlags |= SF_Aggregate | (sNC.ncFlags&NC_MinMaxAgg); | |
| 1235 }else{ | |
| 1236 sNC.ncFlags &= ~NC_AllowAgg; | |
| 1237 } | |
| 1238 | |
| 1239 /* If a HAVING clause is present, then there must be a GROUP BY clause. | |
| 1240 */ | |
| 1241 if( p->pHaving && !pGroupBy ){ | |
| 1242 sqlite3ErrorMsg(pParse, "a GROUP BY clause is required before HAVING"); | |
| 1243 return WRC_Abort; | |
| 1244 } | |
| 1245 | |
| 1246 /* Add the output column list to the name-context before parsing the | |
| 1247 ** other expressions in the SELECT statement. This is so that | |
| 1248 ** expressions in the WHERE clause (etc.) can refer to expressions by | |
| 1249 ** aliases in the result set. | |
| 1250 ** | |
| 1251 ** Minor point: If this is the case, then the expression will be | |
| 1252 ** re-evaluated for each reference to it. | |
| 1253 */ | |
| 1254 sNC.pEList = p->pEList; | |
| 1255 if( sqlite3ResolveExprNames(&sNC, p->pHaving) ) return WRC_Abort; | |
| 1256 if( sqlite3ResolveExprNames(&sNC, p->pWhere) ) return WRC_Abort; | |
| 1257 | |
| 1258 /* The ORDER BY and GROUP BY clauses may not refer to terms in | |
| 1259 ** outer queries | |
| 1260 */ | |
| 1261 sNC.pNext = 0; | |
| 1262 sNC.ncFlags |= NC_AllowAgg; | |
| 1263 | |
| 1264 /* Process the ORDER BY clause for singleton SELECT statements. | |
| 1265 ** The ORDER BY clause for compounds SELECT statements is handled | |
| 1266 ** below, after all of the result-sets for all of the elements of | |
| 1267 ** the compound have been resolved. | |
| 1268 */ | |
| 1269 if( !isCompound && resolveOrderGroupBy(&sNC, p, p->pOrderBy, "ORDER") ){ | |
| 1270 return WRC_Abort; | |
| 1271 } | |
| 1272 if( db->mallocFailed ){ | |
| 1273 return WRC_Abort; | |
| 1274 } | |
| 1275 | |
| 1276 /* Resolve the GROUP BY clause. At the same time, make sure | |
| 1277 ** the GROUP BY clause does not contain aggregate functions. | |
| 1278 */ | |
| 1279 if( pGroupBy ){ | |
| 1280 struct ExprList_item *pItem; | |
| 1281 | |
| 1282 if( resolveOrderGroupBy(&sNC, p, pGroupBy, "GROUP") || db->mallocFailed ){ | |
| 1283 return WRC_Abort; | |
| 1284 } | |
| 1285 for(i=0, pItem=pGroupBy->a; i<pGroupBy->nExpr; i++, pItem++){ | |
| 1286 if( ExprHasProperty(pItem->pExpr, EP_Agg) ){ | |
| 1287 sqlite3ErrorMsg(pParse, "aggregate functions are not allowed in " | |
| 1288 "the GROUP BY clause"); | |
| 1289 return WRC_Abort; | |
| 1290 } | |
| 1291 } | |
| 1292 } | |
| 1293 | |
| 1294 /* Advance to the next term of the compound | |
| 1295 */ | |
| 1296 p = p->pPrior; | |
| 1297 nCompound++; | |
| 1298 } | |
| 1299 | |
| 1300 /* Resolve the ORDER BY on a compound SELECT after all terms of | |
| 1301 ** the compound have been resolved. | |
| 1302 */ | |
| 1303 if( isCompound && resolveCompoundOrderBy(pParse, pLeftmost) ){ | |
| 1304 return WRC_Abort; | |
| 1305 } | |
| 1306 | |
| 1307 return WRC_Prune; | |
| 1308 } | |
| 1309 | |
| 1310 /* | |
| 1311 ** This routine walks an expression tree and resolves references to | |
| 1312 ** table columns and result-set columns. At the same time, do error | |
| 1313 ** checking on function usage and set a flag if any aggregate functions | |
| 1314 ** are seen. | |
| 1315 ** | |
| 1316 ** To resolve table columns references we look for nodes (or subtrees) of the | |
| 1317 ** form X.Y.Z or Y.Z or just Z where | |
| 1318 ** | |
| 1319 ** X: The name of a database. Ex: "main" or "temp" or | |
| 1320 ** the symbolic name assigned to an ATTACH-ed database. | |
| 1321 ** | |
| 1322 ** Y: The name of a table in a FROM clause. Or in a trigger | |
| 1323 ** one of the special names "old" or "new". | |
| 1324 ** | |
| 1325 ** Z: The name of a column in table Y. | |
| 1326 ** | |
| 1327 ** The node at the root of the subtree is modified as follows: | |
| 1328 ** | |
| 1329 ** Expr.op Changed to TK_COLUMN | |
| 1330 ** Expr.pTab Points to the Table object for X.Y | |
| 1331 ** Expr.iColumn The column index in X.Y. -1 for the rowid. | |
| 1332 ** Expr.iTable The VDBE cursor number for X.Y | |
| 1333 ** | |
| 1334 ** | |
| 1335 ** To resolve result-set references, look for expression nodes of the | |
| 1336 ** form Z (with no X and Y prefix) where the Z matches the right-hand | |
| 1337 ** size of an AS clause in the result-set of a SELECT. The Z expression | |
| 1338 ** is replaced by a copy of the left-hand side of the result-set expression. | |
| 1339 ** Table-name and function resolution occurs on the substituted expression | |
| 1340 ** tree. For example, in: | |
| 1341 ** | |
| 1342 ** SELECT a+b AS x, c+d AS y FROM t1 ORDER BY x; | |
| 1343 ** | |
| 1344 ** The "x" term of the order by is replaced by "a+b" to render: | |
| 1345 ** | |
| 1346 ** SELECT a+b AS x, c+d AS y FROM t1 ORDER BY a+b; | |
| 1347 ** | |
| 1348 ** Function calls are checked to make sure that the function is | |
| 1349 ** defined and that the correct number of arguments are specified. | |
| 1350 ** If the function is an aggregate function, then the NC_HasAgg flag is | |
| 1351 ** set and the opcode is changed from TK_FUNCTION to TK_AGG_FUNCTION. | |
| 1352 ** If an expression contains aggregate functions then the EP_Agg | |
| 1353 ** property on the expression is set. | |
| 1354 ** | |
| 1355 ** An error message is left in pParse if anything is amiss. The number | |
| 1356 ** if errors is returned. | |
| 1357 */ | |
| 1358 int sqlite3ResolveExprNames( | |
| 1359 NameContext *pNC, /* Namespace to resolve expressions in. */ | |
| 1360 Expr *pExpr /* The expression to be analyzed. */ | |
| 1361 ){ | |
| 1362 u16 savedHasAgg; | |
| 1363 Walker w; | |
| 1364 | |
| 1365 if( pExpr==0 ) return 0; | |
| 1366 #if SQLITE_MAX_EXPR_DEPTH>0 | |
| 1367 { | |
| 1368 Parse *pParse = pNC->pParse; | |
| 1369 if( sqlite3ExprCheckHeight(pParse, pExpr->nHeight+pNC->pParse->nHeight) ){ | |
| 1370 return 1; | |
| 1371 } | |
| 1372 pParse->nHeight += pExpr->nHeight; | |
| 1373 } | |
| 1374 #endif | |
| 1375 savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg); | |
| 1376 pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg); | |
| 1377 memset(&w, 0, sizeof(w)); | |
| 1378 w.xExprCallback = resolveExprStep; | |
| 1379 w.xSelectCallback = resolveSelectStep; | |
| 1380 w.pParse = pNC->pParse; | |
| 1381 w.u.pNC = pNC; | |
| 1382 sqlite3WalkExpr(&w, pExpr); | |
| 1383 #if SQLITE_MAX_EXPR_DEPTH>0 | |
| 1384 pNC->pParse->nHeight -= pExpr->nHeight; | |
| 1385 #endif | |
| 1386 if( pNC->nErr>0 || w.pParse->nErr>0 ){ | |
| 1387 ExprSetProperty(pExpr, EP_Error); | |
| 1388 } | |
| 1389 if( pNC->ncFlags & NC_HasAgg ){ | |
| 1390 ExprSetProperty(pExpr, EP_Agg); | |
| 1391 } | |
| 1392 pNC->ncFlags |= savedHasAgg; | |
| 1393 return ExprHasProperty(pExpr, EP_Error); | |
| 1394 } | |
| 1395 | |
| 1396 | |
| 1397 /* | |
| 1398 ** Resolve all names in all expressions of a SELECT and in all | |
| 1399 ** decendents of the SELECT, including compounds off of p->pPrior, | |
| 1400 ** subqueries in expressions, and subqueries used as FROM clause | |
| 1401 ** terms. | |
| 1402 ** | |
| 1403 ** See sqlite3ResolveExprNames() for a description of the kinds of | |
| 1404 ** transformations that occur. | |
| 1405 ** | |
| 1406 ** All SELECT statements should have been expanded using | |
| 1407 ** sqlite3SelectExpand() prior to invoking this routine. | |
| 1408 */ | |
| 1409 void sqlite3ResolveSelectNames( | |
| 1410 Parse *pParse, /* The parser context */ | |
| 1411 Select *p, /* The SELECT statement being coded. */ | |
| 1412 NameContext *pOuterNC /* Name context for parent SELECT statement */ | |
| 1413 ){ | |
| 1414 Walker w; | |
| 1415 | |
| 1416 assert( p!=0 ); | |
| 1417 memset(&w, 0, sizeof(w)); | |
| 1418 w.xExprCallback = resolveExprStep; | |
| 1419 w.xSelectCallback = resolveSelectStep; | |
| 1420 w.pParse = pParse; | |
| 1421 w.u.pNC = pOuterNC; | |
| 1422 sqlite3WalkSelect(&w, p); | |
| 1423 } | |
| 1424 | |
| 1425 /* | |
| 1426 ** Resolve names in expressions that can only reference a single table: | |
| 1427 ** | |
| 1428 ** * CHECK constraints | |
| 1429 ** * WHERE clauses on partial indices | |
| 1430 ** | |
| 1431 ** The Expr.iTable value for Expr.op==TK_COLUMN nodes of the expression | |
| 1432 ** is set to -1 and the Expr.iColumn value is set to the column number. | |
| 1433 ** | |
| 1434 ** Any errors cause an error message to be set in pParse. | |
| 1435 */ | |
| 1436 void sqlite3ResolveSelfReference( | |
| 1437 Parse *pParse, /* Parsing context */ | |
| 1438 Table *pTab, /* The table being referenced */ | |
| 1439 int type, /* NC_IsCheck or NC_PartIdx */ | |
| 1440 Expr *pExpr, /* Expression to resolve. May be NULL. */ | |
| 1441 ExprList *pList /* Expression list to resolve. May be NUL. */ | |
| 1442 ){ | |
| 1443 SrcList sSrc; /* Fake SrcList for pParse->pNewTable */ | |
| 1444 NameContext sNC; /* Name context for pParse->pNewTable */ | |
| 1445 int i; /* Loop counter */ | |
| 1446 | |
| 1447 assert( type==NC_IsCheck || type==NC_PartIdx ); | |
| 1448 memset(&sNC, 0, sizeof(sNC)); | |
| 1449 memset(&sSrc, 0, sizeof(sSrc)); | |
| 1450 sSrc.nSrc = 1; | |
| 1451 sSrc.a[0].zName = pTab->zName; | |
| 1452 sSrc.a[0].pTab = pTab; | |
| 1453 sSrc.a[0].iCursor = -1; | |
| 1454 sNC.pParse = pParse; | |
| 1455 sNC.pSrcList = &sSrc; | |
| 1456 sNC.ncFlags = type; | |
| 1457 if( sqlite3ResolveExprNames(&sNC, pExpr) ) return; | |
| 1458 if( pList ){ | |
| 1459 for(i=0; i<pList->nExpr; i++){ | |
| 1460 if( sqlite3ResolveExprNames(&sNC, pList->a[i].pExpr) ){ | |
| 1461 return; | |
| 1462 } | |
| 1463 } | |
| 1464 } | |
| 1465 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2363173002:
[sqlite] Remove obsolete reference version 3.8.7.4. (Closed)
