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