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