blob: 8642dffac9be60c69aa608b12f32cefa4662de6a [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 const char *zType, /* "GROUP" or "ORDER" or "" */
74 int nSubquery /* Number of subqueries that the label is moving */
drh8b213892008-08-29 02:14:02 +000075){
76 Expr *pOrig; /* The iCol-th column of the result set */
77 Expr *pDup; /* Copy of pOrig */
78 sqlite3 *db; /* The database connection */
79
80 assert( iCol>=0 && iCol<pEList->nExpr );
81 pOrig = pEList->a[iCol].pExpr;
82 assert( pOrig!=0 );
drh8b213892008-08-29 02:14:02 +000083 db = pParse->db;
drh0a8a4062012-12-07 18:38:16 +000084 pDup = sqlite3ExprDup(db, pOrig, 0);
drh4344dbd2018-06-02 11:31:15 +000085 if( pDup!=0 ){
86 if( zType[0]!='G' ) incrAggFunctionDepth(pDup, nSubquery);
87 if( pExpr->op==TK_COLLATE ){
88 pDup = sqlite3ExprAddCollateString(pParse, pDup, pExpr->u.zToken);
89 }
danf6963f92009-11-23 14:39:14 +000090
drh4344dbd2018-06-02 11:31:15 +000091 /* Before calling sqlite3ExprDelete(), set the EP_Static flag. This
92 ** prevents ExprDelete() from deleting the Expr structure itself,
93 ** allowing it to be repopulated by the memcpy() on the following line.
94 ** The pExpr->u.zToken might point into memory that will be freed by the
95 ** sqlite3DbFree(db, pDup) on the last line of this block, so be sure to
96 ** make a copy of the token before doing the sqlite3DbFree().
97 */
98 ExprSetProperty(pExpr, EP_Static);
99 sqlite3ExprDelete(db, pExpr);
100 memcpy(pExpr, pDup, sizeof(*pExpr));
101 if( !ExprHasProperty(pExpr, EP_IntValue) && pExpr->u.zToken!=0 ){
102 assert( (pExpr->flags & (EP_Reduced|EP_TokenOnly))==0 );
103 pExpr->u.zToken = sqlite3DbStrDup(db, pExpr->u.zToken);
104 pExpr->flags |= EP_MemToken;
105 }
dana51ddb12019-09-26 15:53:37 +0000106 if( ExprHasProperty(pExpr, EP_WinFunc) ){
drhd79cd922019-09-26 16:08:35 +0000107 if( pExpr->y.pWin!=0 ){
108 pExpr->y.pWin->pOwner = pExpr;
109 }else{
110 assert( db->mallocFailed );
111 }
dana51ddb12019-09-26 15:53:37 +0000112 }
drh4344dbd2018-06-02 11:31:15 +0000113 sqlite3DbFree(db, pDup);
drh0a8a4062012-12-07 18:38:16 +0000114 }
drh8b213892008-08-29 02:14:02 +0000115}
116
drhe802c5d2011-10-18 18:10:40 +0000117
118/*
119** Return TRUE if the name zCol occurs anywhere in the USING clause.
120**
121** Return FALSE if the USING clause is NULL or if it does not contain
122** zCol.
123*/
124static int nameInUsingClause(IdList *pUsing, const char *zCol){
125 if( pUsing ){
126 int k;
127 for(k=0; k<pUsing->nId; k++){
128 if( sqlite3StrICmp(pUsing->a[k].zName, zCol)==0 ) return 1;
129 }
130 }
131 return 0;
132}
133
drh3e3f1a52013-01-03 00:45:56 +0000134/*
135** Subqueries stores the original database, table and column names for their
136** result sets in ExprList.a[].zSpan, in the form "DATABASE.TABLE.COLUMN".
137** Check to see if the zSpan given to this routine matches the zDb, zTab,
138** and zCol. If any of zDb, zTab, and zCol are NULL then those fields will
139** match anything.
140*/
drhc4938ea2019-12-13 00:49:42 +0000141int sqlite3MatchEName(
142 const struct ExprList_item *pItem,
drh3e3f1a52013-01-03 00:45:56 +0000143 const char *zCol,
144 const char *zTab,
145 const char *zDb
146){
147 int n;
drhc4938ea2019-12-13 00:49:42 +0000148 const char *zSpan;
drh47f8ef32020-04-04 11:58:22 +0000149 if( pItem->eEName!=ENAME_TAB ) return 0;
drhc4938ea2019-12-13 00:49:42 +0000150 zSpan = pItem->zEName;
drh3e3f1a52013-01-03 00:45:56 +0000151 for(n=0; ALWAYS(zSpan[n]) && zSpan[n]!='.'; n++){}
drhdd1dd482013-02-26 12:57:42 +0000152 if( zDb && (sqlite3StrNICmp(zSpan, zDb, n)!=0 || zDb[n]!=0) ){
drh3e3f1a52013-01-03 00:45:56 +0000153 return 0;
154 }
155 zSpan += n+1;
156 for(n=0; ALWAYS(zSpan[n]) && zSpan[n]!='.'; n++){}
drhdd1dd482013-02-26 12:57:42 +0000157 if( zTab && (sqlite3StrNICmp(zSpan, zTab, n)!=0 || zTab[n]!=0) ){
drh3e3f1a52013-01-03 00:45:56 +0000158 return 0;
159 }
160 zSpan += n+1;
161 if( zCol && sqlite3StrICmp(zSpan, zCol)!=0 ){
162 return 0;
163 }
164 return 1;
165}
drhe802c5d2011-10-18 18:10:40 +0000166
drh8b213892008-08-29 02:14:02 +0000167/*
drhd0ff6012019-06-17 13:56:11 +0000168** Return TRUE if the double-quoted string mis-feature should be supported.
169*/
170static int areDoubleQuotedStringsEnabled(sqlite3 *db, NameContext *pTopNC){
171 if( db->init.busy ) return 1; /* Always support for legacy schemas */
172 if( pTopNC->ncFlags & NC_IsDDL ){
173 /* Currently parsing a DDL statement */
174 if( sqlite3WritableSchema(db) && (db->flags & SQLITE_DqsDML)!=0 ){
175 return 1;
176 }
177 return (db->flags & SQLITE_DqsDDL)!=0;
178 }else{
179 /* Currently parsing a DML statement */
180 return (db->flags & SQLITE_DqsDML)!=0;
181 }
182}
183
184/*
drh74a07982020-03-21 23:10:38 +0000185** The argument is guaranteed to be a non-NULL Expr node of type TK_COLUMN.
186** return the appropriate colUsed mask.
187*/
188Bitmask sqlite3ExprColUsed(Expr *pExpr){
189 int n;
190 Table *pExTab;
191
192 n = pExpr->iColumn;
193 pExTab = pExpr->y.pTab;
194 assert( pExTab!=0 );
195 if( (pExTab->tabFlags & TF_HasGenerated)!=0
196 && (pExTab->aCol[n].colFlags & COLFLAG_GENERATED)!=0
197 ){
198 testcase( pExTab->nCol==BMS-1 );
199 testcase( pExTab->nCol==BMS );
200 return pExTab->nCol>=BMS ? ALLBITS : MASKBIT(pExTab->nCol)-1;
201 }else{
202 testcase( n==BMS-1 );
203 testcase( n==BMS );
204 if( n>=BMS ) n = BMS-1;
205 return ((Bitmask)1)<<n;
206 }
207}
208
209/*
drh7d10d5a2008-08-20 16:35:10 +0000210** Given the name of a column of the form X.Y.Z or Y.Z or just Z, look up
211** that name in the set of source tables in pSrcList and make the pExpr
212** expression node refer back to that source column. The following changes
213** are made to pExpr:
214**
215** pExpr->iDb Set the index in db->aDb[] of the database X
216** (even if X is implied).
217** pExpr->iTable Set to the cursor number for the table obtained
218** from pSrcList.
drheda079c2018-09-20 19:02:15 +0000219** pExpr->y.pTab Points to the Table structure of X.Y (even if
drh7d10d5a2008-08-20 16:35:10 +0000220** X and/or Y are implied.)
221** pExpr->iColumn Set to the column number within the table.
222** pExpr->op Set to TK_COLUMN.
223** pExpr->pLeft Any expression this points to is deleted
224** pExpr->pRight Any expression this points to is deleted.
225**
drhb7916a72009-05-27 10:31:29 +0000226** The zDb variable is the name of the database (the "X"). This value may be
drh7d10d5a2008-08-20 16:35:10 +0000227** NULL meaning that name is of the form Y.Z or Z. Any available database
drhb7916a72009-05-27 10:31:29 +0000228** can be used. The zTable variable is the name of the table (the "Y"). This
229** value can be NULL if zDb is also NULL. If zTable is NULL it
drh7d10d5a2008-08-20 16:35:10 +0000230** means that the form of the name is Z and that columns from any table
231** can be used.
232**
233** If the name cannot be resolved unambiguously, leave an error message
drhf7828b52009-06-15 23:15:59 +0000234** in pParse and return WRC_Abort. Return WRC_Prune on success.
drh7d10d5a2008-08-20 16:35:10 +0000235*/
236static int lookupName(
237 Parse *pParse, /* The parsing context */
drhb7916a72009-05-27 10:31:29 +0000238 const char *zDb, /* Name of the database containing table, or NULL */
239 const char *zTab, /* Name of table containing column, or NULL */
240 const char *zCol, /* Name of the column. */
drh7d10d5a2008-08-20 16:35:10 +0000241 NameContext *pNC, /* The name context used to resolve the name */
242 Expr *pExpr /* Make this EXPR node point to the selected column */
243){
drhed551b92012-08-23 19:46:11 +0000244 int i, j; /* Loop counters */
drh7d10d5a2008-08-20 16:35:10 +0000245 int cnt = 0; /* Number of matching column names */
246 int cntTab = 0; /* Number of matching table names */
drhed551b92012-08-23 19:46:11 +0000247 int nSubquery = 0; /* How many levels of subquery */
drh7d10d5a2008-08-20 16:35:10 +0000248 sqlite3 *db = pParse->db; /* The database connection */
249 struct SrcList_item *pItem; /* Use for looping over pSrcList items */
250 struct SrcList_item *pMatch = 0; /* The matching pSrcList item */
251 NameContext *pTopNC = pNC; /* First namecontext in the list */
252 Schema *pSchema = 0; /* Schema of the expression */
drheac9fab2018-04-16 13:00:50 +0000253 int eNewExprOp = TK_COLUMN; /* New value for pExpr->op on success */
drh11f9b032013-10-23 17:39:41 +0000254 Table *pTab = 0; /* Table hold the row */
255 Column *pCol; /* A column of pTab */
drh7d10d5a2008-08-20 16:35:10 +0000256
drhb7916a72009-05-27 10:31:29 +0000257 assert( pNC ); /* the name context cannot be NULL. */
258 assert( zCol ); /* The Z in X.Y.Z cannot be NULL */
drhc5cd1242013-09-12 16:50:49 +0000259 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
drh7d10d5a2008-08-20 16:35:10 +0000260
261 /* Initialize the node to no-match */
262 pExpr->iTable = -1;
drhebb6a652013-09-12 23:42:22 +0000263 ExprSetVVAProperty(pExpr, EP_NoReduce);
drh7d10d5a2008-08-20 16:35:10 +0000264
drh8f25d182012-12-19 02:36:45 +0000265 /* Translate the schema name in zDb into a pointer to the corresponding
266 ** schema. If not found, pSchema will remain NULL and nothing will match
267 ** resulting in an appropriate error message toward the end of this routine
268 */
269 if( zDb ){
drh1e7d43c2013-08-02 14:18:18 +0000270 testcase( pNC->ncFlags & NC_PartIdx );
271 testcase( pNC->ncFlags & NC_IsCheck );
272 if( (pNC->ncFlags & (NC_PartIdx|NC_IsCheck))!=0 ){
drh31e71472015-02-09 10:20:19 +0000273 /* Silently ignore database qualifiers inside CHECK constraints and
274 ** partial indices. Do not raise errors because that might break
275 ** legacy and because it does not hurt anything to just ignore the
276 ** database name. */
drh1e7d43c2013-08-02 14:18:18 +0000277 zDb = 0;
278 }else{
279 for(i=0; i<db->nDb; i++){
drh69c33822016-08-18 14:33:11 +0000280 assert( db->aDb[i].zDbSName );
281 if( sqlite3StrICmp(db->aDb[i].zDbSName,zDb)==0 ){
drh1e7d43c2013-08-02 14:18:18 +0000282 pSchema = db->aDb[i].pSchema;
283 break;
284 }
drh8f25d182012-12-19 02:36:45 +0000285 }
dan00bd55e2020-03-20 20:54:28 +0000286 if( i==db->nDb && sqlite3StrICmp("main", zDb)==0 ){
287 /* This branch is taken when the main database has been renamed
288 ** using SQLITE_DBCONFIG_MAINDBNAME. */
289 pSchema = db->aDb[0].pSchema;
290 zDb = db->aDb[0].zDbSName;
291 }
drh8f25d182012-12-19 02:36:45 +0000292 }
293 }
294
drh7d10d5a2008-08-20 16:35:10 +0000295 /* Start at the inner-most context and move outward until a match is found */
drha92b81f2017-03-07 03:40:48 +0000296 assert( pNC && cnt==0 );
297 do{
drh7d10d5a2008-08-20 16:35:10 +0000298 ExprList *pEList;
299 SrcList *pSrcList = pNC->pSrcList;
300
301 if( pSrcList ){
302 for(i=0, pItem=pSrcList->a; i<pSrcList->nSrc; i++, pItem++){
drhd44390c2020-04-06 18:16:31 +0000303 u8 hCol;
drh7d10d5a2008-08-20 16:35:10 +0000304 pTab = pItem->pTab;
drhf4366202008-08-25 12:14:08 +0000305 assert( pTab!=0 && pTab->zName!=0 );
drh7d10d5a2008-08-20 16:35:10 +0000306 assert( pTab->nCol>0 );
drh8f25d182012-12-19 02:36:45 +0000307 if( pItem->pSelect && (pItem->pSelect->selFlags & SF_NestedFrom)!=0 ){
drh8f25d182012-12-19 02:36:45 +0000308 int hit = 0;
drh928d9c62013-02-07 09:33:56 +0000309 pEList = pItem->pSelect->pEList;
drh8f25d182012-12-19 02:36:45 +0000310 for(j=0; j<pEList->nExpr; j++){
drhc4938ea2019-12-13 00:49:42 +0000311 if( sqlite3MatchEName(&pEList->a[j], zCol, zTab, zDb) ){
drh8f25d182012-12-19 02:36:45 +0000312 cnt++;
313 cntTab = 2;
314 pMatch = pItem;
315 pExpr->iColumn = j;
drh38b384a2013-01-03 17:34:28 +0000316 hit = 1;
drh8f25d182012-12-19 02:36:45 +0000317 }
318 }
319 if( hit || zTab==0 ) continue;
320 }
drhc75e09c2013-01-03 16:54:20 +0000321 if( zDb && pTab->pSchema!=pSchema ){
322 continue;
323 }
drh7d10d5a2008-08-20 16:35:10 +0000324 if( zTab ){
drh8f25d182012-12-19 02:36:45 +0000325 const char *zTabName = pItem->zAlias ? pItem->zAlias : pTab->zName;
326 assert( zTabName!=0 );
327 if( sqlite3StrICmp(zTabName, zTab)!=0 ){
328 continue;
drh7d10d5a2008-08-20 16:35:10 +0000329 }
danc9461ec2018-08-29 21:00:16 +0000330 if( IN_RENAME_OBJECT && pItem->zAlias ){
drheda079c2018-09-20 19:02:15 +0000331 sqlite3RenameTokenRemap(pParse, 0, (void*)&pExpr->y.pTab);
danc9461ec2018-08-29 21:00:16 +0000332 }
drh7d10d5a2008-08-20 16:35:10 +0000333 }
334 if( 0==(cntTab++) ){
drh7d10d5a2008-08-20 16:35:10 +0000335 pMatch = pItem;
336 }
drhd44390c2020-04-06 18:16:31 +0000337 hCol = sqlite3StrIHash(zCol);
drh7d10d5a2008-08-20 16:35:10 +0000338 for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
drhd44390c2020-04-06 18:16:31 +0000339 if( pCol->hName==hCol && sqlite3StrICmp(pCol->zName, zCol)==0 ){
drhe802c5d2011-10-18 18:10:40 +0000340 /* If there has been exactly one prior match and this match
341 ** is for the right-hand table of a NATURAL JOIN or is in a
342 ** USING clause, then skip this match.
343 */
344 if( cnt==1 ){
drh8a48b9c2015-08-19 15:20:00 +0000345 if( pItem->fg.jointype & JT_NATURAL ) continue;
drhe802c5d2011-10-18 18:10:40 +0000346 if( nameInUsingClause(pItem->pUsing, zCol) ) continue;
347 }
drh7d10d5a2008-08-20 16:35:10 +0000348 cnt++;
drh7d10d5a2008-08-20 16:35:10 +0000349 pMatch = pItem;
drh7d10d5a2008-08-20 16:35:10 +0000350 /* Substitute the rowid (column -1) for the INTEGER PRIMARY KEY */
shanecf697392009-06-01 16:53:09 +0000351 pExpr->iColumn = j==pTab->iPKey ? -1 : (i16)j;
drh7d10d5a2008-08-20 16:35:10 +0000352 break;
353 }
354 }
355 }
drh8f25d182012-12-19 02:36:45 +0000356 if( pMatch ){
357 pExpr->iTable = pMatch->iCursor;
drheda079c2018-09-20 19:02:15 +0000358 pExpr->y.pTab = pMatch->pTab;
drh31e71472015-02-09 10:20:19 +0000359 /* RIGHT JOIN not (yet) supported */
drh8a48b9c2015-08-19 15:20:00 +0000360 assert( (pMatch->fg.jointype & JT_RIGHT)==0 );
361 if( (pMatch->fg.jointype & JT_LEFT)!=0 ){
drh72673a22014-12-04 16:27:17 +0000362 ExprSetProperty(pExpr, EP_CanBeNull);
363 }
drheda079c2018-09-20 19:02:15 +0000364 pSchema = pExpr->y.pTab->pSchema;
drh8f25d182012-12-19 02:36:45 +0000365 }
366 } /* if( pSrcList ) */
drh7d10d5a2008-08-20 16:35:10 +0000367
drheac9fab2018-04-16 13:00:50 +0000368#if !defined(SQLITE_OMIT_TRIGGER) || !defined(SQLITE_OMIT_UPSERT)
drh7d10d5a2008-08-20 16:35:10 +0000369 /* If we have not already resolved the name, then maybe
drheac9fab2018-04-16 13:00:50 +0000370 ** it is a new.* or old.* trigger argument reference. Or
drhd5101972021-02-08 13:41:17 +0000371 ** maybe it is an excluded.* from an upsert. Or maybe it is
372 ** a reference in the RETURNING clause to a table being modified.
drh7d10d5a2008-08-20 16:35:10 +0000373 */
drhd5101972021-02-08 13:41:17 +0000374 if( cnt==0 && zDb==0 ){
drheac9fab2018-04-16 13:00:50 +0000375 pTab = 0;
376#ifndef SQLITE_OMIT_TRIGGER
377 if( pParse->pTriggerTab!=0 ){
378 int op = pParse->eTriggerOp;
379 assert( op==TK_DELETE || op==TK_UPDATE || op==TK_INSERT );
drhb8352472021-01-29 19:32:17 +0000380 if( op!=TK_DELETE && zTab && sqlite3StrICmp("new",zTab) == 0 ){
drheac9fab2018-04-16 13:00:50 +0000381 pExpr->iTable = 1;
382 pTab = pParse->pTriggerTab;
drhb8352472021-01-29 19:32:17 +0000383 }else if( op!=TK_INSERT && zTab && sqlite3StrICmp("old",zTab)==0 ){
drheac9fab2018-04-16 13:00:50 +0000384 pExpr->iTable = 0;
385 pTab = pParse->pTriggerTab;
drhb8352472021-01-29 19:32:17 +0000386 }else if( pParse->bReturning ){
387 pExpr->iTable = op!=TK_DELETE;
388 pTab = pParse->pTriggerTab;
drheac9fab2018-04-16 13:00:50 +0000389 }
drh7d10d5a2008-08-20 16:35:10 +0000390 }
drheac9fab2018-04-16 13:00:50 +0000391#endif /* SQLITE_OMIT_TRIGGER */
392#ifndef SQLITE_OMIT_UPSERT
drhd5101972021-02-08 13:41:17 +0000393 if( (pNC->ncFlags & NC_UUpsert)!=0 && zTab!=0 ){
drheac9fab2018-04-16 13:00:50 +0000394 Upsert *pUpsert = pNC->uNC.pUpsert;
395 if( pUpsert && sqlite3StrICmp("excluded",zTab)==0 ){
396 pTab = pUpsert->pUpsertSrc->a[0].pTab;
drhec43d802020-06-29 20:20:40 +0000397 pExpr->iTable = EXCLUDED_TABLE_NUMBER;
drheac9fab2018-04-16 13:00:50 +0000398 }
399 }
400#endif /* SQLITE_OMIT_UPSERT */
drh7d10d5a2008-08-20 16:35:10 +0000401
402 if( pTab ){
403 int iCol;
drhd44390c2020-04-06 18:16:31 +0000404 u8 hCol = sqlite3StrIHash(zCol);
drh7d10d5a2008-08-20 16:35:10 +0000405 pSchema = pTab->pSchema;
406 cntTab++;
drh511717c2013-11-08 17:13:23 +0000407 for(iCol=0, pCol=pTab->aCol; iCol<pTab->nCol; iCol++, pCol++){
drhd44390c2020-04-06 18:16:31 +0000408 if( pCol->hName==hCol && sqlite3StrICmp(pCol->zName, zCol)==0 ){
drh25e978d2009-12-29 23:39:04 +0000409 if( iCol==pTab->iPKey ){
410 iCol = -1;
drh7d10d5a2008-08-20 16:35:10 +0000411 }
drh25e978d2009-12-29 23:39:04 +0000412 break;
drh7d10d5a2008-08-20 16:35:10 +0000413 }
414 }
drhfccda8a2015-05-27 13:06:55 +0000415 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && VisibleRowid(pTab) ){
drhe8a537e2014-08-08 18:26:20 +0000416 /* IMP: R-51414-32910 */
drhbbbb0e82013-11-26 23:27:07 +0000417 iCol = -1;
drh25e978d2009-12-29 23:39:04 +0000418 }
dan2bd93512009-08-31 08:22:46 +0000419 if( iCol<pTab->nCol ){
420 cnt++;
drheac9fab2018-04-16 13:00:50 +0000421#ifndef SQLITE_OMIT_UPSERT
drhec43d802020-06-29 20:20:40 +0000422 if( pExpr->iTable==EXCLUDED_TABLE_NUMBER ){
drh99160482018-04-18 01:34:39 +0000423 testcase( iCol==(-1) );
danc9461ec2018-08-29 21:00:16 +0000424 if( IN_RENAME_OBJECT ){
dan85a9d502018-08-24 20:10:22 +0000425 pExpr->iColumn = iCol;
drheda079c2018-09-20 19:02:15 +0000426 pExpr->y.pTab = pTab;
dan85a9d502018-08-24 20:10:22 +0000427 eNewExprOp = TK_COLUMN;
428 }else{
drhb8fec212020-06-29 20:26:50 +0000429 pExpr->iTable = pNC->uNC.pUpsert->regData +
430 sqlite3TableColumnToStorage(pTab, iCol);
dan85a9d502018-08-24 20:10:22 +0000431 eNewExprOp = TK_REGISTER;
dan85a9d502018-08-24 20:10:22 +0000432 }
drheac9fab2018-04-16 13:00:50 +0000433 }else
drh0a6259f2018-04-16 13:26:53 +0000434#endif /* SQLITE_OMIT_UPSERT */
drheac9fab2018-04-16 13:00:50 +0000435 {
drheda079c2018-09-20 19:02:15 +0000436 pExpr->y.pTab = pTab;
drh552562c2021-02-04 20:52:20 +0000437 if( pParse->bReturning ){
drhd5101972021-02-08 13:41:17 +0000438 NameContext *pUp = pNC;
439 while( (pUp->ncFlags & NC_UBaseReg)==0 && ALWAYS(pUp->pNext) ){
440 pUp = pUp->pNext;
441 }
442 assert( pUp->ncFlags & NC_UBaseReg );
drh552562c2021-02-04 20:52:20 +0000443 eNewExprOp = TK_REGISTER;
drhd5101972021-02-08 13:41:17 +0000444 pExpr->iTable = pUp->uNC.iBaseReg + (pTab->nCol+1)*pExpr->iTable
drh552562c2021-02-04 20:52:20 +0000445 + iCol + 1;
446 }else{
447 pExpr->iColumn = (i16)iCol;
448 eNewExprOp = TK_TRIGGER;
449#ifndef SQLITE_OMIT_TRIGGER
drh8873aea2021-02-06 14:37:36 +0000450 if( iCol<0 ){
451 pExpr->affExpr = SQLITE_AFF_INTEGER;
452 }else if( pExpr->iTable==0 ){
drh552562c2021-02-04 20:52:20 +0000453 testcase( iCol==31 );
454 testcase( iCol==32 );
455 pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
456 }else{
457 testcase( iCol==31 );
458 testcase( iCol==32 );
459 pParse->newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
460 }
drh0a6259f2018-04-16 13:26:53 +0000461#endif /* SQLITE_OMIT_TRIGGER */
drh552562c2021-02-04 20:52:20 +0000462 }
dan2bd93512009-08-31 08:22:46 +0000463 }
dan2bd93512009-08-31 08:22:46 +0000464 }
drh7d10d5a2008-08-20 16:35:10 +0000465 }
466 }
drheac9fab2018-04-16 13:00:50 +0000467#endif /* !defined(SQLITE_OMIT_TRIGGER) || !defined(SQLITE_OMIT_UPSERT) */
drh7d10d5a2008-08-20 16:35:10 +0000468
469 /*
470 ** Perhaps the name is a reference to the ROWID
471 */
drh4cbc54b2015-09-19 03:07:30 +0000472 if( cnt==0
473 && cntTab==1
474 && pMatch
drh81f7b372019-10-16 12:18:59 +0000475 && (pNC->ncFlags & (NC_IdxExpr|NC_GenCol))==0
drh4cbc54b2015-09-19 03:07:30 +0000476 && sqlite3IsRowid(zCol)
477 && VisibleRowid(pMatch->pTab)
478 ){
drh7d10d5a2008-08-20 16:35:10 +0000479 cnt = 1;
drh15427272015-12-03 22:33:55 +0000480 pExpr->iColumn = -1;
drh11949042019-08-05 18:01:42 +0000481 pExpr->affExpr = SQLITE_AFF_INTEGER;
drh7d10d5a2008-08-20 16:35:10 +0000482 }
483
484 /*
485 ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z
486 ** might refer to an result-set alias. This happens, for example, when
487 ** we are resolving names in the WHERE clause of the following command:
488 **
489 ** SELECT a+b AS x FROM table WHERE x<10;
490 **
491 ** In cases like this, replace pExpr with a copy of the expression that
492 ** forms the result set entry ("a+b" in the example) and return immediately.
493 ** Note that the expression in the result set should have already been
494 ** resolved by the time the WHERE clause is resolved.
drhe35463b2013-08-15 20:24:27 +0000495 **
496 ** The ability to use an output result-set column in the WHERE, GROUP BY,
drh5579d592015-08-26 14:01:41 +0000497 ** or HAVING clauses, or as part of a larger expression in the ORDER BY
drhe35463b2013-08-15 20:24:27 +0000498 ** clause is not standard SQL. This is a (goofy) SQLite extension, that
drh5579d592015-08-26 14:01:41 +0000499 ** is supported for backwards compatibility only. Hence, we issue a warning
drhe35463b2013-08-15 20:24:27 +0000500 ** on sqlite3_log() whenever the capability is used.
drh7d10d5a2008-08-20 16:35:10 +0000501 */
drh25c3b8c2018-04-16 10:34:13 +0000502 if( (pNC->ncFlags & NC_UEList)!=0
drhe35463b2013-08-15 20:24:27 +0000503 && cnt==0
drh25c3b8c2018-04-16 10:34:13 +0000504 && zTab==0
drha3a5bd92013-04-13 19:59:58 +0000505 ){
drh25c3b8c2018-04-16 10:34:13 +0000506 pEList = pNC->uNC.pEList;
507 assert( pEList!=0 );
drh7d10d5a2008-08-20 16:35:10 +0000508 for(j=0; j<pEList->nExpr; j++){
drh9fc1b9a2020-01-02 22:23:01 +0000509 char *zAs = pEList->a[j].zEName;
drhc4938ea2019-12-13 00:49:42 +0000510 if( pEList->a[j].eEName==ENAME_NAME
dan607dd6e2020-01-03 14:27:08 +0000511 && sqlite3_stricmp(zAs, zCol)==0
drhc4938ea2019-12-13 00:49:42 +0000512 ){
drh8b213892008-08-29 02:14:02 +0000513 Expr *pOrig;
drh7d10d5a2008-08-20 16:35:10 +0000514 assert( pExpr->pLeft==0 && pExpr->pRight==0 );
danielk19776ab3a2e2009-02-19 14:39:25 +0000515 assert( pExpr->x.pList==0 );
516 assert( pExpr->x.pSelect==0 );
drh7d10d5a2008-08-20 16:35:10 +0000517 pOrig = pEList->a[j].pExpr;
drha51009b2012-05-21 19:11:25 +0000518 if( (pNC->ncFlags&NC_AllowAgg)==0 && ExprHasProperty(pOrig, EP_Agg) ){
drh7d10d5a2008-08-20 16:35:10 +0000519 sqlite3ErrorMsg(pParse, "misuse of aliased aggregate %s", zAs);
drhf7828b52009-06-15 23:15:59 +0000520 return WRC_Abort;
drh7d10d5a2008-08-20 16:35:10 +0000521 }
dane3735bf2019-12-27 19:46:07 +0000522 if( ExprHasProperty(pOrig, EP_Win)
523 && ((pNC->ncFlags&NC_AllowWin)==0 || pNC!=pTopNC )
524 ){
dan4ded26a2019-03-28 16:15:05 +0000525 sqlite3ErrorMsg(pParse, "misuse of aliased window function %s",zAs);
526 return WRC_Abort;
527 }
dan3bafded2016-11-11 15:49:01 +0000528 if( sqlite3ExprVectorSize(pOrig)!=1 ){
529 sqlite3ErrorMsg(pParse, "row value misused");
530 return WRC_Abort;
531 }
drhed551b92012-08-23 19:46:11 +0000532 resolveAlias(pParse, pEList, j, pExpr, "", nSubquery);
drh7d10d5a2008-08-20 16:35:10 +0000533 cnt = 1;
534 pMatch = 0;
535 assert( zTab==0 && zDb==0 );
danc9461ec2018-08-29 21:00:16 +0000536 if( IN_RENAME_OBJECT ){
dan1b0c5de2018-08-24 16:04:26 +0000537 sqlite3RenameTokenRemap(pParse, 0, (void*)pExpr);
538 }
drhb7916a72009-05-27 10:31:29 +0000539 goto lookupname_end;
drh7d10d5a2008-08-20 16:35:10 +0000540 }
541 }
542 }
543
544 /* Advance to the next name context. The loop will exit when either
545 ** we have a match (cnt>0) or when we run out of name contexts.
546 */
drha92b81f2017-03-07 03:40:48 +0000547 if( cnt ) break;
548 pNC = pNC->pNext;
549 nSubquery++;
550 }while( pNC );
551
drh7d10d5a2008-08-20 16:35:10 +0000552
553 /*
554 ** If X and Y are NULL (in other words if only the column name Z is
555 ** supplied) and the value of Z is enclosed in double-quotes, then
556 ** Z is a string literal if it doesn't match any column names. In that
557 ** case, we need to return right away and not make any changes to
558 ** pExpr.
559 **
560 ** Because no reference was made to outer contexts, the pNC->nRef
561 ** fields are not changed in any context.
562 */
drh007c8432018-02-26 03:20:18 +0000563 if( cnt==0 && zTab==0 ){
drh171d16b2018-02-26 20:15:54 +0000564 assert( pExpr->op==TK_ID );
drhd0ff6012019-06-17 13:56:11 +0000565 if( ExprHasProperty(pExpr,EP_DblQuoted)
566 && areDoubleQuotedStringsEnabled(db, pTopNC)
dan0d925712019-05-20 17:14:25 +0000567 ){
drhec8fc622018-12-06 16:11:14 +0000568 /* If a double-quoted identifier does not match any known column name,
569 ** then treat it as a string.
570 **
571 ** This hack was added in the early days of SQLite in a misguided attempt
572 ** to be compatible with MySQL 3.x, which used double-quotes for strings.
573 ** I now sorely regret putting in this hack. The effect of this hack is
574 ** that misspelled identifier names are silently converted into strings
575 ** rather than causing an error, to the frustration of countless
576 ** programmers. To all those frustrated programmers, my apologies.
577 **
578 ** Someday, I hope to get rid of this hack. Unfortunately there is
579 ** a huge amount of legacy SQL that uses it. So for now, we just
580 ** issue a warning.
581 */
582 sqlite3_log(SQLITE_WARNING,
583 "double-quoted string literal: \"%w\"", zCol);
drh893bd372018-12-07 16:32:11 +0000584#ifdef SQLITE_ENABLE_NORMALIZE
drh1a6c2b12018-12-10 20:01:40 +0000585 sqlite3VdbeAddDblquoteStr(db, pParse->pVdbe, zCol);
drh893bd372018-12-07 16:32:11 +0000586#endif
drh007c8432018-02-26 03:20:18 +0000587 pExpr->op = TK_STRING;
drheda079c2018-09-20 19:02:15 +0000588 pExpr->y.pTab = 0;
drh007c8432018-02-26 03:20:18 +0000589 return WRC_Prune;
590 }
drh171d16b2018-02-26 20:15:54 +0000591 if( sqlite3ExprIdToTrueFalse(pExpr) ){
drh007c8432018-02-26 03:20:18 +0000592 return WRC_Prune;
593 }
drh7d10d5a2008-08-20 16:35:10 +0000594 }
595
596 /*
597 ** cnt==0 means there was not match. cnt>1 means there were two or
598 ** more matches. Either way, we have an error.
599 */
600 if( cnt!=1 ){
601 const char *zErr;
602 zErr = cnt==0 ? "no such column" : "ambiguous column name";
603 if( zDb ){
604 sqlite3ErrorMsg(pParse, "%s: %s.%s.%s", zErr, zDb, zTab, zCol);
605 }else if( zTab ){
606 sqlite3ErrorMsg(pParse, "%s: %s.%s", zErr, zTab, zCol);
607 }else{
608 sqlite3ErrorMsg(pParse, "%s: %s", zErr, zCol);
609 }
dan1db95102010-06-28 10:15:19 +0000610 pParse->checkSchema = 1;
drh7d10d5a2008-08-20 16:35:10 +0000611 pTopNC->nErr++;
612 }
613
614 /* If a column from a table in pSrcList is referenced, then record
615 ** this fact in the pSrcList.a[].colUsed bitmask. Column 0 causes
drhbf9d0992019-12-08 00:06:39 +0000616 ** bit 0 to be set. Column 1 sets bit 1. And so forth. Bit 63 is
617 ** set if the 63rd or any subsequent column is used.
drh522ebfa2019-11-21 19:37:00 +0000618 **
619 ** The colUsed mask is an optimization used to help determine if an
620 ** index is a covering index. The correct answer is still obtained
drhbf9d0992019-12-08 00:06:39 +0000621 ** if the mask contains extra set bits. However, it is important to
622 ** avoid setting bits beyond the maximum column number of the table.
623 ** (See ticket [b92e5e8ec2cdbaa1]).
drh522ebfa2019-11-21 19:37:00 +0000624 **
drhbf9d0992019-12-08 00:06:39 +0000625 ** If a generated column is referenced, set bits for every column
626 ** of the table.
drh7d10d5a2008-08-20 16:35:10 +0000627 */
danielk19772d2e7bd2009-02-24 10:14:40 +0000628 if( pExpr->iColumn>=0 && pMatch!=0 ){
drh74a07982020-03-21 23:10:38 +0000629 pMatch->colUsed |= sqlite3ExprColUsed(pExpr);
drh7d10d5a2008-08-20 16:35:10 +0000630 }
631
drh7d10d5a2008-08-20 16:35:10 +0000632 /* Clean up and return
633 */
drh7d10d5a2008-08-20 16:35:10 +0000634 sqlite3ExprDelete(db, pExpr->pLeft);
635 pExpr->pLeft = 0;
636 sqlite3ExprDelete(db, pExpr->pRight);
637 pExpr->pRight = 0;
drheac9fab2018-04-16 13:00:50 +0000638 pExpr->op = eNewExprOp;
drhb98a2e32017-07-07 12:43:57 +0000639 ExprSetProperty(pExpr, EP_Leaf);
drhb7916a72009-05-27 10:31:29 +0000640lookupname_end:
drh7d10d5a2008-08-20 16:35:10 +0000641 if( cnt==1 ){
642 assert( pNC!=0 );
drh552562c2021-02-04 20:52:20 +0000643 if( pParse->db->xAuth
drh29f6a362021-02-05 17:34:47 +0000644 && (pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER)
drh552562c2021-02-04 20:52:20 +0000645 ){
drha3a5bd92013-04-13 19:59:58 +0000646 sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList);
647 }
drh7d10d5a2008-08-20 16:35:10 +0000648 /* Increment the nRef value on all name contexts from TopNC up to
649 ** the point where the name matched. */
650 for(;;){
651 assert( pTopNC!=0 );
652 pTopNC->nRef++;
653 if( pTopNC==pNC ) break;
654 pTopNC = pTopNC->pNext;
655 }
drhf7828b52009-06-15 23:15:59 +0000656 return WRC_Prune;
drh7d10d5a2008-08-20 16:35:10 +0000657 } else {
drhf7828b52009-06-15 23:15:59 +0000658 return WRC_Abort;
drh7d10d5a2008-08-20 16:35:10 +0000659 }
660}
661
662/*
danf7b0b0a2009-10-19 15:52:32 +0000663** Allocate and return a pointer to an expression to load the column iCol
drh9e481652010-04-08 17:35:34 +0000664** from datasource iSrc in SrcList pSrc.
danf7b0b0a2009-10-19 15:52:32 +0000665*/
666Expr *sqlite3CreateColumnExpr(sqlite3 *db, SrcList *pSrc, int iSrc, int iCol){
667 Expr *p = sqlite3ExprAlloc(db, TK_COLUMN, 0, 0);
668 if( p ){
669 struct SrcList_item *pItem = &pSrc->a[iSrc];
drh926f7962019-12-09 17:14:48 +0000670 Table *pTab = p->y.pTab = pItem->pTab;
danf7b0b0a2009-10-19 15:52:32 +0000671 p->iTable = pItem->iCursor;
drheda079c2018-09-20 19:02:15 +0000672 if( p->y.pTab->iPKey==iCol ){
danf7b0b0a2009-10-19 15:52:32 +0000673 p->iColumn = -1;
674 }else{
drh8677d302009-11-04 13:17:14 +0000675 p->iColumn = (ynVar)iCol;
drh0824d5b2019-12-09 18:22:17 +0000676 if( (pTab->tabFlags & TF_HasGenerated)!=0
677 && (pTab->aCol[iCol].colFlags & COLFLAG_GENERATED)!=0
678 ){
679 testcase( pTab->nCol==63 );
680 testcase( pTab->nCol==64 );
681 pItem->colUsed = pTab->nCol>=64 ? ALLBITS : MASKBIT(pTab->nCol)-1;
drh926f7962019-12-09 17:14:48 +0000682 }else{
683 testcase( iCol==BMS );
684 testcase( iCol==BMS-1 );
685 pItem->colUsed |= ((Bitmask)1)<<(iCol>=BMS ? BMS-1 : iCol);
686 }
danf7b0b0a2009-10-19 15:52:32 +0000687 }
danf7b0b0a2009-10-19 15:52:32 +0000688 }
689 return p;
690}
691
692/*
drha514b8e2015-08-25 00:27:06 +0000693** Report an error that an expression is not valid for some set of
drh03bf26d2015-08-31 21:16:36 +0000694** pNC->ncFlags values determined by validMask.
drh77318a32019-12-12 15:19:18 +0000695**
696** static void notValid(
697** Parse *pParse, // Leave error message here
698** NameContext *pNC, // The name context
699** const char *zMsg, // Type of error
700** int validMask, // Set of contexts for which prohibited
701** Expr *pExpr // Invalidate this expression on error
702** ){...}
703**
704** As an optimization, since the conditional is almost always false
705** (because errors are rare), the conditional is moved outside of the
706** function call using a macro.
drh3780be12013-07-31 19:05:22 +0000707*/
drh77318a32019-12-12 15:19:18 +0000708static void notValidImpl(
709 Parse *pParse, /* Leave error message here */
710 NameContext *pNC, /* The name context */
711 const char *zMsg, /* Type of error */
712 Expr *pExpr /* Invalidate this expression on error */
drh3780be12013-07-31 19:05:22 +0000713){
drh77318a32019-12-12 15:19:18 +0000714 const char *zIn = "partial index WHERE clauses";
715 if( pNC->ncFlags & NC_IdxExpr ) zIn = "index expressions";
drh3780be12013-07-31 19:05:22 +0000716#ifndef SQLITE_OMIT_CHECK
drh77318a32019-12-12 15:19:18 +0000717 else if( pNC->ncFlags & NC_IsCheck ) zIn = "CHECK constraints";
drha514b8e2015-08-25 00:27:06 +0000718#endif
drh81f7b372019-10-16 12:18:59 +0000719#ifndef SQLITE_OMIT_GENERATED_COLUMNS
drh77318a32019-12-12 15:19:18 +0000720 else if( pNC->ncFlags & NC_GenCol ) zIn = "generated columns";
drh81f7b372019-10-16 12:18:59 +0000721#endif
drh77318a32019-12-12 15:19:18 +0000722 sqlite3ErrorMsg(pParse, "%s prohibited in %s", zMsg, zIn);
723 if( pExpr ) pExpr->op = TK_NULL;
drh3780be12013-07-31 19:05:22 +0000724}
drh77318a32019-12-12 15:19:18 +0000725#define sqlite3ResolveNotValid(P,N,M,X,E) \
726 assert( ((X)&~(NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol))==0 ); \
727 if( ((N)->ncFlags & (X))!=0 ) notValidImpl(P,N,M,E);
drh3780be12013-07-31 19:05:22 +0000728
drhcca9f3d2013-09-06 15:23:29 +0000729/*
730** Expression p should encode a floating point value between 1.0 and 0.0.
731** Return 1024 times this value. Or return -1 if p is not a floating point
732** value between 1.0 and 0.0.
733*/
734static int exprProbability(Expr *p){
735 double r = -1.0;
736 if( p->op!=TK_FLOAT ) return -1;
737 sqlite3AtoF(p->u.zToken, &r, sqlite3Strlen30(p->u.zToken), SQLITE_UTF8);
drh09328c02013-09-11 14:34:58 +0000738 assert( r>=0.0 );
739 if( r>1.0 ) return -1;
drhd05ab6a2014-10-25 13:42:16 +0000740 return (int)(r*134217728.0);
drhcca9f3d2013-09-06 15:23:29 +0000741}
drh3780be12013-07-31 19:05:22 +0000742
743/*
drh7d10d5a2008-08-20 16:35:10 +0000744** This routine is callback for sqlite3WalkExpr().
745**
746** Resolve symbolic names into TK_COLUMN operators for the current
747** node in the expression tree. Return 0 to continue the search down
748** the tree or 2 to abort the tree walk.
749**
750** This routine also does error checking and name resolution for
751** function names. The operator for aggregate functions is changed
752** to TK_AGG_FUNCTION.
753*/
754static int resolveExprStep(Walker *pWalker, Expr *pExpr){
755 NameContext *pNC;
756 Parse *pParse;
757
drh7d10d5a2008-08-20 16:35:10 +0000758 pNC = pWalker->u.pNC;
759 assert( pNC!=0 );
760 pParse = pNC->pParse;
761 assert( pParse==pWalker->pParse );
762
drh7d10d5a2008-08-20 16:35:10 +0000763#ifndef NDEBUG
764 if( pNC->pSrcList && pNC->pSrcList->nAlloc>0 ){
765 SrcList *pSrcList = pNC->pSrcList;
766 int i;
767 for(i=0; i<pNC->pSrcList->nSrc; i++){
768 assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursor<pParse->nTab);
769 }
770 }
771#endif
772 switch( pExpr->op ){
drh41204f12008-10-06 13:54:35 +0000773
drh41204f12008-10-06 13:54:35 +0000774 /* The special operator TK_ROW means use the rowid for the first
775 ** column in the FROM clause. This is used by the LIMIT and ORDER BY
danbe952c12020-07-13 20:10:29 +0000776 ** clause processing on UPDATE and DELETE statements, and by
777 ** UPDATE ... FROM statement processing.
drh41204f12008-10-06 13:54:35 +0000778 */
779 case TK_ROW: {
780 SrcList *pSrcList = pNC->pSrcList;
781 struct SrcList_item *pItem;
danf2972b62020-04-29 20:11:01 +0000782 assert( pSrcList && pSrcList->nSrc>=1 );
drh2fba3942017-11-09 03:55:09 +0000783 pItem = pSrcList->a;
drh41204f12008-10-06 13:54:35 +0000784 pExpr->op = TK_COLUMN;
drheda079c2018-09-20 19:02:15 +0000785 pExpr->y.pTab = pItem->pTab;
drh41204f12008-10-06 13:54:35 +0000786 pExpr->iTable = pItem->iCursor;
dan576d5a82020-07-15 18:30:01 +0000787 pExpr->iColumn--;
drhaf97c3f2019-08-08 18:49:16 +0000788 pExpr->affExpr = SQLITE_AFF_INTEGER;
drh41204f12008-10-06 13:54:35 +0000789 break;
790 }
drh41204f12008-10-06 13:54:35 +0000791
drh3cf48e32017-03-07 03:25:52 +0000792 /* A column name: ID
793 ** Or table name and column name: ID.ID
drh7d10d5a2008-08-20 16:35:10 +0000794 ** Or a database, table and column: ID.ID.ID
drh3cf48e32017-03-07 03:25:52 +0000795 **
796 ** The TK_ID and TK_OUT cases are combined so that there will only
797 ** be one call to lookupName(). Then the compiler will in-line
798 ** lookupName() for a size reduction and performance increase.
drh7d10d5a2008-08-20 16:35:10 +0000799 */
drh3cf48e32017-03-07 03:25:52 +0000800 case TK_ID:
drh7d10d5a2008-08-20 16:35:10 +0000801 case TK_DOT: {
drhb7916a72009-05-27 10:31:29 +0000802 const char *zColumn;
803 const char *zTable;
804 const char *zDb;
drh7d10d5a2008-08-20 16:35:10 +0000805 Expr *pRight;
806
drh3cf48e32017-03-07 03:25:52 +0000807 if( pExpr->op==TK_ID ){
drhb7916a72009-05-27 10:31:29 +0000808 zDb = 0;
drh3cf48e32017-03-07 03:25:52 +0000809 zTable = 0;
810 zColumn = pExpr->u.zToken;
drh7d10d5a2008-08-20 16:35:10 +0000811 }else{
danc9461ec2018-08-29 21:00:16 +0000812 Expr *pLeft = pExpr->pLeft;
drh77318a32019-12-12 15:19:18 +0000813 testcase( pNC->ncFlags & NC_IdxExpr );
814 testcase( pNC->ncFlags & NC_GenCol );
815 sqlite3ResolveNotValid(pParse, pNC, "the \".\" operator",
816 NC_IdxExpr|NC_GenCol, 0);
drh3cf48e32017-03-07 03:25:52 +0000817 pRight = pExpr->pRight;
818 if( pRight->op==TK_ID ){
819 zDb = 0;
drh3cf48e32017-03-07 03:25:52 +0000820 }else{
821 assert( pRight->op==TK_DOT );
danc9461ec2018-08-29 21:00:16 +0000822 zDb = pLeft->u.zToken;
823 pLeft = pRight->pLeft;
dancf8f2892018-08-09 20:47:01 +0000824 pRight = pRight->pRight;
825 }
danc9461ec2018-08-29 21:00:16 +0000826 zTable = pLeft->u.zToken;
dancf8f2892018-08-09 20:47:01 +0000827 zColumn = pRight->u.zToken;
danc9461ec2018-08-29 21:00:16 +0000828 if( IN_RENAME_OBJECT ){
dan07e95232018-08-21 16:32:53 +0000829 sqlite3RenameTokenRemap(pParse, (void*)pExpr, (void*)pRight);
drheda079c2018-09-20 19:02:15 +0000830 sqlite3RenameTokenRemap(pParse, (void*)&pExpr->y.pTab, (void*)pLeft);
danc9461ec2018-08-29 21:00:16 +0000831 }
drh7d10d5a2008-08-20 16:35:10 +0000832 }
drhf7828b52009-06-15 23:15:59 +0000833 return lookupName(pParse, zDb, zTable, zColumn, pNC, pExpr);
drh7d10d5a2008-08-20 16:35:10 +0000834 }
835
836 /* Resolve function names
837 */
drh7d10d5a2008-08-20 16:35:10 +0000838 case TK_FUNCTION: {
danielk19776ab3a2e2009-02-19 14:39:25 +0000839 ExprList *pList = pExpr->x.pList; /* The argument list */
840 int n = pList ? pList->nExpr : 0; /* Number of arguments */
drh7d10d5a2008-08-20 16:35:10 +0000841 int no_such_func = 0; /* True if no such function exists */
842 int wrong_num_args = 0; /* True if wrong number of arguments */
843 int is_agg = 0; /* True if is an aggregate function */
drh7d10d5a2008-08-20 16:35:10 +0000844 int nId; /* Number of characters in function name */
845 const char *zId; /* The function name. */
846 FuncDef *pDef; /* Information about the function */
drhea678832008-12-10 19:26:22 +0000847 u8 enc = ENC(pParse->db); /* The database encoding */
dan4ded26a2019-03-28 16:15:05 +0000848 int savedAllowFlags = (pNC->ncFlags & (NC_AllowAgg | NC_AllowWin));
dan4f9adee2019-07-13 16:22:50 +0000849#ifndef SQLITE_OMIT_WINDOWFUNC
850 Window *pWin = (IsWindowFunc(pExpr) ? pExpr->y.pWin : 0);
851#endif
danielk19776ab3a2e2009-02-19 14:39:25 +0000852 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
drh33e619f2009-05-28 01:00:55 +0000853 zId = pExpr->u.zToken;
drhb7916a72009-05-27 10:31:29 +0000854 nId = sqlite3Strlen30(zId);
drh80738d92016-02-15 00:34:16 +0000855 pDef = sqlite3FindFunction(pParse->db, zId, n, enc, 0);
drh7d10d5a2008-08-20 16:35:10 +0000856 if( pDef==0 ){
drh80738d92016-02-15 00:34:16 +0000857 pDef = sqlite3FindFunction(pParse->db, zId, -2, enc, 0);
drh7d10d5a2008-08-20 16:35:10 +0000858 if( pDef==0 ){
859 no_such_func = 1;
860 }else{
861 wrong_num_args = 1;
862 }
863 }else{
drh2d801512016-01-14 22:19:58 +0000864 is_agg = pDef->xFinalize!=0;
drhcca9f3d2013-09-06 15:23:29 +0000865 if( pDef->funcFlags & SQLITE_FUNC_UNLIKELY ){
drha7d6db62019-06-11 21:02:15 +0000866 ExprSetProperty(pExpr, EP_Unlikely);
drhcca9f3d2013-09-06 15:23:29 +0000867 if( n==2 ){
868 pExpr->iTable = exprProbability(pList->a[1].pExpr);
869 if( pExpr->iTable<0 ){
drh31e71472015-02-09 10:20:19 +0000870 sqlite3ErrorMsg(pParse,
871 "second argument to likelihood() must be a "
872 "constant between 0.0 and 1.0");
drhcca9f3d2013-09-06 15:23:29 +0000873 pNC->nErr++;
874 }
875 }else{
drh31e71472015-02-09 10:20:19 +0000876 /* EVIDENCE-OF: R-61304-29449 The unlikely(X) function is
877 ** equivalent to likelihood(X, 0.0625).
878 ** EVIDENCE-OF: R-01283-11636 The unlikely(X) function is
879 ** short-hand for likelihood(X,0.0625).
880 ** EVIDENCE-OF: R-36850-34127 The likely(X) function is short-hand
881 ** for likelihood(X,0.9375).
882 ** EVIDENCE-OF: R-53436-40973 The likely(X) function is equivalent
883 ** to likelihood(X,0.9375). */
drh03202a92014-06-17 16:11:28 +0000884 /* TUNING: unlikely() probability is 0.0625. likely() is 0.9375 */
drhd05ab6a2014-10-25 13:42:16 +0000885 pExpr->iTable = pDef->zName[0]=='u' ? 8388608 : 125829120;
drhcca9f3d2013-09-06 15:23:29 +0000886 }
887 }
drh7d10d5a2008-08-20 16:35:10 +0000888#ifndef SQLITE_OMIT_AUTHORIZATION
drha0daa752016-09-16 11:53:10 +0000889 {
890 int auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0,pDef->zName,0);
891 if( auth!=SQLITE_OK ){
892 if( auth==SQLITE_DENY ){
893 sqlite3ErrorMsg(pParse, "not authorized to use function: %s",
894 pDef->zName);
895 pNC->nErr++;
896 }
897 pExpr->op = TK_NULL;
898 return WRC_Prune;
drh7d10d5a2008-08-20 16:35:10 +0000899 }
drh7d10d5a2008-08-20 16:35:10 +0000900 }
drh9588ad92014-09-15 14:46:02 +0000901#endif
drha7f910b2015-09-01 13:17:17 +0000902 if( pDef->funcFlags & (SQLITE_FUNC_CONSTANT|SQLITE_FUNC_SLOCHNG) ){
drh1d85e402015-08-31 17:34:41 +0000903 /* For the purposes of the EP_ConstFunc flag, date and time
drh03bf26d2015-08-31 21:16:36 +0000904 ** functions and other functions that change slowly are considered
drh20cee7d2019-10-30 18:50:08 +0000905 ** constant because they are constant for the duration of one query.
906 ** This allows them to be factored out of inner loops. */
drh63f84572015-02-09 14:07:07 +0000907 ExprSetProperty(pExpr,EP_ConstFunc);
drh1d85e402015-08-31 17:34:41 +0000908 }
909 if( (pDef->funcFlags & SQLITE_FUNC_CONSTANT)==0 ){
drhfe704602020-01-18 21:34:31 +0000910 /* Clearly non-deterministic functions like random(), but also
911 ** date/time functions that use 'now', and other functions like
drha7f910b2015-09-01 13:17:17 +0000912 ** sqlite_version() that might change over time cannot be used
drhfe704602020-01-18 21:34:31 +0000913 ** in an index or generated column. Curiously, they can be used
914 ** in a CHECK constraint. SQLServer, MySQL, and PostgreSQL all
915 ** all this. */
drh77318a32019-12-12 15:19:18 +0000916 sqlite3ResolveNotValid(pParse, pNC, "non-deterministic functions",
drhfe704602020-01-18 21:34:31 +0000917 NC_IdxExpr|NC_PartIdx|NC_GenCol, 0);
drh20cee7d2019-10-30 18:50:08 +0000918 }else{
919 assert( (NC_SelfRef & 0xff)==NC_SelfRef ); /* Must fit in 8 bits */
920 pExpr->op2 = pNC->ncFlags & NC_SelfRef;
drh05b32ee2020-01-09 01:20:03 +0000921 if( pNC->ncFlags & NC_FromDDL ) ExprSetProperty(pExpr, EP_FromDDL);
drh31e71472015-02-09 10:20:19 +0000922 }
drheea8eb62018-11-26 18:09:15 +0000923 if( (pDef->funcFlags & SQLITE_FUNC_INTERNAL)!=0
924 && pParse->nested==0
drh171c50e2020-01-01 15:43:30 +0000925 && (pParse->db->mDbFlags & DBFLAG_InternalFunc)==0
drheea8eb62018-11-26 18:09:15 +0000926 ){
927 /* Internal-use-only functions are disallowed unless the
drh0dfa5252020-01-08 17:28:19 +0000928 ** SQL is being compiled using sqlite3NestedParse() or
929 ** the SQLITE_TESTCTRL_INTERNAL_FUNCTIONS test-control has be
930 ** used to activate internal functionsn for testing purposes */
drheea8eb62018-11-26 18:09:15 +0000931 no_such_func = 1;
932 pDef = 0;
drh2eeca202020-01-08 20:37:45 +0000933 }else
934 if( (pDef->funcFlags & (SQLITE_FUNC_DIRECT|SQLITE_FUNC_UNSAFE))!=0
935 && !IN_RENAME_OBJECT
936 ){
937 sqlite3ExprFunctionUsable(pParse, pExpr, pDef);
drheea8eb62018-11-26 18:09:15 +0000938 }
drh7d10d5a2008-08-20 16:35:10 +0000939 }
dan26522d12018-06-11 18:16:51 +0000940
danc9461ec2018-08-29 21:00:16 +0000941 if( 0==IN_RENAME_OBJECT ){
dan67a9b8e2018-06-22 20:51:35 +0000942#ifndef SQLITE_OMIT_WINDOWFUNC
dandabc2682018-08-17 17:18:16 +0000943 assert( is_agg==0 || (pDef->funcFlags & SQLITE_FUNC_MINMAX)
dan7262ca92018-07-02 12:07:32 +0000944 || (pDef->xValue==0 && pDef->xInverse==0)
945 || (pDef->xValue && pDef->xInverse && pDef->xSFunc && pDef->xFinalize)
dan26522d12018-06-11 18:16:51 +0000946 );
dan8117f112019-07-10 20:16:53 +0000947 if( pDef && pDef->xValue==0 && pWin ){
dandabc2682018-08-17 17:18:16 +0000948 sqlite3ErrorMsg(pParse,
949 "%.*s() may not be used as a window function", nId, zId
950 );
951 pNC->nErr++;
952 }else if(
953 (is_agg && (pNC->ncFlags & NC_AllowAgg)==0)
dan8117f112019-07-10 20:16:53 +0000954 || (is_agg && (pDef->funcFlags&SQLITE_FUNC_WINDOW) && !pWin)
955 || (is_agg && pWin && (pNC->ncFlags & NC_AllowWin)==0)
dandabc2682018-08-17 17:18:16 +0000956 ){
957 const char *zType;
dan8117f112019-07-10 20:16:53 +0000958 if( (pDef->funcFlags & SQLITE_FUNC_WINDOW) || pWin ){
dandabc2682018-08-17 17:18:16 +0000959 zType = "window";
960 }else{
961 zType = "aggregate";
962 }
963 sqlite3ErrorMsg(pParse, "misuse of %s function %.*s()",zType,nId,zId);
964 pNC->nErr++;
965 is_agg = 0;
dan26522d12018-06-11 18:16:51 +0000966 }
danc3163072018-06-23 19:29:56 +0000967#else
dandabc2682018-08-17 17:18:16 +0000968 if( (is_agg && (pNC->ncFlags & NC_AllowAgg)==0) ){
969 sqlite3ErrorMsg(pParse,"misuse of aggregate function %.*s()",nId,zId);
970 pNC->nErr++;
971 is_agg = 0;
972 }
danc3163072018-06-23 19:29:56 +0000973#endif
drh3a843f52018-08-25 03:29:34 +0000974 else if( no_such_func && pParse->db->init.busy==0
drhcc153132016-08-04 12:35:17 +0000975#ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
dandabc2682018-08-17 17:18:16 +0000976 && pParse->explain==0
drhcc153132016-08-04 12:35:17 +0000977#endif
dandabc2682018-08-17 17:18:16 +0000978 ){
979 sqlite3ErrorMsg(pParse, "no such function: %.*s", nId, zId);
980 pNC->nErr++;
981 }else if( wrong_num_args ){
982 sqlite3ErrorMsg(pParse,"wrong number of arguments to function %.*s()",
983 nId, zId);
984 pNC->nErr++;
985 }
dan5e61c1b2019-07-13 17:45:25 +0000986#ifndef SQLITE_OMIT_WINDOWFUNC
987 else if( is_agg==0 && ExprHasProperty(pExpr, EP_WinFunc) ){
988 sqlite3ErrorMsg(pParse,
989 "FILTER may not be used with non-aggregate %.*s()",
990 nId, zId
991 );
992 pNC->nErr++;
993 }
994#endif
dandabc2682018-08-17 17:18:16 +0000995 if( is_agg ){
dan4ded26a2019-03-28 16:15:05 +0000996 /* Window functions may not be arguments of aggregate functions.
997 ** Or arguments of other window functions. But aggregate functions
998 ** may be arguments for window functions. */
dan34a7d792018-06-29 20:43:33 +0000999#ifndef SQLITE_OMIT_WINDOWFUNC
dan8117f112019-07-10 20:16:53 +00001000 pNC->ncFlags &= ~(NC_AllowWin | (!pWin ? NC_AllowAgg : 0));
dan34a7d792018-06-29 20:43:33 +00001001#else
dandabc2682018-08-17 17:18:16 +00001002 pNC->ncFlags &= ~NC_AllowAgg;
dan34a7d792018-06-29 20:43:33 +00001003#endif
dandabc2682018-08-17 17:18:16 +00001004 }
danc3163072018-06-23 19:29:56 +00001005 }
dan9bf022d2019-07-19 14:32:42 +00001006#ifndef SQLITE_OMIT_WINDOWFUNC
dan1e602612019-07-22 11:38:43 +00001007 else if( ExprHasProperty(pExpr, EP_WinFunc) ){
dan9bf022d2019-07-19 14:32:42 +00001008 is_agg = 1;
1009 }
1010#endif
drh7d10d5a2008-08-20 16:35:10 +00001011 sqlite3WalkExprList(pWalker, pList);
drh030796d2012-08-23 16:18:10 +00001012 if( is_agg ){
dan67a9b8e2018-06-22 20:51:35 +00001013#ifndef SQLITE_OMIT_WINDOWFUNC
dan4f9adee2019-07-13 16:22:50 +00001014 if( pWin ){
dane3bf6322018-06-08 20:58:27 +00001015 Select *pSel = pNC->pWinSelect;
dan75b08212019-07-22 16:20:03 +00001016 assert( pWin==pExpr->y.pWin );
dan490e6f22019-04-29 11:27:58 +00001017 if( IN_RENAME_OBJECT==0 ){
drh2e2c8812019-12-13 11:42:56 +00001018 sqlite3WindowUpdate(pParse, pSel ? pSel->pWinDefn : 0, pWin, pDef);
dan490e6f22019-04-29 11:27:58 +00001019 }
dan4f9adee2019-07-13 16:22:50 +00001020 sqlite3WalkExprList(pWalker, pWin->pPartition);
1021 sqlite3WalkExprList(pWalker, pWin->pOrderBy);
1022 sqlite3WalkExpr(pWalker, pWin->pFilter);
dana3fcc002019-08-15 13:53:22 +00001023 sqlite3WindowLink(pSel, pWin);
dan4ded26a2019-03-28 16:15:05 +00001024 pNC->ncFlags |= NC_HasWin;
dan67a9b8e2018-06-22 20:51:35 +00001025 }else
1026#endif /* SQLITE_OMIT_WINDOWFUNC */
1027 {
dan86fb6e12018-05-16 20:58:07 +00001028 NameContext *pNC2 = pNC;
1029 pExpr->op = TK_AGG_FUNCTION;
1030 pExpr->op2 = 0;
dan6ba7ab02019-07-02 11:56:47 +00001031#ifndef SQLITE_OMIT_WINDOWFUNC
dan4f9adee2019-07-13 16:22:50 +00001032 if( ExprHasProperty(pExpr, EP_WinFunc) ){
1033 sqlite3WalkExpr(pWalker, pExpr->y.pWin->pFilter);
1034 }
dan6ba7ab02019-07-02 11:56:47 +00001035#endif
dan86fb6e12018-05-16 20:58:07 +00001036 while( pNC2 && !sqlite3FunctionUsesThisSrc(pExpr, pNC2->pSrcList) ){
1037 pExpr->op2++;
1038 pNC2 = pNC2->pNext;
1039 }
dan72d1eac2019-08-05 13:19:25 +00001040 assert( pDef!=0 || IN_RENAME_OBJECT );
1041 if( pNC2 && pDef ){
dan86fb6e12018-05-16 20:58:07 +00001042 assert( SQLITE_FUNC_MINMAX==NC_MinMaxAgg );
1043 testcase( (pDef->funcFlags & SQLITE_FUNC_MINMAX)!=0 );
1044 pNC2->ncFlags |= NC_HasAgg | (pDef->funcFlags & SQLITE_FUNC_MINMAX);
drh9588ad92014-09-15 14:46:02 +00001045
dan86fb6e12018-05-16 20:58:07 +00001046 }
drh9588ad92014-09-15 14:46:02 +00001047 }
dan4ded26a2019-03-28 16:15:05 +00001048 pNC->ncFlags |= savedAllowFlags;
drh030796d2012-08-23 16:18:10 +00001049 }
drh7d10d5a2008-08-20 16:35:10 +00001050 /* FIX ME: Compute pExpr->affinity based on the expected return
1051 ** type of the function
1052 */
1053 return WRC_Prune;
1054 }
1055#ifndef SQLITE_OMIT_SUBQUERY
1056 case TK_SELECT:
drh73c0fdc2009-06-15 18:32:36 +00001057 case TK_EXISTS: testcase( pExpr->op==TK_EXISTS );
drh7d10d5a2008-08-20 16:35:10 +00001058#endif
1059 case TK_IN: {
drh73c0fdc2009-06-15 18:32:36 +00001060 testcase( pExpr->op==TK_IN );
danielk19776ab3a2e2009-02-19 14:39:25 +00001061 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
drh7d10d5a2008-08-20 16:35:10 +00001062 int nRef = pNC->nRef;
drh77318a32019-12-12 15:19:18 +00001063 testcase( pNC->ncFlags & NC_IsCheck );
1064 testcase( pNC->ncFlags & NC_PartIdx );
1065 testcase( pNC->ncFlags & NC_IdxExpr );
1066 testcase( pNC->ncFlags & NC_GenCol );
1067 sqlite3ResolveNotValid(pParse, pNC, "subqueries",
1068 NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol, pExpr);
danielk19776ab3a2e2009-02-19 14:39:25 +00001069 sqlite3WalkSelect(pWalker, pExpr->x.pSelect);
drh7d10d5a2008-08-20 16:35:10 +00001070 assert( pNC->nRef>=nRef );
1071 if( nRef!=pNC->nRef ){
1072 ExprSetProperty(pExpr, EP_VarSelect);
drh91da7072016-05-04 14:45:30 +00001073 pNC->ncFlags |= NC_VarSelect;
drh7d10d5a2008-08-20 16:35:10 +00001074 }
1075 }
1076 break;
1077 }
drh7d10d5a2008-08-20 16:35:10 +00001078 case TK_VARIABLE: {
drh77318a32019-12-12 15:19:18 +00001079 testcase( pNC->ncFlags & NC_IsCheck );
1080 testcase( pNC->ncFlags & NC_PartIdx );
1081 testcase( pNC->ncFlags & NC_IdxExpr );
1082 testcase( pNC->ncFlags & NC_GenCol );
1083 sqlite3ResolveNotValid(pParse, pNC, "parameters",
1084 NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol, pExpr);
drh7d10d5a2008-08-20 16:35:10 +00001085 break;
1086 }
drh007c8432018-02-26 03:20:18 +00001087 case TK_IS:
drh8abed7b2018-02-26 18:49:05 +00001088 case TK_ISNOT: {
drh0d950af2019-08-22 16:38:42 +00001089 Expr *pRight = sqlite3ExprSkipCollateAndLikely(pExpr->pRight);
drh8abed7b2018-02-26 18:49:05 +00001090 assert( !ExprHasProperty(pExpr, EP_Reduced) );
1091 /* Handle special cases of "x IS TRUE", "x IS FALSE", "x IS NOT TRUE",
1092 ** and "x IS NOT FALSE". */
dan599456f2020-08-24 10:52:52 +00001093 if( pRight && (pRight->op==TK_ID || pRight->op==TK_TRUEFALSE) ){
drh8abed7b2018-02-26 18:49:05 +00001094 int rc = resolveExprStep(pWalker, pRight);
drh007c8432018-02-26 03:20:18 +00001095 if( rc==WRC_Abort ) return WRC_Abort;
drh8abed7b2018-02-26 18:49:05 +00001096 if( pRight->op==TK_TRUEFALSE ){
drh8abed7b2018-02-26 18:49:05 +00001097 pExpr->op2 = pExpr->op;
1098 pExpr->op = TK_TRUTH;
drh007c8432018-02-26 03:20:18 +00001099 return WRC_Continue;
1100 }
1101 }
drh08b92082020-08-10 14:18:00 +00001102 /* no break */ deliberate_fall_through
drh8abed7b2018-02-26 18:49:05 +00001103 }
dan3bafded2016-11-11 15:49:01 +00001104 case TK_BETWEEN:
drhb29e60c2016-09-05 12:02:34 +00001105 case TK_EQ:
1106 case TK_NE:
1107 case TK_LT:
1108 case TK_LE:
1109 case TK_GT:
drh8abed7b2018-02-26 18:49:05 +00001110 case TK_GE: {
drhb29e60c2016-09-05 12:02:34 +00001111 int nLeft, nRight;
1112 if( pParse->db->mallocFailed ) break;
drhb29e60c2016-09-05 12:02:34 +00001113 assert( pExpr->pLeft!=0 );
1114 nLeft = sqlite3ExprVectorSize(pExpr->pLeft);
dan3bafded2016-11-11 15:49:01 +00001115 if( pExpr->op==TK_BETWEEN ){
1116 nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[0].pExpr);
1117 if( nRight==nLeft ){
1118 nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[1].pExpr);
1119 }
1120 }else{
1121 assert( pExpr->pRight!=0 );
1122 nRight = sqlite3ExprVectorSize(pExpr->pRight);
1123 }
drhb29e60c2016-09-05 12:02:34 +00001124 if( nLeft!=nRight ){
1125 testcase( pExpr->op==TK_EQ );
1126 testcase( pExpr->op==TK_NE );
1127 testcase( pExpr->op==TK_LT );
1128 testcase( pExpr->op==TK_LE );
1129 testcase( pExpr->op==TK_GT );
1130 testcase( pExpr->op==TK_GE );
1131 testcase( pExpr->op==TK_IS );
1132 testcase( pExpr->op==TK_ISNOT );
dan3bafded2016-11-11 15:49:01 +00001133 testcase( pExpr->op==TK_BETWEEN );
drhb29e60c2016-09-05 12:02:34 +00001134 sqlite3ErrorMsg(pParse, "row value misused");
1135 }
1136 break;
1137 }
drh7d10d5a2008-08-20 16:35:10 +00001138 }
1139 return (pParse->nErr || pParse->db->mallocFailed) ? WRC_Abort : WRC_Continue;
1140}
1141
1142/*
1143** pEList is a list of expressions which are really the result set of the
1144** a SELECT statement. pE is a term in an ORDER BY or GROUP BY clause.
1145** This routine checks to see if pE is a simple identifier which corresponds
1146** to the AS-name of one of the terms of the expression list. If it is,
1147** this routine return an integer between 1 and N where N is the number of
1148** elements in pEList, corresponding to the matching entry. If there is
1149** no match, or if pE is not a simple identifier, then this routine
1150** return 0.
1151**
1152** pEList has been resolved. pE has not.
1153*/
1154static int resolveAsName(
1155 Parse *pParse, /* Parsing context for error messages */
1156 ExprList *pEList, /* List of expressions to scan */
1157 Expr *pE /* Expression we are trying to match */
1158){
1159 int i; /* Loop counter */
1160
shanecf697392009-06-01 16:53:09 +00001161 UNUSED_PARAMETER(pParse);
1162
drh73c0fdc2009-06-15 18:32:36 +00001163 if( pE->op==TK_ID ){
drh33e619f2009-05-28 01:00:55 +00001164 char *zCol = pE->u.zToken;
drh7d10d5a2008-08-20 16:35:10 +00001165 for(i=0; i<pEList->nExpr; i++){
drhc4938ea2019-12-13 00:49:42 +00001166 if( pEList->a[i].eEName==ENAME_NAME
dan607dd6e2020-01-03 14:27:08 +00001167 && sqlite3_stricmp(pEList->a[i].zEName, zCol)==0
drhc4938ea2019-12-13 00:49:42 +00001168 ){
drh7d10d5a2008-08-20 16:35:10 +00001169 return i+1;
1170 }
1171 }
drh7d10d5a2008-08-20 16:35:10 +00001172 }
1173 return 0;
1174}
1175
1176/*
1177** pE is a pointer to an expression which is a single term in the
1178** ORDER BY of a compound SELECT. The expression has not been
1179** name resolved.
1180**
1181** At the point this routine is called, we already know that the
1182** ORDER BY term is not an integer index into the result set. That
1183** case is handled by the calling routine.
1184**
1185** Attempt to match pE against result set columns in the left-most
1186** SELECT statement. Return the index i of the matching column,
1187** as an indication to the caller that it should sort by the i-th column.
1188** The left-most column is 1. In other words, the value returned is the
1189** same integer value that would be used in the SQL statement to indicate
1190** the column.
1191**
1192** If there is no match, return 0. Return -1 if an error occurs.
1193*/
1194static int resolveOrderByTermToExprList(
1195 Parse *pParse, /* Parsing context for error messages */
1196 Select *pSelect, /* The SELECT statement with the ORDER BY clause */
1197 Expr *pE /* The specific ORDER BY term */
1198){
1199 int i; /* Loop counter */
1200 ExprList *pEList; /* The columns of the result set */
1201 NameContext nc; /* Name context for resolving pE */
drha7564662010-02-22 19:32:31 +00001202 sqlite3 *db; /* Database connection */
1203 int rc; /* Return code from subprocedures */
1204 u8 savedSuppErr; /* Saved value of db->suppressErr */
drh7d10d5a2008-08-20 16:35:10 +00001205
1206 assert( sqlite3ExprIsInteger(pE, &i)==0 );
1207 pEList = pSelect->pEList;
1208
1209 /* Resolve all names in the ORDER BY term expression
1210 */
1211 memset(&nc, 0, sizeof(nc));
1212 nc.pParse = pParse;
1213 nc.pSrcList = pSelect->pSrc;
drh25c3b8c2018-04-16 10:34:13 +00001214 nc.uNC.pEList = pEList;
1215 nc.ncFlags = NC_AllowAgg|NC_UEList;
drh7d10d5a2008-08-20 16:35:10 +00001216 nc.nErr = 0;
drha7564662010-02-22 19:32:31 +00001217 db = pParse->db;
1218 savedSuppErr = db->suppressErr;
dan4db7ab52020-04-03 11:52:59 +00001219 if( IN_RENAME_OBJECT==0 ) db->suppressErr = 1;
drha7564662010-02-22 19:32:31 +00001220 rc = sqlite3ResolveExprNames(&nc, pE);
1221 db->suppressErr = savedSuppErr;
1222 if( rc ) return 0;
drh7d10d5a2008-08-20 16:35:10 +00001223
1224 /* Try to match the ORDER BY expression against an expression
1225 ** in the result set. Return an 1-based index of the matching
1226 ** result-set entry.
1227 */
1228 for(i=0; i<pEList->nExpr; i++){
dan5aa550c2017-06-24 18:10:29 +00001229 if( sqlite3ExprCompare(0, pEList->a[i].pExpr, pE, -1)<2 ){
drh7d10d5a2008-08-20 16:35:10 +00001230 return i+1;
1231 }
1232 }
1233
1234 /* If no match, return 0. */
1235 return 0;
1236}
1237
1238/*
1239** Generate an ORDER BY or GROUP BY term out-of-range error.
1240*/
1241static void resolveOutOfRangeError(
1242 Parse *pParse, /* The error context into which to write the error */
1243 const char *zType, /* "ORDER" or "GROUP" */
1244 int i, /* The index (1-based) of the term out of range */
1245 int mx /* Largest permissible value of i */
1246){
1247 sqlite3ErrorMsg(pParse,
1248 "%r %s BY term out of range - should be "
1249 "between 1 and %d", i, zType, mx);
1250}
1251
1252/*
1253** Analyze the ORDER BY clause in a compound SELECT statement. Modify
1254** each term of the ORDER BY clause is a constant integer between 1
1255** and N where N is the number of columns in the compound SELECT.
1256**
1257** ORDER BY terms that are already an integer between 1 and N are
1258** unmodified. ORDER BY terms that are integers outside the range of
1259** 1 through N generate an error. ORDER BY terms that are expressions
1260** are matched against result set expressions of compound SELECT
1261** beginning with the left-most SELECT and working toward the right.
1262** At the first match, the ORDER BY expression is transformed into
1263** the integer column number.
1264**
1265** Return the number of errors seen.
1266*/
1267static int resolveCompoundOrderBy(
1268 Parse *pParse, /* Parsing context. Leave error messages here */
1269 Select *pSelect /* The SELECT statement containing the ORDER BY */
1270){
1271 int i;
1272 ExprList *pOrderBy;
1273 ExprList *pEList;
1274 sqlite3 *db;
1275 int moreToDo = 1;
1276
1277 pOrderBy = pSelect->pOrderBy;
1278 if( pOrderBy==0 ) return 0;
1279 db = pParse->db;
drh7d10d5a2008-08-20 16:35:10 +00001280 if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
1281 sqlite3ErrorMsg(pParse, "too many terms in ORDER BY clause");
1282 return 1;
1283 }
drh7d10d5a2008-08-20 16:35:10 +00001284 for(i=0; i<pOrderBy->nExpr; i++){
1285 pOrderBy->a[i].done = 0;
1286 }
1287 pSelect->pNext = 0;
1288 while( pSelect->pPrior ){
1289 pSelect->pPrior->pNext = pSelect;
1290 pSelect = pSelect->pPrior;
1291 }
1292 while( pSelect && moreToDo ){
1293 struct ExprList_item *pItem;
1294 moreToDo = 0;
1295 pEList = pSelect->pEList;
drh0a846f92008-08-25 17:23:29 +00001296 assert( pEList!=0 );
drh7d10d5a2008-08-20 16:35:10 +00001297 for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
1298 int iCol = -1;
1299 Expr *pE, *pDup;
1300 if( pItem->done ) continue;
drh0d950af2019-08-22 16:38:42 +00001301 pE = sqlite3ExprSkipCollateAndLikely(pItem->pExpr);
drh235667a2020-11-08 20:44:30 +00001302 if( NEVER(pE==0) ) continue;
drh7d10d5a2008-08-20 16:35:10 +00001303 if( sqlite3ExprIsInteger(pE, &iCol) ){
drh73c0fdc2009-06-15 18:32:36 +00001304 if( iCol<=0 || iCol>pEList->nExpr ){
drh7d10d5a2008-08-20 16:35:10 +00001305 resolveOutOfRangeError(pParse, "ORDER", i+1, pEList->nExpr);
1306 return 1;
1307 }
1308 }else{
1309 iCol = resolveAsName(pParse, pEList, pE);
1310 if( iCol==0 ){
dan5e970a82019-01-16 14:58:37 +00001311 /* Now test if expression pE matches one of the values returned
1312 ** by pSelect. In the usual case this is done by duplicating the
1313 ** expression, resolving any symbols in it, and then comparing
1314 ** it against each expression returned by the SELECT statement.
1315 ** Once the comparisons are finished, the duplicate expression
1316 ** is deleted.
1317 **
1318 ** Or, if this is running as part of an ALTER TABLE operation,
1319 ** resolve the symbols in the actual expression, not a duplicate.
1320 ** And, if one of the comparisons is successful, leave the expression
1321 ** as is instead of transforming it to an integer as in the usual
1322 ** case. This allows the code in alter.c to modify column
1323 ** refererences within the ORDER BY expression as required. */
1324 if( IN_RENAME_OBJECT ){
1325 pDup = pE;
1326 }else{
1327 pDup = sqlite3ExprDup(db, pE, 0);
1328 }
drh7d10d5a2008-08-20 16:35:10 +00001329 if( !db->mallocFailed ){
1330 assert(pDup);
1331 iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup);
1332 }
dana5f9f422019-01-23 19:50:46 +00001333 if( !IN_RENAME_OBJECT ){
dan5e970a82019-01-16 14:58:37 +00001334 sqlite3ExprDelete(db, pDup);
1335 }
drh7d10d5a2008-08-20 16:35:10 +00001336 }
drh7d10d5a2008-08-20 16:35:10 +00001337 }
1338 if( iCol>0 ){
drhbd13d342012-12-07 21:02:47 +00001339 /* Convert the ORDER BY term into an integer column number iCol,
1340 ** taking care to preserve the COLLATE clause if it exists */
dana5f9f422019-01-23 19:50:46 +00001341 if( !IN_RENAME_OBJECT ){
1342 Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0);
1343 if( pNew==0 ) return 1;
1344 pNew->flags |= EP_IntValue;
1345 pNew->u.iValue = iCol;
1346 if( pItem->pExpr==pE ){
1347 pItem->pExpr = pNew;
1348 }else{
1349 Expr *pParent = pItem->pExpr;
1350 assert( pParent->op==TK_COLLATE );
1351 while( pParent->pLeft->op==TK_COLLATE ) pParent = pParent->pLeft;
1352 assert( pParent->pLeft==pE );
1353 pParent->pLeft = pNew;
1354 }
1355 sqlite3ExprDelete(db, pE);
1356 pItem->u.x.iOrderByCol = (u16)iCol;
drhbd13d342012-12-07 21:02:47 +00001357 }
drh7d10d5a2008-08-20 16:35:10 +00001358 pItem->done = 1;
1359 }else{
1360 moreToDo = 1;
1361 }
1362 }
1363 pSelect = pSelect->pNext;
1364 }
1365 for(i=0; i<pOrderBy->nExpr; i++){
1366 if( pOrderBy->a[i].done==0 ){
1367 sqlite3ErrorMsg(pParse, "%r ORDER BY term does not match any "
1368 "column in the result set", i+1);
1369 return 1;
1370 }
1371 }
1372 return 0;
1373}
1374
1375/*
1376** Check every term in the ORDER BY or GROUP BY clause pOrderBy of
1377** the SELECT statement pSelect. If any term is reference to a
drhc2acc4e2013-11-15 18:15:19 +00001378** result set expression (as determined by the ExprList.a.u.x.iOrderByCol
1379** field) then convert that term into a copy of the corresponding result set
drh7d10d5a2008-08-20 16:35:10 +00001380** column.
1381**
1382** If any errors are detected, add an error message to pParse and
1383** return non-zero. Return zero if no errors are seen.
1384*/
1385int sqlite3ResolveOrderGroupBy(
1386 Parse *pParse, /* Parsing context. Leave error messages here */
1387 Select *pSelect, /* The SELECT statement containing the clause */
1388 ExprList *pOrderBy, /* The ORDER BY or GROUP BY clause to be processed */
1389 const char *zType /* "ORDER" or "GROUP" */
1390){
1391 int i;
1392 sqlite3 *db = pParse->db;
1393 ExprList *pEList;
1394 struct ExprList_item *pItem;
1395
dan71f059c2019-08-01 10:58:46 +00001396 if( pOrderBy==0 || pParse->db->mallocFailed || IN_RENAME_OBJECT ) return 0;
drh7d10d5a2008-08-20 16:35:10 +00001397 if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
1398 sqlite3ErrorMsg(pParse, "too many terms in %s BY clause", zType);
1399 return 1;
1400 }
drh7d10d5a2008-08-20 16:35:10 +00001401 pEList = pSelect->pEList;
drh0a846f92008-08-25 17:23:29 +00001402 assert( pEList!=0 ); /* sqlite3SelectNew() guarantees this */
drh7d10d5a2008-08-20 16:35:10 +00001403 for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
drhc2acc4e2013-11-15 18:15:19 +00001404 if( pItem->u.x.iOrderByCol ){
1405 if( pItem->u.x.iOrderByCol>pEList->nExpr ){
drh7d10d5a2008-08-20 16:35:10 +00001406 resolveOutOfRangeError(pParse, zType, i+1, pEList->nExpr);
1407 return 1;
1408 }
drh31e71472015-02-09 10:20:19 +00001409 resolveAlias(pParse, pEList, pItem->u.x.iOrderByCol-1, pItem->pExpr,
1410 zType,0);
drh7d10d5a2008-08-20 16:35:10 +00001411 }
1412 }
1413 return 0;
1414}
1415
danf030b372019-02-22 19:24:16 +00001416#ifndef SQLITE_OMIT_WINDOWFUNC
1417/*
dan75b08212019-07-22 16:20:03 +00001418** Walker callback for windowRemoveExprFromSelect().
danf030b372019-02-22 19:24:16 +00001419*/
1420static int resolveRemoveWindowsCb(Walker *pWalker, Expr *pExpr){
drh51755a72019-08-08 19:40:29 +00001421 UNUSED_PARAMETER(pWalker);
danf030b372019-02-22 19:24:16 +00001422 if( ExprHasProperty(pExpr, EP_WinFunc) ){
dan75b08212019-07-22 16:20:03 +00001423 Window *pWin = pExpr->y.pWin;
drhe2094572019-07-22 19:01:38 +00001424 sqlite3WindowUnlinkFromSelect(pWin);
danf030b372019-02-22 19:24:16 +00001425 }
1426 return WRC_Continue;
1427}
1428
1429/*
1430** Remove any Window objects owned by the expression pExpr from the
1431** Select.pWin list of Select object pSelect.
1432*/
dan75b08212019-07-22 16:20:03 +00001433static void windowRemoveExprFromSelect(Select *pSelect, Expr *pExpr){
drhfd15e182019-07-20 21:12:31 +00001434 if( pSelect->pWin ){
1435 Walker sWalker;
1436 memset(&sWalker, 0, sizeof(Walker));
1437 sWalker.xExprCallback = resolveRemoveWindowsCb;
1438 sWalker.u.pSelect = pSelect;
1439 sqlite3WalkExpr(&sWalker, pExpr);
1440 }
danf030b372019-02-22 19:24:16 +00001441}
1442#else
dan75b08212019-07-22 16:20:03 +00001443# define windowRemoveExprFromSelect(a, b)
drhfd15e182019-07-20 21:12:31 +00001444#endif /* SQLITE_OMIT_WINDOWFUNC */
danf030b372019-02-22 19:24:16 +00001445
drh7d10d5a2008-08-20 16:35:10 +00001446/*
1447** pOrderBy is an ORDER BY or GROUP BY clause in SELECT statement pSelect.
1448** The Name context of the SELECT statement is pNC. zType is either
1449** "ORDER" or "GROUP" depending on which type of clause pOrderBy is.
1450**
1451** This routine resolves each term of the clause into an expression.
1452** If the order-by term is an integer I between 1 and N (where N is the
1453** number of columns in the result set of the SELECT) then the expression
1454** in the resolution is a copy of the I-th result-set expression. If
drh26080d92013-08-15 14:27:42 +00001455** the order-by term is an identifier that corresponds to the AS-name of
drh7d10d5a2008-08-20 16:35:10 +00001456** a result-set expression, then the term resolves to a copy of the
1457** result-set expression. Otherwise, the expression is resolved in
1458** the usual way - using sqlite3ResolveExprNames().
1459**
1460** This routine returns the number of errors. If errors occur, then
1461** an appropriate error message might be left in pParse. (OOM errors
1462** excepted.)
1463*/
1464static int resolveOrderGroupBy(
1465 NameContext *pNC, /* The name context of the SELECT statement */
1466 Select *pSelect, /* The SELECT statement holding pOrderBy */
1467 ExprList *pOrderBy, /* An ORDER BY or GROUP BY clause to resolve */
1468 const char *zType /* Either "ORDER" or "GROUP", as appropriate */
1469){
drh70331cd2012-04-27 01:09:06 +00001470 int i, j; /* Loop counters */
drh7d10d5a2008-08-20 16:35:10 +00001471 int iCol; /* Column number */
1472 struct ExprList_item *pItem; /* A term of the ORDER BY clause */
1473 Parse *pParse; /* Parsing context */
1474 int nResult; /* Number of terms in the result set */
1475
1476 if( pOrderBy==0 ) return 0;
1477 nResult = pSelect->pEList->nExpr;
1478 pParse = pNC->pParse;
1479 for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
1480 Expr *pE = pItem->pExpr;
drh0d950af2019-08-22 16:38:42 +00001481 Expr *pE2 = sqlite3ExprSkipCollateAndLikely(pE);
drh235667a2020-11-08 20:44:30 +00001482 if( NEVER(pE2==0) ) continue;
drh0af16ab2013-08-15 22:40:21 +00001483 if( zType[0]!='G' ){
1484 iCol = resolveAsName(pParse, pSelect->pEList, pE2);
1485 if( iCol>0 ){
1486 /* If an AS-name match is found, mark this ORDER BY column as being
1487 ** a copy of the iCol-th result-set column. The subsequent call to
1488 ** sqlite3ResolveOrderGroupBy() will convert the expression to a
1489 ** copy of the iCol-th result-set expression. */
drhc2acc4e2013-11-15 18:15:19 +00001490 pItem->u.x.iOrderByCol = (u16)iCol;
drh0af16ab2013-08-15 22:40:21 +00001491 continue;
1492 }
drh7d10d5a2008-08-20 16:35:10 +00001493 }
drhe35463b2013-08-15 20:24:27 +00001494 if( sqlite3ExprIsInteger(pE2, &iCol) ){
drh7d10d5a2008-08-20 16:35:10 +00001495 /* The ORDER BY term is an integer constant. Again, set the column
1496 ** number so that sqlite3ResolveOrderGroupBy() will convert the
1497 ** order-by term to a copy of the result-set expression */
drh85d641f2012-12-07 23:23:53 +00001498 if( iCol<1 || iCol>0xffff ){
drh7d10d5a2008-08-20 16:35:10 +00001499 resolveOutOfRangeError(pParse, zType, i+1, nResult);
1500 return 1;
1501 }
drhc2acc4e2013-11-15 18:15:19 +00001502 pItem->u.x.iOrderByCol = (u16)iCol;
drh7d10d5a2008-08-20 16:35:10 +00001503 continue;
1504 }
1505
1506 /* Otherwise, treat the ORDER BY term as an ordinary expression */
drhc2acc4e2013-11-15 18:15:19 +00001507 pItem->u.x.iOrderByCol = 0;
drh7d10d5a2008-08-20 16:35:10 +00001508 if( sqlite3ResolveExprNames(pNC, pE) ){
1509 return 1;
1510 }
drh70331cd2012-04-27 01:09:06 +00001511 for(j=0; j<pSelect->pEList->nExpr; j++){
dan5aa550c2017-06-24 18:10:29 +00001512 if( sqlite3ExprCompare(0, pE, pSelect->pEList->a[j].pExpr, -1)==0 ){
danf030b372019-02-22 19:24:16 +00001513 /* Since this expresion is being changed into a reference
1514 ** to an identical expression in the result set, remove all Window
1515 ** objects belonging to the expression from the Select.pWin list. */
dan75b08212019-07-22 16:20:03 +00001516 windowRemoveExprFromSelect(pSelect, pE);
drhc2acc4e2013-11-15 18:15:19 +00001517 pItem->u.x.iOrderByCol = j+1;
drh70331cd2012-04-27 01:09:06 +00001518 }
1519 }
drh7d10d5a2008-08-20 16:35:10 +00001520 }
1521 return sqlite3ResolveOrderGroupBy(pParse, pSelect, pOrderBy, zType);
1522}
1523
1524/*
peter.d.reid60ec9142014-09-06 16:39:46 +00001525** Resolve names in the SELECT statement p and all of its descendants.
drh7d10d5a2008-08-20 16:35:10 +00001526*/
1527static int resolveSelectStep(Walker *pWalker, Select *p){
1528 NameContext *pOuterNC; /* Context that contains this SELECT */
1529 NameContext sNC; /* Name context of this SELECT */
1530 int isCompound; /* True if p is a compound select */
1531 int nCompound; /* Number of compound terms processed so far */
1532 Parse *pParse; /* Parsing context */
drh7d10d5a2008-08-20 16:35:10 +00001533 int i; /* Loop counter */
1534 ExprList *pGroupBy; /* The GROUP BY clause */
1535 Select *pLeftmost; /* Left-most of SELECT of a compound */
1536 sqlite3 *db; /* Database connection */
1537
1538
drh0a846f92008-08-25 17:23:29 +00001539 assert( p!=0 );
drh7d10d5a2008-08-20 16:35:10 +00001540 if( p->selFlags & SF_Resolved ){
1541 return WRC_Prune;
1542 }
1543 pOuterNC = pWalker->u.pNC;
1544 pParse = pWalker->pParse;
1545 db = pParse->db;
1546
1547 /* Normally sqlite3SelectExpand() will be called first and will have
1548 ** already expanded this SELECT. However, if this is a subquery within
1549 ** an expression, sqlite3ResolveExprNames() will be called without a
1550 ** prior call to sqlite3SelectExpand(). When that happens, let
1551 ** sqlite3SelectPrep() do all of the processing for this SELECT.
1552 ** sqlite3SelectPrep() will invoke both sqlite3SelectExpand() and
1553 ** this routine in the correct order.
1554 */
1555 if( (p->selFlags & SF_Expanded)==0 ){
1556 sqlite3SelectPrep(pParse, p, pOuterNC);
1557 return (pParse->nErr || db->mallocFailed) ? WRC_Abort : WRC_Prune;
1558 }
1559
1560 isCompound = p->pPrior!=0;
1561 nCompound = 0;
1562 pLeftmost = p;
1563 while( p ){
1564 assert( (p->selFlags & SF_Expanded)!=0 );
1565 assert( (p->selFlags & SF_Resolved)==0 );
1566 p->selFlags |= SF_Resolved;
1567
1568 /* Resolve the expressions in the LIMIT and OFFSET clauses. These
1569 ** are not allowed to refer to any names, so pass an empty NameContext.
1570 */
1571 memset(&sNC, 0, sizeof(sNC));
1572 sNC.pParse = pParse;
dane3bf6322018-06-08 20:58:27 +00001573 sNC.pWinSelect = p;
drh8c0833f2017-11-14 23:48:23 +00001574 if( sqlite3ResolveExprNames(&sNC, p->pLimit) ){
drh7d10d5a2008-08-20 16:35:10 +00001575 return WRC_Abort;
1576 }
danb33c50f2015-04-04 16:43:16 +00001577
1578 /* If the SF_Converted flags is set, then this Select object was
1579 ** was created by the convertCompoundSelectToSubquery() function.
1580 ** In this case the ORDER BY clause (p->pOrderBy) should be resolved
1581 ** as if it were part of the sub-query, not the parent. This block
1582 ** moves the pOrderBy down to the sub-query. It will be moved back
1583 ** after the names have been resolved. */
1584 if( p->selFlags & SF_Converted ){
1585 Select *pSub = p->pSrc->a[0].pSelect;
drha43f02e2015-04-15 06:45:13 +00001586 assert( p->pSrc->nSrc==1 && p->pOrderBy );
danb33c50f2015-04-04 16:43:16 +00001587 assert( pSub->pPrior && pSub->pOrderBy==0 );
1588 pSub->pOrderBy = p->pOrderBy;
1589 p->pOrderBy = 0;
1590 }
drh7d10d5a2008-08-20 16:35:10 +00001591
drh7d10d5a2008-08-20 16:35:10 +00001592 /* Recursively resolve names in all subqueries
1593 */
1594 for(i=0; i<p->pSrc->nSrc; i++){
1595 struct SrcList_item *pItem = &p->pSrc->a[i];
dan781b7ac2019-03-22 13:56:49 +00001596 if( pItem->pSelect && (pItem->pSelect->selFlags & SF_Resolved)==0 ){
danda79cf02011-07-08 16:10:54 +00001597 NameContext *pNC; /* Used to iterate name contexts */
1598 int nRef = 0; /* Refcount for pOuterNC and outer contexts */
drh7d10d5a2008-08-20 16:35:10 +00001599 const char *zSavedContext = pParse->zAuthContext;
danda79cf02011-07-08 16:10:54 +00001600
1601 /* Count the total number of references to pOuterNC and all of its
1602 ** parent contexts. After resolving references to expressions in
1603 ** pItem->pSelect, check if this value has changed. If so, then
1604 ** SELECT statement pItem->pSelect must be correlated. Set the
drh8a48b9c2015-08-19 15:20:00 +00001605 ** pItem->fg.isCorrelated flag if this is the case. */
danda79cf02011-07-08 16:10:54 +00001606 for(pNC=pOuterNC; pNC; pNC=pNC->pNext) nRef += pNC->nRef;
1607
drh7d10d5a2008-08-20 16:35:10 +00001608 if( pItem->zName ) pParse->zAuthContext = pItem->zName;
drhcd2b5612008-12-09 14:03:22 +00001609 sqlite3ResolveSelectNames(pParse, pItem->pSelect, pOuterNC);
drh7d10d5a2008-08-20 16:35:10 +00001610 pParse->zAuthContext = zSavedContext;
1611 if( pParse->nErr || db->mallocFailed ) return WRC_Abort;
danda79cf02011-07-08 16:10:54 +00001612
1613 for(pNC=pOuterNC; pNC; pNC=pNC->pNext) nRef -= pNC->nRef;
drh8a48b9c2015-08-19 15:20:00 +00001614 assert( pItem->fg.isCorrelated==0 && nRef<=0 );
1615 pItem->fg.isCorrelated = (nRef!=0);
drh7d10d5a2008-08-20 16:35:10 +00001616 }
1617 }
1618
drh92689d22012-12-18 16:07:08 +00001619 /* Set up the local name-context to pass to sqlite3ResolveExprNames() to
1620 ** resolve the result-set expression list.
1621 */
dan86fb6e12018-05-16 20:58:07 +00001622 sNC.ncFlags = NC_AllowAgg|NC_AllowWin;
drh92689d22012-12-18 16:07:08 +00001623 sNC.pSrcList = p->pSrc;
1624 sNC.pNext = pOuterNC;
1625
1626 /* Resolve names in the result set. */
drh01d230c2015-08-19 17:11:37 +00001627 if( sqlite3ResolveExprListNames(&sNC, p->pEList) ) return WRC_Abort;
dan86fb6e12018-05-16 20:58:07 +00001628 sNC.ncFlags &= ~NC_AllowWin;
drh92689d22012-12-18 16:07:08 +00001629
drh7d10d5a2008-08-20 16:35:10 +00001630 /* If there are no aggregate functions in the result-set, and no GROUP BY
1631 ** expression, do not allow aggregates in any of the other expressions.
1632 */
1633 assert( (p->selFlags & SF_Aggregate)==0 );
1634 pGroupBy = p->pGroupBy;
drha51009b2012-05-21 19:11:25 +00001635 if( pGroupBy || (sNC.ncFlags & NC_HasAgg)!=0 ){
drh9588ad92014-09-15 14:46:02 +00001636 assert( NC_MinMaxAgg==SF_MinMaxAgg );
1637 p->selFlags |= SF_Aggregate | (sNC.ncFlags&NC_MinMaxAgg);
drh7d10d5a2008-08-20 16:35:10 +00001638 }else{
drha51009b2012-05-21 19:11:25 +00001639 sNC.ncFlags &= ~NC_AllowAgg;
drh7d10d5a2008-08-20 16:35:10 +00001640 }
1641
1642 /* If a HAVING clause is present, then there must be a GROUP BY clause.
1643 */
1644 if( p->pHaving && !pGroupBy ){
1645 sqlite3ErrorMsg(pParse, "a GROUP BY clause is required before HAVING");
1646 return WRC_Abort;
1647 }
1648
drh26080d92013-08-15 14:27:42 +00001649 /* Add the output column list to the name-context before parsing the
drh7d10d5a2008-08-20 16:35:10 +00001650 ** other expressions in the SELECT statement. This is so that
1651 ** expressions in the WHERE clause (etc.) can refer to expressions by
1652 ** aliases in the result set.
1653 **
1654 ** Minor point: If this is the case, then the expression will be
1655 ** re-evaluated for each reference to it.
1656 */
drhd5101972021-02-08 13:41:17 +00001657 assert( (sNC.ncFlags & (NC_UAggInfo|NC_UUpsert|NC_UBaseReg))==0 );
drh25c3b8c2018-04-16 10:34:13 +00001658 sNC.uNC.pEList = p->pEList;
1659 sNC.ncFlags |= NC_UEList;
drh58a450c2013-05-16 01:02:45 +00001660 if( sqlite3ResolveExprNames(&sNC, p->pHaving) ) return WRC_Abort;
drha3a5bd92013-04-13 19:59:58 +00001661 if( sqlite3ResolveExprNames(&sNC, p->pWhere) ) return WRC_Abort;
drh7d10d5a2008-08-20 16:35:10 +00001662
drh01d230c2015-08-19 17:11:37 +00001663 /* Resolve names in table-valued-function arguments */
1664 for(i=0; i<p->pSrc->nSrc; i++){
1665 struct SrcList_item *pItem = &p->pSrc->a[i];
1666 if( pItem->fg.isTabFunc
1667 && sqlite3ResolveExprListNames(&sNC, pItem->u1.pFuncArg)
1668 ){
1669 return WRC_Abort;
1670 }
1671 }
1672
drh7d10d5a2008-08-20 16:35:10 +00001673 /* The ORDER BY and GROUP BY clauses may not refer to terms in
1674 ** outer queries
1675 */
1676 sNC.pNext = 0;
dan86fb6e12018-05-16 20:58:07 +00001677 sNC.ncFlags |= NC_AllowAgg|NC_AllowWin;
drh7d10d5a2008-08-20 16:35:10 +00001678
danb33c50f2015-04-04 16:43:16 +00001679 /* If this is a converted compound query, move the ORDER BY clause from
1680 ** the sub-query back to the parent query. At this point each term
1681 ** within the ORDER BY clause has been transformed to an integer value.
1682 ** These integers will be replaced by copies of the corresponding result
1683 ** set expressions by the call to resolveOrderGroupBy() below. */
1684 if( p->selFlags & SF_Converted ){
1685 Select *pSub = p->pSrc->a[0].pSelect;
1686 p->pOrderBy = pSub->pOrderBy;
1687 pSub->pOrderBy = 0;
1688 }
1689
drh7d10d5a2008-08-20 16:35:10 +00001690 /* Process the ORDER BY clause for singleton SELECT statements.
1691 ** The ORDER BY clause for compounds SELECT statements is handled
1692 ** below, after all of the result-sets for all of the elements of
1693 ** the compound have been resolved.
drh7b4da152015-04-17 18:52:37 +00001694 **
1695 ** If there is an ORDER BY clause on a term of a compound-select other
1696 ** than the right-most term, then that is a syntax error. But the error
1697 ** is not detected until much later, and so we need to go ahead and
1698 ** resolve those symbols on the incorrect ORDER BY for consistency.
drh7d10d5a2008-08-20 16:35:10 +00001699 */
drh7b4da152015-04-17 18:52:37 +00001700 if( isCompound<=nCompound /* Defer right-most ORDER BY of a compound */
1701 && resolveOrderGroupBy(&sNC, p, p->pOrderBy, "ORDER")
1702 ){
drh7d10d5a2008-08-20 16:35:10 +00001703 return WRC_Abort;
1704 }
1705 if( db->mallocFailed ){
1706 return WRC_Abort;
1707 }
dan86fb6e12018-05-16 20:58:07 +00001708 sNC.ncFlags &= ~NC_AllowWin;
drh7d10d5a2008-08-20 16:35:10 +00001709
1710 /* Resolve the GROUP BY clause. At the same time, make sure
1711 ** the GROUP BY clause does not contain aggregate functions.
1712 */
1713 if( pGroupBy ){
1714 struct ExprList_item *pItem;
1715
1716 if( resolveOrderGroupBy(&sNC, p, pGroupBy, "GROUP") || db->mallocFailed ){
1717 return WRC_Abort;
1718 }
1719 for(i=0, pItem=pGroupBy->a; i<pGroupBy->nExpr; i++, pItem++){
1720 if( ExprHasProperty(pItem->pExpr, EP_Agg) ){
1721 sqlite3ErrorMsg(pParse, "aggregate functions are not allowed in "
1722 "the GROUP BY clause");
1723 return WRC_Abort;
1724 }
1725 }
1726 }
1727
dan8cd2e4a2019-02-11 11:34:01 +00001728#ifndef SQLITE_OMIT_WINDOWFUNC
dand9995032019-01-23 16:59:24 +00001729 if( IN_RENAME_OBJECT ){
1730 Window *pWin;
1731 for(pWin=p->pWinDefn; pWin; pWin=pWin->pNextWin){
1732 if( sqlite3ResolveExprListNames(&sNC, pWin->pOrderBy)
1733 || sqlite3ResolveExprListNames(&sNC, pWin->pPartition)
1734 ){
1735 return WRC_Abort;
1736 }
1737 }
1738 }
dan8cd2e4a2019-02-11 11:34:01 +00001739#endif
dand9995032019-01-23 16:59:24 +00001740
dan923cadb2015-06-23 12:19:55 +00001741 /* If this is part of a compound SELECT, check that it has the right
1742 ** number of expressions in the select list. */
1743 if( p->pNext && p->pEList->nExpr!=p->pNext->pEList->nExpr ){
1744 sqlite3SelectWrongNumTermsError(pParse, p->pNext);
1745 return WRC_Abort;
1746 }
1747
drh7d10d5a2008-08-20 16:35:10 +00001748 /* Advance to the next term of the compound
1749 */
1750 p = p->pPrior;
1751 nCompound++;
1752 }
1753
1754 /* Resolve the ORDER BY on a compound SELECT after all terms of
1755 ** the compound have been resolved.
1756 */
1757 if( isCompound && resolveCompoundOrderBy(pParse, pLeftmost) ){
1758 return WRC_Abort;
1759 }
1760
1761 return WRC_Prune;
1762}
1763
1764/*
1765** This routine walks an expression tree and resolves references to
1766** table columns and result-set columns. At the same time, do error
1767** checking on function usage and set a flag if any aggregate functions
1768** are seen.
1769**
1770** To resolve table columns references we look for nodes (or subtrees) of the
1771** form X.Y.Z or Y.Z or just Z where
1772**
1773** X: The name of a database. Ex: "main" or "temp" or
1774** the symbolic name assigned to an ATTACH-ed database.
1775**
1776** Y: The name of a table in a FROM clause. Or in a trigger
1777** one of the special names "old" or "new".
1778**
1779** Z: The name of a column in table Y.
1780**
1781** The node at the root of the subtree is modified as follows:
1782**
1783** Expr.op Changed to TK_COLUMN
1784** Expr.pTab Points to the Table object for X.Y
1785** Expr.iColumn The column index in X.Y. -1 for the rowid.
1786** Expr.iTable The VDBE cursor number for X.Y
1787**
1788**
1789** To resolve result-set references, look for expression nodes of the
1790** form Z (with no X and Y prefix) where the Z matches the right-hand
1791** size of an AS clause in the result-set of a SELECT. The Z expression
1792** is replaced by a copy of the left-hand side of the result-set expression.
1793** Table-name and function resolution occurs on the substituted expression
1794** tree. For example, in:
1795**
1796** SELECT a+b AS x, c+d AS y FROM t1 ORDER BY x;
1797**
1798** The "x" term of the order by is replaced by "a+b" to render:
1799**
1800** SELECT a+b AS x, c+d AS y FROM t1 ORDER BY a+b;
1801**
1802** Function calls are checked to make sure that the function is
1803** defined and that the correct number of arguments are specified.
drha51009b2012-05-21 19:11:25 +00001804** If the function is an aggregate function, then the NC_HasAgg flag is
drh7d10d5a2008-08-20 16:35:10 +00001805** set and the opcode is changed from TK_FUNCTION to TK_AGG_FUNCTION.
1806** If an expression contains aggregate functions then the EP_Agg
1807** property on the expression is set.
1808**
1809** An error message is left in pParse if anything is amiss. The number
1810** if errors is returned.
1811*/
1812int sqlite3ResolveExprNames(
1813 NameContext *pNC, /* Namespace to resolve expressions in. */
1814 Expr *pExpr /* The expression to be analyzed. */
1815){
dan0d925712019-05-20 17:14:25 +00001816 int savedHasAgg;
drh7d10d5a2008-08-20 16:35:10 +00001817 Walker w;
1818
drhd03257c2017-05-31 00:49:40 +00001819 if( pExpr==0 ) return SQLITE_OK;
dan4ded26a2019-03-28 16:15:05 +00001820 savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
1821 pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
drh9bfb0242016-01-20 02:21:50 +00001822 w.pParse = pNC->pParse;
drh7d10d5a2008-08-20 16:35:10 +00001823 w.xExprCallback = resolveExprStep;
1824 w.xSelectCallback = resolveSelectStep;
drh9bfb0242016-01-20 02:21:50 +00001825 w.xSelectCallback2 = 0;
drh7d10d5a2008-08-20 16:35:10 +00001826 w.u.pNC = pNC;
drhd03257c2017-05-31 00:49:40 +00001827#if SQLITE_MAX_EXPR_DEPTH>0
1828 w.pParse->nHeight += pExpr->nHeight;
1829 if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){
1830 return SQLITE_ERROR;
1831 }
1832#endif
drh7d10d5a2008-08-20 16:35:10 +00001833 sqlite3WalkExpr(&w, pExpr);
1834#if SQLITE_MAX_EXPR_DEPTH>0
drhd03257c2017-05-31 00:49:40 +00001835 w.pParse->nHeight -= pExpr->nHeight;
drh7d10d5a2008-08-20 16:35:10 +00001836#endif
drhd137f4e2019-03-29 01:15:11 +00001837 assert( EP_Agg==NC_HasAgg );
1838 assert( EP_Win==NC_HasWin );
1839 testcase( pNC->ncFlags & NC_HasAgg );
1840 testcase( pNC->ncFlags & NC_HasWin );
1841 ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) );
drh9588ad92014-09-15 14:46:02 +00001842 pNC->ncFlags |= savedHasAgg;
drhd03257c2017-05-31 00:49:40 +00001843 return pNC->nErr>0 || w.pParse->nErr>0;
drh7d10d5a2008-08-20 16:35:10 +00001844}
drh7d10d5a2008-08-20 16:35:10 +00001845
drh01d230c2015-08-19 17:11:37 +00001846/*
1847** Resolve all names for all expression in an expression list. This is
1848** just like sqlite3ResolveExprNames() except that it works for an expression
1849** list rather than a single expression.
1850*/
1851int sqlite3ResolveExprListNames(
1852 NameContext *pNC, /* Namespace to resolve expressions in. */
1853 ExprList *pList /* The expression list to be analyzed. */
1854){
drhd8b1bfc2015-08-20 23:21:34 +00001855 int i;
drh4047bdf2020-04-06 20:35:52 +00001856 int savedHasAgg = 0;
1857 Walker w;
1858 if( pList==0 ) return WRC_Continue;
1859 w.pParse = pNC->pParse;
1860 w.xExprCallback = resolveExprStep;
1861 w.xSelectCallback = resolveSelectStep;
1862 w.xSelectCallback2 = 0;
1863 w.u.pNC = pNC;
1864 savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
1865 pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
1866 for(i=0; i<pList->nExpr; i++){
1867 Expr *pExpr = pList->a[i].pExpr;
1868 if( pExpr==0 ) continue;
1869#if SQLITE_MAX_EXPR_DEPTH>0
1870 w.pParse->nHeight += pExpr->nHeight;
1871 if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){
1872 return WRC_Abort;
drh20292312015-11-21 13:24:46 +00001873 }
drh4047bdf2020-04-06 20:35:52 +00001874#endif
1875 sqlite3WalkExpr(&w, pExpr);
1876#if SQLITE_MAX_EXPR_DEPTH>0
1877 w.pParse->nHeight -= pExpr->nHeight;
1878#endif
1879 assert( EP_Agg==NC_HasAgg );
1880 assert( EP_Win==NC_HasWin );
1881 testcase( pNC->ncFlags & NC_HasAgg );
1882 testcase( pNC->ncFlags & NC_HasWin );
1883 if( pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin) ){
1884 ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) );
1885 savedHasAgg |= pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
1886 pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
1887 }
1888 if( pNC->nErr>0 || w.pParse->nErr>0 ) return WRC_Abort;
drh01d230c2015-08-19 17:11:37 +00001889 }
drh4047bdf2020-04-06 20:35:52 +00001890 pNC->ncFlags |= savedHasAgg;
drh01d230c2015-08-19 17:11:37 +00001891 return WRC_Continue;
1892}
drh7d10d5a2008-08-20 16:35:10 +00001893
1894/*
1895** Resolve all names in all expressions of a SELECT and in all
1896** decendents of the SELECT, including compounds off of p->pPrior,
1897** subqueries in expressions, and subqueries used as FROM clause
1898** terms.
1899**
1900** See sqlite3ResolveExprNames() for a description of the kinds of
1901** transformations that occur.
1902**
1903** All SELECT statements should have been expanded using
1904** sqlite3SelectExpand() prior to invoking this routine.
1905*/
1906void sqlite3ResolveSelectNames(
1907 Parse *pParse, /* The parser context */
1908 Select *p, /* The SELECT statement being coded. */
1909 NameContext *pOuterNC /* Name context for parent SELECT statement */
1910){
1911 Walker w;
1912
drh0a846f92008-08-25 17:23:29 +00001913 assert( p!=0 );
1914 w.xExprCallback = resolveExprStep;
1915 w.xSelectCallback = resolveSelectStep;
drh979dd1b2017-05-29 14:26:07 +00001916 w.xSelectCallback2 = 0;
drh0a846f92008-08-25 17:23:29 +00001917 w.pParse = pParse;
1918 w.u.pNC = pOuterNC;
1919 sqlite3WalkSelect(&w, p);
drh7d10d5a2008-08-20 16:35:10 +00001920}
drh3780be12013-07-31 19:05:22 +00001921
1922/*
drhee751fa2019-01-02 14:34:46 +00001923** Resolve names in expressions that can only reference a single table
1924** or which cannot reference any tables at all. Examples:
drh3780be12013-07-31 19:05:22 +00001925**
drh20cee7d2019-10-30 18:50:08 +00001926** "type" flag
1927** ------------
1928** (1) CHECK constraints NC_IsCheck
1929** (2) WHERE clauses on partial indices NC_PartIdx
1930** (3) Expressions in indexes on expressions NC_IdxExpr
1931** (4) Expression arguments to VACUUM INTO. 0
1932** (5) GENERATED ALWAYS as expressions NC_GenCol
drh3780be12013-07-31 19:05:22 +00001933**
drhee751fa2019-01-02 14:34:46 +00001934** In all cases except (4), the Expr.iTable value for Expr.op==TK_COLUMN
1935** nodes of the expression is set to -1 and the Expr.iColumn value is
1936** set to the column number. In case (4), TK_COLUMN nodes cause an error.
drh3780be12013-07-31 19:05:22 +00001937**
1938** Any errors cause an error message to be set in pParse.
1939*/
drhee751fa2019-01-02 14:34:46 +00001940int sqlite3ResolveSelfReference(
drh81f7b372019-10-16 12:18:59 +00001941 Parse *pParse, /* Parsing context */
1942 Table *pTab, /* The table being referenced, or NULL */
1943 int type, /* NC_IsCheck, NC_PartIdx, NC_IdxExpr, NC_GenCol, or 0 */
1944 Expr *pExpr, /* Expression to resolve. May be NULL. */
1945 ExprList *pList /* Expression list to resolve. May be NULL. */
drh3780be12013-07-31 19:05:22 +00001946){
1947 SrcList sSrc; /* Fake SrcList for pParse->pNewTable */
1948 NameContext sNC; /* Name context for pParse->pNewTable */
drhee751fa2019-01-02 14:34:46 +00001949 int rc;
drh3780be12013-07-31 19:05:22 +00001950
drhee751fa2019-01-02 14:34:46 +00001951 assert( type==0 || pTab!=0 );
drh81f7b372019-10-16 12:18:59 +00001952 assert( type==NC_IsCheck || type==NC_PartIdx || type==NC_IdxExpr
1953 || type==NC_GenCol || pTab==0 );
drh3780be12013-07-31 19:05:22 +00001954 memset(&sNC, 0, sizeof(sNC));
1955 memset(&sSrc, 0, sizeof(sSrc));
drhee751fa2019-01-02 14:34:46 +00001956 if( pTab ){
1957 sSrc.nSrc = 1;
1958 sSrc.a[0].zName = pTab->zName;
1959 sSrc.a[0].pTab = pTab;
1960 sSrc.a[0].iCursor = -1;
drh05b32ee2020-01-09 01:20:03 +00001961 if( pTab->pSchema!=pParse->db->aDb[1].pSchema ){
1962 /* Cause EP_FromDDL to be set on TK_FUNCTION nodes of non-TEMP
1963 ** schema elements */
1964 type |= NC_FromDDL;
1965 }
drhee751fa2019-01-02 14:34:46 +00001966 }
drh3780be12013-07-31 19:05:22 +00001967 sNC.pParse = pParse;
1968 sNC.pSrcList = &sSrc;
drhd0ff6012019-06-17 13:56:11 +00001969 sNC.ncFlags = type | NC_IsDDL;
drhee751fa2019-01-02 14:34:46 +00001970 if( (rc = sqlite3ResolveExprNames(&sNC, pExpr))!=SQLITE_OK ) return rc;
1971 if( pList ) rc = sqlite3ResolveExprListNames(&sNC, pList);
1972 return rc;
drh3780be12013-07-31 19:05:22 +00001973}