blob: bf6900f239f0380344d1eae03b71c9d17b38debb [file] [log] [blame]
drh7d10d5a2008-08-20 16:35:10 +00001/*
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.
drh7d10d5a2008-08-20 16:35:10 +000016*/
17#include "sqliteInt.h"
drh7d10d5a2008-08-20 16:35:10 +000018
19/*
drhec43d802020-06-29 20:20:40 +000020** Magic table number to mean the EXCLUDED table in an UPSERT statement.
21*/
22#define EXCLUDED_TABLE_NUMBER 2
23
24/*
drhed551b92012-08-23 19:46:11 +000025** 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.
drhc37577b2020-05-24 03:38:37 +000032**
33** See also the sqlite3WindowExtraAggFuncDepth() routine in window.c
drhed551b92012-08-23 19:46:11 +000034*/
35static int incrAggDepth(Walker *pWalker, Expr *pExpr){
drh059b2d52014-10-24 19:28:09 +000036 if( pExpr->op==TK_AGG_FUNCTION ) pExpr->op2 += pWalker->u.n;
drhed551b92012-08-23 19:46:11 +000037 return WRC_Continue;
38}
39static void incrAggFunctionDepth(Expr *pExpr, int N){
40 if( N>0 ){
41 Walker w;
42 memset(&w, 0, sizeof(w));
43 w.xExprCallback = incrAggDepth;
drh059b2d52014-10-24 19:28:09 +000044 w.u.n = N;
drhed551b92012-08-23 19:46:11 +000045 sqlite3WalkExpr(&w, pExpr);
46 }
47}
48
49/*
drh8b213892008-08-29 02:14:02 +000050** Turn the pExpr expression into an alias for the iCol-th column of the
51** result set in pEList.
52**
drh0a8a4062012-12-07 18:38:16 +000053** 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**
drhed551b92012-08-23 19:46:11 +000062** The nSubquery parameter specifies how many levels of subquery the
drh41148f82015-04-23 13:37:05 +000063** alias is removed from the original expression. The usual value is
drhed551b92012-08-23 19:46:11 +000064** 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.
drh8b213892008-08-29 02:14:02 +000067*/
68static 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 */
drhed551b92012-08-23 19:46:11 +000073 int nSubquery /* Number of subqueries that the label is moving */
drh8b213892008-08-29 02:14:02 +000074){
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 );
drh8b213892008-08-29 02:14:02 +000082 db = pParse->db;
drh0a8a4062012-12-07 18:38:16 +000083 pDup = sqlite3ExprDup(db, pOrig, 0);
drh3c6edc82021-04-26 15:28:06 +000084 if( db->mallocFailed ){
85 sqlite3ExprDelete(db, pDup);
86 pDup = 0;
87 }else{
drhc7e93f52021-02-18 00:26:11 +000088 incrAggFunctionDepth(pDup, nSubquery);
drh4344dbd2018-06-02 11:31:15 +000089 if( pExpr->op==TK_COLLATE ){
drhf9751072021-10-07 13:40:29 +000090 assert( !ExprHasProperty(pExpr, EP_IntValue) );
drh4344dbd2018-06-02 11:31:15 +000091 pDup = sqlite3ExprAddCollateString(pParse, pDup, pExpr->u.zToken);
92 }
danf6963f92009-11-23 14:39:14 +000093
drh4344dbd2018-06-02 11:31:15 +000094 /* Before calling sqlite3ExprDelete(), set the EP_Static flag. This
95 ** prevents ExprDelete() from deleting the Expr structure itself,
96 ** allowing it to be repopulated by the memcpy() on the following line.
97 ** The pExpr->u.zToken might point into memory that will be freed by the
98 ** sqlite3DbFree(db, pDup) on the last line of this block, so be sure to
99 ** make a copy of the token before doing the sqlite3DbFree().
100 */
101 ExprSetProperty(pExpr, EP_Static);
102 sqlite3ExprDelete(db, pExpr);
103 memcpy(pExpr, pDup, sizeof(*pExpr));
104 if( !ExprHasProperty(pExpr, EP_IntValue) && pExpr->u.zToken!=0 ){
105 assert( (pExpr->flags & (EP_Reduced|EP_TokenOnly))==0 );
106 pExpr->u.zToken = sqlite3DbStrDup(db, pExpr->u.zToken);
107 pExpr->flags |= EP_MemToken;
108 }
dana51ddb12019-09-26 15:53:37 +0000109 if( ExprHasProperty(pExpr, EP_WinFunc) ){
drhfeef4472021-04-26 21:00:51 +0000110 if( ALWAYS(pExpr->y.pWin!=0) ){
drhd79cd922019-09-26 16:08:35 +0000111 pExpr->y.pWin->pOwner = pExpr;
drhd79cd922019-09-26 16:08:35 +0000112 }
dana51ddb12019-09-26 15:53:37 +0000113 }
drh4344dbd2018-06-02 11:31:15 +0000114 sqlite3DbFree(db, pDup);
drh0a8a4062012-12-07 18:38:16 +0000115 }
drh8b213892008-08-29 02:14:02 +0000116}
117
drhe802c5d2011-10-18 18:10:40 +0000118
119/*
120** Return TRUE if the name zCol occurs anywhere in the USING clause.
121**
122** Return FALSE if the USING clause is NULL or if it does not contain
123** zCol.
124*/
125static int nameInUsingClause(IdList *pUsing, const char *zCol){
126 if( pUsing ){
127 int k;
128 for(k=0; k<pUsing->nId; k++){
129 if( sqlite3StrICmp(pUsing->a[k].zName, zCol)==0 ) return 1;
130 }
131 }
132 return 0;
133}
134
drh3e3f1a52013-01-03 00:45:56 +0000135/*
136** Subqueries stores the original database, table and column names for their
137** result sets in ExprList.a[].zSpan, in the form "DATABASE.TABLE.COLUMN".
138** Check to see if the zSpan given to this routine matches the zDb, zTab,
139** and zCol. If any of zDb, zTab, and zCol are NULL then those fields will
140** match anything.
141*/
drhc4938ea2019-12-13 00:49:42 +0000142int sqlite3MatchEName(
143 const struct ExprList_item *pItem,
drh3e3f1a52013-01-03 00:45:56 +0000144 const char *zCol,
145 const char *zTab,
146 const char *zDb
147){
148 int n;
drhc4938ea2019-12-13 00:49:42 +0000149 const char *zSpan;
drh47f8ef32020-04-04 11:58:22 +0000150 if( pItem->eEName!=ENAME_TAB ) return 0;
drhc4938ea2019-12-13 00:49:42 +0000151 zSpan = pItem->zEName;
drh3e3f1a52013-01-03 00:45:56 +0000152 for(n=0; ALWAYS(zSpan[n]) && zSpan[n]!='.'; n++){}
drhdd1dd482013-02-26 12:57:42 +0000153 if( zDb && (sqlite3StrNICmp(zSpan, zDb, n)!=0 || zDb[n]!=0) ){
drh3e3f1a52013-01-03 00:45:56 +0000154 return 0;
155 }
156 zSpan += n+1;
157 for(n=0; ALWAYS(zSpan[n]) && zSpan[n]!='.'; n++){}
drhdd1dd482013-02-26 12:57:42 +0000158 if( zTab && (sqlite3StrNICmp(zSpan, zTab, n)!=0 || zTab[n]!=0) ){
drh3e3f1a52013-01-03 00:45:56 +0000159 return 0;
160 }
161 zSpan += n+1;
162 if( zCol && sqlite3StrICmp(zSpan, zCol)!=0 ){
163 return 0;
164 }
165 return 1;
166}
drhe802c5d2011-10-18 18:10:40 +0000167
drh8b213892008-08-29 02:14:02 +0000168/*
drhd0ff6012019-06-17 13:56:11 +0000169** Return TRUE if the double-quoted string mis-feature should be supported.
170*/
171static int areDoubleQuotedStringsEnabled(sqlite3 *db, NameContext *pTopNC){
172 if( db->init.busy ) return 1; /* Always support for legacy schemas */
173 if( pTopNC->ncFlags & NC_IsDDL ){
174 /* Currently parsing a DDL statement */
175 if( sqlite3WritableSchema(db) && (db->flags & SQLITE_DqsDML)!=0 ){
176 return 1;
177 }
178 return (db->flags & SQLITE_DqsDDL)!=0;
179 }else{
180 /* Currently parsing a DML statement */
181 return (db->flags & SQLITE_DqsDML)!=0;
182 }
183}
184
185/*
drh74a07982020-03-21 23:10:38 +0000186** The argument is guaranteed to be a non-NULL Expr node of type TK_COLUMN.
187** return the appropriate colUsed mask.
188*/
189Bitmask sqlite3ExprColUsed(Expr *pExpr){
190 int n;
191 Table *pExTab;
192
193 n = pExpr->iColumn;
drh477572b2021-10-07 20:46:29 +0000194 assert( ExprUseYTab(pExpr) );
drh74a07982020-03-21 23:10:38 +0000195 pExTab = pExpr->y.pTab;
196 assert( pExTab!=0 );
197 if( (pExTab->tabFlags & TF_HasGenerated)!=0
198 && (pExTab->aCol[n].colFlags & COLFLAG_GENERATED)!=0
199 ){
200 testcase( pExTab->nCol==BMS-1 );
201 testcase( pExTab->nCol==BMS );
202 return pExTab->nCol>=BMS ? ALLBITS : MASKBIT(pExTab->nCol)-1;
203 }else{
204 testcase( n==BMS-1 );
205 testcase( n==BMS );
206 if( n>=BMS ) n = BMS-1;
207 return ((Bitmask)1)<<n;
208 }
209}
210
211/*
drh7d10d5a2008-08-20 16:35:10 +0000212** Given the name of a column of the form X.Y.Z or Y.Z or just Z, look up
213** that name in the set of source tables in pSrcList and make the pExpr
214** expression node refer back to that source column. The following changes
215** are made to pExpr:
216**
217** pExpr->iDb Set the index in db->aDb[] of the database X
218** (even if X is implied).
219** pExpr->iTable Set to the cursor number for the table obtained
220** from pSrcList.
drheda079c2018-09-20 19:02:15 +0000221** pExpr->y.pTab Points to the Table structure of X.Y (even if
drh7d10d5a2008-08-20 16:35:10 +0000222** X and/or Y are implied.)
223** pExpr->iColumn Set to the column number within the table.
224** pExpr->op Set to TK_COLUMN.
225** pExpr->pLeft Any expression this points to is deleted
226** pExpr->pRight Any expression this points to is deleted.
227**
drhb7916a72009-05-27 10:31:29 +0000228** The zDb variable is the name of the database (the "X"). This value may be
drh7d10d5a2008-08-20 16:35:10 +0000229** NULL meaning that name is of the form Y.Z or Z. Any available database
drhb7916a72009-05-27 10:31:29 +0000230** can be used. The zTable variable is the name of the table (the "Y"). This
231** value can be NULL if zDb is also NULL. If zTable is NULL it
drh7d10d5a2008-08-20 16:35:10 +0000232** means that the form of the name is Z and that columns from any table
233** can be used.
234**
235** If the name cannot be resolved unambiguously, leave an error message
drhf7828b52009-06-15 23:15:59 +0000236** in pParse and return WRC_Abort. Return WRC_Prune on success.
drh7d10d5a2008-08-20 16:35:10 +0000237*/
238static int lookupName(
239 Parse *pParse, /* The parsing context */
drhb7916a72009-05-27 10:31:29 +0000240 const char *zDb, /* Name of the database containing table, or NULL */
241 const char *zTab, /* Name of table containing column, or NULL */
242 const char *zCol, /* Name of the column. */
drh7d10d5a2008-08-20 16:35:10 +0000243 NameContext *pNC, /* The name context used to resolve the name */
244 Expr *pExpr /* Make this EXPR node point to the selected column */
245){
drhed551b92012-08-23 19:46:11 +0000246 int i, j; /* Loop counters */
drh7d10d5a2008-08-20 16:35:10 +0000247 int cnt = 0; /* Number of matching column names */
248 int cntTab = 0; /* Number of matching table names */
drhed551b92012-08-23 19:46:11 +0000249 int nSubquery = 0; /* How many levels of subquery */
drh7d10d5a2008-08-20 16:35:10 +0000250 sqlite3 *db = pParse->db; /* The database connection */
drh76012942021-02-21 21:04:54 +0000251 SrcItem *pItem; /* Use for looping over pSrcList items */
252 SrcItem *pMatch = 0; /* The matching pSrcList item */
drh7d10d5a2008-08-20 16:35:10 +0000253 NameContext *pTopNC = pNC; /* First namecontext in the list */
254 Schema *pSchema = 0; /* Schema of the expression */
drheac9fab2018-04-16 13:00:50 +0000255 int eNewExprOp = TK_COLUMN; /* New value for pExpr->op on success */
drh11f9b032013-10-23 17:39:41 +0000256 Table *pTab = 0; /* Table hold the row */
257 Column *pCol; /* A column of pTab */
drh7d10d5a2008-08-20 16:35:10 +0000258
drhb7916a72009-05-27 10:31:29 +0000259 assert( pNC ); /* the name context cannot be NULL. */
260 assert( zCol ); /* The Z in X.Y.Z cannot be NULL */
drhc5cd1242013-09-12 16:50:49 +0000261 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
drh7d10d5a2008-08-20 16:35:10 +0000262
263 /* Initialize the node to no-match */
264 pExpr->iTable = -1;
drhebb6a652013-09-12 23:42:22 +0000265 ExprSetVVAProperty(pExpr, EP_NoReduce);
drh7d10d5a2008-08-20 16:35:10 +0000266
drh8f25d182012-12-19 02:36:45 +0000267 /* Translate the schema name in zDb into a pointer to the corresponding
268 ** schema. If not found, pSchema will remain NULL and nothing will match
269 ** resulting in an appropriate error message toward the end of this routine
270 */
271 if( zDb ){
drh1e7d43c2013-08-02 14:18:18 +0000272 testcase( pNC->ncFlags & NC_PartIdx );
273 testcase( pNC->ncFlags & NC_IsCheck );
274 if( (pNC->ncFlags & (NC_PartIdx|NC_IsCheck))!=0 ){
drh31e71472015-02-09 10:20:19 +0000275 /* Silently ignore database qualifiers inside CHECK constraints and
276 ** partial indices. Do not raise errors because that might break
277 ** legacy and because it does not hurt anything to just ignore the
278 ** database name. */
drh1e7d43c2013-08-02 14:18:18 +0000279 zDb = 0;
280 }else{
281 for(i=0; i<db->nDb; i++){
drh69c33822016-08-18 14:33:11 +0000282 assert( db->aDb[i].zDbSName );
283 if( sqlite3StrICmp(db->aDb[i].zDbSName,zDb)==0 ){
drh1e7d43c2013-08-02 14:18:18 +0000284 pSchema = db->aDb[i].pSchema;
285 break;
286 }
drh8f25d182012-12-19 02:36:45 +0000287 }
dan00bd55e2020-03-20 20:54:28 +0000288 if( i==db->nDb && sqlite3StrICmp("main", zDb)==0 ){
289 /* This branch is taken when the main database has been renamed
290 ** using SQLITE_DBCONFIG_MAINDBNAME. */
291 pSchema = db->aDb[0].pSchema;
292 zDb = db->aDb[0].zDbSName;
293 }
drh8f25d182012-12-19 02:36:45 +0000294 }
295 }
296
drh7d10d5a2008-08-20 16:35:10 +0000297 /* Start at the inner-most context and move outward until a match is found */
drha92b81f2017-03-07 03:40:48 +0000298 assert( pNC && cnt==0 );
299 do{
drh7d10d5a2008-08-20 16:35:10 +0000300 ExprList *pEList;
301 SrcList *pSrcList = pNC->pSrcList;
302
303 if( pSrcList ){
304 for(i=0, pItem=pSrcList->a; i<pSrcList->nSrc; i++, pItem++){
drhd44390c2020-04-06 18:16:31 +0000305 u8 hCol;
drh7d10d5a2008-08-20 16:35:10 +0000306 pTab = pItem->pTab;
drhf4366202008-08-25 12:14:08 +0000307 assert( pTab!=0 && pTab->zName!=0 );
drh4d466692021-07-02 12:08:12 +0000308 assert( pTab->nCol>0 || pParse->nErr );
drh8f25d182012-12-19 02:36:45 +0000309 if( pItem->pSelect && (pItem->pSelect->selFlags & SF_NestedFrom)!=0 ){
drh8f25d182012-12-19 02:36:45 +0000310 int hit = 0;
drh928d9c62013-02-07 09:33:56 +0000311 pEList = pItem->pSelect->pEList;
drh8f25d182012-12-19 02:36:45 +0000312 for(j=0; j<pEList->nExpr; j++){
drhc4938ea2019-12-13 00:49:42 +0000313 if( sqlite3MatchEName(&pEList->a[j], zCol, zTab, zDb) ){
drh8f25d182012-12-19 02:36:45 +0000314 cnt++;
315 cntTab = 2;
316 pMatch = pItem;
317 pExpr->iColumn = j;
drh38b384a2013-01-03 17:34:28 +0000318 hit = 1;
drh8f25d182012-12-19 02:36:45 +0000319 }
320 }
321 if( hit || zTab==0 ) continue;
322 }
drhceeb04b2021-12-24 13:30:22 +0000323 if( zDb ){
324 if( pTab->pSchema!=pSchema ) continue;
325 if( pSchema==0 && strcmp(zDb,"*")!=0 ) continue;
drhc75e09c2013-01-03 16:54:20 +0000326 }
drh7d10d5a2008-08-20 16:35:10 +0000327 if( zTab ){
drh8f25d182012-12-19 02:36:45 +0000328 const char *zTabName = pItem->zAlias ? pItem->zAlias : pTab->zName;
329 assert( zTabName!=0 );
330 if( sqlite3StrICmp(zTabName, zTab)!=0 ){
331 continue;
drh7d10d5a2008-08-20 16:35:10 +0000332 }
drh477572b2021-10-07 20:46:29 +0000333 assert( ExprUseYTab(pExpr) );
danc9461ec2018-08-29 21:00:16 +0000334 if( IN_RENAME_OBJECT && pItem->zAlias ){
drheda079c2018-09-20 19:02:15 +0000335 sqlite3RenameTokenRemap(pParse, 0, (void*)&pExpr->y.pTab);
danc9461ec2018-08-29 21:00:16 +0000336 }
drh7d10d5a2008-08-20 16:35:10 +0000337 }
drhd44390c2020-04-06 18:16:31 +0000338 hCol = sqlite3StrIHash(zCol);
drh7d10d5a2008-08-20 16:35:10 +0000339 for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
drhcf9d36d2021-08-02 18:03:43 +0000340 if( pCol->hName==hCol
341 && sqlite3StrICmp(pCol->zCnName, zCol)==0
342 ){
drhe802c5d2011-10-18 18:10:40 +0000343 /* If there has been exactly one prior match and this match
344 ** is for the right-hand table of a NATURAL JOIN or is in a
345 ** USING clause, then skip this match.
346 */
347 if( cnt==1 ){
drh8a48b9c2015-08-19 15:20:00 +0000348 if( pItem->fg.jointype & JT_NATURAL ) continue;
drhe802c5d2011-10-18 18:10:40 +0000349 if( nameInUsingClause(pItem->pUsing, zCol) ) continue;
350 }
drh7d10d5a2008-08-20 16:35:10 +0000351 cnt++;
drh7d10d5a2008-08-20 16:35:10 +0000352 pMatch = pItem;
drh7d10d5a2008-08-20 16:35:10 +0000353 /* Substitute the rowid (column -1) for the INTEGER PRIMARY KEY */
shanecf697392009-06-01 16:53:09 +0000354 pExpr->iColumn = j==pTab->iPKey ? -1 : (i16)j;
drh7d10d5a2008-08-20 16:35:10 +0000355 break;
356 }
357 }
danb9248ef2021-07-01 18:19:17 +0000358 if( 0==cnt && VisibleRowid(pTab) ){
359 cntTab++;
360 pMatch = pItem;
361 }
drh7d10d5a2008-08-20 16:35:10 +0000362 }
drh8f25d182012-12-19 02:36:45 +0000363 if( pMatch ){
364 pExpr->iTable = pMatch->iCursor;
drh477572b2021-10-07 20:46:29 +0000365 assert( ExprUseYTab(pExpr) );
drheda079c2018-09-20 19:02:15 +0000366 pExpr->y.pTab = pMatch->pTab;
drh31e71472015-02-09 10:20:19 +0000367 /* RIGHT JOIN not (yet) supported */
drh8a48b9c2015-08-19 15:20:00 +0000368 assert( (pMatch->fg.jointype & JT_RIGHT)==0 );
369 if( (pMatch->fg.jointype & JT_LEFT)!=0 ){
drh72673a22014-12-04 16:27:17 +0000370 ExprSetProperty(pExpr, EP_CanBeNull);
371 }
drheda079c2018-09-20 19:02:15 +0000372 pSchema = pExpr->y.pTab->pSchema;
drh8f25d182012-12-19 02:36:45 +0000373 }
374 } /* if( pSrcList ) */
drh7d10d5a2008-08-20 16:35:10 +0000375
drheac9fab2018-04-16 13:00:50 +0000376#if !defined(SQLITE_OMIT_TRIGGER) || !defined(SQLITE_OMIT_UPSERT)
drh7d10d5a2008-08-20 16:35:10 +0000377 /* If we have not already resolved the name, then maybe
drheac9fab2018-04-16 13:00:50 +0000378 ** it is a new.* or old.* trigger argument reference. Or
drhd5101972021-02-08 13:41:17 +0000379 ** maybe it is an excluded.* from an upsert. Or maybe it is
380 ** a reference in the RETURNING clause to a table being modified.
drh7d10d5a2008-08-20 16:35:10 +0000381 */
drhd5101972021-02-08 13:41:17 +0000382 if( cnt==0 && zDb==0 ){
drheac9fab2018-04-16 13:00:50 +0000383 pTab = 0;
384#ifndef SQLITE_OMIT_TRIGGER
385 if( pParse->pTriggerTab!=0 ){
386 int op = pParse->eTriggerOp;
387 assert( op==TK_DELETE || op==TK_UPDATE || op==TK_INSERT );
drh22af5842021-03-31 23:56:55 +0000388 if( pParse->bReturning ){
389 if( (pNC->ncFlags & NC_UBaseReg)!=0
390 && (zTab==0 || sqlite3StrICmp(zTab,pParse->pTriggerTab->zName)==0)
391 ){
drhd75aeee2021-03-31 17:42:24 +0000392 pExpr->iTable = op!=TK_DELETE;
393 pTab = pParse->pTriggerTab;
394 }
395 }else if( op!=TK_DELETE && zTab && sqlite3StrICmp("new",zTab) == 0 ){
drheac9fab2018-04-16 13:00:50 +0000396 pExpr->iTable = 1;
397 pTab = pParse->pTriggerTab;
drhb8352472021-01-29 19:32:17 +0000398 }else if( op!=TK_INSERT && zTab && sqlite3StrICmp("old",zTab)==0 ){
drheac9fab2018-04-16 13:00:50 +0000399 pExpr->iTable = 0;
400 pTab = pParse->pTriggerTab;
401 }
drh7d10d5a2008-08-20 16:35:10 +0000402 }
drheac9fab2018-04-16 13:00:50 +0000403#endif /* SQLITE_OMIT_TRIGGER */
404#ifndef SQLITE_OMIT_UPSERT
drhd5101972021-02-08 13:41:17 +0000405 if( (pNC->ncFlags & NC_UUpsert)!=0 && zTab!=0 ){
drheac9fab2018-04-16 13:00:50 +0000406 Upsert *pUpsert = pNC->uNC.pUpsert;
407 if( pUpsert && sqlite3StrICmp("excluded",zTab)==0 ){
408 pTab = pUpsert->pUpsertSrc->a[0].pTab;
drhec43d802020-06-29 20:20:40 +0000409 pExpr->iTable = EXCLUDED_TABLE_NUMBER;
drheac9fab2018-04-16 13:00:50 +0000410 }
411 }
412#endif /* SQLITE_OMIT_UPSERT */
drh7d10d5a2008-08-20 16:35:10 +0000413
414 if( pTab ){
415 int iCol;
drhd44390c2020-04-06 18:16:31 +0000416 u8 hCol = sqlite3StrIHash(zCol);
drh7d10d5a2008-08-20 16:35:10 +0000417 pSchema = pTab->pSchema;
418 cntTab++;
drh511717c2013-11-08 17:13:23 +0000419 for(iCol=0, pCol=pTab->aCol; iCol<pTab->nCol; iCol++, pCol++){
drhcf9d36d2021-08-02 18:03:43 +0000420 if( pCol->hName==hCol
421 && sqlite3StrICmp(pCol->zCnName, zCol)==0
422 ){
drh25e978d2009-12-29 23:39:04 +0000423 if( iCol==pTab->iPKey ){
424 iCol = -1;
drh7d10d5a2008-08-20 16:35:10 +0000425 }
drh25e978d2009-12-29 23:39:04 +0000426 break;
drh7d10d5a2008-08-20 16:35:10 +0000427 }
428 }
drhfccda8a2015-05-27 13:06:55 +0000429 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && VisibleRowid(pTab) ){
drhe8a537e2014-08-08 18:26:20 +0000430 /* IMP: R-51414-32910 */
drhbbbb0e82013-11-26 23:27:07 +0000431 iCol = -1;
drh25e978d2009-12-29 23:39:04 +0000432 }
dan2bd93512009-08-31 08:22:46 +0000433 if( iCol<pTab->nCol ){
434 cnt++;
dana7e16a22021-03-05 15:10:33 +0000435 pMatch = 0;
drheac9fab2018-04-16 13:00:50 +0000436#ifndef SQLITE_OMIT_UPSERT
drhec43d802020-06-29 20:20:40 +0000437 if( pExpr->iTable==EXCLUDED_TABLE_NUMBER ){
drh99160482018-04-18 01:34:39 +0000438 testcase( iCol==(-1) );
drh477572b2021-10-07 20:46:29 +0000439 assert( ExprUseYTab(pExpr) );
danc9461ec2018-08-29 21:00:16 +0000440 if( IN_RENAME_OBJECT ){
dan85a9d502018-08-24 20:10:22 +0000441 pExpr->iColumn = iCol;
drheda079c2018-09-20 19:02:15 +0000442 pExpr->y.pTab = pTab;
dan85a9d502018-08-24 20:10:22 +0000443 eNewExprOp = TK_COLUMN;
444 }else{
drhb8fec212020-06-29 20:26:50 +0000445 pExpr->iTable = pNC->uNC.pUpsert->regData +
446 sqlite3TableColumnToStorage(pTab, iCol);
dan85a9d502018-08-24 20:10:22 +0000447 eNewExprOp = TK_REGISTER;
dan85a9d502018-08-24 20:10:22 +0000448 }
drheac9fab2018-04-16 13:00:50 +0000449 }else
drh0a6259f2018-04-16 13:26:53 +0000450#endif /* SQLITE_OMIT_UPSERT */
drheac9fab2018-04-16 13:00:50 +0000451 {
drh477572b2021-10-07 20:46:29 +0000452 assert( ExprUseYTab(pExpr) );
drheda079c2018-09-20 19:02:15 +0000453 pExpr->y.pTab = pTab;
drh552562c2021-02-04 20:52:20 +0000454 if( pParse->bReturning ){
455 eNewExprOp = TK_REGISTER;
dan0d080722021-03-05 15:29:22 +0000456 pExpr->iTable = pNC->uNC.iBaseReg + (pTab->nCol+1)*pExpr->iTable +
457 sqlite3TableColumnToStorage(pTab, iCol) + 1;
drh552562c2021-02-04 20:52:20 +0000458 }else{
459 pExpr->iColumn = (i16)iCol;
460 eNewExprOp = TK_TRIGGER;
461#ifndef SQLITE_OMIT_TRIGGER
drh8873aea2021-02-06 14:37:36 +0000462 if( iCol<0 ){
463 pExpr->affExpr = SQLITE_AFF_INTEGER;
464 }else if( pExpr->iTable==0 ){
drh552562c2021-02-04 20:52:20 +0000465 testcase( iCol==31 );
466 testcase( iCol==32 );
467 pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
468 }else{
469 testcase( iCol==31 );
470 testcase( iCol==32 );
471 pParse->newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
472 }
drh0a6259f2018-04-16 13:26:53 +0000473#endif /* SQLITE_OMIT_TRIGGER */
drh552562c2021-02-04 20:52:20 +0000474 }
dan2bd93512009-08-31 08:22:46 +0000475 }
dan2bd93512009-08-31 08:22:46 +0000476 }
drh7d10d5a2008-08-20 16:35:10 +0000477 }
478 }
drheac9fab2018-04-16 13:00:50 +0000479#endif /* !defined(SQLITE_OMIT_TRIGGER) || !defined(SQLITE_OMIT_UPSERT) */
drh7d10d5a2008-08-20 16:35:10 +0000480
481 /*
482 ** Perhaps the name is a reference to the ROWID
483 */
drh4cbc54b2015-09-19 03:07:30 +0000484 if( cnt==0
485 && cntTab==1
486 && pMatch
drh81f7b372019-10-16 12:18:59 +0000487 && (pNC->ncFlags & (NC_IdxExpr|NC_GenCol))==0
drh4cbc54b2015-09-19 03:07:30 +0000488 && sqlite3IsRowid(zCol)
drhdd513652021-07-02 12:25:30 +0000489 && ALWAYS(VisibleRowid(pMatch->pTab))
drh4cbc54b2015-09-19 03:07:30 +0000490 ){
drh7d10d5a2008-08-20 16:35:10 +0000491 cnt = 1;
drh15427272015-12-03 22:33:55 +0000492 pExpr->iColumn = -1;
drh11949042019-08-05 18:01:42 +0000493 pExpr->affExpr = SQLITE_AFF_INTEGER;
drh7d10d5a2008-08-20 16:35:10 +0000494 }
495
496 /*
497 ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z
498 ** might refer to an result-set alias. This happens, for example, when
499 ** we are resolving names in the WHERE clause of the following command:
500 **
501 ** SELECT a+b AS x FROM table WHERE x<10;
502 **
503 ** In cases like this, replace pExpr with a copy of the expression that
504 ** forms the result set entry ("a+b" in the example) and return immediately.
505 ** Note that the expression in the result set should have already been
506 ** resolved by the time the WHERE clause is resolved.
drhe35463b2013-08-15 20:24:27 +0000507 **
508 ** The ability to use an output result-set column in the WHERE, GROUP BY,
drh5579d592015-08-26 14:01:41 +0000509 ** or HAVING clauses, or as part of a larger expression in the ORDER BY
drhe35463b2013-08-15 20:24:27 +0000510 ** clause is not standard SQL. This is a (goofy) SQLite extension, that
drh5579d592015-08-26 14:01:41 +0000511 ** is supported for backwards compatibility only. Hence, we issue a warning
drhe35463b2013-08-15 20:24:27 +0000512 ** on sqlite3_log() whenever the capability is used.
drh7d10d5a2008-08-20 16:35:10 +0000513 */
drhde0e1b12021-04-16 22:53:57 +0000514 if( cnt==0
515 && (pNC->ncFlags & NC_UEList)!=0
drh25c3b8c2018-04-16 10:34:13 +0000516 && zTab==0
drha3a5bd92013-04-13 19:59:58 +0000517 ){
drh25c3b8c2018-04-16 10:34:13 +0000518 pEList = pNC->uNC.pEList;
519 assert( pEList!=0 );
drh7d10d5a2008-08-20 16:35:10 +0000520 for(j=0; j<pEList->nExpr; j++){
drh9fc1b9a2020-01-02 22:23:01 +0000521 char *zAs = pEList->a[j].zEName;
drhc4938ea2019-12-13 00:49:42 +0000522 if( pEList->a[j].eEName==ENAME_NAME
dan607dd6e2020-01-03 14:27:08 +0000523 && sqlite3_stricmp(zAs, zCol)==0
drhc4938ea2019-12-13 00:49:42 +0000524 ){
drh8b213892008-08-29 02:14:02 +0000525 Expr *pOrig;
drh7d10d5a2008-08-20 16:35:10 +0000526 assert( pExpr->pLeft==0 && pExpr->pRight==0 );
drha4eeccd2021-10-07 17:43:30 +0000527 assert( ExprUseXList(pExpr)==0 || pExpr->x.pList==0 );
528 assert( ExprUseXSelect(pExpr)==0 || pExpr->x.pSelect==0 );
drh7d10d5a2008-08-20 16:35:10 +0000529 pOrig = pEList->a[j].pExpr;
drha51009b2012-05-21 19:11:25 +0000530 if( (pNC->ncFlags&NC_AllowAgg)==0 && ExprHasProperty(pOrig, EP_Agg) ){
drh7d10d5a2008-08-20 16:35:10 +0000531 sqlite3ErrorMsg(pParse, "misuse of aliased aggregate %s", zAs);
drhf7828b52009-06-15 23:15:59 +0000532 return WRC_Abort;
drh7d10d5a2008-08-20 16:35:10 +0000533 }
dane3735bf2019-12-27 19:46:07 +0000534 if( ExprHasProperty(pOrig, EP_Win)
535 && ((pNC->ncFlags&NC_AllowWin)==0 || pNC!=pTopNC )
536 ){
dan4ded26a2019-03-28 16:15:05 +0000537 sqlite3ErrorMsg(pParse, "misuse of aliased window function %s",zAs);
538 return WRC_Abort;
539 }
dan3bafded2016-11-11 15:49:01 +0000540 if( sqlite3ExprVectorSize(pOrig)!=1 ){
541 sqlite3ErrorMsg(pParse, "row value misused");
542 return WRC_Abort;
543 }
drh6b37b762021-02-16 20:32:17 +0000544 resolveAlias(pParse, pEList, j, pExpr, nSubquery);
drh7d10d5a2008-08-20 16:35:10 +0000545 cnt = 1;
546 pMatch = 0;
547 assert( zTab==0 && zDb==0 );
danc9461ec2018-08-29 21:00:16 +0000548 if( IN_RENAME_OBJECT ){
dan1b0c5de2018-08-24 16:04:26 +0000549 sqlite3RenameTokenRemap(pParse, 0, (void*)pExpr);
550 }
drhb7916a72009-05-27 10:31:29 +0000551 goto lookupname_end;
drh7d10d5a2008-08-20 16:35:10 +0000552 }
553 }
554 }
555
556 /* Advance to the next name context. The loop will exit when either
557 ** we have a match (cnt>0) or when we run out of name contexts.
558 */
drha92b81f2017-03-07 03:40:48 +0000559 if( cnt ) break;
560 pNC = pNC->pNext;
561 nSubquery++;
562 }while( pNC );
563
drh7d10d5a2008-08-20 16:35:10 +0000564
565 /*
566 ** If X and Y are NULL (in other words if only the column name Z is
567 ** supplied) and the value of Z is enclosed in double-quotes, then
568 ** Z is a string literal if it doesn't match any column names. In that
569 ** case, we need to return right away and not make any changes to
570 ** pExpr.
571 **
572 ** Because no reference was made to outer contexts, the pNC->nRef
573 ** fields are not changed in any context.
574 */
drh007c8432018-02-26 03:20:18 +0000575 if( cnt==0 && zTab==0 ){
drh171d16b2018-02-26 20:15:54 +0000576 assert( pExpr->op==TK_ID );
drhd0ff6012019-06-17 13:56:11 +0000577 if( ExprHasProperty(pExpr,EP_DblQuoted)
578 && areDoubleQuotedStringsEnabled(db, pTopNC)
dan0d925712019-05-20 17:14:25 +0000579 ){
drhec8fc622018-12-06 16:11:14 +0000580 /* If a double-quoted identifier does not match any known column name,
581 ** then treat it as a string.
582 **
583 ** This hack was added in the early days of SQLite in a misguided attempt
584 ** to be compatible with MySQL 3.x, which used double-quotes for strings.
585 ** I now sorely regret putting in this hack. The effect of this hack is
586 ** that misspelled identifier names are silently converted into strings
587 ** rather than causing an error, to the frustration of countless
588 ** programmers. To all those frustrated programmers, my apologies.
589 **
590 ** Someday, I hope to get rid of this hack. Unfortunately there is
591 ** a huge amount of legacy SQL that uses it. So for now, we just
592 ** issue a warning.
593 */
594 sqlite3_log(SQLITE_WARNING,
595 "double-quoted string literal: \"%w\"", zCol);
drh893bd372018-12-07 16:32:11 +0000596#ifdef SQLITE_ENABLE_NORMALIZE
drh1a6c2b12018-12-10 20:01:40 +0000597 sqlite3VdbeAddDblquoteStr(db, pParse->pVdbe, zCol);
drh893bd372018-12-07 16:32:11 +0000598#endif
drh007c8432018-02-26 03:20:18 +0000599 pExpr->op = TK_STRING;
drh477572b2021-10-07 20:46:29 +0000600 memset(&pExpr->y, 0, sizeof(pExpr->y));
drh007c8432018-02-26 03:20:18 +0000601 return WRC_Prune;
602 }
drh171d16b2018-02-26 20:15:54 +0000603 if( sqlite3ExprIdToTrueFalse(pExpr) ){
drh007c8432018-02-26 03:20:18 +0000604 return WRC_Prune;
605 }
drh7d10d5a2008-08-20 16:35:10 +0000606 }
607
608 /*
609 ** cnt==0 means there was not match. cnt>1 means there were two or
610 ** more matches. Either way, we have an error.
611 */
612 if( cnt!=1 ){
613 const char *zErr;
614 zErr = cnt==0 ? "no such column" : "ambiguous column name";
615 if( zDb ){
616 sqlite3ErrorMsg(pParse, "%s: %s.%s.%s", zErr, zDb, zTab, zCol);
617 }else if( zTab ){
618 sqlite3ErrorMsg(pParse, "%s: %s.%s", zErr, zTab, zCol);
619 }else{
620 sqlite3ErrorMsg(pParse, "%s: %s", zErr, zCol);
621 }
dan1db95102010-06-28 10:15:19 +0000622 pParse->checkSchema = 1;
drh050611a2021-04-10 13:37:04 +0000623 pTopNC->nNcErr++;
drh7d10d5a2008-08-20 16:35:10 +0000624 }
625
626 /* If a column from a table in pSrcList is referenced, then record
627 ** this fact in the pSrcList.a[].colUsed bitmask. Column 0 causes
drhbf9d0992019-12-08 00:06:39 +0000628 ** bit 0 to be set. Column 1 sets bit 1. And so forth. Bit 63 is
629 ** set if the 63rd or any subsequent column is used.
drh522ebfa2019-11-21 19:37:00 +0000630 **
631 ** The colUsed mask is an optimization used to help determine if an
632 ** index is a covering index. The correct answer is still obtained
drhbf9d0992019-12-08 00:06:39 +0000633 ** if the mask contains extra set bits. However, it is important to
634 ** avoid setting bits beyond the maximum column number of the table.
635 ** (See ticket [b92e5e8ec2cdbaa1]).
drh522ebfa2019-11-21 19:37:00 +0000636 **
drhbf9d0992019-12-08 00:06:39 +0000637 ** If a generated column is referenced, set bits for every column
638 ** of the table.
drh7d10d5a2008-08-20 16:35:10 +0000639 */
danielk19772d2e7bd2009-02-24 10:14:40 +0000640 if( pExpr->iColumn>=0 && pMatch!=0 ){
drh74a07982020-03-21 23:10:38 +0000641 pMatch->colUsed |= sqlite3ExprColUsed(pExpr);
drh7d10d5a2008-08-20 16:35:10 +0000642 }
643
drh7d10d5a2008-08-20 16:35:10 +0000644 /* Clean up and return
645 */
drh7b7a9cf2021-02-18 00:59:16 +0000646 if( !ExprHasProperty(pExpr,(EP_TokenOnly|EP_Leaf)) ){
647 sqlite3ExprDelete(db, pExpr->pLeft);
648 pExpr->pLeft = 0;
649 sqlite3ExprDelete(db, pExpr->pRight);
650 pExpr->pRight = 0;
651 }
drheac9fab2018-04-16 13:00:50 +0000652 pExpr->op = eNewExprOp;
drhb98a2e32017-07-07 12:43:57 +0000653 ExprSetProperty(pExpr, EP_Leaf);
drhb7916a72009-05-27 10:31:29 +0000654lookupname_end:
drh7d10d5a2008-08-20 16:35:10 +0000655 if( cnt==1 ){
656 assert( pNC!=0 );
drh2d7a6912021-03-01 21:43:25 +0000657#ifndef SQLITE_OMIT_AUTHORIZATION
drh552562c2021-02-04 20:52:20 +0000658 if( pParse->db->xAuth
drh29f6a362021-02-05 17:34:47 +0000659 && (pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER)
drh552562c2021-02-04 20:52:20 +0000660 ){
drha3a5bd92013-04-13 19:59:58 +0000661 sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList);
662 }
drh2d7a6912021-03-01 21:43:25 +0000663#endif
drh7d10d5a2008-08-20 16:35:10 +0000664 /* Increment the nRef value on all name contexts from TopNC up to
665 ** the point where the name matched. */
666 for(;;){
667 assert( pTopNC!=0 );
668 pTopNC->nRef++;
669 if( pTopNC==pNC ) break;
670 pTopNC = pTopNC->pNext;
671 }
drhf7828b52009-06-15 23:15:59 +0000672 return WRC_Prune;
drh7d10d5a2008-08-20 16:35:10 +0000673 } else {
drhf7828b52009-06-15 23:15:59 +0000674 return WRC_Abort;
drh7d10d5a2008-08-20 16:35:10 +0000675 }
676}
677
678/*
danf7b0b0a2009-10-19 15:52:32 +0000679** Allocate and return a pointer to an expression to load the column iCol
drh9e481652010-04-08 17:35:34 +0000680** from datasource iSrc in SrcList pSrc.
danf7b0b0a2009-10-19 15:52:32 +0000681*/
682Expr *sqlite3CreateColumnExpr(sqlite3 *db, SrcList *pSrc, int iSrc, int iCol){
683 Expr *p = sqlite3ExprAlloc(db, TK_COLUMN, 0, 0);
684 if( p ){
drh76012942021-02-21 21:04:54 +0000685 SrcItem *pItem = &pSrc->a[iSrc];
drh477572b2021-10-07 20:46:29 +0000686 Table *pTab;
687 assert( ExprUseYTab(p) );
688 pTab = p->y.pTab = pItem->pTab;
danf7b0b0a2009-10-19 15:52:32 +0000689 p->iTable = pItem->iCursor;
drheda079c2018-09-20 19:02:15 +0000690 if( p->y.pTab->iPKey==iCol ){
danf7b0b0a2009-10-19 15:52:32 +0000691 p->iColumn = -1;
692 }else{
drh8677d302009-11-04 13:17:14 +0000693 p->iColumn = (ynVar)iCol;
drh0824d5b2019-12-09 18:22:17 +0000694 if( (pTab->tabFlags & TF_HasGenerated)!=0
695 && (pTab->aCol[iCol].colFlags & COLFLAG_GENERATED)!=0
696 ){
697 testcase( pTab->nCol==63 );
698 testcase( pTab->nCol==64 );
699 pItem->colUsed = pTab->nCol>=64 ? ALLBITS : MASKBIT(pTab->nCol)-1;
drh926f7962019-12-09 17:14:48 +0000700 }else{
701 testcase( iCol==BMS );
702 testcase( iCol==BMS-1 );
703 pItem->colUsed |= ((Bitmask)1)<<(iCol>=BMS ? BMS-1 : iCol);
704 }
danf7b0b0a2009-10-19 15:52:32 +0000705 }
danf7b0b0a2009-10-19 15:52:32 +0000706 }
707 return p;
708}
709
710/*
drha514b8e2015-08-25 00:27:06 +0000711** Report an error that an expression is not valid for some set of
drh03bf26d2015-08-31 21:16:36 +0000712** pNC->ncFlags values determined by validMask.
drh77318a32019-12-12 15:19:18 +0000713**
714** static void notValid(
715** Parse *pParse, // Leave error message here
716** NameContext *pNC, // The name context
717** const char *zMsg, // Type of error
718** int validMask, // Set of contexts for which prohibited
719** Expr *pExpr // Invalidate this expression on error
720** ){...}
721**
722** As an optimization, since the conditional is almost always false
723** (because errors are rare), the conditional is moved outside of the
724** function call using a macro.
drh3780be12013-07-31 19:05:22 +0000725*/
drh77318a32019-12-12 15:19:18 +0000726static void notValidImpl(
727 Parse *pParse, /* Leave error message here */
728 NameContext *pNC, /* The name context */
729 const char *zMsg, /* Type of error */
730 Expr *pExpr /* Invalidate this expression on error */
drh3780be12013-07-31 19:05:22 +0000731){
drh77318a32019-12-12 15:19:18 +0000732 const char *zIn = "partial index WHERE clauses";
733 if( pNC->ncFlags & NC_IdxExpr ) zIn = "index expressions";
drh3780be12013-07-31 19:05:22 +0000734#ifndef SQLITE_OMIT_CHECK
drh77318a32019-12-12 15:19:18 +0000735 else if( pNC->ncFlags & NC_IsCheck ) zIn = "CHECK constraints";
drha514b8e2015-08-25 00:27:06 +0000736#endif
drh81f7b372019-10-16 12:18:59 +0000737#ifndef SQLITE_OMIT_GENERATED_COLUMNS
drh77318a32019-12-12 15:19:18 +0000738 else if( pNC->ncFlags & NC_GenCol ) zIn = "generated columns";
drh81f7b372019-10-16 12:18:59 +0000739#endif
drh77318a32019-12-12 15:19:18 +0000740 sqlite3ErrorMsg(pParse, "%s prohibited in %s", zMsg, zIn);
741 if( pExpr ) pExpr->op = TK_NULL;
drh3780be12013-07-31 19:05:22 +0000742}
drh77318a32019-12-12 15:19:18 +0000743#define sqlite3ResolveNotValid(P,N,M,X,E) \
744 assert( ((X)&~(NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol))==0 ); \
745 if( ((N)->ncFlags & (X))!=0 ) notValidImpl(P,N,M,E);
drh3780be12013-07-31 19:05:22 +0000746
drhcca9f3d2013-09-06 15:23:29 +0000747/*
748** Expression p should encode a floating point value between 1.0 and 0.0.
749** Return 1024 times this value. Or return -1 if p is not a floating point
750** value between 1.0 and 0.0.
751*/
752static int exprProbability(Expr *p){
753 double r = -1.0;
754 if( p->op!=TK_FLOAT ) return -1;
drhf9751072021-10-07 13:40:29 +0000755 assert( !ExprHasProperty(p, EP_IntValue) );
drhcca9f3d2013-09-06 15:23:29 +0000756 sqlite3AtoF(p->u.zToken, &r, sqlite3Strlen30(p->u.zToken), SQLITE_UTF8);
drh09328c02013-09-11 14:34:58 +0000757 assert( r>=0.0 );
758 if( r>1.0 ) return -1;
drhd05ab6a2014-10-25 13:42:16 +0000759 return (int)(r*134217728.0);
drhcca9f3d2013-09-06 15:23:29 +0000760}
drh3780be12013-07-31 19:05:22 +0000761
762/*
drh7d10d5a2008-08-20 16:35:10 +0000763** This routine is callback for sqlite3WalkExpr().
764**
765** Resolve symbolic names into TK_COLUMN operators for the current
766** node in the expression tree. Return 0 to continue the search down
767** the tree or 2 to abort the tree walk.
768**
769** This routine also does error checking and name resolution for
770** function names. The operator for aggregate functions is changed
771** to TK_AGG_FUNCTION.
772*/
773static int resolveExprStep(Walker *pWalker, Expr *pExpr){
774 NameContext *pNC;
775 Parse *pParse;
776
drh7d10d5a2008-08-20 16:35:10 +0000777 pNC = pWalker->u.pNC;
778 assert( pNC!=0 );
779 pParse = pNC->pParse;
780 assert( pParse==pWalker->pParse );
781
drh7d10d5a2008-08-20 16:35:10 +0000782#ifndef NDEBUG
783 if( pNC->pSrcList && pNC->pSrcList->nAlloc>0 ){
784 SrcList *pSrcList = pNC->pSrcList;
785 int i;
786 for(i=0; i<pNC->pSrcList->nSrc; i++){
787 assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursor<pParse->nTab);
788 }
789 }
790#endif
791 switch( pExpr->op ){
drh41204f12008-10-06 13:54:35 +0000792
drh41204f12008-10-06 13:54:35 +0000793 /* The special operator TK_ROW means use the rowid for the first
794 ** column in the FROM clause. This is used by the LIMIT and ORDER BY
danbe952c12020-07-13 20:10:29 +0000795 ** clause processing on UPDATE and DELETE statements, and by
796 ** UPDATE ... FROM statement processing.
drh41204f12008-10-06 13:54:35 +0000797 */
798 case TK_ROW: {
799 SrcList *pSrcList = pNC->pSrcList;
drh76012942021-02-21 21:04:54 +0000800 SrcItem *pItem;
danf2972b62020-04-29 20:11:01 +0000801 assert( pSrcList && pSrcList->nSrc>=1 );
drh2fba3942017-11-09 03:55:09 +0000802 pItem = pSrcList->a;
drh41204f12008-10-06 13:54:35 +0000803 pExpr->op = TK_COLUMN;
drh477572b2021-10-07 20:46:29 +0000804 assert( ExprUseYTab(pExpr) );
drheda079c2018-09-20 19:02:15 +0000805 pExpr->y.pTab = pItem->pTab;
drh41204f12008-10-06 13:54:35 +0000806 pExpr->iTable = pItem->iCursor;
dan576d5a82020-07-15 18:30:01 +0000807 pExpr->iColumn--;
drhaf97c3f2019-08-08 18:49:16 +0000808 pExpr->affExpr = SQLITE_AFF_INTEGER;
drh41204f12008-10-06 13:54:35 +0000809 break;
810 }
drh41204f12008-10-06 13:54:35 +0000811
drh45e4cb82021-03-09 19:52:15 +0000812 /* An optimization: Attempt to convert
dan8ddf6862021-02-26 20:14:32 +0000813 **
drh45e4cb82021-03-09 19:52:15 +0000814 ** "expr IS NOT NULL" --> "TRUE"
815 ** "expr IS NULL" --> "FALSE"
816 **
817 ** if we can prove that "expr" is never NULL. Call this the
818 ** "NOT NULL strength reduction optimization".
819 **
820 ** If this optimization occurs, also restore the NameContext ref-counts
821 ** to the state they where in before the "column" LHS expression was
822 ** resolved. This prevents "column" from being counted as having been
823 ** referenced, which might prevent a SELECT from being erroneously
824 ** marked as correlated.
dan8ddf6862021-02-26 20:14:32 +0000825 */
826 case TK_NOTNULL:
827 case TK_ISNULL: {
828 int anRef[8];
829 NameContext *p;
830 int i;
831 for(i=0, p=pNC; p && i<ArraySize(anRef); p=p->pNext, i++){
832 anRef[i] = p->nRef;
833 }
834 sqlite3WalkExpr(pWalker, pExpr->pLeft);
dan3083d5f2021-03-03 11:00:31 +0000835 if( 0==sqlite3ExprCanBeNull(pExpr->pLeft) && !IN_RENAME_OBJECT ){
drh348e0022021-07-22 16:07:01 +0000836 testcase( ExprHasProperty(pExpr, EP_FromJoin) );
drhf9751072021-10-07 13:40:29 +0000837 assert( !ExprHasProperty(pExpr, EP_IntValue) );
dan8ddf6862021-02-26 20:14:32 +0000838 if( pExpr->op==TK_NOTNULL ){
839 pExpr->u.zToken = "true";
840 ExprSetProperty(pExpr, EP_IsTrue);
841 }else{
842 pExpr->u.zToken = "false";
843 ExprSetProperty(pExpr, EP_IsFalse);
844 }
845 pExpr->op = TK_TRUEFALSE;
846 for(i=0, p=pNC; p && i<ArraySize(anRef); p=p->pNext, i++){
847 p->nRef = anRef[i];
848 }
849 sqlite3ExprDelete(pParse->db, pExpr->pLeft);
850 pExpr->pLeft = 0;
851 }
852 return WRC_Prune;
853 }
854
drh3cf48e32017-03-07 03:25:52 +0000855 /* A column name: ID
856 ** Or table name and column name: ID.ID
drh7d10d5a2008-08-20 16:35:10 +0000857 ** Or a database, table and column: ID.ID.ID
drh3cf48e32017-03-07 03:25:52 +0000858 **
859 ** The TK_ID and TK_OUT cases are combined so that there will only
860 ** be one call to lookupName(). Then the compiler will in-line
861 ** lookupName() for a size reduction and performance increase.
drh7d10d5a2008-08-20 16:35:10 +0000862 */
drh3cf48e32017-03-07 03:25:52 +0000863 case TK_ID:
drh7d10d5a2008-08-20 16:35:10 +0000864 case TK_DOT: {
drhb7916a72009-05-27 10:31:29 +0000865 const char *zColumn;
866 const char *zTable;
867 const char *zDb;
drh7d10d5a2008-08-20 16:35:10 +0000868 Expr *pRight;
869
drh3cf48e32017-03-07 03:25:52 +0000870 if( pExpr->op==TK_ID ){
drhb7916a72009-05-27 10:31:29 +0000871 zDb = 0;
drh3cf48e32017-03-07 03:25:52 +0000872 zTable = 0;
drhf9751072021-10-07 13:40:29 +0000873 assert( !ExprHasProperty(pExpr, EP_IntValue) );
drh3cf48e32017-03-07 03:25:52 +0000874 zColumn = pExpr->u.zToken;
drh7d10d5a2008-08-20 16:35:10 +0000875 }else{
danc9461ec2018-08-29 21:00:16 +0000876 Expr *pLeft = pExpr->pLeft;
drh77318a32019-12-12 15:19:18 +0000877 testcase( pNC->ncFlags & NC_IdxExpr );
878 testcase( pNC->ncFlags & NC_GenCol );
879 sqlite3ResolveNotValid(pParse, pNC, "the \".\" operator",
880 NC_IdxExpr|NC_GenCol, 0);
drh3cf48e32017-03-07 03:25:52 +0000881 pRight = pExpr->pRight;
882 if( pRight->op==TK_ID ){
883 zDb = 0;
drh3cf48e32017-03-07 03:25:52 +0000884 }else{
885 assert( pRight->op==TK_DOT );
drhf9751072021-10-07 13:40:29 +0000886 assert( !ExprHasProperty(pRight, EP_IntValue) );
danc9461ec2018-08-29 21:00:16 +0000887 zDb = pLeft->u.zToken;
888 pLeft = pRight->pLeft;
dancf8f2892018-08-09 20:47:01 +0000889 pRight = pRight->pRight;
890 }
drh477572b2021-10-07 20:46:29 +0000891 assert( ExprUseUToken(pLeft) && ExprUseUToken(pRight) );
danc9461ec2018-08-29 21:00:16 +0000892 zTable = pLeft->u.zToken;
dancf8f2892018-08-09 20:47:01 +0000893 zColumn = pRight->u.zToken;
drh477572b2021-10-07 20:46:29 +0000894 assert( ExprUseYTab(pExpr) );
danc9461ec2018-08-29 21:00:16 +0000895 if( IN_RENAME_OBJECT ){
dan07e95232018-08-21 16:32:53 +0000896 sqlite3RenameTokenRemap(pParse, (void*)pExpr, (void*)pRight);
drheda079c2018-09-20 19:02:15 +0000897 sqlite3RenameTokenRemap(pParse, (void*)&pExpr->y.pTab, (void*)pLeft);
danc9461ec2018-08-29 21:00:16 +0000898 }
drh7d10d5a2008-08-20 16:35:10 +0000899 }
drhf7828b52009-06-15 23:15:59 +0000900 return lookupName(pParse, zDb, zTable, zColumn, pNC, pExpr);
drh7d10d5a2008-08-20 16:35:10 +0000901 }
902
903 /* Resolve function names
904 */
drh7d10d5a2008-08-20 16:35:10 +0000905 case TK_FUNCTION: {
danielk19776ab3a2e2009-02-19 14:39:25 +0000906 ExprList *pList = pExpr->x.pList; /* The argument list */
907 int n = pList ? pList->nExpr : 0; /* Number of arguments */
drh7d10d5a2008-08-20 16:35:10 +0000908 int no_such_func = 0; /* True if no such function exists */
909 int wrong_num_args = 0; /* True if wrong number of arguments */
910 int is_agg = 0; /* True if is an aggregate function */
drh7d10d5a2008-08-20 16:35:10 +0000911 int nId; /* Number of characters in function name */
912 const char *zId; /* The function name. */
913 FuncDef *pDef; /* Information about the function */
drhea678832008-12-10 19:26:22 +0000914 u8 enc = ENC(pParse->db); /* The database encoding */
dan4ded26a2019-03-28 16:15:05 +0000915 int savedAllowFlags = (pNC->ncFlags & (NC_AllowAgg | NC_AllowWin));
dan4f9adee2019-07-13 16:22:50 +0000916#ifndef SQLITE_OMIT_WINDOWFUNC
917 Window *pWin = (IsWindowFunc(pExpr) ? pExpr->y.pWin : 0);
918#endif
drhf9751072021-10-07 13:40:29 +0000919 assert( !ExprHasProperty(pExpr, EP_xIsSelect|EP_IntValue) );
drh33e619f2009-05-28 01:00:55 +0000920 zId = pExpr->u.zToken;
drhb7916a72009-05-27 10:31:29 +0000921 nId = sqlite3Strlen30(zId);
drh80738d92016-02-15 00:34:16 +0000922 pDef = sqlite3FindFunction(pParse->db, zId, n, enc, 0);
drh7d10d5a2008-08-20 16:35:10 +0000923 if( pDef==0 ){
drh80738d92016-02-15 00:34:16 +0000924 pDef = sqlite3FindFunction(pParse->db, zId, -2, enc, 0);
drh7d10d5a2008-08-20 16:35:10 +0000925 if( pDef==0 ){
926 no_such_func = 1;
927 }else{
928 wrong_num_args = 1;
929 }
930 }else{
drh2d801512016-01-14 22:19:58 +0000931 is_agg = pDef->xFinalize!=0;
drhcca9f3d2013-09-06 15:23:29 +0000932 if( pDef->funcFlags & SQLITE_FUNC_UNLIKELY ){
drha7d6db62019-06-11 21:02:15 +0000933 ExprSetProperty(pExpr, EP_Unlikely);
drhcca9f3d2013-09-06 15:23:29 +0000934 if( n==2 ){
935 pExpr->iTable = exprProbability(pList->a[1].pExpr);
936 if( pExpr->iTable<0 ){
drh31e71472015-02-09 10:20:19 +0000937 sqlite3ErrorMsg(pParse,
938 "second argument to likelihood() must be a "
939 "constant between 0.0 and 1.0");
drh050611a2021-04-10 13:37:04 +0000940 pNC->nNcErr++;
drhcca9f3d2013-09-06 15:23:29 +0000941 }
942 }else{
drh31e71472015-02-09 10:20:19 +0000943 /* EVIDENCE-OF: R-61304-29449 The unlikely(X) function is
944 ** equivalent to likelihood(X, 0.0625).
945 ** EVIDENCE-OF: R-01283-11636 The unlikely(X) function is
946 ** short-hand for likelihood(X,0.0625).
947 ** EVIDENCE-OF: R-36850-34127 The likely(X) function is short-hand
948 ** for likelihood(X,0.9375).
949 ** EVIDENCE-OF: R-53436-40973 The likely(X) function is equivalent
950 ** to likelihood(X,0.9375). */
drh03202a92014-06-17 16:11:28 +0000951 /* TUNING: unlikely() probability is 0.0625. likely() is 0.9375 */
drhd05ab6a2014-10-25 13:42:16 +0000952 pExpr->iTable = pDef->zName[0]=='u' ? 8388608 : 125829120;
drhcca9f3d2013-09-06 15:23:29 +0000953 }
954 }
drh7d10d5a2008-08-20 16:35:10 +0000955#ifndef SQLITE_OMIT_AUTHORIZATION
drha0daa752016-09-16 11:53:10 +0000956 {
957 int auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0,pDef->zName,0);
958 if( auth!=SQLITE_OK ){
959 if( auth==SQLITE_DENY ){
960 sqlite3ErrorMsg(pParse, "not authorized to use function: %s",
961 pDef->zName);
drh050611a2021-04-10 13:37:04 +0000962 pNC->nNcErr++;
drha0daa752016-09-16 11:53:10 +0000963 }
964 pExpr->op = TK_NULL;
965 return WRC_Prune;
drh7d10d5a2008-08-20 16:35:10 +0000966 }
drh7d10d5a2008-08-20 16:35:10 +0000967 }
drh9588ad92014-09-15 14:46:02 +0000968#endif
drha7f910b2015-09-01 13:17:17 +0000969 if( pDef->funcFlags & (SQLITE_FUNC_CONSTANT|SQLITE_FUNC_SLOCHNG) ){
drh1d85e402015-08-31 17:34:41 +0000970 /* For the purposes of the EP_ConstFunc flag, date and time
drh03bf26d2015-08-31 21:16:36 +0000971 ** functions and other functions that change slowly are considered
drh20cee7d2019-10-30 18:50:08 +0000972 ** constant because they are constant for the duration of one query.
973 ** This allows them to be factored out of inner loops. */
drh63f84572015-02-09 14:07:07 +0000974 ExprSetProperty(pExpr,EP_ConstFunc);
drh1d85e402015-08-31 17:34:41 +0000975 }
976 if( (pDef->funcFlags & SQLITE_FUNC_CONSTANT)==0 ){
drhfe704602020-01-18 21:34:31 +0000977 /* Clearly non-deterministic functions like random(), but also
978 ** date/time functions that use 'now', and other functions like
drha7f910b2015-09-01 13:17:17 +0000979 ** sqlite_version() that might change over time cannot be used
drhfe704602020-01-18 21:34:31 +0000980 ** in an index or generated column. Curiously, they can be used
981 ** in a CHECK constraint. SQLServer, MySQL, and PostgreSQL all
982 ** all this. */
drh77318a32019-12-12 15:19:18 +0000983 sqlite3ResolveNotValid(pParse, pNC, "non-deterministic functions",
drhfe704602020-01-18 21:34:31 +0000984 NC_IdxExpr|NC_PartIdx|NC_GenCol, 0);
drh20cee7d2019-10-30 18:50:08 +0000985 }else{
986 assert( (NC_SelfRef & 0xff)==NC_SelfRef ); /* Must fit in 8 bits */
987 pExpr->op2 = pNC->ncFlags & NC_SelfRef;
drh05b32ee2020-01-09 01:20:03 +0000988 if( pNC->ncFlags & NC_FromDDL ) ExprSetProperty(pExpr, EP_FromDDL);
drh31e71472015-02-09 10:20:19 +0000989 }
drheea8eb62018-11-26 18:09:15 +0000990 if( (pDef->funcFlags & SQLITE_FUNC_INTERNAL)!=0
991 && pParse->nested==0
drh171c50e2020-01-01 15:43:30 +0000992 && (pParse->db->mDbFlags & DBFLAG_InternalFunc)==0
drheea8eb62018-11-26 18:09:15 +0000993 ){
994 /* Internal-use-only functions are disallowed unless the
drh0dfa5252020-01-08 17:28:19 +0000995 ** SQL is being compiled using sqlite3NestedParse() or
996 ** the SQLITE_TESTCTRL_INTERNAL_FUNCTIONS test-control has be
997 ** used to activate internal functionsn for testing purposes */
drheea8eb62018-11-26 18:09:15 +0000998 no_such_func = 1;
999 pDef = 0;
drh2eeca202020-01-08 20:37:45 +00001000 }else
1001 if( (pDef->funcFlags & (SQLITE_FUNC_DIRECT|SQLITE_FUNC_UNSAFE))!=0
1002 && !IN_RENAME_OBJECT
1003 ){
1004 sqlite3ExprFunctionUsable(pParse, pExpr, pDef);
drheea8eb62018-11-26 18:09:15 +00001005 }
drh7d10d5a2008-08-20 16:35:10 +00001006 }
dan26522d12018-06-11 18:16:51 +00001007
danc9461ec2018-08-29 21:00:16 +00001008 if( 0==IN_RENAME_OBJECT ){
dan67a9b8e2018-06-22 20:51:35 +00001009#ifndef SQLITE_OMIT_WINDOWFUNC
dandabc2682018-08-17 17:18:16 +00001010 assert( is_agg==0 || (pDef->funcFlags & SQLITE_FUNC_MINMAX)
dan7262ca92018-07-02 12:07:32 +00001011 || (pDef->xValue==0 && pDef->xInverse==0)
1012 || (pDef->xValue && pDef->xInverse && pDef->xSFunc && pDef->xFinalize)
dan26522d12018-06-11 18:16:51 +00001013 );
dan8117f112019-07-10 20:16:53 +00001014 if( pDef && pDef->xValue==0 && pWin ){
dandabc2682018-08-17 17:18:16 +00001015 sqlite3ErrorMsg(pParse,
1016 "%.*s() may not be used as a window function", nId, zId
1017 );
drh050611a2021-04-10 13:37:04 +00001018 pNC->nNcErr++;
dandabc2682018-08-17 17:18:16 +00001019 }else if(
1020 (is_agg && (pNC->ncFlags & NC_AllowAgg)==0)
dan8117f112019-07-10 20:16:53 +00001021 || (is_agg && (pDef->funcFlags&SQLITE_FUNC_WINDOW) && !pWin)
1022 || (is_agg && pWin && (pNC->ncFlags & NC_AllowWin)==0)
dandabc2682018-08-17 17:18:16 +00001023 ){
1024 const char *zType;
dan8117f112019-07-10 20:16:53 +00001025 if( (pDef->funcFlags & SQLITE_FUNC_WINDOW) || pWin ){
dandabc2682018-08-17 17:18:16 +00001026 zType = "window";
1027 }else{
1028 zType = "aggregate";
1029 }
1030 sqlite3ErrorMsg(pParse, "misuse of %s function %.*s()",zType,nId,zId);
drh050611a2021-04-10 13:37:04 +00001031 pNC->nNcErr++;
dandabc2682018-08-17 17:18:16 +00001032 is_agg = 0;
dan26522d12018-06-11 18:16:51 +00001033 }
danc3163072018-06-23 19:29:56 +00001034#else
dandabc2682018-08-17 17:18:16 +00001035 if( (is_agg && (pNC->ncFlags & NC_AllowAgg)==0) ){
1036 sqlite3ErrorMsg(pParse,"misuse of aggregate function %.*s()",nId,zId);
drh050611a2021-04-10 13:37:04 +00001037 pNC->nNcErr++;
dandabc2682018-08-17 17:18:16 +00001038 is_agg = 0;
1039 }
danc3163072018-06-23 19:29:56 +00001040#endif
drh3a843f52018-08-25 03:29:34 +00001041 else if( no_such_func && pParse->db->init.busy==0
drhcc153132016-08-04 12:35:17 +00001042#ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
dandabc2682018-08-17 17:18:16 +00001043 && pParse->explain==0
drhcc153132016-08-04 12:35:17 +00001044#endif
dandabc2682018-08-17 17:18:16 +00001045 ){
1046 sqlite3ErrorMsg(pParse, "no such function: %.*s", nId, zId);
drh050611a2021-04-10 13:37:04 +00001047 pNC->nNcErr++;
dandabc2682018-08-17 17:18:16 +00001048 }else if( wrong_num_args ){
1049 sqlite3ErrorMsg(pParse,"wrong number of arguments to function %.*s()",
1050 nId, zId);
drh050611a2021-04-10 13:37:04 +00001051 pNC->nNcErr++;
dandabc2682018-08-17 17:18:16 +00001052 }
dan5e61c1b2019-07-13 17:45:25 +00001053#ifndef SQLITE_OMIT_WINDOWFUNC
1054 else if( is_agg==0 && ExprHasProperty(pExpr, EP_WinFunc) ){
1055 sqlite3ErrorMsg(pParse,
1056 "FILTER may not be used with non-aggregate %.*s()",
1057 nId, zId
1058 );
drh050611a2021-04-10 13:37:04 +00001059 pNC->nNcErr++;
dan5e61c1b2019-07-13 17:45:25 +00001060 }
1061#endif
dandabc2682018-08-17 17:18:16 +00001062 if( is_agg ){
dan4ded26a2019-03-28 16:15:05 +00001063 /* Window functions may not be arguments of aggregate functions.
1064 ** Or arguments of other window functions. But aggregate functions
1065 ** may be arguments for window functions. */
dan34a7d792018-06-29 20:43:33 +00001066#ifndef SQLITE_OMIT_WINDOWFUNC
dan8117f112019-07-10 20:16:53 +00001067 pNC->ncFlags &= ~(NC_AllowWin | (!pWin ? NC_AllowAgg : 0));
dan34a7d792018-06-29 20:43:33 +00001068#else
dandabc2682018-08-17 17:18:16 +00001069 pNC->ncFlags &= ~NC_AllowAgg;
dan34a7d792018-06-29 20:43:33 +00001070#endif
dandabc2682018-08-17 17:18:16 +00001071 }
danc3163072018-06-23 19:29:56 +00001072 }
dan9bf022d2019-07-19 14:32:42 +00001073#ifndef SQLITE_OMIT_WINDOWFUNC
dan1e602612019-07-22 11:38:43 +00001074 else if( ExprHasProperty(pExpr, EP_WinFunc) ){
dan9bf022d2019-07-19 14:32:42 +00001075 is_agg = 1;
1076 }
1077#endif
drh7d10d5a2008-08-20 16:35:10 +00001078 sqlite3WalkExprList(pWalker, pList);
drh030796d2012-08-23 16:18:10 +00001079 if( is_agg ){
dan67a9b8e2018-06-22 20:51:35 +00001080#ifndef SQLITE_OMIT_WINDOWFUNC
dan4f9adee2019-07-13 16:22:50 +00001081 if( pWin ){
dane3bf6322018-06-08 20:58:27 +00001082 Select *pSel = pNC->pWinSelect;
drh477572b2021-10-07 20:46:29 +00001083 assert( pWin==0 || (ExprUseYWin(pExpr) && pWin==pExpr->y.pWin) );
dan490e6f22019-04-29 11:27:58 +00001084 if( IN_RENAME_OBJECT==0 ){
drh2e2c8812019-12-13 11:42:56 +00001085 sqlite3WindowUpdate(pParse, pSel ? pSel->pWinDefn : 0, pWin, pDef);
dane8dd6a42021-03-04 16:10:23 +00001086 if( pParse->db->mallocFailed ) break;
dan490e6f22019-04-29 11:27:58 +00001087 }
dan4f9adee2019-07-13 16:22:50 +00001088 sqlite3WalkExprList(pWalker, pWin->pPartition);
1089 sqlite3WalkExprList(pWalker, pWin->pOrderBy);
1090 sqlite3WalkExpr(pWalker, pWin->pFilter);
dana3fcc002019-08-15 13:53:22 +00001091 sqlite3WindowLink(pSel, pWin);
dan4ded26a2019-03-28 16:15:05 +00001092 pNC->ncFlags |= NC_HasWin;
dan67a9b8e2018-06-22 20:51:35 +00001093 }else
1094#endif /* SQLITE_OMIT_WINDOWFUNC */
1095 {
drh90cf38b2021-11-08 23:24:00 +00001096 NameContext *pNC2; /* For looping up thru outer contexts */
dan86fb6e12018-05-16 20:58:07 +00001097 pExpr->op = TK_AGG_FUNCTION;
1098 pExpr->op2 = 0;
dan6ba7ab02019-07-02 11:56:47 +00001099#ifndef SQLITE_OMIT_WINDOWFUNC
dan4f9adee2019-07-13 16:22:50 +00001100 if( ExprHasProperty(pExpr, EP_WinFunc) ){
1101 sqlite3WalkExpr(pWalker, pExpr->y.pWin->pFilter);
1102 }
dan6ba7ab02019-07-02 11:56:47 +00001103#endif
drh90cf38b2021-11-08 23:24:00 +00001104 pNC2 = pNC;
1105 while( pNC2
1106 && sqlite3ReferencesSrcList(pParse, pExpr, pNC2->pSrcList)==0
1107 ){
dan86fb6e12018-05-16 20:58:07 +00001108 pExpr->op2++;
1109 pNC2 = pNC2->pNext;
1110 }
dan72d1eac2019-08-05 13:19:25 +00001111 assert( pDef!=0 || IN_RENAME_OBJECT );
1112 if( pNC2 && pDef ){
dan86fb6e12018-05-16 20:58:07 +00001113 assert( SQLITE_FUNC_MINMAX==NC_MinMaxAgg );
drhbb301232021-07-15 19:29:43 +00001114 assert( SQLITE_FUNC_ANYORDER==NC_OrderAgg );
dan86fb6e12018-05-16 20:58:07 +00001115 testcase( (pDef->funcFlags & SQLITE_FUNC_MINMAX)!=0 );
drhbb301232021-07-15 19:29:43 +00001116 testcase( (pDef->funcFlags & SQLITE_FUNC_ANYORDER)!=0 );
1117 pNC2->ncFlags |= NC_HasAgg
1118 | ((pDef->funcFlags^SQLITE_FUNC_ANYORDER)
1119 & (SQLITE_FUNC_MINMAX|SQLITE_FUNC_ANYORDER));
dan86fb6e12018-05-16 20:58:07 +00001120 }
drh9588ad92014-09-15 14:46:02 +00001121 }
dan4ded26a2019-03-28 16:15:05 +00001122 pNC->ncFlags |= savedAllowFlags;
drh030796d2012-08-23 16:18:10 +00001123 }
drh7d10d5a2008-08-20 16:35:10 +00001124 /* FIX ME: Compute pExpr->affinity based on the expected return
1125 ** type of the function
1126 */
1127 return WRC_Prune;
1128 }
1129#ifndef SQLITE_OMIT_SUBQUERY
1130 case TK_SELECT:
drh73c0fdc2009-06-15 18:32:36 +00001131 case TK_EXISTS: testcase( pExpr->op==TK_EXISTS );
drh7d10d5a2008-08-20 16:35:10 +00001132#endif
1133 case TK_IN: {
drh73c0fdc2009-06-15 18:32:36 +00001134 testcase( pExpr->op==TK_IN );
drha4eeccd2021-10-07 17:43:30 +00001135 if( ExprUseXSelect(pExpr) ){
drh7d10d5a2008-08-20 16:35:10 +00001136 int nRef = pNC->nRef;
drh77318a32019-12-12 15:19:18 +00001137 testcase( pNC->ncFlags & NC_IsCheck );
1138 testcase( pNC->ncFlags & NC_PartIdx );
1139 testcase( pNC->ncFlags & NC_IdxExpr );
1140 testcase( pNC->ncFlags & NC_GenCol );
drh84d90312021-09-24 19:57:32 +00001141 if( pNC->ncFlags & NC_SelfRef ){
1142 notValidImpl(pParse, pNC, "subqueries", pExpr);
1143 }else{
1144 sqlite3WalkSelect(pWalker, pExpr->x.pSelect);
1145 }
drh7d10d5a2008-08-20 16:35:10 +00001146 assert( pNC->nRef>=nRef );
1147 if( nRef!=pNC->nRef ){
1148 ExprSetProperty(pExpr, EP_VarSelect);
drh91da7072016-05-04 14:45:30 +00001149 pNC->ncFlags |= NC_VarSelect;
drh7d10d5a2008-08-20 16:35:10 +00001150 }
1151 }
1152 break;
1153 }
drh7d10d5a2008-08-20 16:35:10 +00001154 case TK_VARIABLE: {
drh77318a32019-12-12 15:19:18 +00001155 testcase( pNC->ncFlags & NC_IsCheck );
1156 testcase( pNC->ncFlags & NC_PartIdx );
1157 testcase( pNC->ncFlags & NC_IdxExpr );
1158 testcase( pNC->ncFlags & NC_GenCol );
1159 sqlite3ResolveNotValid(pParse, pNC, "parameters",
1160 NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol, pExpr);
drh7d10d5a2008-08-20 16:35:10 +00001161 break;
1162 }
drh007c8432018-02-26 03:20:18 +00001163 case TK_IS:
drh8abed7b2018-02-26 18:49:05 +00001164 case TK_ISNOT: {
drh0d950af2019-08-22 16:38:42 +00001165 Expr *pRight = sqlite3ExprSkipCollateAndLikely(pExpr->pRight);
drh8abed7b2018-02-26 18:49:05 +00001166 assert( !ExprHasProperty(pExpr, EP_Reduced) );
1167 /* Handle special cases of "x IS TRUE", "x IS FALSE", "x IS NOT TRUE",
1168 ** and "x IS NOT FALSE". */
drh91be05a2021-03-04 18:34:54 +00001169 if( ALWAYS(pRight) && (pRight->op==TK_ID || pRight->op==TK_TRUEFALSE) ){
drh8abed7b2018-02-26 18:49:05 +00001170 int rc = resolveExprStep(pWalker, pRight);
drh007c8432018-02-26 03:20:18 +00001171 if( rc==WRC_Abort ) return WRC_Abort;
drh8abed7b2018-02-26 18:49:05 +00001172 if( pRight->op==TK_TRUEFALSE ){
drh8abed7b2018-02-26 18:49:05 +00001173 pExpr->op2 = pExpr->op;
1174 pExpr->op = TK_TRUTH;
drh007c8432018-02-26 03:20:18 +00001175 return WRC_Continue;
1176 }
1177 }
drh08b92082020-08-10 14:18:00 +00001178 /* no break */ deliberate_fall_through
drh8abed7b2018-02-26 18:49:05 +00001179 }
dan3bafded2016-11-11 15:49:01 +00001180 case TK_BETWEEN:
drhb29e60c2016-09-05 12:02:34 +00001181 case TK_EQ:
1182 case TK_NE:
1183 case TK_LT:
1184 case TK_LE:
1185 case TK_GT:
drh8abed7b2018-02-26 18:49:05 +00001186 case TK_GE: {
drhb29e60c2016-09-05 12:02:34 +00001187 int nLeft, nRight;
1188 if( pParse->db->mallocFailed ) break;
drhb29e60c2016-09-05 12:02:34 +00001189 assert( pExpr->pLeft!=0 );
1190 nLeft = sqlite3ExprVectorSize(pExpr->pLeft);
dan3bafded2016-11-11 15:49:01 +00001191 if( pExpr->op==TK_BETWEEN ){
drha4eeccd2021-10-07 17:43:30 +00001192 assert( ExprUseXList(pExpr) );
dan3bafded2016-11-11 15:49:01 +00001193 nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[0].pExpr);
1194 if( nRight==nLeft ){
1195 nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[1].pExpr);
1196 }
1197 }else{
1198 assert( pExpr->pRight!=0 );
1199 nRight = sqlite3ExprVectorSize(pExpr->pRight);
1200 }
drhb29e60c2016-09-05 12:02:34 +00001201 if( nLeft!=nRight ){
1202 testcase( pExpr->op==TK_EQ );
1203 testcase( pExpr->op==TK_NE );
1204 testcase( pExpr->op==TK_LT );
1205 testcase( pExpr->op==TK_LE );
1206 testcase( pExpr->op==TK_GT );
1207 testcase( pExpr->op==TK_GE );
1208 testcase( pExpr->op==TK_IS );
1209 testcase( pExpr->op==TK_ISNOT );
dan3bafded2016-11-11 15:49:01 +00001210 testcase( pExpr->op==TK_BETWEEN );
drhb29e60c2016-09-05 12:02:34 +00001211 sqlite3ErrorMsg(pParse, "row value misused");
1212 }
1213 break;
1214 }
drh7d10d5a2008-08-20 16:35:10 +00001215 }
1216 return (pParse->nErr || pParse->db->mallocFailed) ? WRC_Abort : WRC_Continue;
1217}
1218
1219/*
1220** pEList is a list of expressions which are really the result set of the
1221** a SELECT statement. pE is a term in an ORDER BY or GROUP BY clause.
1222** This routine checks to see if pE is a simple identifier which corresponds
1223** to the AS-name of one of the terms of the expression list. If it is,
1224** this routine return an integer between 1 and N where N is the number of
1225** elements in pEList, corresponding to the matching entry. If there is
1226** no match, or if pE is not a simple identifier, then this routine
1227** return 0.
1228**
1229** pEList has been resolved. pE has not.
1230*/
1231static int resolveAsName(
1232 Parse *pParse, /* Parsing context for error messages */
1233 ExprList *pEList, /* List of expressions to scan */
1234 Expr *pE /* Expression we are trying to match */
1235){
1236 int i; /* Loop counter */
1237
shanecf697392009-06-01 16:53:09 +00001238 UNUSED_PARAMETER(pParse);
1239
drh73c0fdc2009-06-15 18:32:36 +00001240 if( pE->op==TK_ID ){
drhf9751072021-10-07 13:40:29 +00001241 const char *zCol;
1242 assert( !ExprHasProperty(pE, EP_IntValue) );
1243 zCol = pE->u.zToken;
drh7d10d5a2008-08-20 16:35:10 +00001244 for(i=0; i<pEList->nExpr; i++){
drhc4938ea2019-12-13 00:49:42 +00001245 if( pEList->a[i].eEName==ENAME_NAME
dan607dd6e2020-01-03 14:27:08 +00001246 && sqlite3_stricmp(pEList->a[i].zEName, zCol)==0
drhc4938ea2019-12-13 00:49:42 +00001247 ){
drh7d10d5a2008-08-20 16:35:10 +00001248 return i+1;
1249 }
1250 }
drh7d10d5a2008-08-20 16:35:10 +00001251 }
1252 return 0;
1253}
1254
1255/*
1256** pE is a pointer to an expression which is a single term in the
1257** ORDER BY of a compound SELECT. The expression has not been
1258** name resolved.
1259**
1260** At the point this routine is called, we already know that the
1261** ORDER BY term is not an integer index into the result set. That
1262** case is handled by the calling routine.
1263**
1264** Attempt to match pE against result set columns in the left-most
1265** SELECT statement. Return the index i of the matching column,
1266** as an indication to the caller that it should sort by the i-th column.
1267** The left-most column is 1. In other words, the value returned is the
1268** same integer value that would be used in the SQL statement to indicate
1269** the column.
1270**
1271** If there is no match, return 0. Return -1 if an error occurs.
1272*/
1273static int resolveOrderByTermToExprList(
1274 Parse *pParse, /* Parsing context for error messages */
1275 Select *pSelect, /* The SELECT statement with the ORDER BY clause */
1276 Expr *pE /* The specific ORDER BY term */
1277){
1278 int i; /* Loop counter */
1279 ExprList *pEList; /* The columns of the result set */
1280 NameContext nc; /* Name context for resolving pE */
drha7564662010-02-22 19:32:31 +00001281 sqlite3 *db; /* Database connection */
1282 int rc; /* Return code from subprocedures */
1283 u8 savedSuppErr; /* Saved value of db->suppressErr */
drh7d10d5a2008-08-20 16:35:10 +00001284
1285 assert( sqlite3ExprIsInteger(pE, &i)==0 );
1286 pEList = pSelect->pEList;
1287
1288 /* Resolve all names in the ORDER BY term expression
1289 */
1290 memset(&nc, 0, sizeof(nc));
1291 nc.pParse = pParse;
1292 nc.pSrcList = pSelect->pSrc;
drh25c3b8c2018-04-16 10:34:13 +00001293 nc.uNC.pEList = pEList;
dand487e372021-04-12 16:59:28 +00001294 nc.ncFlags = NC_AllowAgg|NC_UEList|NC_NoSelect;
drh050611a2021-04-10 13:37:04 +00001295 nc.nNcErr = 0;
drha7564662010-02-22 19:32:31 +00001296 db = pParse->db;
1297 savedSuppErr = db->suppressErr;
danb56a0902021-06-01 15:37:14 +00001298 db->suppressErr = 1;
drha7564662010-02-22 19:32:31 +00001299 rc = sqlite3ResolveExprNames(&nc, pE);
1300 db->suppressErr = savedSuppErr;
1301 if( rc ) return 0;
drh7d10d5a2008-08-20 16:35:10 +00001302
1303 /* Try to match the ORDER BY expression against an expression
1304 ** in the result set. Return an 1-based index of the matching
1305 ** result-set entry.
1306 */
1307 for(i=0; i<pEList->nExpr; i++){
dan5aa550c2017-06-24 18:10:29 +00001308 if( sqlite3ExprCompare(0, pEList->a[i].pExpr, pE, -1)<2 ){
drh7d10d5a2008-08-20 16:35:10 +00001309 return i+1;
1310 }
1311 }
1312
1313 /* If no match, return 0. */
1314 return 0;
1315}
1316
1317/*
1318** Generate an ORDER BY or GROUP BY term out-of-range error.
1319*/
1320static void resolveOutOfRangeError(
1321 Parse *pParse, /* The error context into which to write the error */
1322 const char *zType, /* "ORDER" or "GROUP" */
1323 int i, /* The index (1-based) of the term out of range */
1324 int mx /* Largest permissible value of i */
1325){
1326 sqlite3ErrorMsg(pParse,
1327 "%r %s BY term out of range - should be "
1328 "between 1 and %d", i, zType, mx);
1329}
1330
1331/*
1332** Analyze the ORDER BY clause in a compound SELECT statement. Modify
1333** each term of the ORDER BY clause is a constant integer between 1
1334** and N where N is the number of columns in the compound SELECT.
1335**
1336** ORDER BY terms that are already an integer between 1 and N are
1337** unmodified. ORDER BY terms that are integers outside the range of
1338** 1 through N generate an error. ORDER BY terms that are expressions
1339** are matched against result set expressions of compound SELECT
1340** beginning with the left-most SELECT and working toward the right.
1341** At the first match, the ORDER BY expression is transformed into
1342** the integer column number.
1343**
1344** Return the number of errors seen.
1345*/
1346static int resolveCompoundOrderBy(
1347 Parse *pParse, /* Parsing context. Leave error messages here */
1348 Select *pSelect /* The SELECT statement containing the ORDER BY */
1349){
1350 int i;
1351 ExprList *pOrderBy;
1352 ExprList *pEList;
1353 sqlite3 *db;
1354 int moreToDo = 1;
1355
1356 pOrderBy = pSelect->pOrderBy;
1357 if( pOrderBy==0 ) return 0;
1358 db = pParse->db;
drh7d10d5a2008-08-20 16:35:10 +00001359 if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
1360 sqlite3ErrorMsg(pParse, "too many terms in ORDER BY clause");
1361 return 1;
1362 }
drh7d10d5a2008-08-20 16:35:10 +00001363 for(i=0; i<pOrderBy->nExpr; i++){
1364 pOrderBy->a[i].done = 0;
1365 }
1366 pSelect->pNext = 0;
1367 while( pSelect->pPrior ){
1368 pSelect->pPrior->pNext = pSelect;
1369 pSelect = pSelect->pPrior;
1370 }
1371 while( pSelect && moreToDo ){
1372 struct ExprList_item *pItem;
1373 moreToDo = 0;
1374 pEList = pSelect->pEList;
drh0a846f92008-08-25 17:23:29 +00001375 assert( pEList!=0 );
drh7d10d5a2008-08-20 16:35:10 +00001376 for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
1377 int iCol = -1;
1378 Expr *pE, *pDup;
1379 if( pItem->done ) continue;
drh0d950af2019-08-22 16:38:42 +00001380 pE = sqlite3ExprSkipCollateAndLikely(pItem->pExpr);
drh235667a2020-11-08 20:44:30 +00001381 if( NEVER(pE==0) ) continue;
drh7d10d5a2008-08-20 16:35:10 +00001382 if( sqlite3ExprIsInteger(pE, &iCol) ){
drh73c0fdc2009-06-15 18:32:36 +00001383 if( iCol<=0 || iCol>pEList->nExpr ){
drh7d10d5a2008-08-20 16:35:10 +00001384 resolveOutOfRangeError(pParse, "ORDER", i+1, pEList->nExpr);
1385 return 1;
1386 }
1387 }else{
1388 iCol = resolveAsName(pParse, pEList, pE);
1389 if( iCol==0 ){
dan5e970a82019-01-16 14:58:37 +00001390 /* Now test if expression pE matches one of the values returned
1391 ** by pSelect. In the usual case this is done by duplicating the
1392 ** expression, resolving any symbols in it, and then comparing
1393 ** it against each expression returned by the SELECT statement.
1394 ** Once the comparisons are finished, the duplicate expression
1395 ** is deleted.
1396 **
danb56a0902021-06-01 15:37:14 +00001397 ** If this is running as part of an ALTER TABLE operation and
1398 ** the symbols resolve successfully, also resolve the symbols in the
1399 ** actual expression. This allows the code in alter.c to modify
1400 ** column references within the ORDER BY expression as required. */
1401 pDup = sqlite3ExprDup(db, pE, 0);
drh7d10d5a2008-08-20 16:35:10 +00001402 if( !db->mallocFailed ){
1403 assert(pDup);
1404 iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup);
danb56a0902021-06-01 15:37:14 +00001405 if( IN_RENAME_OBJECT && iCol>0 ){
1406 resolveOrderByTermToExprList(pParse, pSelect, pE);
1407 }
drh7d10d5a2008-08-20 16:35:10 +00001408 }
danb56a0902021-06-01 15:37:14 +00001409 sqlite3ExprDelete(db, pDup);
drh7d10d5a2008-08-20 16:35:10 +00001410 }
drh7d10d5a2008-08-20 16:35:10 +00001411 }
1412 if( iCol>0 ){
drhbd13d342012-12-07 21:02:47 +00001413 /* Convert the ORDER BY term into an integer column number iCol,
danb56a0902021-06-01 15:37:14 +00001414 ** taking care to preserve the COLLATE clause if it exists. */
dana5f9f422019-01-23 19:50:46 +00001415 if( !IN_RENAME_OBJECT ){
1416 Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0);
1417 if( pNew==0 ) return 1;
1418 pNew->flags |= EP_IntValue;
1419 pNew->u.iValue = iCol;
1420 if( pItem->pExpr==pE ){
1421 pItem->pExpr = pNew;
1422 }else{
1423 Expr *pParent = pItem->pExpr;
1424 assert( pParent->op==TK_COLLATE );
1425 while( pParent->pLeft->op==TK_COLLATE ) pParent = pParent->pLeft;
1426 assert( pParent->pLeft==pE );
1427 pParent->pLeft = pNew;
1428 }
1429 sqlite3ExprDelete(db, pE);
1430 pItem->u.x.iOrderByCol = (u16)iCol;
drhbd13d342012-12-07 21:02:47 +00001431 }
drh7d10d5a2008-08-20 16:35:10 +00001432 pItem->done = 1;
1433 }else{
1434 moreToDo = 1;
1435 }
1436 }
1437 pSelect = pSelect->pNext;
1438 }
1439 for(i=0; i<pOrderBy->nExpr; i++){
1440 if( pOrderBy->a[i].done==0 ){
1441 sqlite3ErrorMsg(pParse, "%r ORDER BY term does not match any "
1442 "column in the result set", i+1);
1443 return 1;
1444 }
1445 }
1446 return 0;
1447}
1448
1449/*
1450** Check every term in the ORDER BY or GROUP BY clause pOrderBy of
1451** the SELECT statement pSelect. If any term is reference to a
drhc2acc4e2013-11-15 18:15:19 +00001452** result set expression (as determined by the ExprList.a.u.x.iOrderByCol
1453** field) then convert that term into a copy of the corresponding result set
drh7d10d5a2008-08-20 16:35:10 +00001454** column.
1455**
1456** If any errors are detected, add an error message to pParse and
1457** return non-zero. Return zero if no errors are seen.
1458*/
1459int sqlite3ResolveOrderGroupBy(
1460 Parse *pParse, /* Parsing context. Leave error messages here */
1461 Select *pSelect, /* The SELECT statement containing the clause */
1462 ExprList *pOrderBy, /* The ORDER BY or GROUP BY clause to be processed */
1463 const char *zType /* "ORDER" or "GROUP" */
1464){
1465 int i;
1466 sqlite3 *db = pParse->db;
1467 ExprList *pEList;
1468 struct ExprList_item *pItem;
1469
dan71f059c2019-08-01 10:58:46 +00001470 if( pOrderBy==0 || pParse->db->mallocFailed || IN_RENAME_OBJECT ) return 0;
drh7d10d5a2008-08-20 16:35:10 +00001471 if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
1472 sqlite3ErrorMsg(pParse, "too many terms in %s BY clause", zType);
1473 return 1;
1474 }
drh7d10d5a2008-08-20 16:35:10 +00001475 pEList = pSelect->pEList;
drh0a846f92008-08-25 17:23:29 +00001476 assert( pEList!=0 ); /* sqlite3SelectNew() guarantees this */
drh7d10d5a2008-08-20 16:35:10 +00001477 for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
drhc2acc4e2013-11-15 18:15:19 +00001478 if( pItem->u.x.iOrderByCol ){
1479 if( pItem->u.x.iOrderByCol>pEList->nExpr ){
drh7d10d5a2008-08-20 16:35:10 +00001480 resolveOutOfRangeError(pParse, zType, i+1, pEList->nExpr);
1481 return 1;
1482 }
drh6b37b762021-02-16 20:32:17 +00001483 resolveAlias(pParse, pEList, pItem->u.x.iOrderByCol-1, pItem->pExpr,0);
drh7d10d5a2008-08-20 16:35:10 +00001484 }
1485 }
1486 return 0;
1487}
1488
danf030b372019-02-22 19:24:16 +00001489#ifndef SQLITE_OMIT_WINDOWFUNC
1490/*
dan75b08212019-07-22 16:20:03 +00001491** Walker callback for windowRemoveExprFromSelect().
danf030b372019-02-22 19:24:16 +00001492*/
1493static int resolveRemoveWindowsCb(Walker *pWalker, Expr *pExpr){
drh51755a72019-08-08 19:40:29 +00001494 UNUSED_PARAMETER(pWalker);
danf030b372019-02-22 19:24:16 +00001495 if( ExprHasProperty(pExpr, EP_WinFunc) ){
dan75b08212019-07-22 16:20:03 +00001496 Window *pWin = pExpr->y.pWin;
drhe2094572019-07-22 19:01:38 +00001497 sqlite3WindowUnlinkFromSelect(pWin);
danf030b372019-02-22 19:24:16 +00001498 }
1499 return WRC_Continue;
1500}
1501
1502/*
1503** Remove any Window objects owned by the expression pExpr from the
1504** Select.pWin list of Select object pSelect.
1505*/
dan75b08212019-07-22 16:20:03 +00001506static void windowRemoveExprFromSelect(Select *pSelect, Expr *pExpr){
drhfd15e182019-07-20 21:12:31 +00001507 if( pSelect->pWin ){
1508 Walker sWalker;
1509 memset(&sWalker, 0, sizeof(Walker));
1510 sWalker.xExprCallback = resolveRemoveWindowsCb;
1511 sWalker.u.pSelect = pSelect;
1512 sqlite3WalkExpr(&sWalker, pExpr);
1513 }
danf030b372019-02-22 19:24:16 +00001514}
1515#else
dan75b08212019-07-22 16:20:03 +00001516# define windowRemoveExprFromSelect(a, b)
drhfd15e182019-07-20 21:12:31 +00001517#endif /* SQLITE_OMIT_WINDOWFUNC */
danf030b372019-02-22 19:24:16 +00001518
drh7d10d5a2008-08-20 16:35:10 +00001519/*
1520** pOrderBy is an ORDER BY or GROUP BY clause in SELECT statement pSelect.
1521** The Name context of the SELECT statement is pNC. zType is either
1522** "ORDER" or "GROUP" depending on which type of clause pOrderBy is.
1523**
1524** This routine resolves each term of the clause into an expression.
1525** If the order-by term is an integer I between 1 and N (where N is the
1526** number of columns in the result set of the SELECT) then the expression
1527** in the resolution is a copy of the I-th result-set expression. If
drh26080d92013-08-15 14:27:42 +00001528** the order-by term is an identifier that corresponds to the AS-name of
drh7d10d5a2008-08-20 16:35:10 +00001529** a result-set expression, then the term resolves to a copy of the
1530** result-set expression. Otherwise, the expression is resolved in
1531** the usual way - using sqlite3ResolveExprNames().
1532**
1533** This routine returns the number of errors. If errors occur, then
1534** an appropriate error message might be left in pParse. (OOM errors
1535** excepted.)
1536*/
1537static int resolveOrderGroupBy(
1538 NameContext *pNC, /* The name context of the SELECT statement */
1539 Select *pSelect, /* The SELECT statement holding pOrderBy */
1540 ExprList *pOrderBy, /* An ORDER BY or GROUP BY clause to resolve */
1541 const char *zType /* Either "ORDER" or "GROUP", as appropriate */
1542){
drh70331cd2012-04-27 01:09:06 +00001543 int i, j; /* Loop counters */
drh7d10d5a2008-08-20 16:35:10 +00001544 int iCol; /* Column number */
1545 struct ExprList_item *pItem; /* A term of the ORDER BY clause */
1546 Parse *pParse; /* Parsing context */
1547 int nResult; /* Number of terms in the result set */
1548
drhde0e1b12021-04-16 22:53:57 +00001549 assert( pOrderBy!=0 );
drh7d10d5a2008-08-20 16:35:10 +00001550 nResult = pSelect->pEList->nExpr;
1551 pParse = pNC->pParse;
1552 for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
1553 Expr *pE = pItem->pExpr;
drh0d950af2019-08-22 16:38:42 +00001554 Expr *pE2 = sqlite3ExprSkipCollateAndLikely(pE);
drh235667a2020-11-08 20:44:30 +00001555 if( NEVER(pE2==0) ) continue;
drh0af16ab2013-08-15 22:40:21 +00001556 if( zType[0]!='G' ){
1557 iCol = resolveAsName(pParse, pSelect->pEList, pE2);
1558 if( iCol>0 ){
1559 /* If an AS-name match is found, mark this ORDER BY column as being
1560 ** a copy of the iCol-th result-set column. The subsequent call to
1561 ** sqlite3ResolveOrderGroupBy() will convert the expression to a
1562 ** copy of the iCol-th result-set expression. */
drhc2acc4e2013-11-15 18:15:19 +00001563 pItem->u.x.iOrderByCol = (u16)iCol;
drh0af16ab2013-08-15 22:40:21 +00001564 continue;
1565 }
drh7d10d5a2008-08-20 16:35:10 +00001566 }
drhe35463b2013-08-15 20:24:27 +00001567 if( sqlite3ExprIsInteger(pE2, &iCol) ){
drh7d10d5a2008-08-20 16:35:10 +00001568 /* The ORDER BY term is an integer constant. Again, set the column
1569 ** number so that sqlite3ResolveOrderGroupBy() will convert the
1570 ** order-by term to a copy of the result-set expression */
drh85d641f2012-12-07 23:23:53 +00001571 if( iCol<1 || iCol>0xffff ){
drh7d10d5a2008-08-20 16:35:10 +00001572 resolveOutOfRangeError(pParse, zType, i+1, nResult);
1573 return 1;
1574 }
drhc2acc4e2013-11-15 18:15:19 +00001575 pItem->u.x.iOrderByCol = (u16)iCol;
drh7d10d5a2008-08-20 16:35:10 +00001576 continue;
1577 }
1578
1579 /* Otherwise, treat the ORDER BY term as an ordinary expression */
drhc2acc4e2013-11-15 18:15:19 +00001580 pItem->u.x.iOrderByCol = 0;
drh7d10d5a2008-08-20 16:35:10 +00001581 if( sqlite3ResolveExprNames(pNC, pE) ){
1582 return 1;
1583 }
drh70331cd2012-04-27 01:09:06 +00001584 for(j=0; j<pSelect->pEList->nExpr; j++){
dan5aa550c2017-06-24 18:10:29 +00001585 if( sqlite3ExprCompare(0, pE, pSelect->pEList->a[j].pExpr, -1)==0 ){
danf030b372019-02-22 19:24:16 +00001586 /* Since this expresion is being changed into a reference
1587 ** to an identical expression in the result set, remove all Window
1588 ** objects belonging to the expression from the Select.pWin list. */
dan75b08212019-07-22 16:20:03 +00001589 windowRemoveExprFromSelect(pSelect, pE);
drhc2acc4e2013-11-15 18:15:19 +00001590 pItem->u.x.iOrderByCol = j+1;
drh70331cd2012-04-27 01:09:06 +00001591 }
1592 }
drh7d10d5a2008-08-20 16:35:10 +00001593 }
1594 return sqlite3ResolveOrderGroupBy(pParse, pSelect, pOrderBy, zType);
1595}
1596
1597/*
peter.d.reid60ec9142014-09-06 16:39:46 +00001598** Resolve names in the SELECT statement p and all of its descendants.
drh7d10d5a2008-08-20 16:35:10 +00001599*/
1600static int resolveSelectStep(Walker *pWalker, Select *p){
1601 NameContext *pOuterNC; /* Context that contains this SELECT */
1602 NameContext sNC; /* Name context of this SELECT */
1603 int isCompound; /* True if p is a compound select */
1604 int nCompound; /* Number of compound terms processed so far */
1605 Parse *pParse; /* Parsing context */
drh7d10d5a2008-08-20 16:35:10 +00001606 int i; /* Loop counter */
1607 ExprList *pGroupBy; /* The GROUP BY clause */
1608 Select *pLeftmost; /* Left-most of SELECT of a compound */
1609 sqlite3 *db; /* Database connection */
1610
1611
drh0a846f92008-08-25 17:23:29 +00001612 assert( p!=0 );
drh7d10d5a2008-08-20 16:35:10 +00001613 if( p->selFlags & SF_Resolved ){
1614 return WRC_Prune;
1615 }
1616 pOuterNC = pWalker->u.pNC;
1617 pParse = pWalker->pParse;
1618 db = pParse->db;
1619
1620 /* Normally sqlite3SelectExpand() will be called first and will have
1621 ** already expanded this SELECT. However, if this is a subquery within
1622 ** an expression, sqlite3ResolveExprNames() will be called without a
1623 ** prior call to sqlite3SelectExpand(). When that happens, let
1624 ** sqlite3SelectPrep() do all of the processing for this SELECT.
1625 ** sqlite3SelectPrep() will invoke both sqlite3SelectExpand() and
1626 ** this routine in the correct order.
1627 */
1628 if( (p->selFlags & SF_Expanded)==0 ){
1629 sqlite3SelectPrep(pParse, p, pOuterNC);
1630 return (pParse->nErr || db->mallocFailed) ? WRC_Abort : WRC_Prune;
1631 }
1632
1633 isCompound = p->pPrior!=0;
1634 nCompound = 0;
1635 pLeftmost = p;
1636 while( p ){
1637 assert( (p->selFlags & SF_Expanded)!=0 );
1638 assert( (p->selFlags & SF_Resolved)==0 );
drh9920bf92021-04-12 17:34:03 +00001639 assert( db->suppressErr==0 ); /* SF_Resolved not set if errors suppressed */
drh7d10d5a2008-08-20 16:35:10 +00001640 p->selFlags |= SF_Resolved;
1641
drh9920bf92021-04-12 17:34:03 +00001642
drh7d10d5a2008-08-20 16:35:10 +00001643 /* Resolve the expressions in the LIMIT and OFFSET clauses. These
1644 ** are not allowed to refer to any names, so pass an empty NameContext.
1645 */
1646 memset(&sNC, 0, sizeof(sNC));
1647 sNC.pParse = pParse;
dane3bf6322018-06-08 20:58:27 +00001648 sNC.pWinSelect = p;
drh8c0833f2017-11-14 23:48:23 +00001649 if( sqlite3ResolveExprNames(&sNC, p->pLimit) ){
drh7d10d5a2008-08-20 16:35:10 +00001650 return WRC_Abort;
1651 }
danb33c50f2015-04-04 16:43:16 +00001652
1653 /* If the SF_Converted flags is set, then this Select object was
1654 ** was created by the convertCompoundSelectToSubquery() function.
1655 ** In this case the ORDER BY clause (p->pOrderBy) should be resolved
1656 ** as if it were part of the sub-query, not the parent. This block
1657 ** moves the pOrderBy down to the sub-query. It will be moved back
1658 ** after the names have been resolved. */
1659 if( p->selFlags & SF_Converted ){
1660 Select *pSub = p->pSrc->a[0].pSelect;
drha43f02e2015-04-15 06:45:13 +00001661 assert( p->pSrc->nSrc==1 && p->pOrderBy );
danb33c50f2015-04-04 16:43:16 +00001662 assert( pSub->pPrior && pSub->pOrderBy==0 );
1663 pSub->pOrderBy = p->pOrderBy;
1664 p->pOrderBy = 0;
1665 }
drh7d10d5a2008-08-20 16:35:10 +00001666
drhee612e22021-07-16 20:16:19 +00001667 /* Recursively resolve names in all subqueries in the FROM clause
drh7d10d5a2008-08-20 16:35:10 +00001668 */
1669 for(i=0; i<p->pSrc->nSrc; i++){
drh76012942021-02-21 21:04:54 +00001670 SrcItem *pItem = &p->pSrc->a[i];
dan781b7ac2019-03-22 13:56:49 +00001671 if( pItem->pSelect && (pItem->pSelect->selFlags & SF_Resolved)==0 ){
dan4b174552021-02-26 15:20:17 +00001672 int nRef = pOuterNC ? pOuterNC->nRef : 0;
drh7d10d5a2008-08-20 16:35:10 +00001673 const char *zSavedContext = pParse->zAuthContext;
danda79cf02011-07-08 16:10:54 +00001674
drh7d10d5a2008-08-20 16:35:10 +00001675 if( pItem->zName ) pParse->zAuthContext = pItem->zName;
drhcd2b5612008-12-09 14:03:22 +00001676 sqlite3ResolveSelectNames(pParse, pItem->pSelect, pOuterNC);
drh7d10d5a2008-08-20 16:35:10 +00001677 pParse->zAuthContext = zSavedContext;
1678 if( pParse->nErr || db->mallocFailed ) return WRC_Abort;
danda79cf02011-07-08 16:10:54 +00001679
dan4b174552021-02-26 15:20:17 +00001680 /* If the number of references to the outer context changed when
1681 ** expressions in the sub-select were resolved, the sub-select
1682 ** is correlated. It is not required to check the refcount on any
1683 ** but the innermost outer context object, as lookupName() increments
1684 ** the refcount on all contexts between the current one and the
1685 ** context containing the column when it resolves a name. */
1686 if( pOuterNC ){
1687 assert( pItem->fg.isCorrelated==0 && pOuterNC->nRef>=nRef );
1688 pItem->fg.isCorrelated = (pOuterNC->nRef>nRef);
1689 }
drh7d10d5a2008-08-20 16:35:10 +00001690 }
1691 }
1692
drh92689d22012-12-18 16:07:08 +00001693 /* Set up the local name-context to pass to sqlite3ResolveExprNames() to
1694 ** resolve the result-set expression list.
1695 */
dan86fb6e12018-05-16 20:58:07 +00001696 sNC.ncFlags = NC_AllowAgg|NC_AllowWin;
drh92689d22012-12-18 16:07:08 +00001697 sNC.pSrcList = p->pSrc;
1698 sNC.pNext = pOuterNC;
1699
1700 /* Resolve names in the result set. */
drh01d230c2015-08-19 17:11:37 +00001701 if( sqlite3ResolveExprListNames(&sNC, p->pEList) ) return WRC_Abort;
dan86fb6e12018-05-16 20:58:07 +00001702 sNC.ncFlags &= ~NC_AllowWin;
drh92689d22012-12-18 16:07:08 +00001703
drh7d10d5a2008-08-20 16:35:10 +00001704 /* If there are no aggregate functions in the result-set, and no GROUP BY
1705 ** expression, do not allow aggregates in any of the other expressions.
1706 */
1707 assert( (p->selFlags & SF_Aggregate)==0 );
1708 pGroupBy = p->pGroupBy;
drha51009b2012-05-21 19:11:25 +00001709 if( pGroupBy || (sNC.ncFlags & NC_HasAgg)!=0 ){
drh9588ad92014-09-15 14:46:02 +00001710 assert( NC_MinMaxAgg==SF_MinMaxAgg );
drhbb301232021-07-15 19:29:43 +00001711 assert( NC_OrderAgg==SF_OrderByReqd );
1712 p->selFlags |= SF_Aggregate | (sNC.ncFlags&(NC_MinMaxAgg|NC_OrderAgg));
drh7d10d5a2008-08-20 16:35:10 +00001713 }else{
drha51009b2012-05-21 19:11:25 +00001714 sNC.ncFlags &= ~NC_AllowAgg;
drh7d10d5a2008-08-20 16:35:10 +00001715 }
1716
drh26080d92013-08-15 14:27:42 +00001717 /* Add the output column list to the name-context before parsing the
drh7d10d5a2008-08-20 16:35:10 +00001718 ** other expressions in the SELECT statement. This is so that
1719 ** expressions in the WHERE clause (etc.) can refer to expressions by
1720 ** aliases in the result set.
1721 **
1722 ** Minor point: If this is the case, then the expression will be
1723 ** re-evaluated for each reference to it.
1724 */
drhd5101972021-02-08 13:41:17 +00001725 assert( (sNC.ncFlags & (NC_UAggInfo|NC_UUpsert|NC_UBaseReg))==0 );
drh25c3b8c2018-04-16 10:34:13 +00001726 sNC.uNC.pEList = p->pEList;
1727 sNC.ncFlags |= NC_UEList;
drhde0e1b12021-04-16 22:53:57 +00001728 if( p->pHaving ){
1729 if( !pGroupBy ){
1730 sqlite3ErrorMsg(pParse, "a GROUP BY clause is required before HAVING");
1731 return WRC_Abort;
1732 }
1733 if( sqlite3ResolveExprNames(&sNC, p->pHaving) ) return WRC_Abort;
1734 }
drha3a5bd92013-04-13 19:59:58 +00001735 if( sqlite3ResolveExprNames(&sNC, p->pWhere) ) return WRC_Abort;
drh7d10d5a2008-08-20 16:35:10 +00001736
drh01d230c2015-08-19 17:11:37 +00001737 /* Resolve names in table-valued-function arguments */
1738 for(i=0; i<p->pSrc->nSrc; i++){
drh76012942021-02-21 21:04:54 +00001739 SrcItem *pItem = &p->pSrc->a[i];
drh01d230c2015-08-19 17:11:37 +00001740 if( pItem->fg.isTabFunc
1741 && sqlite3ResolveExprListNames(&sNC, pItem->u1.pFuncArg)
1742 ){
1743 return WRC_Abort;
1744 }
1745 }
1746
danbe120832021-05-17 16:20:41 +00001747#ifndef SQLITE_OMIT_WINDOWFUNC
1748 if( IN_RENAME_OBJECT ){
1749 Window *pWin;
1750 for(pWin=p->pWinDefn; pWin; pWin=pWin->pNextWin){
1751 if( sqlite3ResolveExprListNames(&sNC, pWin->pOrderBy)
1752 || sqlite3ResolveExprListNames(&sNC, pWin->pPartition)
1753 ){
1754 return WRC_Abort;
1755 }
1756 }
1757 }
1758#endif
1759
drh7d10d5a2008-08-20 16:35:10 +00001760 /* The ORDER BY and GROUP BY clauses may not refer to terms in
1761 ** outer queries
1762 */
1763 sNC.pNext = 0;
dan86fb6e12018-05-16 20:58:07 +00001764 sNC.ncFlags |= NC_AllowAgg|NC_AllowWin;
drh7d10d5a2008-08-20 16:35:10 +00001765
danb33c50f2015-04-04 16:43:16 +00001766 /* If this is a converted compound query, move the ORDER BY clause from
1767 ** the sub-query back to the parent query. At this point each term
1768 ** within the ORDER BY clause has been transformed to an integer value.
1769 ** These integers will be replaced by copies of the corresponding result
1770 ** set expressions by the call to resolveOrderGroupBy() below. */
1771 if( p->selFlags & SF_Converted ){
1772 Select *pSub = p->pSrc->a[0].pSelect;
1773 p->pOrderBy = pSub->pOrderBy;
1774 pSub->pOrderBy = 0;
1775 }
1776
drh7d10d5a2008-08-20 16:35:10 +00001777 /* Process the ORDER BY clause for singleton SELECT statements.
1778 ** The ORDER BY clause for compounds SELECT statements is handled
1779 ** below, after all of the result-sets for all of the elements of
1780 ** the compound have been resolved.
drh7b4da152015-04-17 18:52:37 +00001781 **
1782 ** If there is an ORDER BY clause on a term of a compound-select other
1783 ** than the right-most term, then that is a syntax error. But the error
1784 ** is not detected until much later, and so we need to go ahead and
1785 ** resolve those symbols on the incorrect ORDER BY for consistency.
drh7d10d5a2008-08-20 16:35:10 +00001786 */
drhde0e1b12021-04-16 22:53:57 +00001787 if( p->pOrderBy!=0
1788 && isCompound<=nCompound /* Defer right-most ORDER BY of a compound */
drh7b4da152015-04-17 18:52:37 +00001789 && resolveOrderGroupBy(&sNC, p, p->pOrderBy, "ORDER")
1790 ){
drh7d10d5a2008-08-20 16:35:10 +00001791 return WRC_Abort;
1792 }
1793 if( db->mallocFailed ){
1794 return WRC_Abort;
1795 }
dan86fb6e12018-05-16 20:58:07 +00001796 sNC.ncFlags &= ~NC_AllowWin;
drh7d10d5a2008-08-20 16:35:10 +00001797
1798 /* Resolve the GROUP BY clause. At the same time, make sure
1799 ** the GROUP BY clause does not contain aggregate functions.
1800 */
1801 if( pGroupBy ){
1802 struct ExprList_item *pItem;
1803
1804 if( resolveOrderGroupBy(&sNC, p, pGroupBy, "GROUP") || db->mallocFailed ){
1805 return WRC_Abort;
1806 }
1807 for(i=0, pItem=pGroupBy->a; i<pGroupBy->nExpr; i++, pItem++){
1808 if( ExprHasProperty(pItem->pExpr, EP_Agg) ){
1809 sqlite3ErrorMsg(pParse, "aggregate functions are not allowed in "
1810 "the GROUP BY clause");
1811 return WRC_Abort;
1812 }
1813 }
1814 }
1815
dan923cadb2015-06-23 12:19:55 +00001816 /* If this is part of a compound SELECT, check that it has the right
1817 ** number of expressions in the select list. */
1818 if( p->pNext && p->pEList->nExpr!=p->pNext->pEList->nExpr ){
1819 sqlite3SelectWrongNumTermsError(pParse, p->pNext);
1820 return WRC_Abort;
1821 }
1822
drh7d10d5a2008-08-20 16:35:10 +00001823 /* Advance to the next term of the compound
1824 */
1825 p = p->pPrior;
1826 nCompound++;
1827 }
1828
1829 /* Resolve the ORDER BY on a compound SELECT after all terms of
1830 ** the compound have been resolved.
1831 */
1832 if( isCompound && resolveCompoundOrderBy(pParse, pLeftmost) ){
1833 return WRC_Abort;
1834 }
1835
1836 return WRC_Prune;
1837}
1838
1839/*
1840** This routine walks an expression tree and resolves references to
1841** table columns and result-set columns. At the same time, do error
1842** checking on function usage and set a flag if any aggregate functions
1843** are seen.
1844**
1845** To resolve table columns references we look for nodes (or subtrees) of the
1846** form X.Y.Z or Y.Z or just Z where
1847**
1848** X: The name of a database. Ex: "main" or "temp" or
1849** the symbolic name assigned to an ATTACH-ed database.
1850**
1851** Y: The name of a table in a FROM clause. Or in a trigger
1852** one of the special names "old" or "new".
1853**
1854** Z: The name of a column in table Y.
1855**
1856** The node at the root of the subtree is modified as follows:
1857**
1858** Expr.op Changed to TK_COLUMN
1859** Expr.pTab Points to the Table object for X.Y
1860** Expr.iColumn The column index in X.Y. -1 for the rowid.
1861** Expr.iTable The VDBE cursor number for X.Y
1862**
1863**
1864** To resolve result-set references, look for expression nodes of the
1865** form Z (with no X and Y prefix) where the Z matches the right-hand
1866** size of an AS clause in the result-set of a SELECT. The Z expression
1867** is replaced by a copy of the left-hand side of the result-set expression.
1868** Table-name and function resolution occurs on the substituted expression
1869** tree. For example, in:
1870**
1871** SELECT a+b AS x, c+d AS y FROM t1 ORDER BY x;
1872**
1873** The "x" term of the order by is replaced by "a+b" to render:
1874**
1875** SELECT a+b AS x, c+d AS y FROM t1 ORDER BY a+b;
1876**
1877** Function calls are checked to make sure that the function is
1878** defined and that the correct number of arguments are specified.
drha51009b2012-05-21 19:11:25 +00001879** If the function is an aggregate function, then the NC_HasAgg flag is
drh7d10d5a2008-08-20 16:35:10 +00001880** set and the opcode is changed from TK_FUNCTION to TK_AGG_FUNCTION.
1881** If an expression contains aggregate functions then the EP_Agg
1882** property on the expression is set.
1883**
1884** An error message is left in pParse if anything is amiss. The number
1885** if errors is returned.
1886*/
1887int sqlite3ResolveExprNames(
1888 NameContext *pNC, /* Namespace to resolve expressions in. */
1889 Expr *pExpr /* The expression to be analyzed. */
1890){
dan0d925712019-05-20 17:14:25 +00001891 int savedHasAgg;
drh7d10d5a2008-08-20 16:35:10 +00001892 Walker w;
1893
drhd03257c2017-05-31 00:49:40 +00001894 if( pExpr==0 ) return SQLITE_OK;
drhbb301232021-07-15 19:29:43 +00001895 savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg);
1896 pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg);
drh9bfb0242016-01-20 02:21:50 +00001897 w.pParse = pNC->pParse;
drh7d10d5a2008-08-20 16:35:10 +00001898 w.xExprCallback = resolveExprStep;
dand487e372021-04-12 16:59:28 +00001899 w.xSelectCallback = (pNC->ncFlags & NC_NoSelect) ? 0 : resolveSelectStep;
drh9bfb0242016-01-20 02:21:50 +00001900 w.xSelectCallback2 = 0;
drh7d10d5a2008-08-20 16:35:10 +00001901 w.u.pNC = pNC;
drhd03257c2017-05-31 00:49:40 +00001902#if SQLITE_MAX_EXPR_DEPTH>0
1903 w.pParse->nHeight += pExpr->nHeight;
1904 if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){
1905 return SQLITE_ERROR;
1906 }
1907#endif
drh7d10d5a2008-08-20 16:35:10 +00001908 sqlite3WalkExpr(&w, pExpr);
1909#if SQLITE_MAX_EXPR_DEPTH>0
drhd03257c2017-05-31 00:49:40 +00001910 w.pParse->nHeight -= pExpr->nHeight;
drh7d10d5a2008-08-20 16:35:10 +00001911#endif
drhd137f4e2019-03-29 01:15:11 +00001912 assert( EP_Agg==NC_HasAgg );
1913 assert( EP_Win==NC_HasWin );
1914 testcase( pNC->ncFlags & NC_HasAgg );
1915 testcase( pNC->ncFlags & NC_HasWin );
1916 ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) );
drh9588ad92014-09-15 14:46:02 +00001917 pNC->ncFlags |= savedHasAgg;
drh050611a2021-04-10 13:37:04 +00001918 return pNC->nNcErr>0 || w.pParse->nErr>0;
drh7d10d5a2008-08-20 16:35:10 +00001919}
drh7d10d5a2008-08-20 16:35:10 +00001920
drh01d230c2015-08-19 17:11:37 +00001921/*
1922** Resolve all names for all expression in an expression list. This is
1923** just like sqlite3ResolveExprNames() except that it works for an expression
1924** list rather than a single expression.
1925*/
1926int sqlite3ResolveExprListNames(
1927 NameContext *pNC, /* Namespace to resolve expressions in. */
1928 ExprList *pList /* The expression list to be analyzed. */
1929){
drhd8b1bfc2015-08-20 23:21:34 +00001930 int i;
drh4047bdf2020-04-06 20:35:52 +00001931 int savedHasAgg = 0;
1932 Walker w;
1933 if( pList==0 ) return WRC_Continue;
1934 w.pParse = pNC->pParse;
1935 w.xExprCallback = resolveExprStep;
1936 w.xSelectCallback = resolveSelectStep;
1937 w.xSelectCallback2 = 0;
1938 w.u.pNC = pNC;
drhbb301232021-07-15 19:29:43 +00001939 savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg);
1940 pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg);
drh4047bdf2020-04-06 20:35:52 +00001941 for(i=0; i<pList->nExpr; i++){
1942 Expr *pExpr = pList->a[i].pExpr;
1943 if( pExpr==0 ) continue;
1944#if SQLITE_MAX_EXPR_DEPTH>0
1945 w.pParse->nHeight += pExpr->nHeight;
1946 if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){
1947 return WRC_Abort;
drh20292312015-11-21 13:24:46 +00001948 }
drh4047bdf2020-04-06 20:35:52 +00001949#endif
1950 sqlite3WalkExpr(&w, pExpr);
1951#if SQLITE_MAX_EXPR_DEPTH>0
1952 w.pParse->nHeight -= pExpr->nHeight;
1953#endif
1954 assert( EP_Agg==NC_HasAgg );
1955 assert( EP_Win==NC_HasWin );
1956 testcase( pNC->ncFlags & NC_HasAgg );
1957 testcase( pNC->ncFlags & NC_HasWin );
drhbb301232021-07-15 19:29:43 +00001958 if( pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg) ){
drh4047bdf2020-04-06 20:35:52 +00001959 ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) );
drhbb301232021-07-15 19:29:43 +00001960 savedHasAgg |= pNC->ncFlags &
1961 (NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg);
1962 pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg);
drh4047bdf2020-04-06 20:35:52 +00001963 }
drh050611a2021-04-10 13:37:04 +00001964 if( w.pParse->nErr>0 ) return WRC_Abort;
drh01d230c2015-08-19 17:11:37 +00001965 }
drh4047bdf2020-04-06 20:35:52 +00001966 pNC->ncFlags |= savedHasAgg;
drh01d230c2015-08-19 17:11:37 +00001967 return WRC_Continue;
1968}
drh7d10d5a2008-08-20 16:35:10 +00001969
1970/*
1971** Resolve all names in all expressions of a SELECT and in all
1972** decendents of the SELECT, including compounds off of p->pPrior,
1973** subqueries in expressions, and subqueries used as FROM clause
1974** terms.
1975**
1976** See sqlite3ResolveExprNames() for a description of the kinds of
1977** transformations that occur.
1978**
1979** All SELECT statements should have been expanded using
1980** sqlite3SelectExpand() prior to invoking this routine.
1981*/
1982void sqlite3ResolveSelectNames(
1983 Parse *pParse, /* The parser context */
1984 Select *p, /* The SELECT statement being coded. */
1985 NameContext *pOuterNC /* Name context for parent SELECT statement */
1986){
1987 Walker w;
1988
drh0a846f92008-08-25 17:23:29 +00001989 assert( p!=0 );
1990 w.xExprCallback = resolveExprStep;
1991 w.xSelectCallback = resolveSelectStep;
drh979dd1b2017-05-29 14:26:07 +00001992 w.xSelectCallback2 = 0;
drh0a846f92008-08-25 17:23:29 +00001993 w.pParse = pParse;
1994 w.u.pNC = pOuterNC;
1995 sqlite3WalkSelect(&w, p);
drh7d10d5a2008-08-20 16:35:10 +00001996}
drh3780be12013-07-31 19:05:22 +00001997
1998/*
drhee751fa2019-01-02 14:34:46 +00001999** Resolve names in expressions that can only reference a single table
2000** or which cannot reference any tables at all. Examples:
drh3780be12013-07-31 19:05:22 +00002001**
drh20cee7d2019-10-30 18:50:08 +00002002** "type" flag
2003** ------------
2004** (1) CHECK constraints NC_IsCheck
2005** (2) WHERE clauses on partial indices NC_PartIdx
2006** (3) Expressions in indexes on expressions NC_IdxExpr
2007** (4) Expression arguments to VACUUM INTO. 0
2008** (5) GENERATED ALWAYS as expressions NC_GenCol
drh3780be12013-07-31 19:05:22 +00002009**
drhee751fa2019-01-02 14:34:46 +00002010** In all cases except (4), the Expr.iTable value for Expr.op==TK_COLUMN
2011** nodes of the expression is set to -1 and the Expr.iColumn value is
2012** set to the column number. In case (4), TK_COLUMN nodes cause an error.
drh3780be12013-07-31 19:05:22 +00002013**
2014** Any errors cause an error message to be set in pParse.
2015*/
drhee751fa2019-01-02 14:34:46 +00002016int sqlite3ResolveSelfReference(
drh81f7b372019-10-16 12:18:59 +00002017 Parse *pParse, /* Parsing context */
2018 Table *pTab, /* The table being referenced, or NULL */
2019 int type, /* NC_IsCheck, NC_PartIdx, NC_IdxExpr, NC_GenCol, or 0 */
2020 Expr *pExpr, /* Expression to resolve. May be NULL. */
2021 ExprList *pList /* Expression list to resolve. May be NULL. */
drh3780be12013-07-31 19:05:22 +00002022){
2023 SrcList sSrc; /* Fake SrcList for pParse->pNewTable */
2024 NameContext sNC; /* Name context for pParse->pNewTable */
drhee751fa2019-01-02 14:34:46 +00002025 int rc;
drh3780be12013-07-31 19:05:22 +00002026
drhee751fa2019-01-02 14:34:46 +00002027 assert( type==0 || pTab!=0 );
drh81f7b372019-10-16 12:18:59 +00002028 assert( type==NC_IsCheck || type==NC_PartIdx || type==NC_IdxExpr
2029 || type==NC_GenCol || pTab==0 );
drh3780be12013-07-31 19:05:22 +00002030 memset(&sNC, 0, sizeof(sNC));
2031 memset(&sSrc, 0, sizeof(sSrc));
drhee751fa2019-01-02 14:34:46 +00002032 if( pTab ){
2033 sSrc.nSrc = 1;
2034 sSrc.a[0].zName = pTab->zName;
2035 sSrc.a[0].pTab = pTab;
2036 sSrc.a[0].iCursor = -1;
drh05b32ee2020-01-09 01:20:03 +00002037 if( pTab->pSchema!=pParse->db->aDb[1].pSchema ){
2038 /* Cause EP_FromDDL to be set on TK_FUNCTION nodes of non-TEMP
2039 ** schema elements */
2040 type |= NC_FromDDL;
2041 }
drhee751fa2019-01-02 14:34:46 +00002042 }
drh3780be12013-07-31 19:05:22 +00002043 sNC.pParse = pParse;
2044 sNC.pSrcList = &sSrc;
drhd0ff6012019-06-17 13:56:11 +00002045 sNC.ncFlags = type | NC_IsDDL;
drhee751fa2019-01-02 14:34:46 +00002046 if( (rc = sqlite3ResolveExprNames(&sNC, pExpr))!=SQLITE_OK ) return rc;
2047 if( pList ) rc = sqlite3ResolveExprListNames(&sNC, pList);
2048 return rc;
drh3780be12013-07-31 19:05:22 +00002049}