blob: 6853965985988fc805013b5cc18009fec9d6eea9 [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);
drh4344dbd2018-06-02 11:31:15 +000084 if( pDup!=0 ){
drhc7e93f52021-02-18 00:26:11 +000085 incrAggFunctionDepth(pDup, nSubquery);
drh4344dbd2018-06-02 11:31:15 +000086 if( pExpr->op==TK_COLLATE ){
87 pDup = sqlite3ExprAddCollateString(pParse, pDup, pExpr->u.zToken);
88 }
danf6963f92009-11-23 14:39:14 +000089
drh4344dbd2018-06-02 11:31:15 +000090 /* Before calling sqlite3ExprDelete(), set the EP_Static flag. This
91 ** prevents ExprDelete() from deleting the Expr structure itself,
92 ** allowing it to be repopulated by the memcpy() on the following line.
93 ** The pExpr->u.zToken might point into memory that will be freed by the
94 ** sqlite3DbFree(db, pDup) on the last line of this block, so be sure to
95 ** make a copy of the token before doing the sqlite3DbFree().
96 */
97 ExprSetProperty(pExpr, EP_Static);
98 sqlite3ExprDelete(db, pExpr);
99 memcpy(pExpr, pDup, sizeof(*pExpr));
100 if( !ExprHasProperty(pExpr, EP_IntValue) && pExpr->u.zToken!=0 ){
101 assert( (pExpr->flags & (EP_Reduced|EP_TokenOnly))==0 );
102 pExpr->u.zToken = sqlite3DbStrDup(db, pExpr->u.zToken);
103 pExpr->flags |= EP_MemToken;
104 }
dana51ddb12019-09-26 15:53:37 +0000105 if( ExprHasProperty(pExpr, EP_WinFunc) ){
drhd79cd922019-09-26 16:08:35 +0000106 if( pExpr->y.pWin!=0 ){
107 pExpr->y.pWin->pOwner = pExpr;
108 }else{
109 assert( db->mallocFailed );
110 }
dana51ddb12019-09-26 15:53:37 +0000111 }
drh4344dbd2018-06-02 11:31:15 +0000112 sqlite3DbFree(db, pDup);
drh0a8a4062012-12-07 18:38:16 +0000113 }
drh8b213892008-08-29 02:14:02 +0000114}
115
drhe802c5d2011-10-18 18:10:40 +0000116
117/*
118** Return TRUE if the name zCol occurs anywhere in the USING clause.
119**
120** Return FALSE if the USING clause is NULL or if it does not contain
121** zCol.
122*/
123static int nameInUsingClause(IdList *pUsing, const char *zCol){
124 if( pUsing ){
125 int k;
126 for(k=0; k<pUsing->nId; k++){
127 if( sqlite3StrICmp(pUsing->a[k].zName, zCol)==0 ) return 1;
128 }
129 }
130 return 0;
131}
132
drh3e3f1a52013-01-03 00:45:56 +0000133/*
134** Subqueries stores the original database, table and column names for their
135** result sets in ExprList.a[].zSpan, in the form "DATABASE.TABLE.COLUMN".
136** Check to see if the zSpan given to this routine matches the zDb, zTab,
137** and zCol. If any of zDb, zTab, and zCol are NULL then those fields will
138** match anything.
139*/
drhc4938ea2019-12-13 00:49:42 +0000140int sqlite3MatchEName(
141 const struct ExprList_item *pItem,
drh3e3f1a52013-01-03 00:45:56 +0000142 const char *zCol,
143 const char *zTab,
144 const char *zDb
145){
146 int n;
drhc4938ea2019-12-13 00:49:42 +0000147 const char *zSpan;
drh47f8ef32020-04-04 11:58:22 +0000148 if( pItem->eEName!=ENAME_TAB ) return 0;
drhc4938ea2019-12-13 00:49:42 +0000149 zSpan = pItem->zEName;
drh3e3f1a52013-01-03 00:45:56 +0000150 for(n=0; ALWAYS(zSpan[n]) && zSpan[n]!='.'; n++){}
drhdd1dd482013-02-26 12:57:42 +0000151 if( zDb && (sqlite3StrNICmp(zSpan, zDb, n)!=0 || zDb[n]!=0) ){
drh3e3f1a52013-01-03 00:45:56 +0000152 return 0;
153 }
154 zSpan += n+1;
155 for(n=0; ALWAYS(zSpan[n]) && zSpan[n]!='.'; n++){}
drhdd1dd482013-02-26 12:57:42 +0000156 if( zTab && (sqlite3StrNICmp(zSpan, zTab, n)!=0 || zTab[n]!=0) ){
drh3e3f1a52013-01-03 00:45:56 +0000157 return 0;
158 }
159 zSpan += n+1;
160 if( zCol && sqlite3StrICmp(zSpan, zCol)!=0 ){
161 return 0;
162 }
163 return 1;
164}
drhe802c5d2011-10-18 18:10:40 +0000165
drh8b213892008-08-29 02:14:02 +0000166/*
drhd0ff6012019-06-17 13:56:11 +0000167** Return TRUE if the double-quoted string mis-feature should be supported.
168*/
169static int areDoubleQuotedStringsEnabled(sqlite3 *db, NameContext *pTopNC){
170 if( db->init.busy ) return 1; /* Always support for legacy schemas */
171 if( pTopNC->ncFlags & NC_IsDDL ){
172 /* Currently parsing a DDL statement */
173 if( sqlite3WritableSchema(db) && (db->flags & SQLITE_DqsDML)!=0 ){
174 return 1;
175 }
176 return (db->flags & SQLITE_DqsDDL)!=0;
177 }else{
178 /* Currently parsing a DML statement */
179 return (db->flags & SQLITE_DqsDML)!=0;
180 }
181}
182
183/*
drh74a07982020-03-21 23:10:38 +0000184** The argument is guaranteed to be a non-NULL Expr node of type TK_COLUMN.
185** return the appropriate colUsed mask.
186*/
187Bitmask sqlite3ExprColUsed(Expr *pExpr){
188 int n;
189 Table *pExTab;
190
191 n = pExpr->iColumn;
192 pExTab = pExpr->y.pTab;
193 assert( pExTab!=0 );
194 if( (pExTab->tabFlags & TF_HasGenerated)!=0
195 && (pExTab->aCol[n].colFlags & COLFLAG_GENERATED)!=0
196 ){
197 testcase( pExTab->nCol==BMS-1 );
198 testcase( pExTab->nCol==BMS );
199 return pExTab->nCol>=BMS ? ALLBITS : MASKBIT(pExTab->nCol)-1;
200 }else{
201 testcase( n==BMS-1 );
202 testcase( n==BMS );
203 if( n>=BMS ) n = BMS-1;
204 return ((Bitmask)1)<<n;
205 }
206}
207
208/*
drh7d10d5a2008-08-20 16:35:10 +0000209** Given the name of a column of the form X.Y.Z or Y.Z or just Z, look up
210** that name in the set of source tables in pSrcList and make the pExpr
211** expression node refer back to that source column. The following changes
212** are made to pExpr:
213**
214** pExpr->iDb Set the index in db->aDb[] of the database X
215** (even if X is implied).
216** pExpr->iTable Set to the cursor number for the table obtained
217** from pSrcList.
drheda079c2018-09-20 19:02:15 +0000218** pExpr->y.pTab Points to the Table structure of X.Y (even if
drh7d10d5a2008-08-20 16:35:10 +0000219** X and/or Y are implied.)
220** pExpr->iColumn Set to the column number within the table.
221** pExpr->op Set to TK_COLUMN.
222** pExpr->pLeft Any expression this points to is deleted
223** pExpr->pRight Any expression this points to is deleted.
224**
drhb7916a72009-05-27 10:31:29 +0000225** The zDb variable is the name of the database (the "X"). This value may be
drh7d10d5a2008-08-20 16:35:10 +0000226** NULL meaning that name is of the form Y.Z or Z. Any available database
drhb7916a72009-05-27 10:31:29 +0000227** can be used. The zTable variable is the name of the table (the "Y"). This
228** value can be NULL if zDb is also NULL. If zTable is NULL it
drh7d10d5a2008-08-20 16:35:10 +0000229** means that the form of the name is Z and that columns from any table
230** can be used.
231**
232** If the name cannot be resolved unambiguously, leave an error message
drhf7828b52009-06-15 23:15:59 +0000233** in pParse and return WRC_Abort. Return WRC_Prune on success.
drh7d10d5a2008-08-20 16:35:10 +0000234*/
235static int lookupName(
236 Parse *pParse, /* The parsing context */
drhb7916a72009-05-27 10:31:29 +0000237 const char *zDb, /* Name of the database containing table, or NULL */
238 const char *zTab, /* Name of table containing column, or NULL */
239 const char *zCol, /* Name of the column. */
drh7d10d5a2008-08-20 16:35:10 +0000240 NameContext *pNC, /* The name context used to resolve the name */
241 Expr *pExpr /* Make this EXPR node point to the selected column */
242){
drhed551b92012-08-23 19:46:11 +0000243 int i, j; /* Loop counters */
drh7d10d5a2008-08-20 16:35:10 +0000244 int cnt = 0; /* Number of matching column names */
245 int cntTab = 0; /* Number of matching table names */
drhed551b92012-08-23 19:46:11 +0000246 int nSubquery = 0; /* How many levels of subquery */
drh7d10d5a2008-08-20 16:35:10 +0000247 sqlite3 *db = pParse->db; /* The database connection */
drh76012942021-02-21 21:04:54 +0000248 SrcItem *pItem; /* Use for looping over pSrcList items */
249 SrcItem *pMatch = 0; /* The matching pSrcList item */
drh7d10d5a2008-08-20 16:35:10 +0000250 NameContext *pTopNC = pNC; /* First namecontext in the list */
251 Schema *pSchema = 0; /* Schema of the expression */
drheac9fab2018-04-16 13:00:50 +0000252 int eNewExprOp = TK_COLUMN; /* New value for pExpr->op on success */
drh11f9b032013-10-23 17:39:41 +0000253 Table *pTab = 0; /* Table hold the row */
254 Column *pCol; /* A column of pTab */
drh7d10d5a2008-08-20 16:35:10 +0000255
drhb7916a72009-05-27 10:31:29 +0000256 assert( pNC ); /* the name context cannot be NULL. */
257 assert( zCol ); /* The Z in X.Y.Z cannot be NULL */
drhc5cd1242013-09-12 16:50:49 +0000258 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
drh7d10d5a2008-08-20 16:35:10 +0000259
260 /* Initialize the node to no-match */
261 pExpr->iTable = -1;
drhebb6a652013-09-12 23:42:22 +0000262 ExprSetVVAProperty(pExpr, EP_NoReduce);
drh7d10d5a2008-08-20 16:35:10 +0000263
drh8f25d182012-12-19 02:36:45 +0000264 /* Translate the schema name in zDb into a pointer to the corresponding
265 ** schema. If not found, pSchema will remain NULL and nothing will match
266 ** resulting in an appropriate error message toward the end of this routine
267 */
268 if( zDb ){
drh1e7d43c2013-08-02 14:18:18 +0000269 testcase( pNC->ncFlags & NC_PartIdx );
270 testcase( pNC->ncFlags & NC_IsCheck );
271 if( (pNC->ncFlags & (NC_PartIdx|NC_IsCheck))!=0 ){
drh31e71472015-02-09 10:20:19 +0000272 /* Silently ignore database qualifiers inside CHECK constraints and
273 ** partial indices. Do not raise errors because that might break
274 ** legacy and because it does not hurt anything to just ignore the
275 ** database name. */
drh1e7d43c2013-08-02 14:18:18 +0000276 zDb = 0;
277 }else{
278 for(i=0; i<db->nDb; i++){
drh69c33822016-08-18 14:33:11 +0000279 assert( db->aDb[i].zDbSName );
280 if( sqlite3StrICmp(db->aDb[i].zDbSName,zDb)==0 ){
drh1e7d43c2013-08-02 14:18:18 +0000281 pSchema = db->aDb[i].pSchema;
282 break;
283 }
drh8f25d182012-12-19 02:36:45 +0000284 }
dan00bd55e2020-03-20 20:54:28 +0000285 if( i==db->nDb && sqlite3StrICmp("main", zDb)==0 ){
286 /* This branch is taken when the main database has been renamed
287 ** using SQLITE_DBCONFIG_MAINDBNAME. */
288 pSchema = db->aDb[0].pSchema;
289 zDb = db->aDb[0].zDbSName;
290 }
drh8f25d182012-12-19 02:36:45 +0000291 }
292 }
293
drh7d10d5a2008-08-20 16:35:10 +0000294 /* Start at the inner-most context and move outward until a match is found */
drha92b81f2017-03-07 03:40:48 +0000295 assert( pNC && cnt==0 );
296 do{
drh7d10d5a2008-08-20 16:35:10 +0000297 ExprList *pEList;
298 SrcList *pSrcList = pNC->pSrcList;
299
300 if( pSrcList ){
301 for(i=0, pItem=pSrcList->a; i<pSrcList->nSrc; i++, pItem++){
drhd44390c2020-04-06 18:16:31 +0000302 u8 hCol;
drh7d10d5a2008-08-20 16:35:10 +0000303 pTab = pItem->pTab;
drhf4366202008-08-25 12:14:08 +0000304 assert( pTab!=0 && pTab->zName!=0 );
drh7d10d5a2008-08-20 16:35:10 +0000305 assert( pTab->nCol>0 );
drh8f25d182012-12-19 02:36:45 +0000306 if( pItem->pSelect && (pItem->pSelect->selFlags & SF_NestedFrom)!=0 ){
drh8f25d182012-12-19 02:36:45 +0000307 int hit = 0;
drh928d9c62013-02-07 09:33:56 +0000308 pEList = pItem->pSelect->pEList;
drh8f25d182012-12-19 02:36:45 +0000309 for(j=0; j<pEList->nExpr; j++){
drhc4938ea2019-12-13 00:49:42 +0000310 if( sqlite3MatchEName(&pEList->a[j], zCol, zTab, zDb) ){
drh8f25d182012-12-19 02:36:45 +0000311 cnt++;
312 cntTab = 2;
313 pMatch = pItem;
314 pExpr->iColumn = j;
drh38b384a2013-01-03 17:34:28 +0000315 hit = 1;
drh8f25d182012-12-19 02:36:45 +0000316 }
317 }
318 if( hit || zTab==0 ) continue;
319 }
drhc75e09c2013-01-03 16:54:20 +0000320 if( zDb && pTab->pSchema!=pSchema ){
321 continue;
322 }
drh7d10d5a2008-08-20 16:35:10 +0000323 if( zTab ){
drh8f25d182012-12-19 02:36:45 +0000324 const char *zTabName = pItem->zAlias ? pItem->zAlias : pTab->zName;
325 assert( zTabName!=0 );
326 if( sqlite3StrICmp(zTabName, zTab)!=0 ){
327 continue;
drh7d10d5a2008-08-20 16:35:10 +0000328 }
danc9461ec2018-08-29 21:00:16 +0000329 if( IN_RENAME_OBJECT && pItem->zAlias ){
drheda079c2018-09-20 19:02:15 +0000330 sqlite3RenameTokenRemap(pParse, 0, (void*)&pExpr->y.pTab);
danc9461ec2018-08-29 21:00:16 +0000331 }
drh7d10d5a2008-08-20 16:35:10 +0000332 }
333 if( 0==(cntTab++) ){
drh7d10d5a2008-08-20 16:35:10 +0000334 pMatch = pItem;
335 }
drhd44390c2020-04-06 18:16:31 +0000336 hCol = sqlite3StrIHash(zCol);
drh7d10d5a2008-08-20 16:35:10 +0000337 for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
drhd44390c2020-04-06 18:16:31 +0000338 if( pCol->hName==hCol && sqlite3StrICmp(pCol->zName, zCol)==0 ){
drhe802c5d2011-10-18 18:10:40 +0000339 /* If there has been exactly one prior match and this match
340 ** is for the right-hand table of a NATURAL JOIN or is in a
341 ** USING clause, then skip this match.
342 */
343 if( cnt==1 ){
drh8a48b9c2015-08-19 15:20:00 +0000344 if( pItem->fg.jointype & JT_NATURAL ) continue;
drhe802c5d2011-10-18 18:10:40 +0000345 if( nameInUsingClause(pItem->pUsing, zCol) ) continue;
346 }
drh7d10d5a2008-08-20 16:35:10 +0000347 cnt++;
drh7d10d5a2008-08-20 16:35:10 +0000348 pMatch = pItem;
drh7d10d5a2008-08-20 16:35:10 +0000349 /* Substitute the rowid (column -1) for the INTEGER PRIMARY KEY */
shanecf697392009-06-01 16:53:09 +0000350 pExpr->iColumn = j==pTab->iPKey ? -1 : (i16)j;
drh7d10d5a2008-08-20 16:35:10 +0000351 break;
352 }
353 }
354 }
drh8f25d182012-12-19 02:36:45 +0000355 if( pMatch ){
356 pExpr->iTable = pMatch->iCursor;
drheda079c2018-09-20 19:02:15 +0000357 pExpr->y.pTab = pMatch->pTab;
drh31e71472015-02-09 10:20:19 +0000358 /* RIGHT JOIN not (yet) supported */
drh8a48b9c2015-08-19 15:20:00 +0000359 assert( (pMatch->fg.jointype & JT_RIGHT)==0 );
360 if( (pMatch->fg.jointype & JT_LEFT)!=0 ){
drh72673a22014-12-04 16:27:17 +0000361 ExprSetProperty(pExpr, EP_CanBeNull);
362 }
drheda079c2018-09-20 19:02:15 +0000363 pSchema = pExpr->y.pTab->pSchema;
drh8f25d182012-12-19 02:36:45 +0000364 }
365 } /* if( pSrcList ) */
drh7d10d5a2008-08-20 16:35:10 +0000366
drheac9fab2018-04-16 13:00:50 +0000367#if !defined(SQLITE_OMIT_TRIGGER) || !defined(SQLITE_OMIT_UPSERT)
drh7d10d5a2008-08-20 16:35:10 +0000368 /* If we have not already resolved the name, then maybe
drheac9fab2018-04-16 13:00:50 +0000369 ** it is a new.* or old.* trigger argument reference. Or
drhd5101972021-02-08 13:41:17 +0000370 ** maybe it is an excluded.* from an upsert. Or maybe it is
371 ** a reference in the RETURNING clause to a table being modified.
drh7d10d5a2008-08-20 16:35:10 +0000372 */
drhd5101972021-02-08 13:41:17 +0000373 if( cnt==0 && zDb==0 ){
drheac9fab2018-04-16 13:00:50 +0000374 pTab = 0;
375#ifndef SQLITE_OMIT_TRIGGER
376 if( pParse->pTriggerTab!=0 ){
377 int op = pParse->eTriggerOp;
378 assert( op==TK_DELETE || op==TK_UPDATE || op==TK_INSERT );
drhb8352472021-01-29 19:32:17 +0000379 if( op!=TK_DELETE && zTab && sqlite3StrICmp("new",zTab) == 0 ){
drheac9fab2018-04-16 13:00:50 +0000380 pExpr->iTable = 1;
381 pTab = pParse->pTriggerTab;
drhb8352472021-01-29 19:32:17 +0000382 }else if( op!=TK_INSERT && zTab && sqlite3StrICmp("old",zTab)==0 ){
drheac9fab2018-04-16 13:00:50 +0000383 pExpr->iTable = 0;
384 pTab = pParse->pTriggerTab;
drh82ab4f62021-02-08 15:56:01 +0000385 }else if( pParse->bReturning && (pNC->ncFlags & NC_UBaseReg)!=0 ){
drhb8352472021-01-29 19:32:17 +0000386 pExpr->iTable = op!=TK_DELETE;
387 pTab = pParse->pTriggerTab;
drheac9fab2018-04-16 13:00:50 +0000388 }
drh7d10d5a2008-08-20 16:35:10 +0000389 }
drheac9fab2018-04-16 13:00:50 +0000390#endif /* SQLITE_OMIT_TRIGGER */
391#ifndef SQLITE_OMIT_UPSERT
drhd5101972021-02-08 13:41:17 +0000392 if( (pNC->ncFlags & NC_UUpsert)!=0 && zTab!=0 ){
drheac9fab2018-04-16 13:00:50 +0000393 Upsert *pUpsert = pNC->uNC.pUpsert;
394 if( pUpsert && sqlite3StrICmp("excluded",zTab)==0 ){
395 pTab = pUpsert->pUpsertSrc->a[0].pTab;
drhec43d802020-06-29 20:20:40 +0000396 pExpr->iTable = EXCLUDED_TABLE_NUMBER;
drheac9fab2018-04-16 13:00:50 +0000397 }
398 }
399#endif /* SQLITE_OMIT_UPSERT */
drh7d10d5a2008-08-20 16:35:10 +0000400
401 if( pTab ){
402 int iCol;
drhd44390c2020-04-06 18:16:31 +0000403 u8 hCol = sqlite3StrIHash(zCol);
drh7d10d5a2008-08-20 16:35:10 +0000404 pSchema = pTab->pSchema;
405 cntTab++;
drh511717c2013-11-08 17:13:23 +0000406 for(iCol=0, pCol=pTab->aCol; iCol<pTab->nCol; iCol++, pCol++){
drhd44390c2020-04-06 18:16:31 +0000407 if( pCol->hName==hCol && sqlite3StrICmp(pCol->zName, zCol)==0 ){
drh25e978d2009-12-29 23:39:04 +0000408 if( iCol==pTab->iPKey ){
409 iCol = -1;
drh7d10d5a2008-08-20 16:35:10 +0000410 }
drh25e978d2009-12-29 23:39:04 +0000411 break;
drh7d10d5a2008-08-20 16:35:10 +0000412 }
413 }
drhfccda8a2015-05-27 13:06:55 +0000414 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && VisibleRowid(pTab) ){
drhe8a537e2014-08-08 18:26:20 +0000415 /* IMP: R-51414-32910 */
drhbbbb0e82013-11-26 23:27:07 +0000416 iCol = -1;
drh25e978d2009-12-29 23:39:04 +0000417 }
dan2bd93512009-08-31 08:22:46 +0000418 if( iCol<pTab->nCol ){
419 cnt++;
drheac9fab2018-04-16 13:00:50 +0000420#ifndef SQLITE_OMIT_UPSERT
drhec43d802020-06-29 20:20:40 +0000421 if( pExpr->iTable==EXCLUDED_TABLE_NUMBER ){
drh99160482018-04-18 01:34:39 +0000422 testcase( iCol==(-1) );
danc9461ec2018-08-29 21:00:16 +0000423 if( IN_RENAME_OBJECT ){
dan85a9d502018-08-24 20:10:22 +0000424 pExpr->iColumn = iCol;
drheda079c2018-09-20 19:02:15 +0000425 pExpr->y.pTab = pTab;
dan85a9d502018-08-24 20:10:22 +0000426 eNewExprOp = TK_COLUMN;
427 }else{
drhb8fec212020-06-29 20:26:50 +0000428 pExpr->iTable = pNC->uNC.pUpsert->regData +
429 sqlite3TableColumnToStorage(pTab, iCol);
dan85a9d502018-08-24 20:10:22 +0000430 eNewExprOp = TK_REGISTER;
dan85a9d502018-08-24 20:10:22 +0000431 }
drheac9fab2018-04-16 13:00:50 +0000432 }else
drh0a6259f2018-04-16 13:26:53 +0000433#endif /* SQLITE_OMIT_UPSERT */
drheac9fab2018-04-16 13:00:50 +0000434 {
drheda079c2018-09-20 19:02:15 +0000435 pExpr->y.pTab = pTab;
drh552562c2021-02-04 20:52:20 +0000436 if( pParse->bReturning ){
437 eNewExprOp = TK_REGISTER;
drh82ab4f62021-02-08 15:56:01 +0000438 pExpr->iTable = pNC->uNC.iBaseReg + (pTab->nCol+1)*pExpr->iTable
439 + iCol + 1;
drh552562c2021-02-04 20:52:20 +0000440 }else{
441 pExpr->iColumn = (i16)iCol;
442 eNewExprOp = TK_TRIGGER;
443#ifndef SQLITE_OMIT_TRIGGER
drh8873aea2021-02-06 14:37:36 +0000444 if( iCol<0 ){
445 pExpr->affExpr = SQLITE_AFF_INTEGER;
446 }else if( pExpr->iTable==0 ){
drh552562c2021-02-04 20:52:20 +0000447 testcase( iCol==31 );
448 testcase( iCol==32 );
449 pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
450 }else{
451 testcase( iCol==31 );
452 testcase( iCol==32 );
453 pParse->newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
454 }
drh0a6259f2018-04-16 13:26:53 +0000455#endif /* SQLITE_OMIT_TRIGGER */
drh552562c2021-02-04 20:52:20 +0000456 }
dan2bd93512009-08-31 08:22:46 +0000457 }
dan2bd93512009-08-31 08:22:46 +0000458 }
drh7d10d5a2008-08-20 16:35:10 +0000459 }
460 }
drheac9fab2018-04-16 13:00:50 +0000461#endif /* !defined(SQLITE_OMIT_TRIGGER) || !defined(SQLITE_OMIT_UPSERT) */
drh7d10d5a2008-08-20 16:35:10 +0000462
463 /*
464 ** Perhaps the name is a reference to the ROWID
465 */
drh4cbc54b2015-09-19 03:07:30 +0000466 if( cnt==0
467 && cntTab==1
468 && pMatch
drh81f7b372019-10-16 12:18:59 +0000469 && (pNC->ncFlags & (NC_IdxExpr|NC_GenCol))==0
drh4cbc54b2015-09-19 03:07:30 +0000470 && sqlite3IsRowid(zCol)
471 && VisibleRowid(pMatch->pTab)
472 ){
drh7d10d5a2008-08-20 16:35:10 +0000473 cnt = 1;
drh15427272015-12-03 22:33:55 +0000474 pExpr->iColumn = -1;
drh11949042019-08-05 18:01:42 +0000475 pExpr->affExpr = SQLITE_AFF_INTEGER;
drh7d10d5a2008-08-20 16:35:10 +0000476 }
477
478 /*
479 ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z
480 ** might refer to an result-set alias. This happens, for example, when
481 ** we are resolving names in the WHERE clause of the following command:
482 **
483 ** SELECT a+b AS x FROM table WHERE x<10;
484 **
485 ** In cases like this, replace pExpr with a copy of the expression that
486 ** forms the result set entry ("a+b" in the example) and return immediately.
487 ** Note that the expression in the result set should have already been
488 ** resolved by the time the WHERE clause is resolved.
drhe35463b2013-08-15 20:24:27 +0000489 **
490 ** The ability to use an output result-set column in the WHERE, GROUP BY,
drh5579d592015-08-26 14:01:41 +0000491 ** or HAVING clauses, or as part of a larger expression in the ORDER BY
drhe35463b2013-08-15 20:24:27 +0000492 ** clause is not standard SQL. This is a (goofy) SQLite extension, that
drh5579d592015-08-26 14:01:41 +0000493 ** is supported for backwards compatibility only. Hence, we issue a warning
drhe35463b2013-08-15 20:24:27 +0000494 ** on sqlite3_log() whenever the capability is used.
drh7d10d5a2008-08-20 16:35:10 +0000495 */
drh25c3b8c2018-04-16 10:34:13 +0000496 if( (pNC->ncFlags & NC_UEList)!=0
drhe35463b2013-08-15 20:24:27 +0000497 && cnt==0
drh25c3b8c2018-04-16 10:34:13 +0000498 && zTab==0
drha3a5bd92013-04-13 19:59:58 +0000499 ){
drh25c3b8c2018-04-16 10:34:13 +0000500 pEList = pNC->uNC.pEList;
501 assert( pEList!=0 );
drh7d10d5a2008-08-20 16:35:10 +0000502 for(j=0; j<pEList->nExpr; j++){
drh9fc1b9a2020-01-02 22:23:01 +0000503 char *zAs = pEList->a[j].zEName;
drhc4938ea2019-12-13 00:49:42 +0000504 if( pEList->a[j].eEName==ENAME_NAME
dan607dd6e2020-01-03 14:27:08 +0000505 && sqlite3_stricmp(zAs, zCol)==0
drhc4938ea2019-12-13 00:49:42 +0000506 ){
drh8b213892008-08-29 02:14:02 +0000507 Expr *pOrig;
drh7d10d5a2008-08-20 16:35:10 +0000508 assert( pExpr->pLeft==0 && pExpr->pRight==0 );
danielk19776ab3a2e2009-02-19 14:39:25 +0000509 assert( pExpr->x.pList==0 );
510 assert( pExpr->x.pSelect==0 );
drh7d10d5a2008-08-20 16:35:10 +0000511 pOrig = pEList->a[j].pExpr;
drha51009b2012-05-21 19:11:25 +0000512 if( (pNC->ncFlags&NC_AllowAgg)==0 && ExprHasProperty(pOrig, EP_Agg) ){
drh7d10d5a2008-08-20 16:35:10 +0000513 sqlite3ErrorMsg(pParse, "misuse of aliased aggregate %s", zAs);
drhf7828b52009-06-15 23:15:59 +0000514 return WRC_Abort;
drh7d10d5a2008-08-20 16:35:10 +0000515 }
dane3735bf2019-12-27 19:46:07 +0000516 if( ExprHasProperty(pOrig, EP_Win)
517 && ((pNC->ncFlags&NC_AllowWin)==0 || pNC!=pTopNC )
518 ){
dan4ded26a2019-03-28 16:15:05 +0000519 sqlite3ErrorMsg(pParse, "misuse of aliased window function %s",zAs);
520 return WRC_Abort;
521 }
dan3bafded2016-11-11 15:49:01 +0000522 if( sqlite3ExprVectorSize(pOrig)!=1 ){
523 sqlite3ErrorMsg(pParse, "row value misused");
524 return WRC_Abort;
525 }
drh6b37b762021-02-16 20:32:17 +0000526 resolveAlias(pParse, pEList, j, pExpr, nSubquery);
drh7d10d5a2008-08-20 16:35:10 +0000527 cnt = 1;
528 pMatch = 0;
529 assert( zTab==0 && zDb==0 );
danc9461ec2018-08-29 21:00:16 +0000530 if( IN_RENAME_OBJECT ){
dan1b0c5de2018-08-24 16:04:26 +0000531 sqlite3RenameTokenRemap(pParse, 0, (void*)pExpr);
532 }
drhb7916a72009-05-27 10:31:29 +0000533 goto lookupname_end;
drh7d10d5a2008-08-20 16:35:10 +0000534 }
535 }
536 }
537
538 /* Advance to the next name context. The loop will exit when either
539 ** we have a match (cnt>0) or when we run out of name contexts.
540 */
drha92b81f2017-03-07 03:40:48 +0000541 if( cnt ) break;
542 pNC = pNC->pNext;
543 nSubquery++;
544 }while( pNC );
545
drh7d10d5a2008-08-20 16:35:10 +0000546
547 /*
548 ** If X and Y are NULL (in other words if only the column name Z is
549 ** supplied) and the value of Z is enclosed in double-quotes, then
550 ** Z is a string literal if it doesn't match any column names. In that
551 ** case, we need to return right away and not make any changes to
552 ** pExpr.
553 **
554 ** Because no reference was made to outer contexts, the pNC->nRef
555 ** fields are not changed in any context.
556 */
drh007c8432018-02-26 03:20:18 +0000557 if( cnt==0 && zTab==0 ){
drh171d16b2018-02-26 20:15:54 +0000558 assert( pExpr->op==TK_ID );
drhd0ff6012019-06-17 13:56:11 +0000559 if( ExprHasProperty(pExpr,EP_DblQuoted)
560 && areDoubleQuotedStringsEnabled(db, pTopNC)
dan0d925712019-05-20 17:14:25 +0000561 ){
drhec8fc622018-12-06 16:11:14 +0000562 /* If a double-quoted identifier does not match any known column name,
563 ** then treat it as a string.
564 **
565 ** This hack was added in the early days of SQLite in a misguided attempt
566 ** to be compatible with MySQL 3.x, which used double-quotes for strings.
567 ** I now sorely regret putting in this hack. The effect of this hack is
568 ** that misspelled identifier names are silently converted into strings
569 ** rather than causing an error, to the frustration of countless
570 ** programmers. To all those frustrated programmers, my apologies.
571 **
572 ** Someday, I hope to get rid of this hack. Unfortunately there is
573 ** a huge amount of legacy SQL that uses it. So for now, we just
574 ** issue a warning.
575 */
576 sqlite3_log(SQLITE_WARNING,
577 "double-quoted string literal: \"%w\"", zCol);
drh893bd372018-12-07 16:32:11 +0000578#ifdef SQLITE_ENABLE_NORMALIZE
drh1a6c2b12018-12-10 20:01:40 +0000579 sqlite3VdbeAddDblquoteStr(db, pParse->pVdbe, zCol);
drh893bd372018-12-07 16:32:11 +0000580#endif
drh007c8432018-02-26 03:20:18 +0000581 pExpr->op = TK_STRING;
drheda079c2018-09-20 19:02:15 +0000582 pExpr->y.pTab = 0;
drh007c8432018-02-26 03:20:18 +0000583 return WRC_Prune;
584 }
drh171d16b2018-02-26 20:15:54 +0000585 if( sqlite3ExprIdToTrueFalse(pExpr) ){
drh007c8432018-02-26 03:20:18 +0000586 return WRC_Prune;
587 }
drh7d10d5a2008-08-20 16:35:10 +0000588 }
589
590 /*
591 ** cnt==0 means there was not match. cnt>1 means there were two or
592 ** more matches. Either way, we have an error.
593 */
594 if( cnt!=1 ){
595 const char *zErr;
596 zErr = cnt==0 ? "no such column" : "ambiguous column name";
597 if( zDb ){
598 sqlite3ErrorMsg(pParse, "%s: %s.%s.%s", zErr, zDb, zTab, zCol);
599 }else if( zTab ){
600 sqlite3ErrorMsg(pParse, "%s: %s.%s", zErr, zTab, zCol);
601 }else{
602 sqlite3ErrorMsg(pParse, "%s: %s", zErr, zCol);
603 }
dan1db95102010-06-28 10:15:19 +0000604 pParse->checkSchema = 1;
drh7d10d5a2008-08-20 16:35:10 +0000605 pTopNC->nErr++;
606 }
607
608 /* If a column from a table in pSrcList is referenced, then record
609 ** this fact in the pSrcList.a[].colUsed bitmask. Column 0 causes
drhbf9d0992019-12-08 00:06:39 +0000610 ** bit 0 to be set. Column 1 sets bit 1. And so forth. Bit 63 is
611 ** set if the 63rd or any subsequent column is used.
drh522ebfa2019-11-21 19:37:00 +0000612 **
613 ** The colUsed mask is an optimization used to help determine if an
614 ** index is a covering index. The correct answer is still obtained
drhbf9d0992019-12-08 00:06:39 +0000615 ** if the mask contains extra set bits. However, it is important to
616 ** avoid setting bits beyond the maximum column number of the table.
617 ** (See ticket [b92e5e8ec2cdbaa1]).
drh522ebfa2019-11-21 19:37:00 +0000618 **
drhbf9d0992019-12-08 00:06:39 +0000619 ** If a generated column is referenced, set bits for every column
620 ** of the table.
drh7d10d5a2008-08-20 16:35:10 +0000621 */
danielk19772d2e7bd2009-02-24 10:14:40 +0000622 if( pExpr->iColumn>=0 && pMatch!=0 ){
drh74a07982020-03-21 23:10:38 +0000623 pMatch->colUsed |= sqlite3ExprColUsed(pExpr);
drh7d10d5a2008-08-20 16:35:10 +0000624 }
625
drh7d10d5a2008-08-20 16:35:10 +0000626 /* Clean up and return
627 */
drh7b7a9cf2021-02-18 00:59:16 +0000628 if( !ExprHasProperty(pExpr,(EP_TokenOnly|EP_Leaf)) ){
629 sqlite3ExprDelete(db, pExpr->pLeft);
630 pExpr->pLeft = 0;
631 sqlite3ExprDelete(db, pExpr->pRight);
632 pExpr->pRight = 0;
633 }
drheac9fab2018-04-16 13:00:50 +0000634 pExpr->op = eNewExprOp;
drhb98a2e32017-07-07 12:43:57 +0000635 ExprSetProperty(pExpr, EP_Leaf);
drhb7916a72009-05-27 10:31:29 +0000636lookupname_end:
drh7d10d5a2008-08-20 16:35:10 +0000637 if( cnt==1 ){
638 assert( pNC!=0 );
drh2d7a6912021-03-01 21:43:25 +0000639#ifndef SQLITE_OMIT_AUTHORIZATION
drh552562c2021-02-04 20:52:20 +0000640 if( pParse->db->xAuth
drh29f6a362021-02-05 17:34:47 +0000641 && (pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER)
drh552562c2021-02-04 20:52:20 +0000642 ){
drha3a5bd92013-04-13 19:59:58 +0000643 sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList);
644 }
drh2d7a6912021-03-01 21:43:25 +0000645#endif
drh7d10d5a2008-08-20 16:35:10 +0000646 /* Increment the nRef value on all name contexts from TopNC up to
647 ** the point where the name matched. */
648 for(;;){
649 assert( pTopNC!=0 );
650 pTopNC->nRef++;
651 if( pTopNC==pNC ) break;
652 pTopNC = pTopNC->pNext;
653 }
drhf7828b52009-06-15 23:15:59 +0000654 return WRC_Prune;
drh7d10d5a2008-08-20 16:35:10 +0000655 } else {
drhf7828b52009-06-15 23:15:59 +0000656 return WRC_Abort;
drh7d10d5a2008-08-20 16:35:10 +0000657 }
658}
659
660/*
danf7b0b0a2009-10-19 15:52:32 +0000661** Allocate and return a pointer to an expression to load the column iCol
drh9e481652010-04-08 17:35:34 +0000662** from datasource iSrc in SrcList pSrc.
danf7b0b0a2009-10-19 15:52:32 +0000663*/
664Expr *sqlite3CreateColumnExpr(sqlite3 *db, SrcList *pSrc, int iSrc, int iCol){
665 Expr *p = sqlite3ExprAlloc(db, TK_COLUMN, 0, 0);
666 if( p ){
drh76012942021-02-21 21:04:54 +0000667 SrcItem *pItem = &pSrc->a[iSrc];
drh926f7962019-12-09 17:14:48 +0000668 Table *pTab = p->y.pTab = pItem->pTab;
danf7b0b0a2009-10-19 15:52:32 +0000669 p->iTable = pItem->iCursor;
drheda079c2018-09-20 19:02:15 +0000670 if( p->y.pTab->iPKey==iCol ){
danf7b0b0a2009-10-19 15:52:32 +0000671 p->iColumn = -1;
672 }else{
drh8677d302009-11-04 13:17:14 +0000673 p->iColumn = (ynVar)iCol;
drh0824d5b2019-12-09 18:22:17 +0000674 if( (pTab->tabFlags & TF_HasGenerated)!=0
675 && (pTab->aCol[iCol].colFlags & COLFLAG_GENERATED)!=0
676 ){
677 testcase( pTab->nCol==63 );
678 testcase( pTab->nCol==64 );
679 pItem->colUsed = pTab->nCol>=64 ? ALLBITS : MASKBIT(pTab->nCol)-1;
drh926f7962019-12-09 17:14:48 +0000680 }else{
681 testcase( iCol==BMS );
682 testcase( iCol==BMS-1 );
683 pItem->colUsed |= ((Bitmask)1)<<(iCol>=BMS ? BMS-1 : iCol);
684 }
danf7b0b0a2009-10-19 15:52:32 +0000685 }
danf7b0b0a2009-10-19 15:52:32 +0000686 }
687 return p;
688}
689
690/*
drha514b8e2015-08-25 00:27:06 +0000691** Report an error that an expression is not valid for some set of
drh03bf26d2015-08-31 21:16:36 +0000692** pNC->ncFlags values determined by validMask.
drh77318a32019-12-12 15:19:18 +0000693**
694** static void notValid(
695** Parse *pParse, // Leave error message here
696** NameContext *pNC, // The name context
697** const char *zMsg, // Type of error
698** int validMask, // Set of contexts for which prohibited
699** Expr *pExpr // Invalidate this expression on error
700** ){...}
701**
702** As an optimization, since the conditional is almost always false
703** (because errors are rare), the conditional is moved outside of the
704** function call using a macro.
drh3780be12013-07-31 19:05:22 +0000705*/
drh77318a32019-12-12 15:19:18 +0000706static void notValidImpl(
707 Parse *pParse, /* Leave error message here */
708 NameContext *pNC, /* The name context */
709 const char *zMsg, /* Type of error */
710 Expr *pExpr /* Invalidate this expression on error */
drh3780be12013-07-31 19:05:22 +0000711){
drh77318a32019-12-12 15:19:18 +0000712 const char *zIn = "partial index WHERE clauses";
713 if( pNC->ncFlags & NC_IdxExpr ) zIn = "index expressions";
drh3780be12013-07-31 19:05:22 +0000714#ifndef SQLITE_OMIT_CHECK
drh77318a32019-12-12 15:19:18 +0000715 else if( pNC->ncFlags & NC_IsCheck ) zIn = "CHECK constraints";
drha514b8e2015-08-25 00:27:06 +0000716#endif
drh81f7b372019-10-16 12:18:59 +0000717#ifndef SQLITE_OMIT_GENERATED_COLUMNS
drh77318a32019-12-12 15:19:18 +0000718 else if( pNC->ncFlags & NC_GenCol ) zIn = "generated columns";
drh81f7b372019-10-16 12:18:59 +0000719#endif
drh77318a32019-12-12 15:19:18 +0000720 sqlite3ErrorMsg(pParse, "%s prohibited in %s", zMsg, zIn);
721 if( pExpr ) pExpr->op = TK_NULL;
drh3780be12013-07-31 19:05:22 +0000722}
drh77318a32019-12-12 15:19:18 +0000723#define sqlite3ResolveNotValid(P,N,M,X,E) \
724 assert( ((X)&~(NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol))==0 ); \
725 if( ((N)->ncFlags & (X))!=0 ) notValidImpl(P,N,M,E);
drh3780be12013-07-31 19:05:22 +0000726
drhcca9f3d2013-09-06 15:23:29 +0000727/*
728** Expression p should encode a floating point value between 1.0 and 0.0.
729** Return 1024 times this value. Or return -1 if p is not a floating point
730** value between 1.0 and 0.0.
731*/
732static int exprProbability(Expr *p){
733 double r = -1.0;
734 if( p->op!=TK_FLOAT ) return -1;
735 sqlite3AtoF(p->u.zToken, &r, sqlite3Strlen30(p->u.zToken), SQLITE_UTF8);
drh09328c02013-09-11 14:34:58 +0000736 assert( r>=0.0 );
737 if( r>1.0 ) return -1;
drhd05ab6a2014-10-25 13:42:16 +0000738 return (int)(r*134217728.0);
drhcca9f3d2013-09-06 15:23:29 +0000739}
drh3780be12013-07-31 19:05:22 +0000740
741/*
drh7d10d5a2008-08-20 16:35:10 +0000742** This routine is callback for sqlite3WalkExpr().
743**
744** Resolve symbolic names into TK_COLUMN operators for the current
745** node in the expression tree. Return 0 to continue the search down
746** the tree or 2 to abort the tree walk.
747**
748** This routine also does error checking and name resolution for
749** function names. The operator for aggregate functions is changed
750** to TK_AGG_FUNCTION.
751*/
752static int resolveExprStep(Walker *pWalker, Expr *pExpr){
753 NameContext *pNC;
754 Parse *pParse;
755
drh7d10d5a2008-08-20 16:35:10 +0000756 pNC = pWalker->u.pNC;
757 assert( pNC!=0 );
758 pParse = pNC->pParse;
759 assert( pParse==pWalker->pParse );
760
drh7d10d5a2008-08-20 16:35:10 +0000761#ifndef NDEBUG
762 if( pNC->pSrcList && pNC->pSrcList->nAlloc>0 ){
763 SrcList *pSrcList = pNC->pSrcList;
764 int i;
765 for(i=0; i<pNC->pSrcList->nSrc; i++){
766 assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursor<pParse->nTab);
767 }
768 }
769#endif
770 switch( pExpr->op ){
drh41204f12008-10-06 13:54:35 +0000771
drh41204f12008-10-06 13:54:35 +0000772 /* The special operator TK_ROW means use the rowid for the first
773 ** column in the FROM clause. This is used by the LIMIT and ORDER BY
danbe952c12020-07-13 20:10:29 +0000774 ** clause processing on UPDATE and DELETE statements, and by
775 ** UPDATE ... FROM statement processing.
drh41204f12008-10-06 13:54:35 +0000776 */
777 case TK_ROW: {
778 SrcList *pSrcList = pNC->pSrcList;
drh76012942021-02-21 21:04:54 +0000779 SrcItem *pItem;
danf2972b62020-04-29 20:11:01 +0000780 assert( pSrcList && pSrcList->nSrc>=1 );
drh2fba3942017-11-09 03:55:09 +0000781 pItem = pSrcList->a;
drh41204f12008-10-06 13:54:35 +0000782 pExpr->op = TK_COLUMN;
drheda079c2018-09-20 19:02:15 +0000783 pExpr->y.pTab = pItem->pTab;
drh41204f12008-10-06 13:54:35 +0000784 pExpr->iTable = pItem->iCursor;
dan576d5a82020-07-15 18:30:01 +0000785 pExpr->iColumn--;
drhaf97c3f2019-08-08 18:49:16 +0000786 pExpr->affExpr = SQLITE_AFF_INTEGER;
drh41204f12008-10-06 13:54:35 +0000787 break;
788 }
drh41204f12008-10-06 13:54:35 +0000789
dan8ddf6862021-02-26 20:14:32 +0000790 /* An "<expr> IS NOT NULL" or "<expr> IS NULL". After resolving the
791 ** LHS, check if there is a NOT NULL constraint in the schema that
792 ** means the value of the expression can be determined immediately.
793 ** If that is the case, replace the current expression node with
794 ** a TK_TRUEFALSE node.
795 **
796 ** If the node is replaced with a TK_TRUEFALSE node, then also restore
797 ** the NameContext ref-counts to the state they where in before the
798 ** LHS expression was resolved. This prevents the current select
799 ** from being erroneously marked as correlated in some cases.
800 */
801 case TK_NOTNULL:
802 case TK_ISNULL: {
803 int anRef[8];
804 NameContext *p;
805 int i;
806 for(i=0, p=pNC; p && i<ArraySize(anRef); p=p->pNext, i++){
807 anRef[i] = p->nRef;
808 }
809 sqlite3WalkExpr(pWalker, pExpr->pLeft);
dan3083d5f2021-03-03 11:00:31 +0000810 if( 0==sqlite3ExprCanBeNull(pExpr->pLeft) && !IN_RENAME_OBJECT ){
dan8ddf6862021-02-26 20:14:32 +0000811 if( pExpr->op==TK_NOTNULL ){
812 pExpr->u.zToken = "true";
813 ExprSetProperty(pExpr, EP_IsTrue);
814 }else{
815 pExpr->u.zToken = "false";
816 ExprSetProperty(pExpr, EP_IsFalse);
817 }
818 pExpr->op = TK_TRUEFALSE;
819 for(i=0, p=pNC; p && i<ArraySize(anRef); p=p->pNext, i++){
820 p->nRef = anRef[i];
821 }
822 sqlite3ExprDelete(pParse->db, pExpr->pLeft);
823 pExpr->pLeft = 0;
824 }
825 return WRC_Prune;
826 }
827
drh3cf48e32017-03-07 03:25:52 +0000828 /* A column name: ID
829 ** Or table name and column name: ID.ID
drh7d10d5a2008-08-20 16:35:10 +0000830 ** Or a database, table and column: ID.ID.ID
drh3cf48e32017-03-07 03:25:52 +0000831 **
832 ** The TK_ID and TK_OUT cases are combined so that there will only
833 ** be one call to lookupName(). Then the compiler will in-line
834 ** lookupName() for a size reduction and performance increase.
drh7d10d5a2008-08-20 16:35:10 +0000835 */
drh3cf48e32017-03-07 03:25:52 +0000836 case TK_ID:
drh7d10d5a2008-08-20 16:35:10 +0000837 case TK_DOT: {
drhb7916a72009-05-27 10:31:29 +0000838 const char *zColumn;
839 const char *zTable;
840 const char *zDb;
drh7d10d5a2008-08-20 16:35:10 +0000841 Expr *pRight;
842
drh3cf48e32017-03-07 03:25:52 +0000843 if( pExpr->op==TK_ID ){
drhb7916a72009-05-27 10:31:29 +0000844 zDb = 0;
drh3cf48e32017-03-07 03:25:52 +0000845 zTable = 0;
846 zColumn = pExpr->u.zToken;
drh7d10d5a2008-08-20 16:35:10 +0000847 }else{
danc9461ec2018-08-29 21:00:16 +0000848 Expr *pLeft = pExpr->pLeft;
drh77318a32019-12-12 15:19:18 +0000849 testcase( pNC->ncFlags & NC_IdxExpr );
850 testcase( pNC->ncFlags & NC_GenCol );
851 sqlite3ResolveNotValid(pParse, pNC, "the \".\" operator",
852 NC_IdxExpr|NC_GenCol, 0);
drh3cf48e32017-03-07 03:25:52 +0000853 pRight = pExpr->pRight;
854 if( pRight->op==TK_ID ){
855 zDb = 0;
drh3cf48e32017-03-07 03:25:52 +0000856 }else{
857 assert( pRight->op==TK_DOT );
danc9461ec2018-08-29 21:00:16 +0000858 zDb = pLeft->u.zToken;
859 pLeft = pRight->pLeft;
dancf8f2892018-08-09 20:47:01 +0000860 pRight = pRight->pRight;
861 }
danc9461ec2018-08-29 21:00:16 +0000862 zTable = pLeft->u.zToken;
dancf8f2892018-08-09 20:47:01 +0000863 zColumn = pRight->u.zToken;
danc9461ec2018-08-29 21:00:16 +0000864 if( IN_RENAME_OBJECT ){
dan07e95232018-08-21 16:32:53 +0000865 sqlite3RenameTokenRemap(pParse, (void*)pExpr, (void*)pRight);
drheda079c2018-09-20 19:02:15 +0000866 sqlite3RenameTokenRemap(pParse, (void*)&pExpr->y.pTab, (void*)pLeft);
danc9461ec2018-08-29 21:00:16 +0000867 }
drh7d10d5a2008-08-20 16:35:10 +0000868 }
drhf7828b52009-06-15 23:15:59 +0000869 return lookupName(pParse, zDb, zTable, zColumn, pNC, pExpr);
drh7d10d5a2008-08-20 16:35:10 +0000870 }
871
872 /* Resolve function names
873 */
drh7d10d5a2008-08-20 16:35:10 +0000874 case TK_FUNCTION: {
danielk19776ab3a2e2009-02-19 14:39:25 +0000875 ExprList *pList = pExpr->x.pList; /* The argument list */
876 int n = pList ? pList->nExpr : 0; /* Number of arguments */
drh7d10d5a2008-08-20 16:35:10 +0000877 int no_such_func = 0; /* True if no such function exists */
878 int wrong_num_args = 0; /* True if wrong number of arguments */
879 int is_agg = 0; /* True if is an aggregate function */
drh7d10d5a2008-08-20 16:35:10 +0000880 int nId; /* Number of characters in function name */
881 const char *zId; /* The function name. */
882 FuncDef *pDef; /* Information about the function */
drhea678832008-12-10 19:26:22 +0000883 u8 enc = ENC(pParse->db); /* The database encoding */
dan4ded26a2019-03-28 16:15:05 +0000884 int savedAllowFlags = (pNC->ncFlags & (NC_AllowAgg | NC_AllowWin));
dan4f9adee2019-07-13 16:22:50 +0000885#ifndef SQLITE_OMIT_WINDOWFUNC
886 Window *pWin = (IsWindowFunc(pExpr) ? pExpr->y.pWin : 0);
887#endif
danielk19776ab3a2e2009-02-19 14:39:25 +0000888 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
drh33e619f2009-05-28 01:00:55 +0000889 zId = pExpr->u.zToken;
drhb7916a72009-05-27 10:31:29 +0000890 nId = sqlite3Strlen30(zId);
drh80738d92016-02-15 00:34:16 +0000891 pDef = sqlite3FindFunction(pParse->db, zId, n, enc, 0);
drh7d10d5a2008-08-20 16:35:10 +0000892 if( pDef==0 ){
drh80738d92016-02-15 00:34:16 +0000893 pDef = sqlite3FindFunction(pParse->db, zId, -2, enc, 0);
drh7d10d5a2008-08-20 16:35:10 +0000894 if( pDef==0 ){
895 no_such_func = 1;
896 }else{
897 wrong_num_args = 1;
898 }
899 }else{
drh2d801512016-01-14 22:19:58 +0000900 is_agg = pDef->xFinalize!=0;
drhcca9f3d2013-09-06 15:23:29 +0000901 if( pDef->funcFlags & SQLITE_FUNC_UNLIKELY ){
drha7d6db62019-06-11 21:02:15 +0000902 ExprSetProperty(pExpr, EP_Unlikely);
drhcca9f3d2013-09-06 15:23:29 +0000903 if( n==2 ){
904 pExpr->iTable = exprProbability(pList->a[1].pExpr);
905 if( pExpr->iTable<0 ){
drh31e71472015-02-09 10:20:19 +0000906 sqlite3ErrorMsg(pParse,
907 "second argument to likelihood() must be a "
908 "constant between 0.0 and 1.0");
drhcca9f3d2013-09-06 15:23:29 +0000909 pNC->nErr++;
910 }
911 }else{
drh31e71472015-02-09 10:20:19 +0000912 /* EVIDENCE-OF: R-61304-29449 The unlikely(X) function is
913 ** equivalent to likelihood(X, 0.0625).
914 ** EVIDENCE-OF: R-01283-11636 The unlikely(X) function is
915 ** short-hand for likelihood(X,0.0625).
916 ** EVIDENCE-OF: R-36850-34127 The likely(X) function is short-hand
917 ** for likelihood(X,0.9375).
918 ** EVIDENCE-OF: R-53436-40973 The likely(X) function is equivalent
919 ** to likelihood(X,0.9375). */
drh03202a92014-06-17 16:11:28 +0000920 /* TUNING: unlikely() probability is 0.0625. likely() is 0.9375 */
drhd05ab6a2014-10-25 13:42:16 +0000921 pExpr->iTable = pDef->zName[0]=='u' ? 8388608 : 125829120;
drhcca9f3d2013-09-06 15:23:29 +0000922 }
923 }
drh7d10d5a2008-08-20 16:35:10 +0000924#ifndef SQLITE_OMIT_AUTHORIZATION
drha0daa752016-09-16 11:53:10 +0000925 {
926 int auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0,pDef->zName,0);
927 if( auth!=SQLITE_OK ){
928 if( auth==SQLITE_DENY ){
929 sqlite3ErrorMsg(pParse, "not authorized to use function: %s",
930 pDef->zName);
931 pNC->nErr++;
932 }
933 pExpr->op = TK_NULL;
934 return WRC_Prune;
drh7d10d5a2008-08-20 16:35:10 +0000935 }
drh7d10d5a2008-08-20 16:35:10 +0000936 }
drh9588ad92014-09-15 14:46:02 +0000937#endif
drha7f910b2015-09-01 13:17:17 +0000938 if( pDef->funcFlags & (SQLITE_FUNC_CONSTANT|SQLITE_FUNC_SLOCHNG) ){
drh1d85e402015-08-31 17:34:41 +0000939 /* For the purposes of the EP_ConstFunc flag, date and time
drh03bf26d2015-08-31 21:16:36 +0000940 ** functions and other functions that change slowly are considered
drh20cee7d2019-10-30 18:50:08 +0000941 ** constant because they are constant for the duration of one query.
942 ** This allows them to be factored out of inner loops. */
drh63f84572015-02-09 14:07:07 +0000943 ExprSetProperty(pExpr,EP_ConstFunc);
drh1d85e402015-08-31 17:34:41 +0000944 }
945 if( (pDef->funcFlags & SQLITE_FUNC_CONSTANT)==0 ){
drhfe704602020-01-18 21:34:31 +0000946 /* Clearly non-deterministic functions like random(), but also
947 ** date/time functions that use 'now', and other functions like
drha7f910b2015-09-01 13:17:17 +0000948 ** sqlite_version() that might change over time cannot be used
drhfe704602020-01-18 21:34:31 +0000949 ** in an index or generated column. Curiously, they can be used
950 ** in a CHECK constraint. SQLServer, MySQL, and PostgreSQL all
951 ** all this. */
drh77318a32019-12-12 15:19:18 +0000952 sqlite3ResolveNotValid(pParse, pNC, "non-deterministic functions",
drhfe704602020-01-18 21:34:31 +0000953 NC_IdxExpr|NC_PartIdx|NC_GenCol, 0);
drh20cee7d2019-10-30 18:50:08 +0000954 }else{
955 assert( (NC_SelfRef & 0xff)==NC_SelfRef ); /* Must fit in 8 bits */
956 pExpr->op2 = pNC->ncFlags & NC_SelfRef;
drh05b32ee2020-01-09 01:20:03 +0000957 if( pNC->ncFlags & NC_FromDDL ) ExprSetProperty(pExpr, EP_FromDDL);
drh31e71472015-02-09 10:20:19 +0000958 }
drheea8eb62018-11-26 18:09:15 +0000959 if( (pDef->funcFlags & SQLITE_FUNC_INTERNAL)!=0
960 && pParse->nested==0
drh171c50e2020-01-01 15:43:30 +0000961 && (pParse->db->mDbFlags & DBFLAG_InternalFunc)==0
drheea8eb62018-11-26 18:09:15 +0000962 ){
963 /* Internal-use-only functions are disallowed unless the
drh0dfa5252020-01-08 17:28:19 +0000964 ** SQL is being compiled using sqlite3NestedParse() or
965 ** the SQLITE_TESTCTRL_INTERNAL_FUNCTIONS test-control has be
966 ** used to activate internal functionsn for testing purposes */
drheea8eb62018-11-26 18:09:15 +0000967 no_such_func = 1;
968 pDef = 0;
drh2eeca202020-01-08 20:37:45 +0000969 }else
970 if( (pDef->funcFlags & (SQLITE_FUNC_DIRECT|SQLITE_FUNC_UNSAFE))!=0
971 && !IN_RENAME_OBJECT
972 ){
973 sqlite3ExprFunctionUsable(pParse, pExpr, pDef);
drheea8eb62018-11-26 18:09:15 +0000974 }
drh7d10d5a2008-08-20 16:35:10 +0000975 }
dan26522d12018-06-11 18:16:51 +0000976
danc9461ec2018-08-29 21:00:16 +0000977 if( 0==IN_RENAME_OBJECT ){
dan67a9b8e2018-06-22 20:51:35 +0000978#ifndef SQLITE_OMIT_WINDOWFUNC
dandabc2682018-08-17 17:18:16 +0000979 assert( is_agg==0 || (pDef->funcFlags & SQLITE_FUNC_MINMAX)
dan7262ca92018-07-02 12:07:32 +0000980 || (pDef->xValue==0 && pDef->xInverse==0)
981 || (pDef->xValue && pDef->xInverse && pDef->xSFunc && pDef->xFinalize)
dan26522d12018-06-11 18:16:51 +0000982 );
dan8117f112019-07-10 20:16:53 +0000983 if( pDef && pDef->xValue==0 && pWin ){
dandabc2682018-08-17 17:18:16 +0000984 sqlite3ErrorMsg(pParse,
985 "%.*s() may not be used as a window function", nId, zId
986 );
987 pNC->nErr++;
988 }else if(
989 (is_agg && (pNC->ncFlags & NC_AllowAgg)==0)
dan8117f112019-07-10 20:16:53 +0000990 || (is_agg && (pDef->funcFlags&SQLITE_FUNC_WINDOW) && !pWin)
991 || (is_agg && pWin && (pNC->ncFlags & NC_AllowWin)==0)
dandabc2682018-08-17 17:18:16 +0000992 ){
993 const char *zType;
dan8117f112019-07-10 20:16:53 +0000994 if( (pDef->funcFlags & SQLITE_FUNC_WINDOW) || pWin ){
dandabc2682018-08-17 17:18:16 +0000995 zType = "window";
996 }else{
997 zType = "aggregate";
998 }
999 sqlite3ErrorMsg(pParse, "misuse of %s function %.*s()",zType,nId,zId);
1000 pNC->nErr++;
1001 is_agg = 0;
dan26522d12018-06-11 18:16:51 +00001002 }
danc3163072018-06-23 19:29:56 +00001003#else
dandabc2682018-08-17 17:18:16 +00001004 if( (is_agg && (pNC->ncFlags & NC_AllowAgg)==0) ){
1005 sqlite3ErrorMsg(pParse,"misuse of aggregate function %.*s()",nId,zId);
1006 pNC->nErr++;
1007 is_agg = 0;
1008 }
danc3163072018-06-23 19:29:56 +00001009#endif
drh3a843f52018-08-25 03:29:34 +00001010 else if( no_such_func && pParse->db->init.busy==0
drhcc153132016-08-04 12:35:17 +00001011#ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
dandabc2682018-08-17 17:18:16 +00001012 && pParse->explain==0
drhcc153132016-08-04 12:35:17 +00001013#endif
dandabc2682018-08-17 17:18:16 +00001014 ){
1015 sqlite3ErrorMsg(pParse, "no such function: %.*s", nId, zId);
1016 pNC->nErr++;
1017 }else if( wrong_num_args ){
1018 sqlite3ErrorMsg(pParse,"wrong number of arguments to function %.*s()",
1019 nId, zId);
1020 pNC->nErr++;
1021 }
dan5e61c1b2019-07-13 17:45:25 +00001022#ifndef SQLITE_OMIT_WINDOWFUNC
1023 else if( is_agg==0 && ExprHasProperty(pExpr, EP_WinFunc) ){
1024 sqlite3ErrorMsg(pParse,
1025 "FILTER may not be used with non-aggregate %.*s()",
1026 nId, zId
1027 );
1028 pNC->nErr++;
1029 }
1030#endif
dandabc2682018-08-17 17:18:16 +00001031 if( is_agg ){
dan4ded26a2019-03-28 16:15:05 +00001032 /* Window functions may not be arguments of aggregate functions.
1033 ** Or arguments of other window functions. But aggregate functions
1034 ** may be arguments for window functions. */
dan34a7d792018-06-29 20:43:33 +00001035#ifndef SQLITE_OMIT_WINDOWFUNC
dan8117f112019-07-10 20:16:53 +00001036 pNC->ncFlags &= ~(NC_AllowWin | (!pWin ? NC_AllowAgg : 0));
dan34a7d792018-06-29 20:43:33 +00001037#else
dandabc2682018-08-17 17:18:16 +00001038 pNC->ncFlags &= ~NC_AllowAgg;
dan34a7d792018-06-29 20:43:33 +00001039#endif
dandabc2682018-08-17 17:18:16 +00001040 }
danc3163072018-06-23 19:29:56 +00001041 }
dan9bf022d2019-07-19 14:32:42 +00001042#ifndef SQLITE_OMIT_WINDOWFUNC
dan1e602612019-07-22 11:38:43 +00001043 else if( ExprHasProperty(pExpr, EP_WinFunc) ){
dan9bf022d2019-07-19 14:32:42 +00001044 is_agg = 1;
1045 }
1046#endif
drh7d10d5a2008-08-20 16:35:10 +00001047 sqlite3WalkExprList(pWalker, pList);
drh030796d2012-08-23 16:18:10 +00001048 if( is_agg ){
dan67a9b8e2018-06-22 20:51:35 +00001049#ifndef SQLITE_OMIT_WINDOWFUNC
dan4f9adee2019-07-13 16:22:50 +00001050 if( pWin ){
dane3bf6322018-06-08 20:58:27 +00001051 Select *pSel = pNC->pWinSelect;
dan75b08212019-07-22 16:20:03 +00001052 assert( pWin==pExpr->y.pWin );
dan490e6f22019-04-29 11:27:58 +00001053 if( IN_RENAME_OBJECT==0 ){
drh2e2c8812019-12-13 11:42:56 +00001054 sqlite3WindowUpdate(pParse, pSel ? pSel->pWinDefn : 0, pWin, pDef);
dane8dd6a42021-03-04 16:10:23 +00001055 if( pParse->db->mallocFailed ) break;
dan490e6f22019-04-29 11:27:58 +00001056 }
dan4f9adee2019-07-13 16:22:50 +00001057 sqlite3WalkExprList(pWalker, pWin->pPartition);
1058 sqlite3WalkExprList(pWalker, pWin->pOrderBy);
1059 sqlite3WalkExpr(pWalker, pWin->pFilter);
dana3fcc002019-08-15 13:53:22 +00001060 sqlite3WindowLink(pSel, pWin);
dan4ded26a2019-03-28 16:15:05 +00001061 pNC->ncFlags |= NC_HasWin;
dan67a9b8e2018-06-22 20:51:35 +00001062 }else
1063#endif /* SQLITE_OMIT_WINDOWFUNC */
1064 {
dan86fb6e12018-05-16 20:58:07 +00001065 NameContext *pNC2 = pNC;
1066 pExpr->op = TK_AGG_FUNCTION;
1067 pExpr->op2 = 0;
dan6ba7ab02019-07-02 11:56:47 +00001068#ifndef SQLITE_OMIT_WINDOWFUNC
dan4f9adee2019-07-13 16:22:50 +00001069 if( ExprHasProperty(pExpr, EP_WinFunc) ){
1070 sqlite3WalkExpr(pWalker, pExpr->y.pWin->pFilter);
1071 }
dan6ba7ab02019-07-02 11:56:47 +00001072#endif
dan86fb6e12018-05-16 20:58:07 +00001073 while( pNC2 && !sqlite3FunctionUsesThisSrc(pExpr, pNC2->pSrcList) ){
1074 pExpr->op2++;
1075 pNC2 = pNC2->pNext;
1076 }
dan72d1eac2019-08-05 13:19:25 +00001077 assert( pDef!=0 || IN_RENAME_OBJECT );
1078 if( pNC2 && pDef ){
dan86fb6e12018-05-16 20:58:07 +00001079 assert( SQLITE_FUNC_MINMAX==NC_MinMaxAgg );
1080 testcase( (pDef->funcFlags & SQLITE_FUNC_MINMAX)!=0 );
1081 pNC2->ncFlags |= NC_HasAgg | (pDef->funcFlags & SQLITE_FUNC_MINMAX);
drh9588ad92014-09-15 14:46:02 +00001082
dan86fb6e12018-05-16 20:58:07 +00001083 }
drh9588ad92014-09-15 14:46:02 +00001084 }
dan4ded26a2019-03-28 16:15:05 +00001085 pNC->ncFlags |= savedAllowFlags;
drh030796d2012-08-23 16:18:10 +00001086 }
drh7d10d5a2008-08-20 16:35:10 +00001087 /* FIX ME: Compute pExpr->affinity based on the expected return
1088 ** type of the function
1089 */
1090 return WRC_Prune;
1091 }
1092#ifndef SQLITE_OMIT_SUBQUERY
1093 case TK_SELECT:
drh73c0fdc2009-06-15 18:32:36 +00001094 case TK_EXISTS: testcase( pExpr->op==TK_EXISTS );
drh7d10d5a2008-08-20 16:35:10 +00001095#endif
1096 case TK_IN: {
drh73c0fdc2009-06-15 18:32:36 +00001097 testcase( pExpr->op==TK_IN );
danielk19776ab3a2e2009-02-19 14:39:25 +00001098 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
drh7d10d5a2008-08-20 16:35:10 +00001099 int nRef = pNC->nRef;
drh77318a32019-12-12 15:19:18 +00001100 testcase( pNC->ncFlags & NC_IsCheck );
1101 testcase( pNC->ncFlags & NC_PartIdx );
1102 testcase( pNC->ncFlags & NC_IdxExpr );
1103 testcase( pNC->ncFlags & NC_GenCol );
1104 sqlite3ResolveNotValid(pParse, pNC, "subqueries",
1105 NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol, pExpr);
danielk19776ab3a2e2009-02-19 14:39:25 +00001106 sqlite3WalkSelect(pWalker, pExpr->x.pSelect);
drh7d10d5a2008-08-20 16:35:10 +00001107 assert( pNC->nRef>=nRef );
1108 if( nRef!=pNC->nRef ){
1109 ExprSetProperty(pExpr, EP_VarSelect);
drh91da7072016-05-04 14:45:30 +00001110 pNC->ncFlags |= NC_VarSelect;
drh7d10d5a2008-08-20 16:35:10 +00001111 }
1112 }
1113 break;
1114 }
drh7d10d5a2008-08-20 16:35:10 +00001115 case TK_VARIABLE: {
drh77318a32019-12-12 15:19:18 +00001116 testcase( pNC->ncFlags & NC_IsCheck );
1117 testcase( pNC->ncFlags & NC_PartIdx );
1118 testcase( pNC->ncFlags & NC_IdxExpr );
1119 testcase( pNC->ncFlags & NC_GenCol );
1120 sqlite3ResolveNotValid(pParse, pNC, "parameters",
1121 NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol, pExpr);
drh7d10d5a2008-08-20 16:35:10 +00001122 break;
1123 }
drh007c8432018-02-26 03:20:18 +00001124 case TK_IS:
drh8abed7b2018-02-26 18:49:05 +00001125 case TK_ISNOT: {
drh0d950af2019-08-22 16:38:42 +00001126 Expr *pRight = sqlite3ExprSkipCollateAndLikely(pExpr->pRight);
drh8abed7b2018-02-26 18:49:05 +00001127 assert( !ExprHasProperty(pExpr, EP_Reduced) );
1128 /* Handle special cases of "x IS TRUE", "x IS FALSE", "x IS NOT TRUE",
1129 ** and "x IS NOT FALSE". */
drh91be05a2021-03-04 18:34:54 +00001130 if( ALWAYS(pRight) && (pRight->op==TK_ID || pRight->op==TK_TRUEFALSE) ){
drh8abed7b2018-02-26 18:49:05 +00001131 int rc = resolveExprStep(pWalker, pRight);
drh007c8432018-02-26 03:20:18 +00001132 if( rc==WRC_Abort ) return WRC_Abort;
drh8abed7b2018-02-26 18:49:05 +00001133 if( pRight->op==TK_TRUEFALSE ){
drh8abed7b2018-02-26 18:49:05 +00001134 pExpr->op2 = pExpr->op;
1135 pExpr->op = TK_TRUTH;
drh007c8432018-02-26 03:20:18 +00001136 return WRC_Continue;
1137 }
1138 }
drh08b92082020-08-10 14:18:00 +00001139 /* no break */ deliberate_fall_through
drh8abed7b2018-02-26 18:49:05 +00001140 }
dan3bafded2016-11-11 15:49:01 +00001141 case TK_BETWEEN:
drhb29e60c2016-09-05 12:02:34 +00001142 case TK_EQ:
1143 case TK_NE:
1144 case TK_LT:
1145 case TK_LE:
1146 case TK_GT:
drh8abed7b2018-02-26 18:49:05 +00001147 case TK_GE: {
drhb29e60c2016-09-05 12:02:34 +00001148 int nLeft, nRight;
1149 if( pParse->db->mallocFailed ) break;
drhb29e60c2016-09-05 12:02:34 +00001150 assert( pExpr->pLeft!=0 );
1151 nLeft = sqlite3ExprVectorSize(pExpr->pLeft);
dan3bafded2016-11-11 15:49:01 +00001152 if( pExpr->op==TK_BETWEEN ){
1153 nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[0].pExpr);
1154 if( nRight==nLeft ){
1155 nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[1].pExpr);
1156 }
1157 }else{
1158 assert( pExpr->pRight!=0 );
1159 nRight = sqlite3ExprVectorSize(pExpr->pRight);
1160 }
drhb29e60c2016-09-05 12:02:34 +00001161 if( nLeft!=nRight ){
1162 testcase( pExpr->op==TK_EQ );
1163 testcase( pExpr->op==TK_NE );
1164 testcase( pExpr->op==TK_LT );
1165 testcase( pExpr->op==TK_LE );
1166 testcase( pExpr->op==TK_GT );
1167 testcase( pExpr->op==TK_GE );
1168 testcase( pExpr->op==TK_IS );
1169 testcase( pExpr->op==TK_ISNOT );
dan3bafded2016-11-11 15:49:01 +00001170 testcase( pExpr->op==TK_BETWEEN );
drhb29e60c2016-09-05 12:02:34 +00001171 sqlite3ErrorMsg(pParse, "row value misused");
1172 }
1173 break;
1174 }
drh7d10d5a2008-08-20 16:35:10 +00001175 }
1176 return (pParse->nErr || pParse->db->mallocFailed) ? WRC_Abort : WRC_Continue;
1177}
1178
1179/*
1180** pEList is a list of expressions which are really the result set of the
1181** a SELECT statement. pE is a term in an ORDER BY or GROUP BY clause.
1182** This routine checks to see if pE is a simple identifier which corresponds
1183** to the AS-name of one of the terms of the expression list. If it is,
1184** this routine return an integer between 1 and N where N is the number of
1185** elements in pEList, corresponding to the matching entry. If there is
1186** no match, or if pE is not a simple identifier, then this routine
1187** return 0.
1188**
1189** pEList has been resolved. pE has not.
1190*/
1191static int resolveAsName(
1192 Parse *pParse, /* Parsing context for error messages */
1193 ExprList *pEList, /* List of expressions to scan */
1194 Expr *pE /* Expression we are trying to match */
1195){
1196 int i; /* Loop counter */
1197
shanecf697392009-06-01 16:53:09 +00001198 UNUSED_PARAMETER(pParse);
1199
drh73c0fdc2009-06-15 18:32:36 +00001200 if( pE->op==TK_ID ){
drh33e619f2009-05-28 01:00:55 +00001201 char *zCol = pE->u.zToken;
drh7d10d5a2008-08-20 16:35:10 +00001202 for(i=0; i<pEList->nExpr; i++){
drhc4938ea2019-12-13 00:49:42 +00001203 if( pEList->a[i].eEName==ENAME_NAME
dan607dd6e2020-01-03 14:27:08 +00001204 && sqlite3_stricmp(pEList->a[i].zEName, zCol)==0
drhc4938ea2019-12-13 00:49:42 +00001205 ){
drh7d10d5a2008-08-20 16:35:10 +00001206 return i+1;
1207 }
1208 }
drh7d10d5a2008-08-20 16:35:10 +00001209 }
1210 return 0;
1211}
1212
1213/*
1214** pE is a pointer to an expression which is a single term in the
1215** ORDER BY of a compound SELECT. The expression has not been
1216** name resolved.
1217**
1218** At the point this routine is called, we already know that the
1219** ORDER BY term is not an integer index into the result set. That
1220** case is handled by the calling routine.
1221**
1222** Attempt to match pE against result set columns in the left-most
1223** SELECT statement. Return the index i of the matching column,
1224** as an indication to the caller that it should sort by the i-th column.
1225** The left-most column is 1. In other words, the value returned is the
1226** same integer value that would be used in the SQL statement to indicate
1227** the column.
1228**
1229** If there is no match, return 0. Return -1 if an error occurs.
1230*/
1231static int resolveOrderByTermToExprList(
1232 Parse *pParse, /* Parsing context for error messages */
1233 Select *pSelect, /* The SELECT statement with the ORDER BY clause */
1234 Expr *pE /* The specific ORDER BY term */
1235){
1236 int i; /* Loop counter */
1237 ExprList *pEList; /* The columns of the result set */
1238 NameContext nc; /* Name context for resolving pE */
drha7564662010-02-22 19:32:31 +00001239 sqlite3 *db; /* Database connection */
1240 int rc; /* Return code from subprocedures */
1241 u8 savedSuppErr; /* Saved value of db->suppressErr */
drh7d10d5a2008-08-20 16:35:10 +00001242
1243 assert( sqlite3ExprIsInteger(pE, &i)==0 );
1244 pEList = pSelect->pEList;
1245
1246 /* Resolve all names in the ORDER BY term expression
1247 */
1248 memset(&nc, 0, sizeof(nc));
1249 nc.pParse = pParse;
1250 nc.pSrcList = pSelect->pSrc;
drh25c3b8c2018-04-16 10:34:13 +00001251 nc.uNC.pEList = pEList;
1252 nc.ncFlags = NC_AllowAgg|NC_UEList;
drh7d10d5a2008-08-20 16:35:10 +00001253 nc.nErr = 0;
drha7564662010-02-22 19:32:31 +00001254 db = pParse->db;
1255 savedSuppErr = db->suppressErr;
dan4db7ab52020-04-03 11:52:59 +00001256 if( IN_RENAME_OBJECT==0 ) db->suppressErr = 1;
drha7564662010-02-22 19:32:31 +00001257 rc = sqlite3ResolveExprNames(&nc, pE);
1258 db->suppressErr = savedSuppErr;
1259 if( rc ) return 0;
drh7d10d5a2008-08-20 16:35:10 +00001260
1261 /* Try to match the ORDER BY expression against an expression
1262 ** in the result set. Return an 1-based index of the matching
1263 ** result-set entry.
1264 */
1265 for(i=0; i<pEList->nExpr; i++){
dan5aa550c2017-06-24 18:10:29 +00001266 if( sqlite3ExprCompare(0, pEList->a[i].pExpr, pE, -1)<2 ){
drh7d10d5a2008-08-20 16:35:10 +00001267 return i+1;
1268 }
1269 }
1270
1271 /* If no match, return 0. */
1272 return 0;
1273}
1274
1275/*
1276** Generate an ORDER BY or GROUP BY term out-of-range error.
1277*/
1278static void resolveOutOfRangeError(
1279 Parse *pParse, /* The error context into which to write the error */
1280 const char *zType, /* "ORDER" or "GROUP" */
1281 int i, /* The index (1-based) of the term out of range */
1282 int mx /* Largest permissible value of i */
1283){
1284 sqlite3ErrorMsg(pParse,
1285 "%r %s BY term out of range - should be "
1286 "between 1 and %d", i, zType, mx);
1287}
1288
1289/*
1290** Analyze the ORDER BY clause in a compound SELECT statement. Modify
1291** each term of the ORDER BY clause is a constant integer between 1
1292** and N where N is the number of columns in the compound SELECT.
1293**
1294** ORDER BY terms that are already an integer between 1 and N are
1295** unmodified. ORDER BY terms that are integers outside the range of
1296** 1 through N generate an error. ORDER BY terms that are expressions
1297** are matched against result set expressions of compound SELECT
1298** beginning with the left-most SELECT and working toward the right.
1299** At the first match, the ORDER BY expression is transformed into
1300** the integer column number.
1301**
1302** Return the number of errors seen.
1303*/
1304static int resolveCompoundOrderBy(
1305 Parse *pParse, /* Parsing context. Leave error messages here */
1306 Select *pSelect /* The SELECT statement containing the ORDER BY */
1307){
1308 int i;
1309 ExprList *pOrderBy;
1310 ExprList *pEList;
1311 sqlite3 *db;
1312 int moreToDo = 1;
1313
1314 pOrderBy = pSelect->pOrderBy;
1315 if( pOrderBy==0 ) return 0;
1316 db = pParse->db;
drh7d10d5a2008-08-20 16:35:10 +00001317 if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
1318 sqlite3ErrorMsg(pParse, "too many terms in ORDER BY clause");
1319 return 1;
1320 }
drh7d10d5a2008-08-20 16:35:10 +00001321 for(i=0; i<pOrderBy->nExpr; i++){
1322 pOrderBy->a[i].done = 0;
1323 }
1324 pSelect->pNext = 0;
1325 while( pSelect->pPrior ){
1326 pSelect->pPrior->pNext = pSelect;
1327 pSelect = pSelect->pPrior;
1328 }
1329 while( pSelect && moreToDo ){
1330 struct ExprList_item *pItem;
1331 moreToDo = 0;
1332 pEList = pSelect->pEList;
drh0a846f92008-08-25 17:23:29 +00001333 assert( pEList!=0 );
drh7d10d5a2008-08-20 16:35:10 +00001334 for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
1335 int iCol = -1;
1336 Expr *pE, *pDup;
1337 if( pItem->done ) continue;
drh0d950af2019-08-22 16:38:42 +00001338 pE = sqlite3ExprSkipCollateAndLikely(pItem->pExpr);
drh235667a2020-11-08 20:44:30 +00001339 if( NEVER(pE==0) ) continue;
drh7d10d5a2008-08-20 16:35:10 +00001340 if( sqlite3ExprIsInteger(pE, &iCol) ){
drh73c0fdc2009-06-15 18:32:36 +00001341 if( iCol<=0 || iCol>pEList->nExpr ){
drh7d10d5a2008-08-20 16:35:10 +00001342 resolveOutOfRangeError(pParse, "ORDER", i+1, pEList->nExpr);
1343 return 1;
1344 }
1345 }else{
1346 iCol = resolveAsName(pParse, pEList, pE);
1347 if( iCol==0 ){
dan5e970a82019-01-16 14:58:37 +00001348 /* Now test if expression pE matches one of the values returned
1349 ** by pSelect. In the usual case this is done by duplicating the
1350 ** expression, resolving any symbols in it, and then comparing
1351 ** it against each expression returned by the SELECT statement.
1352 ** Once the comparisons are finished, the duplicate expression
1353 ** is deleted.
1354 **
1355 ** Or, if this is running as part of an ALTER TABLE operation,
1356 ** resolve the symbols in the actual expression, not a duplicate.
1357 ** And, if one of the comparisons is successful, leave the expression
1358 ** as is instead of transforming it to an integer as in the usual
1359 ** case. This allows the code in alter.c to modify column
1360 ** refererences within the ORDER BY expression as required. */
1361 if( IN_RENAME_OBJECT ){
1362 pDup = pE;
1363 }else{
1364 pDup = sqlite3ExprDup(db, pE, 0);
1365 }
drh7d10d5a2008-08-20 16:35:10 +00001366 if( !db->mallocFailed ){
1367 assert(pDup);
1368 iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup);
1369 }
dana5f9f422019-01-23 19:50:46 +00001370 if( !IN_RENAME_OBJECT ){
dan5e970a82019-01-16 14:58:37 +00001371 sqlite3ExprDelete(db, pDup);
1372 }
drh7d10d5a2008-08-20 16:35:10 +00001373 }
drh7d10d5a2008-08-20 16:35:10 +00001374 }
1375 if( iCol>0 ){
drhbd13d342012-12-07 21:02:47 +00001376 /* Convert the ORDER BY term into an integer column number iCol,
1377 ** taking care to preserve the COLLATE clause if it exists */
dana5f9f422019-01-23 19:50:46 +00001378 if( !IN_RENAME_OBJECT ){
1379 Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0);
1380 if( pNew==0 ) return 1;
1381 pNew->flags |= EP_IntValue;
1382 pNew->u.iValue = iCol;
1383 if( pItem->pExpr==pE ){
1384 pItem->pExpr = pNew;
1385 }else{
1386 Expr *pParent = pItem->pExpr;
1387 assert( pParent->op==TK_COLLATE );
1388 while( pParent->pLeft->op==TK_COLLATE ) pParent = pParent->pLeft;
1389 assert( pParent->pLeft==pE );
1390 pParent->pLeft = pNew;
1391 }
1392 sqlite3ExprDelete(db, pE);
1393 pItem->u.x.iOrderByCol = (u16)iCol;
drhbd13d342012-12-07 21:02:47 +00001394 }
drh7d10d5a2008-08-20 16:35:10 +00001395 pItem->done = 1;
1396 }else{
1397 moreToDo = 1;
1398 }
1399 }
1400 pSelect = pSelect->pNext;
1401 }
1402 for(i=0; i<pOrderBy->nExpr; i++){
1403 if( pOrderBy->a[i].done==0 ){
1404 sqlite3ErrorMsg(pParse, "%r ORDER BY term does not match any "
1405 "column in the result set", i+1);
1406 return 1;
1407 }
1408 }
1409 return 0;
1410}
1411
1412/*
1413** Check every term in the ORDER BY or GROUP BY clause pOrderBy of
1414** the SELECT statement pSelect. If any term is reference to a
drhc2acc4e2013-11-15 18:15:19 +00001415** result set expression (as determined by the ExprList.a.u.x.iOrderByCol
1416** field) then convert that term into a copy of the corresponding result set
drh7d10d5a2008-08-20 16:35:10 +00001417** column.
1418**
1419** If any errors are detected, add an error message to pParse and
1420** return non-zero. Return zero if no errors are seen.
1421*/
1422int sqlite3ResolveOrderGroupBy(
1423 Parse *pParse, /* Parsing context. Leave error messages here */
1424 Select *pSelect, /* The SELECT statement containing the clause */
1425 ExprList *pOrderBy, /* The ORDER BY or GROUP BY clause to be processed */
1426 const char *zType /* "ORDER" or "GROUP" */
1427){
1428 int i;
1429 sqlite3 *db = pParse->db;
1430 ExprList *pEList;
1431 struct ExprList_item *pItem;
1432
dan71f059c2019-08-01 10:58:46 +00001433 if( pOrderBy==0 || pParse->db->mallocFailed || IN_RENAME_OBJECT ) return 0;
drh7d10d5a2008-08-20 16:35:10 +00001434 if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
1435 sqlite3ErrorMsg(pParse, "too many terms in %s BY clause", zType);
1436 return 1;
1437 }
drh7d10d5a2008-08-20 16:35:10 +00001438 pEList = pSelect->pEList;
drh0a846f92008-08-25 17:23:29 +00001439 assert( pEList!=0 ); /* sqlite3SelectNew() guarantees this */
drh7d10d5a2008-08-20 16:35:10 +00001440 for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
drhc2acc4e2013-11-15 18:15:19 +00001441 if( pItem->u.x.iOrderByCol ){
1442 if( pItem->u.x.iOrderByCol>pEList->nExpr ){
drh7d10d5a2008-08-20 16:35:10 +00001443 resolveOutOfRangeError(pParse, zType, i+1, pEList->nExpr);
1444 return 1;
1445 }
drh6b37b762021-02-16 20:32:17 +00001446 resolveAlias(pParse, pEList, pItem->u.x.iOrderByCol-1, pItem->pExpr,0);
drh7d10d5a2008-08-20 16:35:10 +00001447 }
1448 }
1449 return 0;
1450}
1451
danf030b372019-02-22 19:24:16 +00001452#ifndef SQLITE_OMIT_WINDOWFUNC
1453/*
dan75b08212019-07-22 16:20:03 +00001454** Walker callback for windowRemoveExprFromSelect().
danf030b372019-02-22 19:24:16 +00001455*/
1456static int resolveRemoveWindowsCb(Walker *pWalker, Expr *pExpr){
drh51755a72019-08-08 19:40:29 +00001457 UNUSED_PARAMETER(pWalker);
danf030b372019-02-22 19:24:16 +00001458 if( ExprHasProperty(pExpr, EP_WinFunc) ){
dan75b08212019-07-22 16:20:03 +00001459 Window *pWin = pExpr->y.pWin;
drhe2094572019-07-22 19:01:38 +00001460 sqlite3WindowUnlinkFromSelect(pWin);
danf030b372019-02-22 19:24:16 +00001461 }
1462 return WRC_Continue;
1463}
1464
1465/*
1466** Remove any Window objects owned by the expression pExpr from the
1467** Select.pWin list of Select object pSelect.
1468*/
dan75b08212019-07-22 16:20:03 +00001469static void windowRemoveExprFromSelect(Select *pSelect, Expr *pExpr){
drhfd15e182019-07-20 21:12:31 +00001470 if( pSelect->pWin ){
1471 Walker sWalker;
1472 memset(&sWalker, 0, sizeof(Walker));
1473 sWalker.xExprCallback = resolveRemoveWindowsCb;
1474 sWalker.u.pSelect = pSelect;
1475 sqlite3WalkExpr(&sWalker, pExpr);
1476 }
danf030b372019-02-22 19:24:16 +00001477}
1478#else
dan75b08212019-07-22 16:20:03 +00001479# define windowRemoveExprFromSelect(a, b)
drhfd15e182019-07-20 21:12:31 +00001480#endif /* SQLITE_OMIT_WINDOWFUNC */
danf030b372019-02-22 19:24:16 +00001481
drh7d10d5a2008-08-20 16:35:10 +00001482/*
1483** pOrderBy is an ORDER BY or GROUP BY clause in SELECT statement pSelect.
1484** The Name context of the SELECT statement is pNC. zType is either
1485** "ORDER" or "GROUP" depending on which type of clause pOrderBy is.
1486**
1487** This routine resolves each term of the clause into an expression.
1488** If the order-by term is an integer I between 1 and N (where N is the
1489** number of columns in the result set of the SELECT) then the expression
1490** in the resolution is a copy of the I-th result-set expression. If
drh26080d92013-08-15 14:27:42 +00001491** the order-by term is an identifier that corresponds to the AS-name of
drh7d10d5a2008-08-20 16:35:10 +00001492** a result-set expression, then the term resolves to a copy of the
1493** result-set expression. Otherwise, the expression is resolved in
1494** the usual way - using sqlite3ResolveExprNames().
1495**
1496** This routine returns the number of errors. If errors occur, then
1497** an appropriate error message might be left in pParse. (OOM errors
1498** excepted.)
1499*/
1500static int resolveOrderGroupBy(
1501 NameContext *pNC, /* The name context of the SELECT statement */
1502 Select *pSelect, /* The SELECT statement holding pOrderBy */
1503 ExprList *pOrderBy, /* An ORDER BY or GROUP BY clause to resolve */
1504 const char *zType /* Either "ORDER" or "GROUP", as appropriate */
1505){
drh70331cd2012-04-27 01:09:06 +00001506 int i, j; /* Loop counters */
drh7d10d5a2008-08-20 16:35:10 +00001507 int iCol; /* Column number */
1508 struct ExprList_item *pItem; /* A term of the ORDER BY clause */
1509 Parse *pParse; /* Parsing context */
1510 int nResult; /* Number of terms in the result set */
1511
1512 if( pOrderBy==0 ) return 0;
1513 nResult = pSelect->pEList->nExpr;
1514 pParse = pNC->pParse;
1515 for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
1516 Expr *pE = pItem->pExpr;
drh0d950af2019-08-22 16:38:42 +00001517 Expr *pE2 = sqlite3ExprSkipCollateAndLikely(pE);
drh235667a2020-11-08 20:44:30 +00001518 if( NEVER(pE2==0) ) continue;
drh0af16ab2013-08-15 22:40:21 +00001519 if( zType[0]!='G' ){
1520 iCol = resolveAsName(pParse, pSelect->pEList, pE2);
1521 if( iCol>0 ){
1522 /* If an AS-name match is found, mark this ORDER BY column as being
1523 ** a copy of the iCol-th result-set column. The subsequent call to
1524 ** sqlite3ResolveOrderGroupBy() will convert the expression to a
1525 ** copy of the iCol-th result-set expression. */
drhc2acc4e2013-11-15 18:15:19 +00001526 pItem->u.x.iOrderByCol = (u16)iCol;
drh0af16ab2013-08-15 22:40:21 +00001527 continue;
1528 }
drh7d10d5a2008-08-20 16:35:10 +00001529 }
drhe35463b2013-08-15 20:24:27 +00001530 if( sqlite3ExprIsInteger(pE2, &iCol) ){
drh7d10d5a2008-08-20 16:35:10 +00001531 /* The ORDER BY term is an integer constant. Again, set the column
1532 ** number so that sqlite3ResolveOrderGroupBy() will convert the
1533 ** order-by term to a copy of the result-set expression */
drh85d641f2012-12-07 23:23:53 +00001534 if( iCol<1 || iCol>0xffff ){
drh7d10d5a2008-08-20 16:35:10 +00001535 resolveOutOfRangeError(pParse, zType, i+1, nResult);
1536 return 1;
1537 }
drhc2acc4e2013-11-15 18:15:19 +00001538 pItem->u.x.iOrderByCol = (u16)iCol;
drh7d10d5a2008-08-20 16:35:10 +00001539 continue;
1540 }
1541
1542 /* Otherwise, treat the ORDER BY term as an ordinary expression */
drhc2acc4e2013-11-15 18:15:19 +00001543 pItem->u.x.iOrderByCol = 0;
drh7d10d5a2008-08-20 16:35:10 +00001544 if( sqlite3ResolveExprNames(pNC, pE) ){
1545 return 1;
1546 }
drh70331cd2012-04-27 01:09:06 +00001547 for(j=0; j<pSelect->pEList->nExpr; j++){
dan5aa550c2017-06-24 18:10:29 +00001548 if( sqlite3ExprCompare(0, pE, pSelect->pEList->a[j].pExpr, -1)==0 ){
danf030b372019-02-22 19:24:16 +00001549 /* Since this expresion is being changed into a reference
1550 ** to an identical expression in the result set, remove all Window
1551 ** objects belonging to the expression from the Select.pWin list. */
dan75b08212019-07-22 16:20:03 +00001552 windowRemoveExprFromSelect(pSelect, pE);
drhc2acc4e2013-11-15 18:15:19 +00001553 pItem->u.x.iOrderByCol = j+1;
drh70331cd2012-04-27 01:09:06 +00001554 }
1555 }
drh7d10d5a2008-08-20 16:35:10 +00001556 }
1557 return sqlite3ResolveOrderGroupBy(pParse, pSelect, pOrderBy, zType);
1558}
1559
1560/*
peter.d.reid60ec9142014-09-06 16:39:46 +00001561** Resolve names in the SELECT statement p and all of its descendants.
drh7d10d5a2008-08-20 16:35:10 +00001562*/
1563static int resolveSelectStep(Walker *pWalker, Select *p){
1564 NameContext *pOuterNC; /* Context that contains this SELECT */
1565 NameContext sNC; /* Name context of this SELECT */
1566 int isCompound; /* True if p is a compound select */
1567 int nCompound; /* Number of compound terms processed so far */
1568 Parse *pParse; /* Parsing context */
drh7d10d5a2008-08-20 16:35:10 +00001569 int i; /* Loop counter */
1570 ExprList *pGroupBy; /* The GROUP BY clause */
1571 Select *pLeftmost; /* Left-most of SELECT of a compound */
1572 sqlite3 *db; /* Database connection */
1573
1574
drh0a846f92008-08-25 17:23:29 +00001575 assert( p!=0 );
drh7d10d5a2008-08-20 16:35:10 +00001576 if( p->selFlags & SF_Resolved ){
1577 return WRC_Prune;
1578 }
1579 pOuterNC = pWalker->u.pNC;
1580 pParse = pWalker->pParse;
1581 db = pParse->db;
1582
1583 /* Normally sqlite3SelectExpand() will be called first and will have
1584 ** already expanded this SELECT. However, if this is a subquery within
1585 ** an expression, sqlite3ResolveExprNames() will be called without a
1586 ** prior call to sqlite3SelectExpand(). When that happens, let
1587 ** sqlite3SelectPrep() do all of the processing for this SELECT.
1588 ** sqlite3SelectPrep() will invoke both sqlite3SelectExpand() and
1589 ** this routine in the correct order.
1590 */
1591 if( (p->selFlags & SF_Expanded)==0 ){
1592 sqlite3SelectPrep(pParse, p, pOuterNC);
1593 return (pParse->nErr || db->mallocFailed) ? WRC_Abort : WRC_Prune;
1594 }
1595
1596 isCompound = p->pPrior!=0;
1597 nCompound = 0;
1598 pLeftmost = p;
1599 while( p ){
1600 assert( (p->selFlags & SF_Expanded)!=0 );
1601 assert( (p->selFlags & SF_Resolved)==0 );
1602 p->selFlags |= SF_Resolved;
1603
1604 /* Resolve the expressions in the LIMIT and OFFSET clauses. These
1605 ** are not allowed to refer to any names, so pass an empty NameContext.
1606 */
1607 memset(&sNC, 0, sizeof(sNC));
1608 sNC.pParse = pParse;
dane3bf6322018-06-08 20:58:27 +00001609 sNC.pWinSelect = p;
drh8c0833f2017-11-14 23:48:23 +00001610 if( sqlite3ResolveExprNames(&sNC, p->pLimit) ){
drh7d10d5a2008-08-20 16:35:10 +00001611 return WRC_Abort;
1612 }
danb33c50f2015-04-04 16:43:16 +00001613
1614 /* If the SF_Converted flags is set, then this Select object was
1615 ** was created by the convertCompoundSelectToSubquery() function.
1616 ** In this case the ORDER BY clause (p->pOrderBy) should be resolved
1617 ** as if it were part of the sub-query, not the parent. This block
1618 ** moves the pOrderBy down to the sub-query. It will be moved back
1619 ** after the names have been resolved. */
1620 if( p->selFlags & SF_Converted ){
1621 Select *pSub = p->pSrc->a[0].pSelect;
drha43f02e2015-04-15 06:45:13 +00001622 assert( p->pSrc->nSrc==1 && p->pOrderBy );
danb33c50f2015-04-04 16:43:16 +00001623 assert( pSub->pPrior && pSub->pOrderBy==0 );
1624 pSub->pOrderBy = p->pOrderBy;
1625 p->pOrderBy = 0;
1626 }
drh7d10d5a2008-08-20 16:35:10 +00001627
drh7d10d5a2008-08-20 16:35:10 +00001628 /* Recursively resolve names in all subqueries
1629 */
1630 for(i=0; i<p->pSrc->nSrc; i++){
drh76012942021-02-21 21:04:54 +00001631 SrcItem *pItem = &p->pSrc->a[i];
dan781b7ac2019-03-22 13:56:49 +00001632 if( pItem->pSelect && (pItem->pSelect->selFlags & SF_Resolved)==0 ){
dan4b174552021-02-26 15:20:17 +00001633 int nRef = pOuterNC ? pOuterNC->nRef : 0;
drh7d10d5a2008-08-20 16:35:10 +00001634 const char *zSavedContext = pParse->zAuthContext;
danda79cf02011-07-08 16:10:54 +00001635
drh7d10d5a2008-08-20 16:35:10 +00001636 if( pItem->zName ) pParse->zAuthContext = pItem->zName;
drhcd2b5612008-12-09 14:03:22 +00001637 sqlite3ResolveSelectNames(pParse, pItem->pSelect, pOuterNC);
drh7d10d5a2008-08-20 16:35:10 +00001638 pParse->zAuthContext = zSavedContext;
1639 if( pParse->nErr || db->mallocFailed ) return WRC_Abort;
danda79cf02011-07-08 16:10:54 +00001640
dan4b174552021-02-26 15:20:17 +00001641 /* If the number of references to the outer context changed when
1642 ** expressions in the sub-select were resolved, the sub-select
1643 ** is correlated. It is not required to check the refcount on any
1644 ** but the innermost outer context object, as lookupName() increments
1645 ** the refcount on all contexts between the current one and the
1646 ** context containing the column when it resolves a name. */
1647 if( pOuterNC ){
1648 assert( pItem->fg.isCorrelated==0 && pOuterNC->nRef>=nRef );
1649 pItem->fg.isCorrelated = (pOuterNC->nRef>nRef);
1650 }
drh7d10d5a2008-08-20 16:35:10 +00001651 }
1652 }
1653
drh92689d22012-12-18 16:07:08 +00001654 /* Set up the local name-context to pass to sqlite3ResolveExprNames() to
1655 ** resolve the result-set expression list.
1656 */
dan86fb6e12018-05-16 20:58:07 +00001657 sNC.ncFlags = NC_AllowAgg|NC_AllowWin;
drh92689d22012-12-18 16:07:08 +00001658 sNC.pSrcList = p->pSrc;
1659 sNC.pNext = pOuterNC;
1660
1661 /* Resolve names in the result set. */
drh01d230c2015-08-19 17:11:37 +00001662 if( sqlite3ResolveExprListNames(&sNC, p->pEList) ) return WRC_Abort;
dan86fb6e12018-05-16 20:58:07 +00001663 sNC.ncFlags &= ~NC_AllowWin;
drh92689d22012-12-18 16:07:08 +00001664
drh7d10d5a2008-08-20 16:35:10 +00001665 /* If there are no aggregate functions in the result-set, and no GROUP BY
1666 ** expression, do not allow aggregates in any of the other expressions.
1667 */
1668 assert( (p->selFlags & SF_Aggregate)==0 );
1669 pGroupBy = p->pGroupBy;
drha51009b2012-05-21 19:11:25 +00001670 if( pGroupBy || (sNC.ncFlags & NC_HasAgg)!=0 ){
drh9588ad92014-09-15 14:46:02 +00001671 assert( NC_MinMaxAgg==SF_MinMaxAgg );
1672 p->selFlags |= SF_Aggregate | (sNC.ncFlags&NC_MinMaxAgg);
drh7d10d5a2008-08-20 16:35:10 +00001673 }else{
drha51009b2012-05-21 19:11:25 +00001674 sNC.ncFlags &= ~NC_AllowAgg;
drh7d10d5a2008-08-20 16:35:10 +00001675 }
1676
1677 /* If a HAVING clause is present, then there must be a GROUP BY clause.
1678 */
1679 if( p->pHaving && !pGroupBy ){
1680 sqlite3ErrorMsg(pParse, "a GROUP BY clause is required before HAVING");
1681 return WRC_Abort;
1682 }
1683
drh26080d92013-08-15 14:27:42 +00001684 /* Add the output column list to the name-context before parsing the
drh7d10d5a2008-08-20 16:35:10 +00001685 ** other expressions in the SELECT statement. This is so that
1686 ** expressions in the WHERE clause (etc.) can refer to expressions by
1687 ** aliases in the result set.
1688 **
1689 ** Minor point: If this is the case, then the expression will be
1690 ** re-evaluated for each reference to it.
1691 */
drhd5101972021-02-08 13:41:17 +00001692 assert( (sNC.ncFlags & (NC_UAggInfo|NC_UUpsert|NC_UBaseReg))==0 );
drh25c3b8c2018-04-16 10:34:13 +00001693 sNC.uNC.pEList = p->pEList;
1694 sNC.ncFlags |= NC_UEList;
drh58a450c2013-05-16 01:02:45 +00001695 if( sqlite3ResolveExprNames(&sNC, p->pHaving) ) return WRC_Abort;
drha3a5bd92013-04-13 19:59:58 +00001696 if( sqlite3ResolveExprNames(&sNC, p->pWhere) ) return WRC_Abort;
drh7d10d5a2008-08-20 16:35:10 +00001697
drh01d230c2015-08-19 17:11:37 +00001698 /* Resolve names in table-valued-function arguments */
1699 for(i=0; i<p->pSrc->nSrc; i++){
drh76012942021-02-21 21:04:54 +00001700 SrcItem *pItem = &p->pSrc->a[i];
drh01d230c2015-08-19 17:11:37 +00001701 if( pItem->fg.isTabFunc
1702 && sqlite3ResolveExprListNames(&sNC, pItem->u1.pFuncArg)
1703 ){
1704 return WRC_Abort;
1705 }
1706 }
1707
drh7d10d5a2008-08-20 16:35:10 +00001708 /* The ORDER BY and GROUP BY clauses may not refer to terms in
1709 ** outer queries
1710 */
1711 sNC.pNext = 0;
dan86fb6e12018-05-16 20:58:07 +00001712 sNC.ncFlags |= NC_AllowAgg|NC_AllowWin;
drh7d10d5a2008-08-20 16:35:10 +00001713
danb33c50f2015-04-04 16:43:16 +00001714 /* If this is a converted compound query, move the ORDER BY clause from
1715 ** the sub-query back to the parent query. At this point each term
1716 ** within the ORDER BY clause has been transformed to an integer value.
1717 ** These integers will be replaced by copies of the corresponding result
1718 ** set expressions by the call to resolveOrderGroupBy() below. */
1719 if( p->selFlags & SF_Converted ){
1720 Select *pSub = p->pSrc->a[0].pSelect;
1721 p->pOrderBy = pSub->pOrderBy;
1722 pSub->pOrderBy = 0;
1723 }
1724
drh7d10d5a2008-08-20 16:35:10 +00001725 /* Process the ORDER BY clause for singleton SELECT statements.
1726 ** The ORDER BY clause for compounds SELECT statements is handled
1727 ** below, after all of the result-sets for all of the elements of
1728 ** the compound have been resolved.
drh7b4da152015-04-17 18:52:37 +00001729 **
1730 ** If there is an ORDER BY clause on a term of a compound-select other
1731 ** than the right-most term, then that is a syntax error. But the error
1732 ** is not detected until much later, and so we need to go ahead and
1733 ** resolve those symbols on the incorrect ORDER BY for consistency.
drh7d10d5a2008-08-20 16:35:10 +00001734 */
drh7b4da152015-04-17 18:52:37 +00001735 if( isCompound<=nCompound /* Defer right-most ORDER BY of a compound */
1736 && resolveOrderGroupBy(&sNC, p, p->pOrderBy, "ORDER")
1737 ){
drh7d10d5a2008-08-20 16:35:10 +00001738 return WRC_Abort;
1739 }
1740 if( db->mallocFailed ){
1741 return WRC_Abort;
1742 }
dan86fb6e12018-05-16 20:58:07 +00001743 sNC.ncFlags &= ~NC_AllowWin;
drh7d10d5a2008-08-20 16:35:10 +00001744
1745 /* Resolve the GROUP BY clause. At the same time, make sure
1746 ** the GROUP BY clause does not contain aggregate functions.
1747 */
1748 if( pGroupBy ){
1749 struct ExprList_item *pItem;
1750
1751 if( resolveOrderGroupBy(&sNC, p, pGroupBy, "GROUP") || db->mallocFailed ){
1752 return WRC_Abort;
1753 }
1754 for(i=0, pItem=pGroupBy->a; i<pGroupBy->nExpr; i++, pItem++){
1755 if( ExprHasProperty(pItem->pExpr, EP_Agg) ){
1756 sqlite3ErrorMsg(pParse, "aggregate functions are not allowed in "
1757 "the GROUP BY clause");
1758 return WRC_Abort;
1759 }
1760 }
1761 }
1762
dan8cd2e4a2019-02-11 11:34:01 +00001763#ifndef SQLITE_OMIT_WINDOWFUNC
dand9995032019-01-23 16:59:24 +00001764 if( IN_RENAME_OBJECT ){
1765 Window *pWin;
1766 for(pWin=p->pWinDefn; pWin; pWin=pWin->pNextWin){
1767 if( sqlite3ResolveExprListNames(&sNC, pWin->pOrderBy)
1768 || sqlite3ResolveExprListNames(&sNC, pWin->pPartition)
1769 ){
1770 return WRC_Abort;
1771 }
1772 }
1773 }
dan8cd2e4a2019-02-11 11:34:01 +00001774#endif
dand9995032019-01-23 16:59:24 +00001775
dan923cadb2015-06-23 12:19:55 +00001776 /* If this is part of a compound SELECT, check that it has the right
1777 ** number of expressions in the select list. */
1778 if( p->pNext && p->pEList->nExpr!=p->pNext->pEList->nExpr ){
1779 sqlite3SelectWrongNumTermsError(pParse, p->pNext);
1780 return WRC_Abort;
1781 }
1782
drh7d10d5a2008-08-20 16:35:10 +00001783 /* Advance to the next term of the compound
1784 */
1785 p = p->pPrior;
1786 nCompound++;
1787 }
1788
1789 /* Resolve the ORDER BY on a compound SELECT after all terms of
1790 ** the compound have been resolved.
1791 */
1792 if( isCompound && resolveCompoundOrderBy(pParse, pLeftmost) ){
1793 return WRC_Abort;
1794 }
1795
1796 return WRC_Prune;
1797}
1798
1799/*
1800** This routine walks an expression tree and resolves references to
1801** table columns and result-set columns. At the same time, do error
1802** checking on function usage and set a flag if any aggregate functions
1803** are seen.
1804**
1805** To resolve table columns references we look for nodes (or subtrees) of the
1806** form X.Y.Z or Y.Z or just Z where
1807**
1808** X: The name of a database. Ex: "main" or "temp" or
1809** the symbolic name assigned to an ATTACH-ed database.
1810**
1811** Y: The name of a table in a FROM clause. Or in a trigger
1812** one of the special names "old" or "new".
1813**
1814** Z: The name of a column in table Y.
1815**
1816** The node at the root of the subtree is modified as follows:
1817**
1818** Expr.op Changed to TK_COLUMN
1819** Expr.pTab Points to the Table object for X.Y
1820** Expr.iColumn The column index in X.Y. -1 for the rowid.
1821** Expr.iTable The VDBE cursor number for X.Y
1822**
1823**
1824** To resolve result-set references, look for expression nodes of the
1825** form Z (with no X and Y prefix) where the Z matches the right-hand
1826** size of an AS clause in the result-set of a SELECT. The Z expression
1827** is replaced by a copy of the left-hand side of the result-set expression.
1828** Table-name and function resolution occurs on the substituted expression
1829** tree. For example, in:
1830**
1831** SELECT a+b AS x, c+d AS y FROM t1 ORDER BY x;
1832**
1833** The "x" term of the order by is replaced by "a+b" to render:
1834**
1835** SELECT a+b AS x, c+d AS y FROM t1 ORDER BY a+b;
1836**
1837** Function calls are checked to make sure that the function is
1838** defined and that the correct number of arguments are specified.
drha51009b2012-05-21 19:11:25 +00001839** If the function is an aggregate function, then the NC_HasAgg flag is
drh7d10d5a2008-08-20 16:35:10 +00001840** set and the opcode is changed from TK_FUNCTION to TK_AGG_FUNCTION.
1841** If an expression contains aggregate functions then the EP_Agg
1842** property on the expression is set.
1843**
1844** An error message is left in pParse if anything is amiss. The number
1845** if errors is returned.
1846*/
1847int sqlite3ResolveExprNames(
1848 NameContext *pNC, /* Namespace to resolve expressions in. */
1849 Expr *pExpr /* The expression to be analyzed. */
1850){
dan0d925712019-05-20 17:14:25 +00001851 int savedHasAgg;
drh7d10d5a2008-08-20 16:35:10 +00001852 Walker w;
1853
drhd03257c2017-05-31 00:49:40 +00001854 if( pExpr==0 ) return SQLITE_OK;
dan4ded26a2019-03-28 16:15:05 +00001855 savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
1856 pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
drh9bfb0242016-01-20 02:21:50 +00001857 w.pParse = pNC->pParse;
drh7d10d5a2008-08-20 16:35:10 +00001858 w.xExprCallback = resolveExprStep;
1859 w.xSelectCallback = resolveSelectStep;
drh9bfb0242016-01-20 02:21:50 +00001860 w.xSelectCallback2 = 0;
drh7d10d5a2008-08-20 16:35:10 +00001861 w.u.pNC = pNC;
drhd03257c2017-05-31 00:49:40 +00001862#if SQLITE_MAX_EXPR_DEPTH>0
1863 w.pParse->nHeight += pExpr->nHeight;
1864 if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){
1865 return SQLITE_ERROR;
1866 }
1867#endif
drh7d10d5a2008-08-20 16:35:10 +00001868 sqlite3WalkExpr(&w, pExpr);
1869#if SQLITE_MAX_EXPR_DEPTH>0
drhd03257c2017-05-31 00:49:40 +00001870 w.pParse->nHeight -= pExpr->nHeight;
drh7d10d5a2008-08-20 16:35:10 +00001871#endif
drhd137f4e2019-03-29 01:15:11 +00001872 assert( EP_Agg==NC_HasAgg );
1873 assert( EP_Win==NC_HasWin );
1874 testcase( pNC->ncFlags & NC_HasAgg );
1875 testcase( pNC->ncFlags & NC_HasWin );
1876 ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) );
drh9588ad92014-09-15 14:46:02 +00001877 pNC->ncFlags |= savedHasAgg;
drhd03257c2017-05-31 00:49:40 +00001878 return pNC->nErr>0 || w.pParse->nErr>0;
drh7d10d5a2008-08-20 16:35:10 +00001879}
drh7d10d5a2008-08-20 16:35:10 +00001880
drh01d230c2015-08-19 17:11:37 +00001881/*
1882** Resolve all names for all expression in an expression list. This is
1883** just like sqlite3ResolveExprNames() except that it works for an expression
1884** list rather than a single expression.
1885*/
1886int sqlite3ResolveExprListNames(
1887 NameContext *pNC, /* Namespace to resolve expressions in. */
1888 ExprList *pList /* The expression list to be analyzed. */
1889){
drhd8b1bfc2015-08-20 23:21:34 +00001890 int i;
drh4047bdf2020-04-06 20:35:52 +00001891 int savedHasAgg = 0;
1892 Walker w;
1893 if( pList==0 ) return WRC_Continue;
1894 w.pParse = pNC->pParse;
1895 w.xExprCallback = resolveExprStep;
1896 w.xSelectCallback = resolveSelectStep;
1897 w.xSelectCallback2 = 0;
1898 w.u.pNC = pNC;
1899 savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
1900 pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
1901 for(i=0; i<pList->nExpr; i++){
1902 Expr *pExpr = pList->a[i].pExpr;
1903 if( pExpr==0 ) continue;
1904#if SQLITE_MAX_EXPR_DEPTH>0
1905 w.pParse->nHeight += pExpr->nHeight;
1906 if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){
1907 return WRC_Abort;
drh20292312015-11-21 13:24:46 +00001908 }
drh4047bdf2020-04-06 20:35:52 +00001909#endif
1910 sqlite3WalkExpr(&w, pExpr);
1911#if SQLITE_MAX_EXPR_DEPTH>0
1912 w.pParse->nHeight -= pExpr->nHeight;
1913#endif
1914 assert( EP_Agg==NC_HasAgg );
1915 assert( EP_Win==NC_HasWin );
1916 testcase( pNC->ncFlags & NC_HasAgg );
1917 testcase( pNC->ncFlags & NC_HasWin );
1918 if( pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin) ){
1919 ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) );
1920 savedHasAgg |= pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
1921 pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
1922 }
1923 if( pNC->nErr>0 || w.pParse->nErr>0 ) return WRC_Abort;
drh01d230c2015-08-19 17:11:37 +00001924 }
drh4047bdf2020-04-06 20:35:52 +00001925 pNC->ncFlags |= savedHasAgg;
drh01d230c2015-08-19 17:11:37 +00001926 return WRC_Continue;
1927}
drh7d10d5a2008-08-20 16:35:10 +00001928
1929/*
1930** Resolve all names in all expressions of a SELECT and in all
1931** decendents of the SELECT, including compounds off of p->pPrior,
1932** subqueries in expressions, and subqueries used as FROM clause
1933** terms.
1934**
1935** See sqlite3ResolveExprNames() for a description of the kinds of
1936** transformations that occur.
1937**
1938** All SELECT statements should have been expanded using
1939** sqlite3SelectExpand() prior to invoking this routine.
1940*/
1941void sqlite3ResolveSelectNames(
1942 Parse *pParse, /* The parser context */
1943 Select *p, /* The SELECT statement being coded. */
1944 NameContext *pOuterNC /* Name context for parent SELECT statement */
1945){
1946 Walker w;
1947
drh0a846f92008-08-25 17:23:29 +00001948 assert( p!=0 );
1949 w.xExprCallback = resolveExprStep;
1950 w.xSelectCallback = resolveSelectStep;
drh979dd1b2017-05-29 14:26:07 +00001951 w.xSelectCallback2 = 0;
drh0a846f92008-08-25 17:23:29 +00001952 w.pParse = pParse;
1953 w.u.pNC = pOuterNC;
1954 sqlite3WalkSelect(&w, p);
drh7d10d5a2008-08-20 16:35:10 +00001955}
drh3780be12013-07-31 19:05:22 +00001956
1957/*
drhee751fa2019-01-02 14:34:46 +00001958** Resolve names in expressions that can only reference a single table
1959** or which cannot reference any tables at all. Examples:
drh3780be12013-07-31 19:05:22 +00001960**
drh20cee7d2019-10-30 18:50:08 +00001961** "type" flag
1962** ------------
1963** (1) CHECK constraints NC_IsCheck
1964** (2) WHERE clauses on partial indices NC_PartIdx
1965** (3) Expressions in indexes on expressions NC_IdxExpr
1966** (4) Expression arguments to VACUUM INTO. 0
1967** (5) GENERATED ALWAYS as expressions NC_GenCol
drh3780be12013-07-31 19:05:22 +00001968**
drhee751fa2019-01-02 14:34:46 +00001969** In all cases except (4), the Expr.iTable value for Expr.op==TK_COLUMN
1970** nodes of the expression is set to -1 and the Expr.iColumn value is
1971** set to the column number. In case (4), TK_COLUMN nodes cause an error.
drh3780be12013-07-31 19:05:22 +00001972**
1973** Any errors cause an error message to be set in pParse.
1974*/
drhee751fa2019-01-02 14:34:46 +00001975int sqlite3ResolveSelfReference(
drh81f7b372019-10-16 12:18:59 +00001976 Parse *pParse, /* Parsing context */
1977 Table *pTab, /* The table being referenced, or NULL */
1978 int type, /* NC_IsCheck, NC_PartIdx, NC_IdxExpr, NC_GenCol, or 0 */
1979 Expr *pExpr, /* Expression to resolve. May be NULL. */
1980 ExprList *pList /* Expression list to resolve. May be NULL. */
drh3780be12013-07-31 19:05:22 +00001981){
1982 SrcList sSrc; /* Fake SrcList for pParse->pNewTable */
1983 NameContext sNC; /* Name context for pParse->pNewTable */
drhee751fa2019-01-02 14:34:46 +00001984 int rc;
drh3780be12013-07-31 19:05:22 +00001985
drhee751fa2019-01-02 14:34:46 +00001986 assert( type==0 || pTab!=0 );
drh81f7b372019-10-16 12:18:59 +00001987 assert( type==NC_IsCheck || type==NC_PartIdx || type==NC_IdxExpr
1988 || type==NC_GenCol || pTab==0 );
drh3780be12013-07-31 19:05:22 +00001989 memset(&sNC, 0, sizeof(sNC));
1990 memset(&sSrc, 0, sizeof(sSrc));
drhee751fa2019-01-02 14:34:46 +00001991 if( pTab ){
1992 sSrc.nSrc = 1;
1993 sSrc.a[0].zName = pTab->zName;
1994 sSrc.a[0].pTab = pTab;
1995 sSrc.a[0].iCursor = -1;
drh05b32ee2020-01-09 01:20:03 +00001996 if( pTab->pSchema!=pParse->db->aDb[1].pSchema ){
1997 /* Cause EP_FromDDL to be set on TK_FUNCTION nodes of non-TEMP
1998 ** schema elements */
1999 type |= NC_FromDDL;
2000 }
drhee751fa2019-01-02 14:34:46 +00002001 }
drh3780be12013-07-31 19:05:22 +00002002 sNC.pParse = pParse;
2003 sNC.pSrcList = &sSrc;
drhd0ff6012019-06-17 13:56:11 +00002004 sNC.ncFlags = type | NC_IsDDL;
drhee751fa2019-01-02 14:34:46 +00002005 if( (rc = sqlite3ResolveExprNames(&sNC, pExpr))!=SQLITE_OK ) return rc;
2006 if( pList ) rc = sqlite3ResolveExprListNames(&sNC, pList);
2007 return rc;
drh3780be12013-07-31 19:05:22 +00002008}