1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sqlite3api/SQLite/resolve.c Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1149 @@
1.4 +/*
1.5 +** 2008 August 18
1.6 +**
1.7 +** The author disclaims copyright to this source code. In place of
1.8 +** a legal notice, here is a blessing:
1.9 +**
1.10 +** May you do good and not evil.
1.11 +** May you find forgiveness for yourself and forgive others.
1.12 +** May you share freely, never taking more than you give.
1.13 +**
1.14 +*************************************************************************
1.15 +**
1.16 +** This file contains routines used for walking the parser tree and
1.17 +** resolve all identifiers by associating them with a particular
1.18 +** table and column.
1.19 +**
1.20 +** $Id: resolve.c,v 1.5 2008/08/29 02:14:03 drh Exp $
1.21 +*/
1.22 +#include "sqliteInt.h"
1.23 +#include <stdlib.h>
1.24 +#include <string.h>
1.25 +
1.26 +/*
1.27 +** Turn the pExpr expression into an alias for the iCol-th column of the
1.28 +** result set in pEList.
1.29 +**
1.30 +** If the result set column is a simple column reference, then this routine
1.31 +** makes an exact copy. But for any other kind of expression, this
1.32 +** routine make a copy of the result set column as the argument to the
1.33 +** TK_AS operator. The TK_AS operator causes the expression to be
1.34 +** evaluated just once and then reused for each alias.
1.35 +**
1.36 +** The reason for suppressing the TK_AS term when the expression is a simple
1.37 +** column reference is so that the column reference will be recognized as
1.38 +** usable by indices within the WHERE clause processing logic.
1.39 +**
1.40 +** Hack: The TK_AS operator is inhibited if zType[0]=='G'. This means
1.41 +** that in a GROUP BY clause, the expression is evaluated twice. Hence:
1.42 +**
1.43 +** SELECT random()%5 AS x, count(*) FROM tab GROUP BY x
1.44 +**
1.45 +** Is equivalent to:
1.46 +**
1.47 +** SELECT random()%5 AS x, count(*) FROM tab GROUP BY random()%5
1.48 +**
1.49 +** The result of random()%5 in the GROUP BY clause is probably different
1.50 +** from the result in the result-set. We might fix this someday. Or
1.51 +** then again, we might not...
1.52 +*/
1.53 +static void resolveAlias(
1.54 + Parse *pParse, /* Parsing context */
1.55 + ExprList *pEList, /* A result set */
1.56 + int iCol, /* A column in the result set. 0..pEList->nExpr-1 */
1.57 + Expr *pExpr, /* Transform this into an alias to the result set */
1.58 + const char *zType /* "GROUP" or "ORDER" or "" */
1.59 +){
1.60 + Expr *pOrig; /* The iCol-th column of the result set */
1.61 + Expr *pDup; /* Copy of pOrig */
1.62 + sqlite3 *db; /* The database connection */
1.63 +
1.64 + assert( iCol>=0 && iCol<pEList->nExpr );
1.65 + pOrig = pEList->a[iCol].pExpr;
1.66 + assert( pOrig!=0 );
1.67 + assert( pOrig->flags & EP_Resolved );
1.68 + db = pParse->db;
1.69 + pDup = sqlite3ExprDup(db, pOrig);
1.70 + if( pDup==0 ) return;
1.71 + if( pDup->op!=TK_COLUMN && zType[0]!='G' ){
1.72 + pDup = sqlite3PExpr(pParse, TK_AS, pDup, 0, 0);
1.73 + if( pDup==0 ) return;
1.74 + if( pEList->a[iCol].iAlias==0 ){
1.75 + pEList->a[iCol].iAlias = ++pParse->nAlias;
1.76 + }
1.77 + pDup->iTable = pEList->a[iCol].iAlias;
1.78 + }
1.79 + if( pExpr->flags & EP_ExpCollate ){
1.80 + pDup->pColl = pExpr->pColl;
1.81 + pDup->flags |= EP_ExpCollate;
1.82 + }
1.83 + if( pExpr->span.dyn ) sqlite3DbFree(db, (char*)pExpr->span.z);
1.84 + if( pExpr->token.dyn ) sqlite3DbFree(db, (char*)pExpr->token.z);
1.85 + memcpy(pExpr, pDup, sizeof(*pExpr));
1.86 + sqlite3DbFree(db, pDup);
1.87 +}
1.88 +
1.89 +/*
1.90 +** Given the name of a column of the form X.Y.Z or Y.Z or just Z, look up
1.91 +** that name in the set of source tables in pSrcList and make the pExpr
1.92 +** expression node refer back to that source column. The following changes
1.93 +** are made to pExpr:
1.94 +**
1.95 +** pExpr->iDb Set the index in db->aDb[] of the database X
1.96 +** (even if X is implied).
1.97 +** pExpr->iTable Set to the cursor number for the table obtained
1.98 +** from pSrcList.
1.99 +** pExpr->pTab Points to the Table structure of X.Y (even if
1.100 +** X and/or Y are implied.)
1.101 +** pExpr->iColumn Set to the column number within the table.
1.102 +** pExpr->op Set to TK_COLUMN.
1.103 +** pExpr->pLeft Any expression this points to is deleted
1.104 +** pExpr->pRight Any expression this points to is deleted.
1.105 +**
1.106 +** The pDbToken is the name of the database (the "X"). This value may be
1.107 +** NULL meaning that name is of the form Y.Z or Z. Any available database
1.108 +** can be used. The pTableToken is the name of the table (the "Y"). This
1.109 +** value can be NULL if pDbToken is also NULL. If pTableToken is NULL it
1.110 +** means that the form of the name is Z and that columns from any table
1.111 +** can be used.
1.112 +**
1.113 +** If the name cannot be resolved unambiguously, leave an error message
1.114 +** in pParse and return non-zero. Return zero on success.
1.115 +*/
1.116 +static int lookupName(
1.117 + Parse *pParse, /* The parsing context */
1.118 + Token *pDbToken, /* Name of the database containing table, or NULL */
1.119 + Token *pTableToken, /* Name of table containing column, or NULL */
1.120 + Token *pColumnToken, /* Name of the column. */
1.121 + NameContext *pNC, /* The name context used to resolve the name */
1.122 + Expr *pExpr /* Make this EXPR node point to the selected column */
1.123 +){
1.124 + char *zDb = 0; /* Name of the database. The "X" in X.Y.Z */
1.125 + char *zTab = 0; /* Name of the table. The "Y" in X.Y.Z or Y.Z */
1.126 + char *zCol = 0; /* Name of the column. The "Z" */
1.127 + int i, j; /* Loop counters */
1.128 + int cnt = 0; /* Number of matching column names */
1.129 + int cntTab = 0; /* Number of matching table names */
1.130 + sqlite3 *db = pParse->db; /* The database connection */
1.131 + struct SrcList_item *pItem; /* Use for looping over pSrcList items */
1.132 + struct SrcList_item *pMatch = 0; /* The matching pSrcList item */
1.133 + NameContext *pTopNC = pNC; /* First namecontext in the list */
1.134 + Schema *pSchema = 0; /* Schema of the expression */
1.135 +
1.136 + assert( pColumnToken && pColumnToken->z ); /* The Z in X.Y.Z cannot be NULL */
1.137 +
1.138 + /* Dequote and zero-terminate the names */
1.139 + zDb = sqlite3NameFromToken(db, pDbToken);
1.140 + zTab = sqlite3NameFromToken(db, pTableToken);
1.141 + zCol = sqlite3NameFromToken(db, pColumnToken);
1.142 + if( db->mallocFailed ){
1.143 + goto lookupname_end;
1.144 + }
1.145 +
1.146 + /* Initialize the node to no-match */
1.147 + pExpr->iTable = -1;
1.148 + pExpr->pTab = 0;
1.149 +
1.150 + /* Start at the inner-most context and move outward until a match is found */
1.151 + while( pNC && cnt==0 ){
1.152 + ExprList *pEList;
1.153 + SrcList *pSrcList = pNC->pSrcList;
1.154 +
1.155 + if( pSrcList ){
1.156 + for(i=0, pItem=pSrcList->a; i<pSrcList->nSrc; i++, pItem++){
1.157 + Table *pTab;
1.158 + int iDb;
1.159 + Column *pCol;
1.160 +
1.161 + pTab = pItem->pTab;
1.162 + assert( pTab!=0 && pTab->zName!=0 );
1.163 + iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
1.164 + assert( pTab->nCol>0 );
1.165 + if( zTab ){
1.166 + if( pItem->zAlias ){
1.167 + char *zTabName = pItem->zAlias;
1.168 + if( sqlite3StrICmp(zTabName, zTab)!=0 ) continue;
1.169 + }else{
1.170 + char *zTabName = pTab->zName;
1.171 + if( zTabName==0 || sqlite3StrICmp(zTabName, zTab)!=0 ) continue;
1.172 + if( zDb!=0 && sqlite3StrICmp(db->aDb[iDb].zName, zDb)!=0 ){
1.173 + continue;
1.174 + }
1.175 + }
1.176 + }
1.177 + if( 0==(cntTab++) ){
1.178 + pExpr->iTable = pItem->iCursor;
1.179 + pExpr->pTab = pTab;
1.180 + pSchema = pTab->pSchema;
1.181 + pMatch = pItem;
1.182 + }
1.183 + for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
1.184 + if( sqlite3StrICmp(pCol->zName, zCol)==0 ){
1.185 + IdList *pUsing;
1.186 + cnt++;
1.187 + pExpr->iTable = pItem->iCursor;
1.188 + pExpr->pTab = pTab;
1.189 + pMatch = pItem;
1.190 + pSchema = pTab->pSchema;
1.191 + /* Substitute the rowid (column -1) for the INTEGER PRIMARY KEY */
1.192 + pExpr->iColumn = j==pTab->iPKey ? -1 : j;
1.193 + if( i<pSrcList->nSrc-1 ){
1.194 + if( pItem[1].jointype & JT_NATURAL ){
1.195 + /* If this match occurred in the left table of a natural join,
1.196 + ** then skip the right table to avoid a duplicate match */
1.197 + pItem++;
1.198 + i++;
1.199 + }else if( (pUsing = pItem[1].pUsing)!=0 ){
1.200 + /* If this match occurs on a column that is in the USING clause
1.201 + ** of a join, skip the search of the right table of the join
1.202 + ** to avoid a duplicate match there. */
1.203 + int k;
1.204 + for(k=0; k<pUsing->nId; k++){
1.205 + if( sqlite3StrICmp(pUsing->a[k].zName, zCol)==0 ){
1.206 + pItem++;
1.207 + i++;
1.208 + break;
1.209 + }
1.210 + }
1.211 + }
1.212 + }
1.213 + break;
1.214 + }
1.215 + }
1.216 + }
1.217 + }
1.218 +
1.219 +#ifndef SQLITE_OMIT_TRIGGER
1.220 + /* If we have not already resolved the name, then maybe
1.221 + ** it is a new.* or old.* trigger argument reference
1.222 + */
1.223 + if( zDb==0 && zTab!=0 && cnt==0 && pParse->trigStack!=0 ){
1.224 + TriggerStack *pTriggerStack = pParse->trigStack;
1.225 + Table *pTab = 0;
1.226 + u32 *piColMask;
1.227 + if( pTriggerStack->newIdx != -1 && sqlite3StrICmp("new", zTab) == 0 ){
1.228 + pExpr->iTable = pTriggerStack->newIdx;
1.229 + assert( pTriggerStack->pTab );
1.230 + pTab = pTriggerStack->pTab;
1.231 + piColMask = &(pTriggerStack->newColMask);
1.232 + }else if( pTriggerStack->oldIdx != -1 && sqlite3StrICmp("old", zTab)==0 ){
1.233 + pExpr->iTable = pTriggerStack->oldIdx;
1.234 + assert( pTriggerStack->pTab );
1.235 + pTab = pTriggerStack->pTab;
1.236 + piColMask = &(pTriggerStack->oldColMask);
1.237 + }
1.238 +
1.239 + if( pTab ){
1.240 + int iCol;
1.241 + Column *pCol = pTab->aCol;
1.242 +
1.243 + pSchema = pTab->pSchema;
1.244 + cntTab++;
1.245 + for(iCol=0; iCol < pTab->nCol; iCol++, pCol++) {
1.246 + if( sqlite3StrICmp(pCol->zName, zCol)==0 ){
1.247 + cnt++;
1.248 + pExpr->iColumn = iCol==pTab->iPKey ? -1 : iCol;
1.249 + pExpr->pTab = pTab;
1.250 + if( iCol>=0 ){
1.251 + testcase( iCol==31 );
1.252 + testcase( iCol==32 );
1.253 + *piColMask |= ((u32)1<<iCol) | (iCol>=32?0xffffffff:0);
1.254 + }
1.255 + break;
1.256 + }
1.257 + }
1.258 + }
1.259 + }
1.260 +#endif /* !defined(SQLITE_OMIT_TRIGGER) */
1.261 +
1.262 + /*
1.263 + ** Perhaps the name is a reference to the ROWID
1.264 + */
1.265 + if( cnt==0 && cntTab==1 && sqlite3IsRowid(zCol) ){
1.266 + cnt = 1;
1.267 + pExpr->iColumn = -1;
1.268 + pExpr->affinity = SQLITE_AFF_INTEGER;
1.269 + }
1.270 +
1.271 + /*
1.272 + ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z
1.273 + ** might refer to an result-set alias. This happens, for example, when
1.274 + ** we are resolving names in the WHERE clause of the following command:
1.275 + **
1.276 + ** SELECT a+b AS x FROM table WHERE x<10;
1.277 + **
1.278 + ** In cases like this, replace pExpr with a copy of the expression that
1.279 + ** forms the result set entry ("a+b" in the example) and return immediately.
1.280 + ** Note that the expression in the result set should have already been
1.281 + ** resolved by the time the WHERE clause is resolved.
1.282 + */
1.283 + if( cnt==0 && (pEList = pNC->pEList)!=0 && zTab==0 ){
1.284 + for(j=0; j<pEList->nExpr; j++){
1.285 + char *zAs = pEList->a[j].zName;
1.286 + if( zAs!=0 && sqlite3StrICmp(zAs, zCol)==0 ){
1.287 + Expr *pOrig;
1.288 + assert( pExpr->pLeft==0 && pExpr->pRight==0 );
1.289 + assert( pExpr->pList==0 );
1.290 + assert( pExpr->pSelect==0 );
1.291 + pOrig = pEList->a[j].pExpr;
1.292 + if( !pNC->allowAgg && ExprHasProperty(pOrig, EP_Agg) ){
1.293 + sqlite3ErrorMsg(pParse, "misuse of aliased aggregate %s", zAs);
1.294 + sqlite3DbFree(db, zCol);
1.295 + return 2;
1.296 + }
1.297 + resolveAlias(pParse, pEList, j, pExpr, "");
1.298 + cnt = 1;
1.299 + pMatch = 0;
1.300 + assert( zTab==0 && zDb==0 );
1.301 + goto lookupname_end_2;
1.302 + }
1.303 + }
1.304 + }
1.305 +
1.306 + /* Advance to the next name context. The loop will exit when either
1.307 + ** we have a match (cnt>0) or when we run out of name contexts.
1.308 + */
1.309 + if( cnt==0 ){
1.310 + pNC = pNC->pNext;
1.311 + }
1.312 + }
1.313 +
1.314 + /*
1.315 + ** If X and Y are NULL (in other words if only the column name Z is
1.316 + ** supplied) and the value of Z is enclosed in double-quotes, then
1.317 + ** Z is a string literal if it doesn't match any column names. In that
1.318 + ** case, we need to return right away and not make any changes to
1.319 + ** pExpr.
1.320 + **
1.321 + ** Because no reference was made to outer contexts, the pNC->nRef
1.322 + ** fields are not changed in any context.
1.323 + */
1.324 + if( cnt==0 && zTab==0 && pColumnToken->z[0]=='"' ){
1.325 + sqlite3DbFree(db, zCol);
1.326 + pExpr->op = TK_STRING;
1.327 + return 0;
1.328 + }
1.329 +
1.330 + /*
1.331 + ** cnt==0 means there was not match. cnt>1 means there were two or
1.332 + ** more matches. Either way, we have an error.
1.333 + */
1.334 + if( cnt!=1 ){
1.335 + const char *zErr;
1.336 + zErr = cnt==0 ? "no such column" : "ambiguous column name";
1.337 + if( zDb ){
1.338 + sqlite3ErrorMsg(pParse, "%s: %s.%s.%s", zErr, zDb, zTab, zCol);
1.339 + }else if( zTab ){
1.340 + sqlite3ErrorMsg(pParse, "%s: %s.%s", zErr, zTab, zCol);
1.341 + }else{
1.342 + sqlite3ErrorMsg(pParse, "%s: %s", zErr, zCol);
1.343 + }
1.344 + pTopNC->nErr++;
1.345 + }
1.346 +
1.347 + /* If a column from a table in pSrcList is referenced, then record
1.348 + ** this fact in the pSrcList.a[].colUsed bitmask. Column 0 causes
1.349 + ** bit 0 to be set. Column 1 sets bit 1. And so forth. If the
1.350 + ** column number is greater than the number of bits in the bitmask
1.351 + ** then set the high-order bit of the bitmask.
1.352 + */
1.353 + if( pExpr->iColumn>=0 && pMatch!=0 ){
1.354 + int n = pExpr->iColumn;
1.355 + testcase( n==sizeof(Bitmask)*8-1 );
1.356 + if( n>=sizeof(Bitmask)*8 ){
1.357 + n = sizeof(Bitmask)*8-1;
1.358 + }
1.359 + assert( pMatch->iCursor==pExpr->iTable );
1.360 + pMatch->colUsed |= ((Bitmask)1)<<n;
1.361 + }
1.362 +
1.363 +lookupname_end:
1.364 + /* Clean up and return
1.365 + */
1.366 + sqlite3DbFree(db, zDb);
1.367 + sqlite3DbFree(db, zTab);
1.368 + sqlite3ExprDelete(db, pExpr->pLeft);
1.369 + pExpr->pLeft = 0;
1.370 + sqlite3ExprDelete(db, pExpr->pRight);
1.371 + pExpr->pRight = 0;
1.372 + pExpr->op = TK_COLUMN;
1.373 +lookupname_end_2:
1.374 + sqlite3DbFree(db, zCol);
1.375 + if( cnt==1 ){
1.376 + assert( pNC!=0 );
1.377 + sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList);
1.378 + /* Increment the nRef value on all name contexts from TopNC up to
1.379 + ** the point where the name matched. */
1.380 + for(;;){
1.381 + assert( pTopNC!=0 );
1.382 + pTopNC->nRef++;
1.383 + if( pTopNC==pNC ) break;
1.384 + pTopNC = pTopNC->pNext;
1.385 + }
1.386 + return 0;
1.387 + } else {
1.388 + return 1;
1.389 + }
1.390 +}
1.391 +
1.392 +/*
1.393 +** This routine is callback for sqlite3WalkExpr().
1.394 +**
1.395 +** Resolve symbolic names into TK_COLUMN operators for the current
1.396 +** node in the expression tree. Return 0 to continue the search down
1.397 +** the tree or 2 to abort the tree walk.
1.398 +**
1.399 +** This routine also does error checking and name resolution for
1.400 +** function names. The operator for aggregate functions is changed
1.401 +** to TK_AGG_FUNCTION.
1.402 +*/
1.403 +static int resolveExprStep(Walker *pWalker, Expr *pExpr){
1.404 + NameContext *pNC;
1.405 + Parse *pParse;
1.406 +
1.407 + pNC = pWalker->u.pNC;
1.408 + assert( pNC!=0 );
1.409 + pParse = pNC->pParse;
1.410 + assert( pParse==pWalker->pParse );
1.411 +
1.412 + if( ExprHasAnyProperty(pExpr, EP_Resolved) ) return WRC_Prune;
1.413 + ExprSetProperty(pExpr, EP_Resolved);
1.414 +#ifndef NDEBUG
1.415 + if( pNC->pSrcList && pNC->pSrcList->nAlloc>0 ){
1.416 + SrcList *pSrcList = pNC->pSrcList;
1.417 + int i;
1.418 + for(i=0; i<pNC->pSrcList->nSrc; i++){
1.419 + assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursor<pParse->nTab);
1.420 + }
1.421 + }
1.422 +#endif
1.423 + switch( pExpr->op ){
1.424 + /* A lone identifier is the name of a column.
1.425 + */
1.426 + case TK_ID: {
1.427 + lookupName(pParse, 0, 0, &pExpr->token, pNC, pExpr);
1.428 + return WRC_Prune;
1.429 + }
1.430 +
1.431 + /* A table name and column name: ID.ID
1.432 + ** Or a database, table and column: ID.ID.ID
1.433 + */
1.434 + case TK_DOT: {
1.435 + Token *pColumn;
1.436 + Token *pTable;
1.437 + Token *pDb;
1.438 + Expr *pRight;
1.439 +
1.440 + /* if( pSrcList==0 ) break; */
1.441 + pRight = pExpr->pRight;
1.442 + if( pRight->op==TK_ID ){
1.443 + pDb = 0;
1.444 + pTable = &pExpr->pLeft->token;
1.445 + pColumn = &pRight->token;
1.446 + }else{
1.447 + assert( pRight->op==TK_DOT );
1.448 + pDb = &pExpr->pLeft->token;
1.449 + pTable = &pRight->pLeft->token;
1.450 + pColumn = &pRight->pRight->token;
1.451 + }
1.452 + lookupName(pParse, pDb, pTable, pColumn, pNC, pExpr);
1.453 + return WRC_Prune;
1.454 + }
1.455 +
1.456 + /* Resolve function names
1.457 + */
1.458 + case TK_CONST_FUNC:
1.459 + case TK_FUNCTION: {
1.460 + ExprList *pList = pExpr->pList; /* The argument list */
1.461 + int n = pList ? pList->nExpr : 0; /* Number of arguments */
1.462 + int no_such_func = 0; /* True if no such function exists */
1.463 + int wrong_num_args = 0; /* True if wrong number of arguments */
1.464 + int is_agg = 0; /* True if is an aggregate function */
1.465 + int auth; /* Authorization to use the function */
1.466 + int nId; /* Number of characters in function name */
1.467 + const char *zId; /* The function name. */
1.468 + FuncDef *pDef; /* Information about the function */
1.469 + int enc = ENC(pParse->db); /* The database encoding */
1.470 +
1.471 + zId = (char*)pExpr->token.z;
1.472 + nId = pExpr->token.n;
1.473 + pDef = sqlite3FindFunction(pParse->db, zId, nId, n, enc, 0);
1.474 + if( pDef==0 ){
1.475 + pDef = sqlite3FindFunction(pParse->db, zId, nId, -1, enc, 0);
1.476 + if( pDef==0 ){
1.477 + no_such_func = 1;
1.478 + }else{
1.479 + wrong_num_args = 1;
1.480 + }
1.481 + }else{
1.482 + is_agg = pDef->xFunc==0;
1.483 + }
1.484 +#ifndef SQLITE_OMIT_AUTHORIZATION
1.485 + if( pDef ){
1.486 + auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0, pDef->zName, 0);
1.487 + if( auth!=SQLITE_OK ){
1.488 + if( auth==SQLITE_DENY ){
1.489 + sqlite3ErrorMsg(pParse, "not authorized to use function: %s",
1.490 + pDef->zName);
1.491 + pNC->nErr++;
1.492 + }
1.493 + pExpr->op = TK_NULL;
1.494 + return WRC_Prune;
1.495 + }
1.496 + }
1.497 +#endif
1.498 + if( is_agg && !pNC->allowAgg ){
1.499 + sqlite3ErrorMsg(pParse, "misuse of aggregate function %.*s()", nId,zId);
1.500 + pNC->nErr++;
1.501 + is_agg = 0;
1.502 + }else if( no_such_func ){
1.503 + sqlite3ErrorMsg(pParse, "no such function: %.*s", nId, zId);
1.504 + pNC->nErr++;
1.505 + }else if( wrong_num_args ){
1.506 + sqlite3ErrorMsg(pParse,"wrong number of arguments to function %.*s()",
1.507 + nId, zId);
1.508 + pNC->nErr++;
1.509 + }
1.510 + if( is_agg ){
1.511 + pExpr->op = TK_AGG_FUNCTION;
1.512 + pNC->hasAgg = 1;
1.513 + }
1.514 + if( is_agg ) pNC->allowAgg = 0;
1.515 + sqlite3WalkExprList(pWalker, pList);
1.516 + if( is_agg ) pNC->allowAgg = 1;
1.517 + /* FIX ME: Compute pExpr->affinity based on the expected return
1.518 + ** type of the function
1.519 + */
1.520 + return WRC_Prune;
1.521 + }
1.522 +#ifndef SQLITE_OMIT_SUBQUERY
1.523 + case TK_SELECT:
1.524 + case TK_EXISTS:
1.525 +#endif
1.526 + case TK_IN: {
1.527 + if( pExpr->pSelect ){
1.528 + int nRef = pNC->nRef;
1.529 +#ifndef SQLITE_OMIT_CHECK
1.530 + if( pNC->isCheck ){
1.531 + sqlite3ErrorMsg(pParse,"subqueries prohibited in CHECK constraints");
1.532 + }
1.533 +#endif
1.534 + sqlite3WalkSelect(pWalker, pExpr->pSelect);
1.535 + assert( pNC->nRef>=nRef );
1.536 + if( nRef!=pNC->nRef ){
1.537 + ExprSetProperty(pExpr, EP_VarSelect);
1.538 + }
1.539 + }
1.540 + break;
1.541 + }
1.542 +#ifndef SQLITE_OMIT_CHECK
1.543 + case TK_VARIABLE: {
1.544 + if( pNC->isCheck ){
1.545 + sqlite3ErrorMsg(pParse,"parameters prohibited in CHECK constraints");
1.546 + }
1.547 + break;
1.548 + }
1.549 +#endif
1.550 + }
1.551 + return (pParse->nErr || pParse->db->mallocFailed) ? WRC_Abort : WRC_Continue;
1.552 +}
1.553 +
1.554 +/*
1.555 +** pEList is a list of expressions which are really the result set of the
1.556 +** a SELECT statement. pE is a term in an ORDER BY or GROUP BY clause.
1.557 +** This routine checks to see if pE is a simple identifier which corresponds
1.558 +** to the AS-name of one of the terms of the expression list. If it is,
1.559 +** this routine return an integer between 1 and N where N is the number of
1.560 +** elements in pEList, corresponding to the matching entry. If there is
1.561 +** no match, or if pE is not a simple identifier, then this routine
1.562 +** return 0.
1.563 +**
1.564 +** pEList has been resolved. pE has not.
1.565 +*/
1.566 +static int resolveAsName(
1.567 + Parse *pParse, /* Parsing context for error messages */
1.568 + ExprList *pEList, /* List of expressions to scan */
1.569 + Expr *pE /* Expression we are trying to match */
1.570 +){
1.571 + int i; /* Loop counter */
1.572 +
1.573 + if( pE->op==TK_ID || (pE->op==TK_STRING && pE->token.z[0]!='\'') ){
1.574 + sqlite3 *db = pParse->db;
1.575 + char *zCol = sqlite3NameFromToken(db, &pE->token);
1.576 + if( zCol==0 ){
1.577 + return -1;
1.578 + }
1.579 + for(i=0; i<pEList->nExpr; i++){
1.580 + char *zAs = pEList->a[i].zName;
1.581 + if( zAs!=0 && sqlite3StrICmp(zAs, zCol)==0 ){
1.582 + sqlite3DbFree(db, zCol);
1.583 + return i+1;
1.584 + }
1.585 + }
1.586 + sqlite3DbFree(db, zCol);
1.587 + }
1.588 + return 0;
1.589 +}
1.590 +
1.591 +/*
1.592 +** pE is a pointer to an expression which is a single term in the
1.593 +** ORDER BY of a compound SELECT. The expression has not been
1.594 +** name resolved.
1.595 +**
1.596 +** At the point this routine is called, we already know that the
1.597 +** ORDER BY term is not an integer index into the result set. That
1.598 +** case is handled by the calling routine.
1.599 +**
1.600 +** Attempt to match pE against result set columns in the left-most
1.601 +** SELECT statement. Return the index i of the matching column,
1.602 +** as an indication to the caller that it should sort by the i-th column.
1.603 +** The left-most column is 1. In other words, the value returned is the
1.604 +** same integer value that would be used in the SQL statement to indicate
1.605 +** the column.
1.606 +**
1.607 +** If there is no match, return 0. Return -1 if an error occurs.
1.608 +*/
1.609 +static int resolveOrderByTermToExprList(
1.610 + Parse *pParse, /* Parsing context for error messages */
1.611 + Select *pSelect, /* The SELECT statement with the ORDER BY clause */
1.612 + Expr *pE /* The specific ORDER BY term */
1.613 +){
1.614 + int i; /* Loop counter */
1.615 + ExprList *pEList; /* The columns of the result set */
1.616 + NameContext nc; /* Name context for resolving pE */
1.617 +
1.618 + assert( sqlite3ExprIsInteger(pE, &i)==0 );
1.619 + pEList = pSelect->pEList;
1.620 +
1.621 + /* Resolve all names in the ORDER BY term expression
1.622 + */
1.623 + memset(&nc, 0, sizeof(nc));
1.624 + nc.pParse = pParse;
1.625 + nc.pSrcList = pSelect->pSrc;
1.626 + nc.pEList = pEList;
1.627 + nc.allowAgg = 1;
1.628 + nc.nErr = 0;
1.629 + if( sqlite3ResolveExprNames(&nc, pE) ){
1.630 + sqlite3ErrorClear(pParse);
1.631 + return 0;
1.632 + }
1.633 +
1.634 + /* Try to match the ORDER BY expression against an expression
1.635 + ** in the result set. Return an 1-based index of the matching
1.636 + ** result-set entry.
1.637 + */
1.638 + for(i=0; i<pEList->nExpr; i++){
1.639 + if( sqlite3ExprCompare(pEList->a[i].pExpr, pE) ){
1.640 + return i+1;
1.641 + }
1.642 + }
1.643 +
1.644 + /* If no match, return 0. */
1.645 + return 0;
1.646 +}
1.647 +
1.648 +/*
1.649 +** Generate an ORDER BY or GROUP BY term out-of-range error.
1.650 +*/
1.651 +static void resolveOutOfRangeError(
1.652 + Parse *pParse, /* The error context into which to write the error */
1.653 + const char *zType, /* "ORDER" or "GROUP" */
1.654 + int i, /* The index (1-based) of the term out of range */
1.655 + int mx /* Largest permissible value of i */
1.656 +){
1.657 + sqlite3ErrorMsg(pParse,
1.658 + "%r %s BY term out of range - should be "
1.659 + "between 1 and %d", i, zType, mx);
1.660 +}
1.661 +
1.662 +/*
1.663 +** Analyze the ORDER BY clause in a compound SELECT statement. Modify
1.664 +** each term of the ORDER BY clause is a constant integer between 1
1.665 +** and N where N is the number of columns in the compound SELECT.
1.666 +**
1.667 +** ORDER BY terms that are already an integer between 1 and N are
1.668 +** unmodified. ORDER BY terms that are integers outside the range of
1.669 +** 1 through N generate an error. ORDER BY terms that are expressions
1.670 +** are matched against result set expressions of compound SELECT
1.671 +** beginning with the left-most SELECT and working toward the right.
1.672 +** At the first match, the ORDER BY expression is transformed into
1.673 +** the integer column number.
1.674 +**
1.675 +** Return the number of errors seen.
1.676 +*/
1.677 +static int resolveCompoundOrderBy(
1.678 + Parse *pParse, /* Parsing context. Leave error messages here */
1.679 + Select *pSelect /* The SELECT statement containing the ORDER BY */
1.680 +){
1.681 + int i;
1.682 + ExprList *pOrderBy;
1.683 + ExprList *pEList;
1.684 + sqlite3 *db;
1.685 + int moreToDo = 1;
1.686 +
1.687 + pOrderBy = pSelect->pOrderBy;
1.688 + if( pOrderBy==0 ) return 0;
1.689 + db = pParse->db;
1.690 +#if SQLITE_MAX_COLUMN
1.691 + if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
1.692 + sqlite3ErrorMsg(pParse, "too many terms in ORDER BY clause");
1.693 + return 1;
1.694 + }
1.695 +#endif
1.696 + for(i=0; i<pOrderBy->nExpr; i++){
1.697 + pOrderBy->a[i].done = 0;
1.698 + }
1.699 + pSelect->pNext = 0;
1.700 + while( pSelect->pPrior ){
1.701 + pSelect->pPrior->pNext = pSelect;
1.702 + pSelect = pSelect->pPrior;
1.703 + }
1.704 + while( pSelect && moreToDo ){
1.705 + struct ExprList_item *pItem;
1.706 + moreToDo = 0;
1.707 + pEList = pSelect->pEList;
1.708 + assert( pEList!=0 );
1.709 + for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
1.710 + int iCol = -1;
1.711 + Expr *pE, *pDup;
1.712 + if( pItem->done ) continue;
1.713 + pE = pItem->pExpr;
1.714 + if( sqlite3ExprIsInteger(pE, &iCol) ){
1.715 + if( iCol<0 || iCol>pEList->nExpr ){
1.716 + resolveOutOfRangeError(pParse, "ORDER", i+1, pEList->nExpr);
1.717 + return 1;
1.718 + }
1.719 + }else{
1.720 + iCol = resolveAsName(pParse, pEList, pE);
1.721 + if( iCol==0 ){
1.722 + pDup = sqlite3ExprDup(db, pE);
1.723 + if( !db->mallocFailed ){
1.724 + assert(pDup);
1.725 + iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup);
1.726 + }
1.727 + sqlite3ExprDelete(db, pDup);
1.728 + }
1.729 + if( iCol<0 ){
1.730 + return 1;
1.731 + }
1.732 + }
1.733 + if( iCol>0 ){
1.734 + CollSeq *pColl = pE->pColl;
1.735 + int flags = pE->flags & EP_ExpCollate;
1.736 + sqlite3ExprDelete(db, pE);
1.737 + pItem->pExpr = pE = sqlite3Expr(db, TK_INTEGER, 0, 0, 0);
1.738 + if( pE==0 ) return 1;
1.739 + pE->pColl = pColl;
1.740 + pE->flags |= EP_IntValue | flags;
1.741 + pE->iTable = iCol;
1.742 + pItem->iCol = iCol;
1.743 + pItem->done = 1;
1.744 + }else{
1.745 + moreToDo = 1;
1.746 + }
1.747 + }
1.748 + pSelect = pSelect->pNext;
1.749 + }
1.750 + for(i=0; i<pOrderBy->nExpr; i++){
1.751 + if( pOrderBy->a[i].done==0 ){
1.752 + sqlite3ErrorMsg(pParse, "%r ORDER BY term does not match any "
1.753 + "column in the result set", i+1);
1.754 + return 1;
1.755 + }
1.756 + }
1.757 + return 0;
1.758 +}
1.759 +
1.760 +/*
1.761 +** Check every term in the ORDER BY or GROUP BY clause pOrderBy of
1.762 +** the SELECT statement pSelect. If any term is reference to a
1.763 +** result set expression (as determined by the ExprList.a.iCol field)
1.764 +** then convert that term into a copy of the corresponding result set
1.765 +** column.
1.766 +**
1.767 +** If any errors are detected, add an error message to pParse and
1.768 +** return non-zero. Return zero if no errors are seen.
1.769 +*/
1.770 +int sqlite3ResolveOrderGroupBy(
1.771 + Parse *pParse, /* Parsing context. Leave error messages here */
1.772 + Select *pSelect, /* The SELECT statement containing the clause */
1.773 + ExprList *pOrderBy, /* The ORDER BY or GROUP BY clause to be processed */
1.774 + const char *zType /* "ORDER" or "GROUP" */
1.775 +){
1.776 + int i;
1.777 + sqlite3 *db = pParse->db;
1.778 + ExprList *pEList;
1.779 + struct ExprList_item *pItem;
1.780 +
1.781 + if( pOrderBy==0 || pParse->db->mallocFailed ) return 0;
1.782 +#if SQLITE_MAX_COLUMN
1.783 + if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
1.784 + sqlite3ErrorMsg(pParse, "too many terms in %s BY clause", zType);
1.785 + return 1;
1.786 + }
1.787 +#endif
1.788 + pEList = pSelect->pEList;
1.789 + assert( pEList!=0 ); /* sqlite3SelectNew() guarantees this */
1.790 + for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
1.791 + if( pItem->iCol ){
1.792 + if( pItem->iCol>pEList->nExpr ){
1.793 + resolveOutOfRangeError(pParse, zType, i+1, pEList->nExpr);
1.794 + return 1;
1.795 + }
1.796 + resolveAlias(pParse, pEList, pItem->iCol-1, pItem->pExpr, zType);
1.797 + }
1.798 + }
1.799 + return 0;
1.800 +}
1.801 +
1.802 +/*
1.803 +** pOrderBy is an ORDER BY or GROUP BY clause in SELECT statement pSelect.
1.804 +** The Name context of the SELECT statement is pNC. zType is either
1.805 +** "ORDER" or "GROUP" depending on which type of clause pOrderBy is.
1.806 +**
1.807 +** This routine resolves each term of the clause into an expression.
1.808 +** If the order-by term is an integer I between 1 and N (where N is the
1.809 +** number of columns in the result set of the SELECT) then the expression
1.810 +** in the resolution is a copy of the I-th result-set expression. If
1.811 +** the order-by term is an identify that corresponds to the AS-name of
1.812 +** a result-set expression, then the term resolves to a copy of the
1.813 +** result-set expression. Otherwise, the expression is resolved in
1.814 +** the usual way - using sqlite3ResolveExprNames().
1.815 +**
1.816 +** This routine returns the number of errors. If errors occur, then
1.817 +** an appropriate error message might be left in pParse. (OOM errors
1.818 +** excepted.)
1.819 +*/
1.820 +static int resolveOrderGroupBy(
1.821 + NameContext *pNC, /* The name context of the SELECT statement */
1.822 + Select *pSelect, /* The SELECT statement holding pOrderBy */
1.823 + ExprList *pOrderBy, /* An ORDER BY or GROUP BY clause to resolve */
1.824 + const char *zType /* Either "ORDER" or "GROUP", as appropriate */
1.825 +){
1.826 + int i; /* Loop counter */
1.827 + int iCol; /* Column number */
1.828 + struct ExprList_item *pItem; /* A term of the ORDER BY clause */
1.829 + Parse *pParse; /* Parsing context */
1.830 + int nResult; /* Number of terms in the result set */
1.831 +
1.832 + if( pOrderBy==0 ) return 0;
1.833 + nResult = pSelect->pEList->nExpr;
1.834 + pParse = pNC->pParse;
1.835 + for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
1.836 + Expr *pE = pItem->pExpr;
1.837 + iCol = resolveAsName(pParse, pSelect->pEList, pE);
1.838 + if( iCol<0 ){
1.839 + return 1; /* OOM error */
1.840 + }
1.841 + if( iCol>0 ){
1.842 + /* If an AS-name match is found, mark this ORDER BY column as being
1.843 + ** a copy of the iCol-th result-set column. The subsequent call to
1.844 + ** sqlite3ResolveOrderGroupBy() will convert the expression to a
1.845 + ** copy of the iCol-th result-set expression. */
1.846 + pItem->iCol = iCol;
1.847 + continue;
1.848 + }
1.849 + if( sqlite3ExprIsInteger(pE, &iCol) ){
1.850 + /* The ORDER BY term is an integer constant. Again, set the column
1.851 + ** number so that sqlite3ResolveOrderGroupBy() will convert the
1.852 + ** order-by term to a copy of the result-set expression */
1.853 + if( iCol<1 ){
1.854 + resolveOutOfRangeError(pParse, zType, i+1, nResult);
1.855 + return 1;
1.856 + }
1.857 + pItem->iCol = iCol;
1.858 + continue;
1.859 + }
1.860 +
1.861 + /* Otherwise, treat the ORDER BY term as an ordinary expression */
1.862 + pItem->iCol = 0;
1.863 + if( sqlite3ResolveExprNames(pNC, pE) ){
1.864 + return 1;
1.865 + }
1.866 + }
1.867 + return sqlite3ResolveOrderGroupBy(pParse, pSelect, pOrderBy, zType);
1.868 +}
1.869 +
1.870 +/*
1.871 +** Resolve names in the SELECT statement p and all of its descendents.
1.872 +*/
1.873 +static int resolveSelectStep(Walker *pWalker, Select *p){
1.874 + NameContext *pOuterNC; /* Context that contains this SELECT */
1.875 + NameContext sNC; /* Name context of this SELECT */
1.876 + int isCompound; /* True if p is a compound select */
1.877 + int nCompound; /* Number of compound terms processed so far */
1.878 + Parse *pParse; /* Parsing context */
1.879 + ExprList *pEList; /* Result set expression list */
1.880 + int i; /* Loop counter */
1.881 + ExprList *pGroupBy; /* The GROUP BY clause */
1.882 + Select *pLeftmost; /* Left-most of SELECT of a compound */
1.883 + sqlite3 *db; /* Database connection */
1.884 +
1.885 +
1.886 + assert( p!=0 );
1.887 + if( p->selFlags & SF_Resolved ){
1.888 + return WRC_Prune;
1.889 + }
1.890 + pOuterNC = pWalker->u.pNC;
1.891 + pParse = pWalker->pParse;
1.892 + db = pParse->db;
1.893 +
1.894 + /* Normally sqlite3SelectExpand() will be called first and will have
1.895 + ** already expanded this SELECT. However, if this is a subquery within
1.896 + ** an expression, sqlite3ResolveExprNames() will be called without a
1.897 + ** prior call to sqlite3SelectExpand(). When that happens, let
1.898 + ** sqlite3SelectPrep() do all of the processing for this SELECT.
1.899 + ** sqlite3SelectPrep() will invoke both sqlite3SelectExpand() and
1.900 + ** this routine in the correct order.
1.901 + */
1.902 + if( (p->selFlags & SF_Expanded)==0 ){
1.903 + sqlite3SelectPrep(pParse, p, pOuterNC);
1.904 + return (pParse->nErr || db->mallocFailed) ? WRC_Abort : WRC_Prune;
1.905 + }
1.906 +
1.907 + isCompound = p->pPrior!=0;
1.908 + nCompound = 0;
1.909 + pLeftmost = p;
1.910 + while( p ){
1.911 + assert( (p->selFlags & SF_Expanded)!=0 );
1.912 + assert( (p->selFlags & SF_Resolved)==0 );
1.913 + p->selFlags |= SF_Resolved;
1.914 +
1.915 + /* Resolve the expressions in the LIMIT and OFFSET clauses. These
1.916 + ** are not allowed to refer to any names, so pass an empty NameContext.
1.917 + */
1.918 + memset(&sNC, 0, sizeof(sNC));
1.919 + sNC.pParse = pParse;
1.920 + if( sqlite3ResolveExprNames(&sNC, p->pLimit) ||
1.921 + sqlite3ResolveExprNames(&sNC, p->pOffset) ){
1.922 + return WRC_Abort;
1.923 + }
1.924 +
1.925 + /* Set up the local name-context to pass to sqlite3ResolveExprNames() to
1.926 + ** resolve the result-set expression list.
1.927 + */
1.928 + sNC.allowAgg = 1;
1.929 + sNC.pSrcList = p->pSrc;
1.930 + sNC.pNext = pOuterNC;
1.931 +
1.932 + /* Resolve names in the result set. */
1.933 + pEList = p->pEList;
1.934 + assert( pEList!=0 );
1.935 + for(i=0; i<pEList->nExpr; i++){
1.936 + Expr *pX = pEList->a[i].pExpr;
1.937 + if( sqlite3ResolveExprNames(&sNC, pX) ){
1.938 + return WRC_Abort;
1.939 + }
1.940 + }
1.941 +
1.942 + /* Recursively resolve names in all subqueries
1.943 + */
1.944 + for(i=0; i<p->pSrc->nSrc; i++){
1.945 + struct SrcList_item *pItem = &p->pSrc->a[i];
1.946 + if( pItem->pSelect ){
1.947 + const char *zSavedContext = pParse->zAuthContext;
1.948 + if( pItem->zName ) pParse->zAuthContext = pItem->zName;
1.949 + sqlite3ResolveSelectNames(pParse, pItem->pSelect, &sNC);
1.950 + pParse->zAuthContext = zSavedContext;
1.951 + if( pParse->nErr || db->mallocFailed ) return WRC_Abort;
1.952 + }
1.953 + }
1.954 +
1.955 + /* If there are no aggregate functions in the result-set, and no GROUP BY
1.956 + ** expression, do not allow aggregates in any of the other expressions.
1.957 + */
1.958 + assert( (p->selFlags & SF_Aggregate)==0 );
1.959 + pGroupBy = p->pGroupBy;
1.960 + if( pGroupBy || sNC.hasAgg ){
1.961 + p->selFlags |= SF_Aggregate;
1.962 + }else{
1.963 + sNC.allowAgg = 0;
1.964 + }
1.965 +
1.966 + /* If a HAVING clause is present, then there must be a GROUP BY clause.
1.967 + */
1.968 + if( p->pHaving && !pGroupBy ){
1.969 + sqlite3ErrorMsg(pParse, "a GROUP BY clause is required before HAVING");
1.970 + return WRC_Abort;
1.971 + }
1.972 +
1.973 + /* Add the expression list to the name-context before parsing the
1.974 + ** other expressions in the SELECT statement. This is so that
1.975 + ** expressions in the WHERE clause (etc.) can refer to expressions by
1.976 + ** aliases in the result set.
1.977 + **
1.978 + ** Minor point: If this is the case, then the expression will be
1.979 + ** re-evaluated for each reference to it.
1.980 + */
1.981 + sNC.pEList = p->pEList;
1.982 + if( sqlite3ResolveExprNames(&sNC, p->pWhere) ||
1.983 + sqlite3ResolveExprNames(&sNC, p->pHaving)
1.984 + ){
1.985 + return WRC_Abort;
1.986 + }
1.987 +
1.988 + /* The ORDER BY and GROUP BY clauses may not refer to terms in
1.989 + ** outer queries
1.990 + */
1.991 + sNC.pNext = 0;
1.992 + sNC.allowAgg = 1;
1.993 +
1.994 + /* Process the ORDER BY clause for singleton SELECT statements.
1.995 + ** The ORDER BY clause for compounds SELECT statements is handled
1.996 + ** below, after all of the result-sets for all of the elements of
1.997 + ** the compound have been resolved.
1.998 + */
1.999 + if( !isCompound && resolveOrderGroupBy(&sNC, p, p->pOrderBy, "ORDER") ){
1.1000 + return WRC_Abort;
1.1001 + }
1.1002 + if( db->mallocFailed ){
1.1003 + return WRC_Abort;
1.1004 + }
1.1005 +
1.1006 + /* Resolve the GROUP BY clause. At the same time, make sure
1.1007 + ** the GROUP BY clause does not contain aggregate functions.
1.1008 + */
1.1009 + if( pGroupBy ){
1.1010 + struct ExprList_item *pItem;
1.1011 +
1.1012 + if( resolveOrderGroupBy(&sNC, p, pGroupBy, "GROUP") || db->mallocFailed ){
1.1013 + return WRC_Abort;
1.1014 + }
1.1015 + for(i=0, pItem=pGroupBy->a; i<pGroupBy->nExpr; i++, pItem++){
1.1016 + if( ExprHasProperty(pItem->pExpr, EP_Agg) ){
1.1017 + sqlite3ErrorMsg(pParse, "aggregate functions are not allowed in "
1.1018 + "the GROUP BY clause");
1.1019 + return WRC_Abort;
1.1020 + }
1.1021 + }
1.1022 + }
1.1023 +
1.1024 + /* Advance to the next term of the compound
1.1025 + */
1.1026 + p = p->pPrior;
1.1027 + nCompound++;
1.1028 + }
1.1029 +
1.1030 + /* Resolve the ORDER BY on a compound SELECT after all terms of
1.1031 + ** the compound have been resolved.
1.1032 + */
1.1033 + if( isCompound && resolveCompoundOrderBy(pParse, pLeftmost) ){
1.1034 + return WRC_Abort;
1.1035 + }
1.1036 +
1.1037 + return WRC_Prune;
1.1038 +}
1.1039 +
1.1040 +/*
1.1041 +** This routine walks an expression tree and resolves references to
1.1042 +** table columns and result-set columns. At the same time, do error
1.1043 +** checking on function usage and set a flag if any aggregate functions
1.1044 +** are seen.
1.1045 +**
1.1046 +** To resolve table columns references we look for nodes (or subtrees) of the
1.1047 +** form X.Y.Z or Y.Z or just Z where
1.1048 +**
1.1049 +** X: The name of a database. Ex: "main" or "temp" or
1.1050 +** the symbolic name assigned to an ATTACH-ed database.
1.1051 +**
1.1052 +** Y: The name of a table in a FROM clause. Or in a trigger
1.1053 +** one of the special names "old" or "new".
1.1054 +**
1.1055 +** Z: The name of a column in table Y.
1.1056 +**
1.1057 +** The node at the root of the subtree is modified as follows:
1.1058 +**
1.1059 +** Expr.op Changed to TK_COLUMN
1.1060 +** Expr.pTab Points to the Table object for X.Y
1.1061 +** Expr.iColumn The column index in X.Y. -1 for the rowid.
1.1062 +** Expr.iTable The VDBE cursor number for X.Y
1.1063 +**
1.1064 +**
1.1065 +** To resolve result-set references, look for expression nodes of the
1.1066 +** form Z (with no X and Y prefix) where the Z matches the right-hand
1.1067 +** size of an AS clause in the result-set of a SELECT. The Z expression
1.1068 +** is replaced by a copy of the left-hand side of the result-set expression.
1.1069 +** Table-name and function resolution occurs on the substituted expression
1.1070 +** tree. For example, in:
1.1071 +**
1.1072 +** SELECT a+b AS x, c+d AS y FROM t1 ORDER BY x;
1.1073 +**
1.1074 +** The "x" term of the order by is replaced by "a+b" to render:
1.1075 +**
1.1076 +** SELECT a+b AS x, c+d AS y FROM t1 ORDER BY a+b;
1.1077 +**
1.1078 +** Function calls are checked to make sure that the function is
1.1079 +** defined and that the correct number of arguments are specified.
1.1080 +** If the function is an aggregate function, then the pNC->hasAgg is
1.1081 +** set and the opcode is changed from TK_FUNCTION to TK_AGG_FUNCTION.
1.1082 +** If an expression contains aggregate functions then the EP_Agg
1.1083 +** property on the expression is set.
1.1084 +**
1.1085 +** An error message is left in pParse if anything is amiss. The number
1.1086 +** if errors is returned.
1.1087 +*/
1.1088 +int sqlite3ResolveExprNames(
1.1089 + NameContext *pNC, /* Namespace to resolve expressions in. */
1.1090 + Expr *pExpr /* The expression to be analyzed. */
1.1091 +){
1.1092 + int savedHasAgg;
1.1093 + Walker w;
1.1094 +
1.1095 + if( pExpr==0 ) return 0;
1.1096 +#if SQLITE_MAX_EXPR_DEPTH>0
1.1097 + {
1.1098 + Parse *pParse = pNC->pParse;
1.1099 + if( sqlite3ExprCheckHeight(pParse, pExpr->nHeight+pNC->pParse->nHeight) ){
1.1100 + return 1;
1.1101 + }
1.1102 + pParse->nHeight += pExpr->nHeight;
1.1103 + }
1.1104 +#endif
1.1105 + savedHasAgg = pNC->hasAgg;
1.1106 + pNC->hasAgg = 0;
1.1107 + w.xExprCallback = resolveExprStep;
1.1108 + w.xSelectCallback = resolveSelectStep;
1.1109 + w.pParse = pNC->pParse;
1.1110 + w.u.pNC = pNC;
1.1111 + sqlite3WalkExpr(&w, pExpr);
1.1112 +#if SQLITE_MAX_EXPR_DEPTH>0
1.1113 + pNC->pParse->nHeight -= pExpr->nHeight;
1.1114 +#endif
1.1115 + if( pNC->nErr>0 ){
1.1116 + ExprSetProperty(pExpr, EP_Error);
1.1117 + }
1.1118 + if( pNC->hasAgg ){
1.1119 + ExprSetProperty(pExpr, EP_Agg);
1.1120 + }else if( savedHasAgg ){
1.1121 + pNC->hasAgg = 1;
1.1122 + }
1.1123 + return ExprHasProperty(pExpr, EP_Error);
1.1124 +}
1.1125 +
1.1126 +
1.1127 +/*
1.1128 +** Resolve all names in all expressions of a SELECT and in all
1.1129 +** decendents of the SELECT, including compounds off of p->pPrior,
1.1130 +** subqueries in expressions, and subqueries used as FROM clause
1.1131 +** terms.
1.1132 +**
1.1133 +** See sqlite3ResolveExprNames() for a description of the kinds of
1.1134 +** transformations that occur.
1.1135 +**
1.1136 +** All SELECT statements should have been expanded using
1.1137 +** sqlite3SelectExpand() prior to invoking this routine.
1.1138 +*/
1.1139 +void sqlite3ResolveSelectNames(
1.1140 + Parse *pParse, /* The parser context */
1.1141 + Select *p, /* The SELECT statement being coded. */
1.1142 + NameContext *pOuterNC /* Name context for parent SELECT statement */
1.1143 +){
1.1144 + Walker w;
1.1145 +
1.1146 + assert( p!=0 );
1.1147 + w.xExprCallback = resolveExprStep;
1.1148 + w.xSelectCallback = resolveSelectStep;
1.1149 + w.pParse = pParse;
1.1150 + w.u.pNC = pOuterNC;
1.1151 + sqlite3WalkSelect(&w, p);
1.1152 +}