blob: d88abc4a4b45c0f631278756fe0153659812f8e6 [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/*
drhed551b92012-08-23 19:46:11 +000020** Walk the expression tree pExpr and increase the aggregate function
21** depth (the Expr.op2 field) by N on every TK_AGG_FUNCTION node.
22** This needs to occur when copying a TK_AGG_FUNCTION node from an
23** outer query into an inner subquery.
24**
25** incrAggFunctionDepth(pExpr,n) is the main routine. incrAggDepth(..)
26** is a helper function - a callback for the tree walker.
27*/
28static int incrAggDepth(Walker *pWalker, Expr *pExpr){
drh059b2d52014-10-24 19:28:09 +000029 if( pExpr->op==TK_AGG_FUNCTION ) pExpr->op2 += pWalker->u.n;
drhed551b92012-08-23 19:46:11 +000030 return WRC_Continue;
31}
32static void incrAggFunctionDepth(Expr *pExpr, int N){
33 if( N>0 ){
34 Walker w;
35 memset(&w, 0, sizeof(w));
36 w.xExprCallback = incrAggDepth;
drh059b2d52014-10-24 19:28:09 +000037 w.u.n = N;
drhed551b92012-08-23 19:46:11 +000038 sqlite3WalkExpr(&w, pExpr);
39 }
40}
41
42/*
drh8b213892008-08-29 02:14:02 +000043** Turn the pExpr expression into an alias for the iCol-th column of the
44** result set in pEList.
45**
drh0a8a4062012-12-07 18:38:16 +000046** If the reference is followed by a COLLATE operator, then make sure
47** the COLLATE operator is preserved. For example:
48**
49** SELECT a+b, c+d FROM t1 ORDER BY 1 COLLATE nocase;
50**
51** Should be transformed into:
52**
53** SELECT a+b, c+d FROM t1 ORDER BY (a+b) COLLATE nocase;
54**
drhed551b92012-08-23 19:46:11 +000055** The nSubquery parameter specifies how many levels of subquery the
drh41148f82015-04-23 13:37:05 +000056** alias is removed from the original expression. The usual value is
drhed551b92012-08-23 19:46:11 +000057** zero but it might be more if the alias is contained within a subquery
58** of the original expression. The Expr.op2 field of TK_AGG_FUNCTION
59** structures must be increased by the nSubquery amount.
drh8b213892008-08-29 02:14:02 +000060*/
61static void resolveAlias(
62 Parse *pParse, /* Parsing context */
63 ExprList *pEList, /* A result set */
64 int iCol, /* A column in the result set. 0..pEList->nExpr-1 */
65 Expr *pExpr, /* Transform this into an alias to the result set */
drhed551b92012-08-23 19:46:11 +000066 const char *zType, /* "GROUP" or "ORDER" or "" */
67 int nSubquery /* Number of subqueries that the label is moving */
drh8b213892008-08-29 02:14:02 +000068){
69 Expr *pOrig; /* The iCol-th column of the result set */
70 Expr *pDup; /* Copy of pOrig */
71 sqlite3 *db; /* The database connection */
72
73 assert( iCol>=0 && iCol<pEList->nExpr );
74 pOrig = pEList->a[iCol].pExpr;
75 assert( pOrig!=0 );
drh8b213892008-08-29 02:14:02 +000076 db = pParse->db;
drh0a8a4062012-12-07 18:38:16 +000077 pDup = sqlite3ExprDup(db, pOrig, 0);
drh4344dbd2018-06-02 11:31:15 +000078 if( pDup!=0 ){
79 if( zType[0]!='G' ) incrAggFunctionDepth(pDup, nSubquery);
80 if( pExpr->op==TK_COLLATE ){
81 pDup = sqlite3ExprAddCollateString(pParse, pDup, pExpr->u.zToken);
82 }
danf6963f92009-11-23 14:39:14 +000083
drh4344dbd2018-06-02 11:31:15 +000084 /* Before calling sqlite3ExprDelete(), set the EP_Static flag. This
85 ** prevents ExprDelete() from deleting the Expr structure itself,
86 ** allowing it to be repopulated by the memcpy() on the following line.
87 ** The pExpr->u.zToken might point into memory that will be freed by the
88 ** sqlite3DbFree(db, pDup) on the last line of this block, so be sure to
89 ** make a copy of the token before doing the sqlite3DbFree().
90 */
91 ExprSetProperty(pExpr, EP_Static);
92 sqlite3ExprDelete(db, pExpr);
93 memcpy(pExpr, pDup, sizeof(*pExpr));
94 if( !ExprHasProperty(pExpr, EP_IntValue) && pExpr->u.zToken!=0 ){
95 assert( (pExpr->flags & (EP_Reduced|EP_TokenOnly))==0 );
96 pExpr->u.zToken = sqlite3DbStrDup(db, pExpr->u.zToken);
97 pExpr->flags |= EP_MemToken;
98 }
99 sqlite3DbFree(db, pDup);
drh0a8a4062012-12-07 18:38:16 +0000100 }
drh4344dbd2018-06-02 11:31:15 +0000101 ExprSetProperty(pExpr, EP_Alias);
drh8b213892008-08-29 02:14:02 +0000102}
103
drhe802c5d2011-10-18 18:10:40 +0000104
105/*
106** Return TRUE if the name zCol occurs anywhere in the USING clause.
107**
108** Return FALSE if the USING clause is NULL or if it does not contain
109** zCol.
110*/
111static int nameInUsingClause(IdList *pUsing, const char *zCol){
112 if( pUsing ){
113 int k;
114 for(k=0; k<pUsing->nId; k++){
115 if( sqlite3StrICmp(pUsing->a[k].zName, zCol)==0 ) return 1;
116 }
117 }
118 return 0;
119}
120
drh3e3f1a52013-01-03 00:45:56 +0000121/*
122** Subqueries stores the original database, table and column names for their
123** result sets in ExprList.a[].zSpan, in the form "DATABASE.TABLE.COLUMN".
124** Check to see if the zSpan given to this routine matches the zDb, zTab,
125** and zCol. If any of zDb, zTab, and zCol are NULL then those fields will
126** match anything.
127*/
128int sqlite3MatchSpanName(
129 const char *zSpan,
130 const char *zCol,
131 const char *zTab,
132 const char *zDb
133){
134 int n;
135 for(n=0; ALWAYS(zSpan[n]) && zSpan[n]!='.'; n++){}
drhdd1dd482013-02-26 12:57:42 +0000136 if( zDb && (sqlite3StrNICmp(zSpan, zDb, n)!=0 || zDb[n]!=0) ){
drh3e3f1a52013-01-03 00:45:56 +0000137 return 0;
138 }
139 zSpan += n+1;
140 for(n=0; ALWAYS(zSpan[n]) && zSpan[n]!='.'; n++){}
drhdd1dd482013-02-26 12:57:42 +0000141 if( zTab && (sqlite3StrNICmp(zSpan, zTab, n)!=0 || zTab[n]!=0) ){
drh3e3f1a52013-01-03 00:45:56 +0000142 return 0;
143 }
144 zSpan += n+1;
145 if( zCol && sqlite3StrICmp(zSpan, zCol)!=0 ){
146 return 0;
147 }
148 return 1;
149}
drhe802c5d2011-10-18 18:10:40 +0000150
drh8b213892008-08-29 02:14:02 +0000151/*
drhd0ff6012019-06-17 13:56:11 +0000152** Return TRUE if the double-quoted string mis-feature should be supported.
153*/
154static int areDoubleQuotedStringsEnabled(sqlite3 *db, NameContext *pTopNC){
155 if( db->init.busy ) return 1; /* Always support for legacy schemas */
156 if( pTopNC->ncFlags & NC_IsDDL ){
157 /* Currently parsing a DDL statement */
158 if( sqlite3WritableSchema(db) && (db->flags & SQLITE_DqsDML)!=0 ){
159 return 1;
160 }
161 return (db->flags & SQLITE_DqsDDL)!=0;
162 }else{
163 /* Currently parsing a DML statement */
164 return (db->flags & SQLITE_DqsDML)!=0;
165 }
166}
167
168/*
drh7d10d5a2008-08-20 16:35:10 +0000169** Given the name of a column of the form X.Y.Z or Y.Z or just Z, look up
170** that name in the set of source tables in pSrcList and make the pExpr
171** expression node refer back to that source column. The following changes
172** are made to pExpr:
173**
174** pExpr->iDb Set the index in db->aDb[] of the database X
175** (even if X is implied).
176** pExpr->iTable Set to the cursor number for the table obtained
177** from pSrcList.
drheda079c2018-09-20 19:02:15 +0000178** pExpr->y.pTab Points to the Table structure of X.Y (even if
drh7d10d5a2008-08-20 16:35:10 +0000179** X and/or Y are implied.)
180** pExpr->iColumn Set to the column number within the table.
181** pExpr->op Set to TK_COLUMN.
182** pExpr->pLeft Any expression this points to is deleted
183** pExpr->pRight Any expression this points to is deleted.
184**
drhb7916a72009-05-27 10:31:29 +0000185** The zDb variable is the name of the database (the "X"). This value may be
drh7d10d5a2008-08-20 16:35:10 +0000186** NULL meaning that name is of the form Y.Z or Z. Any available database
drhb7916a72009-05-27 10:31:29 +0000187** can be used. The zTable variable is the name of the table (the "Y"). This
188** value can be NULL if zDb is also NULL. If zTable is NULL it
drh7d10d5a2008-08-20 16:35:10 +0000189** means that the form of the name is Z and that columns from any table
190** can be used.
191**
192** If the name cannot be resolved unambiguously, leave an error message
drhf7828b52009-06-15 23:15:59 +0000193** in pParse and return WRC_Abort. Return WRC_Prune on success.
drh7d10d5a2008-08-20 16:35:10 +0000194*/
195static int lookupName(
196 Parse *pParse, /* The parsing context */
drhb7916a72009-05-27 10:31:29 +0000197 const char *zDb, /* Name of the database containing table, or NULL */
198 const char *zTab, /* Name of table containing column, or NULL */
199 const char *zCol, /* Name of the column. */
drh7d10d5a2008-08-20 16:35:10 +0000200 NameContext *pNC, /* The name context used to resolve the name */
201 Expr *pExpr /* Make this EXPR node point to the selected column */
202){
drhed551b92012-08-23 19:46:11 +0000203 int i, j; /* Loop counters */
drh7d10d5a2008-08-20 16:35:10 +0000204 int cnt = 0; /* Number of matching column names */
205 int cntTab = 0; /* Number of matching table names */
drhed551b92012-08-23 19:46:11 +0000206 int nSubquery = 0; /* How many levels of subquery */
drh7d10d5a2008-08-20 16:35:10 +0000207 sqlite3 *db = pParse->db; /* The database connection */
208 struct SrcList_item *pItem; /* Use for looping over pSrcList items */
209 struct SrcList_item *pMatch = 0; /* The matching pSrcList item */
210 NameContext *pTopNC = pNC; /* First namecontext in the list */
211 Schema *pSchema = 0; /* Schema of the expression */
drheac9fab2018-04-16 13:00:50 +0000212 int eNewExprOp = TK_COLUMN; /* New value for pExpr->op on success */
drh11f9b032013-10-23 17:39:41 +0000213 Table *pTab = 0; /* Table hold the row */
214 Column *pCol; /* A column of pTab */
drh7d10d5a2008-08-20 16:35:10 +0000215
drhb7916a72009-05-27 10:31:29 +0000216 assert( pNC ); /* the name context cannot be NULL. */
217 assert( zCol ); /* The Z in X.Y.Z cannot be NULL */
drhc5cd1242013-09-12 16:50:49 +0000218 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
drh7d10d5a2008-08-20 16:35:10 +0000219
220 /* Initialize the node to no-match */
221 pExpr->iTable = -1;
drhebb6a652013-09-12 23:42:22 +0000222 ExprSetVVAProperty(pExpr, EP_NoReduce);
drh7d10d5a2008-08-20 16:35:10 +0000223
drh8f25d182012-12-19 02:36:45 +0000224 /* Translate the schema name in zDb into a pointer to the corresponding
225 ** schema. If not found, pSchema will remain NULL and nothing will match
226 ** resulting in an appropriate error message toward the end of this routine
227 */
228 if( zDb ){
drh1e7d43c2013-08-02 14:18:18 +0000229 testcase( pNC->ncFlags & NC_PartIdx );
230 testcase( pNC->ncFlags & NC_IsCheck );
231 if( (pNC->ncFlags & (NC_PartIdx|NC_IsCheck))!=0 ){
drh31e71472015-02-09 10:20:19 +0000232 /* Silently ignore database qualifiers inside CHECK constraints and
233 ** partial indices. Do not raise errors because that might break
234 ** legacy and because it does not hurt anything to just ignore the
235 ** database name. */
drh1e7d43c2013-08-02 14:18:18 +0000236 zDb = 0;
237 }else{
238 for(i=0; i<db->nDb; i++){
drh69c33822016-08-18 14:33:11 +0000239 assert( db->aDb[i].zDbSName );
240 if( sqlite3StrICmp(db->aDb[i].zDbSName,zDb)==0 ){
drh1e7d43c2013-08-02 14:18:18 +0000241 pSchema = db->aDb[i].pSchema;
242 break;
243 }
drh8f25d182012-12-19 02:36:45 +0000244 }
245 }
246 }
247
drh7d10d5a2008-08-20 16:35:10 +0000248 /* Start at the inner-most context and move outward until a match is found */
drha92b81f2017-03-07 03:40:48 +0000249 assert( pNC && cnt==0 );
250 do{
drh7d10d5a2008-08-20 16:35:10 +0000251 ExprList *pEList;
252 SrcList *pSrcList = pNC->pSrcList;
253
254 if( pSrcList ){
255 for(i=0, pItem=pSrcList->a; i<pSrcList->nSrc; i++, pItem++){
drh7d10d5a2008-08-20 16:35:10 +0000256 pTab = pItem->pTab;
drhf4366202008-08-25 12:14:08 +0000257 assert( pTab!=0 && pTab->zName!=0 );
drh7d10d5a2008-08-20 16:35:10 +0000258 assert( pTab->nCol>0 );
drh8f25d182012-12-19 02:36:45 +0000259 if( pItem->pSelect && (pItem->pSelect->selFlags & SF_NestedFrom)!=0 ){
drh8f25d182012-12-19 02:36:45 +0000260 int hit = 0;
drh928d9c62013-02-07 09:33:56 +0000261 pEList = pItem->pSelect->pEList;
drh8f25d182012-12-19 02:36:45 +0000262 for(j=0; j<pEList->nExpr; j++){
drh3e3f1a52013-01-03 00:45:56 +0000263 if( sqlite3MatchSpanName(pEList->a[j].zSpan, zCol, zTab, zDb) ){
drh8f25d182012-12-19 02:36:45 +0000264 cnt++;
265 cntTab = 2;
266 pMatch = pItem;
267 pExpr->iColumn = j;
drh38b384a2013-01-03 17:34:28 +0000268 hit = 1;
drh8f25d182012-12-19 02:36:45 +0000269 }
270 }
271 if( hit || zTab==0 ) continue;
272 }
drhc75e09c2013-01-03 16:54:20 +0000273 if( zDb && pTab->pSchema!=pSchema ){
274 continue;
275 }
drh7d10d5a2008-08-20 16:35:10 +0000276 if( zTab ){
drh8f25d182012-12-19 02:36:45 +0000277 const char *zTabName = pItem->zAlias ? pItem->zAlias : pTab->zName;
278 assert( zTabName!=0 );
279 if( sqlite3StrICmp(zTabName, zTab)!=0 ){
280 continue;
drh7d10d5a2008-08-20 16:35:10 +0000281 }
danc9461ec2018-08-29 21:00:16 +0000282 if( IN_RENAME_OBJECT && pItem->zAlias ){
drheda079c2018-09-20 19:02:15 +0000283 sqlite3RenameTokenRemap(pParse, 0, (void*)&pExpr->y.pTab);
danc9461ec2018-08-29 21:00:16 +0000284 }
drh7d10d5a2008-08-20 16:35:10 +0000285 }
286 if( 0==(cntTab++) ){
drh7d10d5a2008-08-20 16:35:10 +0000287 pMatch = pItem;
288 }
289 for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
290 if( sqlite3StrICmp(pCol->zName, zCol)==0 ){
drhe802c5d2011-10-18 18:10:40 +0000291 /* If there has been exactly one prior match and this match
292 ** is for the right-hand table of a NATURAL JOIN or is in a
293 ** USING clause, then skip this match.
294 */
295 if( cnt==1 ){
drh8a48b9c2015-08-19 15:20:00 +0000296 if( pItem->fg.jointype & JT_NATURAL ) continue;
drhe802c5d2011-10-18 18:10:40 +0000297 if( nameInUsingClause(pItem->pUsing, zCol) ) continue;
298 }
drh7d10d5a2008-08-20 16:35:10 +0000299 cnt++;
drh7d10d5a2008-08-20 16:35:10 +0000300 pMatch = pItem;
drh7d10d5a2008-08-20 16:35:10 +0000301 /* Substitute the rowid (column -1) for the INTEGER PRIMARY KEY */
shanecf697392009-06-01 16:53:09 +0000302 pExpr->iColumn = j==pTab->iPKey ? -1 : (i16)j;
drh7d10d5a2008-08-20 16:35:10 +0000303 break;
304 }
305 }
306 }
drh8f25d182012-12-19 02:36:45 +0000307 if( pMatch ){
308 pExpr->iTable = pMatch->iCursor;
drheda079c2018-09-20 19:02:15 +0000309 pExpr->y.pTab = pMatch->pTab;
drh31e71472015-02-09 10:20:19 +0000310 /* RIGHT JOIN not (yet) supported */
drh8a48b9c2015-08-19 15:20:00 +0000311 assert( (pMatch->fg.jointype & JT_RIGHT)==0 );
312 if( (pMatch->fg.jointype & JT_LEFT)!=0 ){
drh72673a22014-12-04 16:27:17 +0000313 ExprSetProperty(pExpr, EP_CanBeNull);
314 }
drheda079c2018-09-20 19:02:15 +0000315 pSchema = pExpr->y.pTab->pSchema;
drh8f25d182012-12-19 02:36:45 +0000316 }
317 } /* if( pSrcList ) */
drh7d10d5a2008-08-20 16:35:10 +0000318
drheac9fab2018-04-16 13:00:50 +0000319#if !defined(SQLITE_OMIT_TRIGGER) || !defined(SQLITE_OMIT_UPSERT)
drh7d10d5a2008-08-20 16:35:10 +0000320 /* If we have not already resolved the name, then maybe
drheac9fab2018-04-16 13:00:50 +0000321 ** it is a new.* or old.* trigger argument reference. Or
322 ** maybe it is an excluded.* from an upsert.
drh7d10d5a2008-08-20 16:35:10 +0000323 */
drheac9fab2018-04-16 13:00:50 +0000324 if( zDb==0 && zTab!=0 && cntTab==0 ){
325 pTab = 0;
326#ifndef SQLITE_OMIT_TRIGGER
327 if( pParse->pTriggerTab!=0 ){
328 int op = pParse->eTriggerOp;
329 assert( op==TK_DELETE || op==TK_UPDATE || op==TK_INSERT );
330 if( op!=TK_DELETE && sqlite3StrICmp("new",zTab) == 0 ){
331 pExpr->iTable = 1;
332 pTab = pParse->pTriggerTab;
333 }else if( op!=TK_INSERT && sqlite3StrICmp("old",zTab)==0 ){
334 pExpr->iTable = 0;
335 pTab = pParse->pTriggerTab;
336 }
drh7d10d5a2008-08-20 16:35:10 +0000337 }
drheac9fab2018-04-16 13:00:50 +0000338#endif /* SQLITE_OMIT_TRIGGER */
339#ifndef SQLITE_OMIT_UPSERT
340 if( (pNC->ncFlags & NC_UUpsert)!=0 ){
341 Upsert *pUpsert = pNC->uNC.pUpsert;
342 if( pUpsert && sqlite3StrICmp("excluded",zTab)==0 ){
343 pTab = pUpsert->pUpsertSrc->a[0].pTab;
344 pExpr->iTable = 2;
345 }
346 }
347#endif /* SQLITE_OMIT_UPSERT */
drh7d10d5a2008-08-20 16:35:10 +0000348
349 if( pTab ){
350 int iCol;
drh7d10d5a2008-08-20 16:35:10 +0000351 pSchema = pTab->pSchema;
352 cntTab++;
drh511717c2013-11-08 17:13:23 +0000353 for(iCol=0, pCol=pTab->aCol; iCol<pTab->nCol; iCol++, pCol++){
drh25e978d2009-12-29 23:39:04 +0000354 if( sqlite3StrICmp(pCol->zName, zCol)==0 ){
355 if( iCol==pTab->iPKey ){
356 iCol = -1;
drh7d10d5a2008-08-20 16:35:10 +0000357 }
drh25e978d2009-12-29 23:39:04 +0000358 break;
drh7d10d5a2008-08-20 16:35:10 +0000359 }
360 }
drhfccda8a2015-05-27 13:06:55 +0000361 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && VisibleRowid(pTab) ){
drhe8a537e2014-08-08 18:26:20 +0000362 /* IMP: R-51414-32910 */
drhbbbb0e82013-11-26 23:27:07 +0000363 iCol = -1;
drh25e978d2009-12-29 23:39:04 +0000364 }
dan2bd93512009-08-31 08:22:46 +0000365 if( iCol<pTab->nCol ){
366 cnt++;
drheac9fab2018-04-16 13:00:50 +0000367#ifndef SQLITE_OMIT_UPSERT
368 if( pExpr->iTable==2 ){
drh99160482018-04-18 01:34:39 +0000369 testcase( iCol==(-1) );
danc9461ec2018-08-29 21:00:16 +0000370 if( IN_RENAME_OBJECT ){
dan85a9d502018-08-24 20:10:22 +0000371 pExpr->iColumn = iCol;
drheda079c2018-09-20 19:02:15 +0000372 pExpr->y.pTab = pTab;
dan85a9d502018-08-24 20:10:22 +0000373 eNewExprOp = TK_COLUMN;
374 }else{
375 pExpr->iTable = pNC->uNC.pUpsert->regData + iCol;
376 eNewExprOp = TK_REGISTER;
377 ExprSetProperty(pExpr, EP_Alias);
378 }
drheac9fab2018-04-16 13:00:50 +0000379 }else
drh0a6259f2018-04-16 13:26:53 +0000380#endif /* SQLITE_OMIT_UPSERT */
drheac9fab2018-04-16 13:00:50 +0000381 {
382#ifndef SQLITE_OMIT_TRIGGER
383 if( iCol<0 ){
drh11949042019-08-05 18:01:42 +0000384 pExpr->affExpr = SQLITE_AFF_INTEGER;
drheac9fab2018-04-16 13:00:50 +0000385 }else if( pExpr->iTable==0 ){
386 testcase( iCol==31 );
387 testcase( iCol==32 );
388 pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
389 }else{
390 testcase( iCol==31 );
391 testcase( iCol==32 );
392 pParse->newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
393 }
drheda079c2018-09-20 19:02:15 +0000394 pExpr->y.pTab = pTab;
drheac9fab2018-04-16 13:00:50 +0000395 pExpr->iColumn = (i16)iCol;
396 eNewExprOp = TK_TRIGGER;
drh0a6259f2018-04-16 13:26:53 +0000397#endif /* SQLITE_OMIT_TRIGGER */
dan2bd93512009-08-31 08:22:46 +0000398 }
dan2bd93512009-08-31 08:22:46 +0000399 }
drh7d10d5a2008-08-20 16:35:10 +0000400 }
401 }
drheac9fab2018-04-16 13:00:50 +0000402#endif /* !defined(SQLITE_OMIT_TRIGGER) || !defined(SQLITE_OMIT_UPSERT) */
drh7d10d5a2008-08-20 16:35:10 +0000403
404 /*
405 ** Perhaps the name is a reference to the ROWID
406 */
drh4cbc54b2015-09-19 03:07:30 +0000407 if( cnt==0
408 && cntTab==1
409 && pMatch
410 && (pNC->ncFlags & NC_IdxExpr)==0
411 && sqlite3IsRowid(zCol)
412 && VisibleRowid(pMatch->pTab)
413 ){
drh7d10d5a2008-08-20 16:35:10 +0000414 cnt = 1;
drh15427272015-12-03 22:33:55 +0000415 pExpr->iColumn = -1;
drh11949042019-08-05 18:01:42 +0000416 pExpr->affExpr = SQLITE_AFF_INTEGER;
drh7d10d5a2008-08-20 16:35:10 +0000417 }
418
419 /*
420 ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z
421 ** might refer to an result-set alias. This happens, for example, when
422 ** we are resolving names in the WHERE clause of the following command:
423 **
424 ** SELECT a+b AS x FROM table WHERE x<10;
425 **
426 ** In cases like this, replace pExpr with a copy of the expression that
427 ** forms the result set entry ("a+b" in the example) and return immediately.
428 ** Note that the expression in the result set should have already been
429 ** resolved by the time the WHERE clause is resolved.
drhe35463b2013-08-15 20:24:27 +0000430 **
431 ** The ability to use an output result-set column in the WHERE, GROUP BY,
drh5579d592015-08-26 14:01:41 +0000432 ** or HAVING clauses, or as part of a larger expression in the ORDER BY
drhe35463b2013-08-15 20:24:27 +0000433 ** clause is not standard SQL. This is a (goofy) SQLite extension, that
drh5579d592015-08-26 14:01:41 +0000434 ** is supported for backwards compatibility only. Hence, we issue a warning
drhe35463b2013-08-15 20:24:27 +0000435 ** on sqlite3_log() whenever the capability is used.
drh7d10d5a2008-08-20 16:35:10 +0000436 */
drh25c3b8c2018-04-16 10:34:13 +0000437 if( (pNC->ncFlags & NC_UEList)!=0
drhe35463b2013-08-15 20:24:27 +0000438 && cnt==0
drh25c3b8c2018-04-16 10:34:13 +0000439 && zTab==0
drha3a5bd92013-04-13 19:59:58 +0000440 ){
drh25c3b8c2018-04-16 10:34:13 +0000441 pEList = pNC->uNC.pEList;
442 assert( pEList!=0 );
drh7d10d5a2008-08-20 16:35:10 +0000443 for(j=0; j<pEList->nExpr; j++){
444 char *zAs = pEList->a[j].zName;
445 if( zAs!=0 && sqlite3StrICmp(zAs, zCol)==0 ){
drh8b213892008-08-29 02:14:02 +0000446 Expr *pOrig;
drh7d10d5a2008-08-20 16:35:10 +0000447 assert( pExpr->pLeft==0 && pExpr->pRight==0 );
danielk19776ab3a2e2009-02-19 14:39:25 +0000448 assert( pExpr->x.pList==0 );
449 assert( pExpr->x.pSelect==0 );
drh7d10d5a2008-08-20 16:35:10 +0000450 pOrig = pEList->a[j].pExpr;
drha51009b2012-05-21 19:11:25 +0000451 if( (pNC->ncFlags&NC_AllowAgg)==0 && ExprHasProperty(pOrig, EP_Agg) ){
drh7d10d5a2008-08-20 16:35:10 +0000452 sqlite3ErrorMsg(pParse, "misuse of aliased aggregate %s", zAs);
drhf7828b52009-06-15 23:15:59 +0000453 return WRC_Abort;
drh7d10d5a2008-08-20 16:35:10 +0000454 }
dan4ded26a2019-03-28 16:15:05 +0000455 if( (pNC->ncFlags&NC_AllowWin)==0 && ExprHasProperty(pOrig, EP_Win) ){
456 sqlite3ErrorMsg(pParse, "misuse of aliased window function %s",zAs);
457 return WRC_Abort;
458 }
dan3bafded2016-11-11 15:49:01 +0000459 if( sqlite3ExprVectorSize(pOrig)!=1 ){
460 sqlite3ErrorMsg(pParse, "row value misused");
461 return WRC_Abort;
462 }
drhed551b92012-08-23 19:46:11 +0000463 resolveAlias(pParse, pEList, j, pExpr, "", nSubquery);
drh7d10d5a2008-08-20 16:35:10 +0000464 cnt = 1;
465 pMatch = 0;
466 assert( zTab==0 && zDb==0 );
danc9461ec2018-08-29 21:00:16 +0000467 if( IN_RENAME_OBJECT ){
dan1b0c5de2018-08-24 16:04:26 +0000468 sqlite3RenameTokenRemap(pParse, 0, (void*)pExpr);
469 }
drhb7916a72009-05-27 10:31:29 +0000470 goto lookupname_end;
drh7d10d5a2008-08-20 16:35:10 +0000471 }
472 }
473 }
474
475 /* Advance to the next name context. The loop will exit when either
476 ** we have a match (cnt>0) or when we run out of name contexts.
477 */
drha92b81f2017-03-07 03:40:48 +0000478 if( cnt ) break;
479 pNC = pNC->pNext;
480 nSubquery++;
481 }while( pNC );
482
drh7d10d5a2008-08-20 16:35:10 +0000483
484 /*
485 ** If X and Y are NULL (in other words if only the column name Z is
486 ** supplied) and the value of Z is enclosed in double-quotes, then
487 ** Z is a string literal if it doesn't match any column names. In that
488 ** case, we need to return right away and not make any changes to
489 ** pExpr.
490 **
491 ** Because no reference was made to outer contexts, the pNC->nRef
492 ** fields are not changed in any context.
493 */
drh007c8432018-02-26 03:20:18 +0000494 if( cnt==0 && zTab==0 ){
drh171d16b2018-02-26 20:15:54 +0000495 assert( pExpr->op==TK_ID );
drhd0ff6012019-06-17 13:56:11 +0000496 if( ExprHasProperty(pExpr,EP_DblQuoted)
497 && areDoubleQuotedStringsEnabled(db, pTopNC)
dan0d925712019-05-20 17:14:25 +0000498 ){
drhec8fc622018-12-06 16:11:14 +0000499 /* If a double-quoted identifier does not match any known column name,
500 ** then treat it as a string.
501 **
502 ** This hack was added in the early days of SQLite in a misguided attempt
503 ** to be compatible with MySQL 3.x, which used double-quotes for strings.
504 ** I now sorely regret putting in this hack. The effect of this hack is
505 ** that misspelled identifier names are silently converted into strings
506 ** rather than causing an error, to the frustration of countless
507 ** programmers. To all those frustrated programmers, my apologies.
508 **
509 ** Someday, I hope to get rid of this hack. Unfortunately there is
510 ** a huge amount of legacy SQL that uses it. So for now, we just
511 ** issue a warning.
512 */
513 sqlite3_log(SQLITE_WARNING,
514 "double-quoted string literal: \"%w\"", zCol);
drh893bd372018-12-07 16:32:11 +0000515#ifdef SQLITE_ENABLE_NORMALIZE
drh1a6c2b12018-12-10 20:01:40 +0000516 sqlite3VdbeAddDblquoteStr(db, pParse->pVdbe, zCol);
drh893bd372018-12-07 16:32:11 +0000517#endif
drh007c8432018-02-26 03:20:18 +0000518 pExpr->op = TK_STRING;
drheda079c2018-09-20 19:02:15 +0000519 pExpr->y.pTab = 0;
drh007c8432018-02-26 03:20:18 +0000520 return WRC_Prune;
521 }
drh171d16b2018-02-26 20:15:54 +0000522 if( sqlite3ExprIdToTrueFalse(pExpr) ){
drh007c8432018-02-26 03:20:18 +0000523 return WRC_Prune;
524 }
drh7d10d5a2008-08-20 16:35:10 +0000525 }
526
527 /*
528 ** cnt==0 means there was not match. cnt>1 means there were two or
529 ** more matches. Either way, we have an error.
530 */
531 if( cnt!=1 ){
532 const char *zErr;
533 zErr = cnt==0 ? "no such column" : "ambiguous column name";
534 if( zDb ){
535 sqlite3ErrorMsg(pParse, "%s: %s.%s.%s", zErr, zDb, zTab, zCol);
536 }else if( zTab ){
537 sqlite3ErrorMsg(pParse, "%s: %s.%s", zErr, zTab, zCol);
538 }else{
539 sqlite3ErrorMsg(pParse, "%s: %s", zErr, zCol);
540 }
dan1db95102010-06-28 10:15:19 +0000541 pParse->checkSchema = 1;
drh7d10d5a2008-08-20 16:35:10 +0000542 pTopNC->nErr++;
543 }
544
545 /* If a column from a table in pSrcList is referenced, then record
546 ** this fact in the pSrcList.a[].colUsed bitmask. Column 0 causes
547 ** bit 0 to be set. Column 1 sets bit 1. And so forth. If the
548 ** column number is greater than the number of bits in the bitmask
549 ** then set the high-order bit of the bitmask.
550 */
danielk19772d2e7bd2009-02-24 10:14:40 +0000551 if( pExpr->iColumn>=0 && pMatch!=0 ){
552 int n = pExpr->iColumn;
553 testcase( n==BMS-1 );
554 if( n>=BMS ){
555 n = BMS-1;
drh7d10d5a2008-08-20 16:35:10 +0000556 }
danielk19772d2e7bd2009-02-24 10:14:40 +0000557 assert( pMatch->iCursor==pExpr->iTable );
558 pMatch->colUsed |= ((Bitmask)1)<<n;
drh7d10d5a2008-08-20 16:35:10 +0000559 }
560
drh7d10d5a2008-08-20 16:35:10 +0000561 /* Clean up and return
562 */
drh7d10d5a2008-08-20 16:35:10 +0000563 sqlite3ExprDelete(db, pExpr->pLeft);
564 pExpr->pLeft = 0;
565 sqlite3ExprDelete(db, pExpr->pRight);
566 pExpr->pRight = 0;
drheac9fab2018-04-16 13:00:50 +0000567 pExpr->op = eNewExprOp;
drhb98a2e32017-07-07 12:43:57 +0000568 ExprSetProperty(pExpr, EP_Leaf);
drhb7916a72009-05-27 10:31:29 +0000569lookupname_end:
drh7d10d5a2008-08-20 16:35:10 +0000570 if( cnt==1 ){
571 assert( pNC!=0 );
drh0b8d2552015-09-05 22:36:07 +0000572 if( !ExprHasProperty(pExpr, EP_Alias) ){
drha3a5bd92013-04-13 19:59:58 +0000573 sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList);
574 }
drh7d10d5a2008-08-20 16:35:10 +0000575 /* Increment the nRef value on all name contexts from TopNC up to
576 ** the point where the name matched. */
577 for(;;){
578 assert( pTopNC!=0 );
579 pTopNC->nRef++;
580 if( pTopNC==pNC ) break;
581 pTopNC = pTopNC->pNext;
582 }
drhf7828b52009-06-15 23:15:59 +0000583 return WRC_Prune;
drh7d10d5a2008-08-20 16:35:10 +0000584 } else {
drhf7828b52009-06-15 23:15:59 +0000585 return WRC_Abort;
drh7d10d5a2008-08-20 16:35:10 +0000586 }
587}
588
589/*
danf7b0b0a2009-10-19 15:52:32 +0000590** Allocate and return a pointer to an expression to load the column iCol
drh9e481652010-04-08 17:35:34 +0000591** from datasource iSrc in SrcList pSrc.
danf7b0b0a2009-10-19 15:52:32 +0000592*/
593Expr *sqlite3CreateColumnExpr(sqlite3 *db, SrcList *pSrc, int iSrc, int iCol){
594 Expr *p = sqlite3ExprAlloc(db, TK_COLUMN, 0, 0);
595 if( p ){
596 struct SrcList_item *pItem = &pSrc->a[iSrc];
drheda079c2018-09-20 19:02:15 +0000597 p->y.pTab = pItem->pTab;
danf7b0b0a2009-10-19 15:52:32 +0000598 p->iTable = pItem->iCursor;
drheda079c2018-09-20 19:02:15 +0000599 if( p->y.pTab->iPKey==iCol ){
danf7b0b0a2009-10-19 15:52:32 +0000600 p->iColumn = -1;
601 }else{
drh8677d302009-11-04 13:17:14 +0000602 p->iColumn = (ynVar)iCol;
drh7caba662010-04-08 15:01:44 +0000603 testcase( iCol==BMS );
604 testcase( iCol==BMS-1 );
danf7b0b0a2009-10-19 15:52:32 +0000605 pItem->colUsed |= ((Bitmask)1)<<(iCol>=BMS ? BMS-1 : iCol);
606 }
danf7b0b0a2009-10-19 15:52:32 +0000607 }
608 return p;
609}
610
611/*
drha514b8e2015-08-25 00:27:06 +0000612** Report an error that an expression is not valid for some set of
drh03bf26d2015-08-31 21:16:36 +0000613** pNC->ncFlags values determined by validMask.
drh3780be12013-07-31 19:05:22 +0000614*/
drha514b8e2015-08-25 00:27:06 +0000615static void notValid(
drh3780be12013-07-31 19:05:22 +0000616 Parse *pParse, /* Leave error message here */
617 NameContext *pNC, /* The name context */
drha514b8e2015-08-25 00:27:06 +0000618 const char *zMsg, /* Type of error */
drh03bf26d2015-08-31 21:16:36 +0000619 int validMask /* Set of contexts for which prohibited */
drh3780be12013-07-31 19:05:22 +0000620){
drha514b8e2015-08-25 00:27:06 +0000621 assert( (validMask&~(NC_IsCheck|NC_PartIdx|NC_IdxExpr))==0 );
drh03bf26d2015-08-31 21:16:36 +0000622 if( (pNC->ncFlags & validMask)!=0 ){
drha514b8e2015-08-25 00:27:06 +0000623 const char *zIn = "partial index WHERE clauses";
624 if( pNC->ncFlags & NC_IdxExpr ) zIn = "index expressions";
drh3780be12013-07-31 19:05:22 +0000625#ifndef SQLITE_OMIT_CHECK
drha514b8e2015-08-25 00:27:06 +0000626 else if( pNC->ncFlags & NC_IsCheck ) zIn = "CHECK constraints";
627#endif
628 sqlite3ErrorMsg(pParse, "%s prohibited in %s", zMsg, zIn);
drh3780be12013-07-31 19:05:22 +0000629 }
630}
drh3780be12013-07-31 19:05:22 +0000631
drhcca9f3d2013-09-06 15:23:29 +0000632/*
633** Expression p should encode a floating point value between 1.0 and 0.0.
634** Return 1024 times this value. Or return -1 if p is not a floating point
635** value between 1.0 and 0.0.
636*/
637static int exprProbability(Expr *p){
638 double r = -1.0;
639 if( p->op!=TK_FLOAT ) return -1;
640 sqlite3AtoF(p->u.zToken, &r, sqlite3Strlen30(p->u.zToken), SQLITE_UTF8);
drh09328c02013-09-11 14:34:58 +0000641 assert( r>=0.0 );
642 if( r>1.0 ) return -1;
drhd05ab6a2014-10-25 13:42:16 +0000643 return (int)(r*134217728.0);
drhcca9f3d2013-09-06 15:23:29 +0000644}
drh3780be12013-07-31 19:05:22 +0000645
646/*
drh7d10d5a2008-08-20 16:35:10 +0000647** This routine is callback for sqlite3WalkExpr().
648**
649** Resolve symbolic names into TK_COLUMN operators for the current
650** node in the expression tree. Return 0 to continue the search down
651** the tree or 2 to abort the tree walk.
652**
653** This routine also does error checking and name resolution for
654** function names. The operator for aggregate functions is changed
655** to TK_AGG_FUNCTION.
656*/
657static int resolveExprStep(Walker *pWalker, Expr *pExpr){
658 NameContext *pNC;
659 Parse *pParse;
660
drh7d10d5a2008-08-20 16:35:10 +0000661 pNC = pWalker->u.pNC;
662 assert( pNC!=0 );
663 pParse = pNC->pParse;
664 assert( pParse==pWalker->pParse );
665
drh7d10d5a2008-08-20 16:35:10 +0000666#ifndef NDEBUG
667 if( pNC->pSrcList && pNC->pSrcList->nAlloc>0 ){
668 SrcList *pSrcList = pNC->pSrcList;
669 int i;
670 for(i=0; i<pNC->pSrcList->nSrc; i++){
671 assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursor<pParse->nTab);
672 }
673 }
674#endif
675 switch( pExpr->op ){
drh41204f12008-10-06 13:54:35 +0000676
shane273f6192008-10-10 04:34:16 +0000677#if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY)
drh41204f12008-10-06 13:54:35 +0000678 /* The special operator TK_ROW means use the rowid for the first
679 ** column in the FROM clause. This is used by the LIMIT and ORDER BY
680 ** clause processing on UPDATE and DELETE statements.
681 */
682 case TK_ROW: {
683 SrcList *pSrcList = pNC->pSrcList;
684 struct SrcList_item *pItem;
685 assert( pSrcList && pSrcList->nSrc==1 );
drh2fba3942017-11-09 03:55:09 +0000686 pItem = pSrcList->a;
dan3b61ebb2017-11-10 20:13:14 +0000687 assert( HasRowid(pItem->pTab) && pItem->pTab->pSelect==0 );
drh41204f12008-10-06 13:54:35 +0000688 pExpr->op = TK_COLUMN;
drheda079c2018-09-20 19:02:15 +0000689 pExpr->y.pTab = pItem->pTab;
drh41204f12008-10-06 13:54:35 +0000690 pExpr->iTable = pItem->iCursor;
691 pExpr->iColumn = -1;
drhaf97c3f2019-08-08 18:49:16 +0000692 pExpr->affExpr = SQLITE_AFF_INTEGER;
drh41204f12008-10-06 13:54:35 +0000693 break;
694 }
drh31e71472015-02-09 10:20:19 +0000695#endif /* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT)
696 && !defined(SQLITE_OMIT_SUBQUERY) */
drh41204f12008-10-06 13:54:35 +0000697
drh3cf48e32017-03-07 03:25:52 +0000698 /* A column name: ID
699 ** Or table name and column name: ID.ID
drh7d10d5a2008-08-20 16:35:10 +0000700 ** Or a database, table and column: ID.ID.ID
drh3cf48e32017-03-07 03:25:52 +0000701 **
702 ** The TK_ID and TK_OUT cases are combined so that there will only
703 ** be one call to lookupName(). Then the compiler will in-line
704 ** lookupName() for a size reduction and performance increase.
drh7d10d5a2008-08-20 16:35:10 +0000705 */
drh3cf48e32017-03-07 03:25:52 +0000706 case TK_ID:
drh7d10d5a2008-08-20 16:35:10 +0000707 case TK_DOT: {
drhb7916a72009-05-27 10:31:29 +0000708 const char *zColumn;
709 const char *zTable;
710 const char *zDb;
drh7d10d5a2008-08-20 16:35:10 +0000711 Expr *pRight;
712
drh3cf48e32017-03-07 03:25:52 +0000713 if( pExpr->op==TK_ID ){
drhb7916a72009-05-27 10:31:29 +0000714 zDb = 0;
drh3cf48e32017-03-07 03:25:52 +0000715 zTable = 0;
716 zColumn = pExpr->u.zToken;
drh7d10d5a2008-08-20 16:35:10 +0000717 }else{
danc9461ec2018-08-29 21:00:16 +0000718 Expr *pLeft = pExpr->pLeft;
drh3cf48e32017-03-07 03:25:52 +0000719 notValid(pParse, pNC, "the \".\" operator", NC_IdxExpr);
720 pRight = pExpr->pRight;
721 if( pRight->op==TK_ID ){
722 zDb = 0;
drh3cf48e32017-03-07 03:25:52 +0000723 }else{
724 assert( pRight->op==TK_DOT );
danc9461ec2018-08-29 21:00:16 +0000725 zDb = pLeft->u.zToken;
726 pLeft = pRight->pLeft;
dancf8f2892018-08-09 20:47:01 +0000727 pRight = pRight->pRight;
728 }
danc9461ec2018-08-29 21:00:16 +0000729 zTable = pLeft->u.zToken;
dancf8f2892018-08-09 20:47:01 +0000730 zColumn = pRight->u.zToken;
danc9461ec2018-08-29 21:00:16 +0000731 if( IN_RENAME_OBJECT ){
dan07e95232018-08-21 16:32:53 +0000732 sqlite3RenameTokenRemap(pParse, (void*)pExpr, (void*)pRight);
drheda079c2018-09-20 19:02:15 +0000733 sqlite3RenameTokenRemap(pParse, (void*)&pExpr->y.pTab, (void*)pLeft);
danc9461ec2018-08-29 21:00:16 +0000734 }
drh7d10d5a2008-08-20 16:35:10 +0000735 }
drhf7828b52009-06-15 23:15:59 +0000736 return lookupName(pParse, zDb, zTable, zColumn, pNC, pExpr);
drh7d10d5a2008-08-20 16:35:10 +0000737 }
738
739 /* Resolve function names
740 */
drh7d10d5a2008-08-20 16:35:10 +0000741 case TK_FUNCTION: {
danielk19776ab3a2e2009-02-19 14:39:25 +0000742 ExprList *pList = pExpr->x.pList; /* The argument list */
743 int n = pList ? pList->nExpr : 0; /* Number of arguments */
drh7d10d5a2008-08-20 16:35:10 +0000744 int no_such_func = 0; /* True if no such function exists */
745 int wrong_num_args = 0; /* True if wrong number of arguments */
746 int is_agg = 0; /* True if is an aggregate function */
drh7d10d5a2008-08-20 16:35:10 +0000747 int nId; /* Number of characters in function name */
748 const char *zId; /* The function name. */
749 FuncDef *pDef; /* Information about the function */
drhea678832008-12-10 19:26:22 +0000750 u8 enc = ENC(pParse->db); /* The database encoding */
dan4ded26a2019-03-28 16:15:05 +0000751 int savedAllowFlags = (pNC->ncFlags & (NC_AllowAgg | NC_AllowWin));
dan4f9adee2019-07-13 16:22:50 +0000752#ifndef SQLITE_OMIT_WINDOWFUNC
753 Window *pWin = (IsWindowFunc(pExpr) ? pExpr->y.pWin : 0);
754#endif
danielk19776ab3a2e2009-02-19 14:39:25 +0000755 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
drh33e619f2009-05-28 01:00:55 +0000756 zId = pExpr->u.zToken;
drhb7916a72009-05-27 10:31:29 +0000757 nId = sqlite3Strlen30(zId);
drh80738d92016-02-15 00:34:16 +0000758 pDef = sqlite3FindFunction(pParse->db, zId, n, enc, 0);
drh7d10d5a2008-08-20 16:35:10 +0000759 if( pDef==0 ){
drh80738d92016-02-15 00:34:16 +0000760 pDef = sqlite3FindFunction(pParse->db, zId, -2, enc, 0);
drh7d10d5a2008-08-20 16:35:10 +0000761 if( pDef==0 ){
762 no_such_func = 1;
763 }else{
764 wrong_num_args = 1;
765 }
766 }else{
drh2d801512016-01-14 22:19:58 +0000767 is_agg = pDef->xFinalize!=0;
drhcca9f3d2013-09-06 15:23:29 +0000768 if( pDef->funcFlags & SQLITE_FUNC_UNLIKELY ){
drha7d6db62019-06-11 21:02:15 +0000769 ExprSetProperty(pExpr, EP_Unlikely);
drhcca9f3d2013-09-06 15:23:29 +0000770 if( n==2 ){
771 pExpr->iTable = exprProbability(pList->a[1].pExpr);
772 if( pExpr->iTable<0 ){
drh31e71472015-02-09 10:20:19 +0000773 sqlite3ErrorMsg(pParse,
774 "second argument to likelihood() must be a "
775 "constant between 0.0 and 1.0");
drhcca9f3d2013-09-06 15:23:29 +0000776 pNC->nErr++;
777 }
778 }else{
drh31e71472015-02-09 10:20:19 +0000779 /* EVIDENCE-OF: R-61304-29449 The unlikely(X) function is
780 ** equivalent to likelihood(X, 0.0625).
781 ** EVIDENCE-OF: R-01283-11636 The unlikely(X) function is
782 ** short-hand for likelihood(X,0.0625).
783 ** EVIDENCE-OF: R-36850-34127 The likely(X) function is short-hand
784 ** for likelihood(X,0.9375).
785 ** EVIDENCE-OF: R-53436-40973 The likely(X) function is equivalent
786 ** to likelihood(X,0.9375). */
drh03202a92014-06-17 16:11:28 +0000787 /* TUNING: unlikely() probability is 0.0625. likely() is 0.9375 */
drhd05ab6a2014-10-25 13:42:16 +0000788 pExpr->iTable = pDef->zName[0]=='u' ? 8388608 : 125829120;
drhcca9f3d2013-09-06 15:23:29 +0000789 }
790 }
drh7d10d5a2008-08-20 16:35:10 +0000791#ifndef SQLITE_OMIT_AUTHORIZATION
drha0daa752016-09-16 11:53:10 +0000792 {
793 int auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0,pDef->zName,0);
794 if( auth!=SQLITE_OK ){
795 if( auth==SQLITE_DENY ){
796 sqlite3ErrorMsg(pParse, "not authorized to use function: %s",
797 pDef->zName);
798 pNC->nErr++;
799 }
800 pExpr->op = TK_NULL;
801 return WRC_Prune;
drh7d10d5a2008-08-20 16:35:10 +0000802 }
drh7d10d5a2008-08-20 16:35:10 +0000803 }
drh9588ad92014-09-15 14:46:02 +0000804#endif
drha7f910b2015-09-01 13:17:17 +0000805 if( pDef->funcFlags & (SQLITE_FUNC_CONSTANT|SQLITE_FUNC_SLOCHNG) ){
drh1d85e402015-08-31 17:34:41 +0000806 /* For the purposes of the EP_ConstFunc flag, date and time
drh03bf26d2015-08-31 21:16:36 +0000807 ** functions and other functions that change slowly are considered
808 ** constant because they are constant for the duration of one query */
drh63f84572015-02-09 14:07:07 +0000809 ExprSetProperty(pExpr,EP_ConstFunc);
drh1d85e402015-08-31 17:34:41 +0000810 }
811 if( (pDef->funcFlags & SQLITE_FUNC_CONSTANT)==0 ){
drha7f910b2015-09-01 13:17:17 +0000812 /* Date/time functions that use 'now', and other functions like
813 ** sqlite_version() that might change over time cannot be used
814 ** in an index. */
drha71c7432016-10-03 18:13:23 +0000815 notValid(pParse, pNC, "non-deterministic functions",
816 NC_IdxExpr|NC_PartIdx);
drh31e71472015-02-09 10:20:19 +0000817 }
drheea8eb62018-11-26 18:09:15 +0000818 if( (pDef->funcFlags & SQLITE_FUNC_INTERNAL)!=0
819 && pParse->nested==0
820 && sqlite3Config.bInternalFunctions==0
821 ){
822 /* Internal-use-only functions are disallowed unless the
823 ** SQL is being compiled using sqlite3NestedParse() */
824 no_such_func = 1;
825 pDef = 0;
826 }
drh7d10d5a2008-08-20 16:35:10 +0000827 }
dan26522d12018-06-11 18:16:51 +0000828
danc9461ec2018-08-29 21:00:16 +0000829 if( 0==IN_RENAME_OBJECT ){
dan67a9b8e2018-06-22 20:51:35 +0000830#ifndef SQLITE_OMIT_WINDOWFUNC
dandabc2682018-08-17 17:18:16 +0000831 assert( is_agg==0 || (pDef->funcFlags & SQLITE_FUNC_MINMAX)
dan7262ca92018-07-02 12:07:32 +0000832 || (pDef->xValue==0 && pDef->xInverse==0)
833 || (pDef->xValue && pDef->xInverse && pDef->xSFunc && pDef->xFinalize)
dan26522d12018-06-11 18:16:51 +0000834 );
dan8117f112019-07-10 20:16:53 +0000835 if( pDef && pDef->xValue==0 && pWin ){
dandabc2682018-08-17 17:18:16 +0000836 sqlite3ErrorMsg(pParse,
837 "%.*s() may not be used as a window function", nId, zId
838 );
839 pNC->nErr++;
840 }else if(
841 (is_agg && (pNC->ncFlags & NC_AllowAgg)==0)
dan8117f112019-07-10 20:16:53 +0000842 || (is_agg && (pDef->funcFlags&SQLITE_FUNC_WINDOW) && !pWin)
843 || (is_agg && pWin && (pNC->ncFlags & NC_AllowWin)==0)
dandabc2682018-08-17 17:18:16 +0000844 ){
845 const char *zType;
dan8117f112019-07-10 20:16:53 +0000846 if( (pDef->funcFlags & SQLITE_FUNC_WINDOW) || pWin ){
dandabc2682018-08-17 17:18:16 +0000847 zType = "window";
848 }else{
849 zType = "aggregate";
850 }
851 sqlite3ErrorMsg(pParse, "misuse of %s function %.*s()",zType,nId,zId);
852 pNC->nErr++;
853 is_agg = 0;
dan26522d12018-06-11 18:16:51 +0000854 }
danc3163072018-06-23 19:29:56 +0000855#else
dandabc2682018-08-17 17:18:16 +0000856 if( (is_agg && (pNC->ncFlags & NC_AllowAgg)==0) ){
857 sqlite3ErrorMsg(pParse,"misuse of aggregate function %.*s()",nId,zId);
858 pNC->nErr++;
859 is_agg = 0;
860 }
danc3163072018-06-23 19:29:56 +0000861#endif
drh3a843f52018-08-25 03:29:34 +0000862 else if( no_such_func && pParse->db->init.busy==0
drhcc153132016-08-04 12:35:17 +0000863#ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
dandabc2682018-08-17 17:18:16 +0000864 && pParse->explain==0
drhcc153132016-08-04 12:35:17 +0000865#endif
dandabc2682018-08-17 17:18:16 +0000866 ){
867 sqlite3ErrorMsg(pParse, "no such function: %.*s", nId, zId);
868 pNC->nErr++;
869 }else if( wrong_num_args ){
870 sqlite3ErrorMsg(pParse,"wrong number of arguments to function %.*s()",
871 nId, zId);
872 pNC->nErr++;
873 }
dan5e61c1b2019-07-13 17:45:25 +0000874#ifndef SQLITE_OMIT_WINDOWFUNC
875 else if( is_agg==0 && ExprHasProperty(pExpr, EP_WinFunc) ){
876 sqlite3ErrorMsg(pParse,
877 "FILTER may not be used with non-aggregate %.*s()",
878 nId, zId
879 );
880 pNC->nErr++;
881 }
882#endif
dandabc2682018-08-17 17:18:16 +0000883 if( is_agg ){
dan4ded26a2019-03-28 16:15:05 +0000884 /* Window functions may not be arguments of aggregate functions.
885 ** Or arguments of other window functions. But aggregate functions
886 ** may be arguments for window functions. */
dan34a7d792018-06-29 20:43:33 +0000887#ifndef SQLITE_OMIT_WINDOWFUNC
dan8117f112019-07-10 20:16:53 +0000888 pNC->ncFlags &= ~(NC_AllowWin | (!pWin ? NC_AllowAgg : 0));
dan34a7d792018-06-29 20:43:33 +0000889#else
dandabc2682018-08-17 17:18:16 +0000890 pNC->ncFlags &= ~NC_AllowAgg;
dan34a7d792018-06-29 20:43:33 +0000891#endif
dandabc2682018-08-17 17:18:16 +0000892 }
danc3163072018-06-23 19:29:56 +0000893 }
dan9bf022d2019-07-19 14:32:42 +0000894#ifndef SQLITE_OMIT_WINDOWFUNC
dan1e602612019-07-22 11:38:43 +0000895 else if( ExprHasProperty(pExpr, EP_WinFunc) ){
dan9bf022d2019-07-19 14:32:42 +0000896 is_agg = 1;
897 }
898#endif
drh7d10d5a2008-08-20 16:35:10 +0000899 sqlite3WalkExprList(pWalker, pList);
drh030796d2012-08-23 16:18:10 +0000900 if( is_agg ){
dan67a9b8e2018-06-22 20:51:35 +0000901#ifndef SQLITE_OMIT_WINDOWFUNC
dan4f9adee2019-07-13 16:22:50 +0000902 if( pWin ){
dane3bf6322018-06-08 20:58:27 +0000903 Select *pSel = pNC->pWinSelect;
dan75b08212019-07-22 16:20:03 +0000904 assert( pWin==pExpr->y.pWin );
dan490e6f22019-04-29 11:27:58 +0000905 if( IN_RENAME_OBJECT==0 ){
dan4f9adee2019-07-13 16:22:50 +0000906 sqlite3WindowUpdate(pParse, pSel->pWinDefn, pWin, pDef);
dan490e6f22019-04-29 11:27:58 +0000907 }
dan4f9adee2019-07-13 16:22:50 +0000908 sqlite3WalkExprList(pWalker, pWin->pPartition);
909 sqlite3WalkExprList(pWalker, pWin->pOrderBy);
910 sqlite3WalkExpr(pWalker, pWin->pFilter);
dane3bf6322018-06-08 20:58:27 +0000911 if( 0==pSel->pWin
dan4f9adee2019-07-13 16:22:50 +0000912 || 0==sqlite3WindowCompare(pParse, pSel->pWin, pWin, 0)
dane2f781b2018-05-17 19:24:08 +0000913 ){
dan75b08212019-07-22 16:20:03 +0000914 pWin->pNextWin = pSel->pWin;
915 if( pSel->pWin ){
916 pSel->pWin->ppThis = &pWin->pNextWin;
917 }
918 pSel->pWin = pWin;
919 pWin->ppThis = &pSel->pWin;
dane2f781b2018-05-17 19:24:08 +0000920 }
dan4ded26a2019-03-28 16:15:05 +0000921 pNC->ncFlags |= NC_HasWin;
dan67a9b8e2018-06-22 20:51:35 +0000922 }else
923#endif /* SQLITE_OMIT_WINDOWFUNC */
924 {
dan86fb6e12018-05-16 20:58:07 +0000925 NameContext *pNC2 = pNC;
926 pExpr->op = TK_AGG_FUNCTION;
927 pExpr->op2 = 0;
dan6ba7ab02019-07-02 11:56:47 +0000928#ifndef SQLITE_OMIT_WINDOWFUNC
dan4f9adee2019-07-13 16:22:50 +0000929 if( ExprHasProperty(pExpr, EP_WinFunc) ){
930 sqlite3WalkExpr(pWalker, pExpr->y.pWin->pFilter);
931 }
dan6ba7ab02019-07-02 11:56:47 +0000932#endif
dan86fb6e12018-05-16 20:58:07 +0000933 while( pNC2 && !sqlite3FunctionUsesThisSrc(pExpr, pNC2->pSrcList) ){
934 pExpr->op2++;
935 pNC2 = pNC2->pNext;
936 }
dan72d1eac2019-08-05 13:19:25 +0000937 assert( pDef!=0 || IN_RENAME_OBJECT );
938 if( pNC2 && pDef ){
dan86fb6e12018-05-16 20:58:07 +0000939 assert( SQLITE_FUNC_MINMAX==NC_MinMaxAgg );
940 testcase( (pDef->funcFlags & SQLITE_FUNC_MINMAX)!=0 );
941 pNC2->ncFlags |= NC_HasAgg | (pDef->funcFlags & SQLITE_FUNC_MINMAX);
drh9588ad92014-09-15 14:46:02 +0000942
dan86fb6e12018-05-16 20:58:07 +0000943 }
drh9588ad92014-09-15 14:46:02 +0000944 }
dan4ded26a2019-03-28 16:15:05 +0000945 pNC->ncFlags |= savedAllowFlags;
drh030796d2012-08-23 16:18:10 +0000946 }
drh7d10d5a2008-08-20 16:35:10 +0000947 /* FIX ME: Compute pExpr->affinity based on the expected return
948 ** type of the function
949 */
950 return WRC_Prune;
951 }
952#ifndef SQLITE_OMIT_SUBQUERY
953 case TK_SELECT:
drh73c0fdc2009-06-15 18:32:36 +0000954 case TK_EXISTS: testcase( pExpr->op==TK_EXISTS );
drh7d10d5a2008-08-20 16:35:10 +0000955#endif
956 case TK_IN: {
drh73c0fdc2009-06-15 18:32:36 +0000957 testcase( pExpr->op==TK_IN );
danielk19776ab3a2e2009-02-19 14:39:25 +0000958 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
drh7d10d5a2008-08-20 16:35:10 +0000959 int nRef = pNC->nRef;
drh03bf26d2015-08-31 21:16:36 +0000960 notValid(pParse, pNC, "subqueries", NC_IsCheck|NC_PartIdx|NC_IdxExpr);
danielk19776ab3a2e2009-02-19 14:39:25 +0000961 sqlite3WalkSelect(pWalker, pExpr->x.pSelect);
drh7d10d5a2008-08-20 16:35:10 +0000962 assert( pNC->nRef>=nRef );
963 if( nRef!=pNC->nRef ){
964 ExprSetProperty(pExpr, EP_VarSelect);
drh91da7072016-05-04 14:45:30 +0000965 pNC->ncFlags |= NC_VarSelect;
drh7d10d5a2008-08-20 16:35:10 +0000966 }
967 }
968 break;
969 }
drh7d10d5a2008-08-20 16:35:10 +0000970 case TK_VARIABLE: {
drh03bf26d2015-08-31 21:16:36 +0000971 notValid(pParse, pNC, "parameters", NC_IsCheck|NC_PartIdx|NC_IdxExpr);
drh7d10d5a2008-08-20 16:35:10 +0000972 break;
973 }
drh007c8432018-02-26 03:20:18 +0000974 case TK_IS:
drh8abed7b2018-02-26 18:49:05 +0000975 case TK_ISNOT: {
dan6ece3532019-06-12 13:49:32 +0000976 Expr *pRight = sqlite3ExprSkipCollate(pExpr->pRight);
drh8abed7b2018-02-26 18:49:05 +0000977 assert( !ExprHasProperty(pExpr, EP_Reduced) );
978 /* Handle special cases of "x IS TRUE", "x IS FALSE", "x IS NOT TRUE",
979 ** and "x IS NOT FALSE". */
dan6ece3532019-06-12 13:49:32 +0000980 if( pRight->op==TK_ID ){
drh8abed7b2018-02-26 18:49:05 +0000981 int rc = resolveExprStep(pWalker, pRight);
drh007c8432018-02-26 03:20:18 +0000982 if( rc==WRC_Abort ) return WRC_Abort;
drh8abed7b2018-02-26 18:49:05 +0000983 if( pRight->op==TK_TRUEFALSE ){
drh8abed7b2018-02-26 18:49:05 +0000984 pExpr->op2 = pExpr->op;
985 pExpr->op = TK_TRUTH;
drh007c8432018-02-26 03:20:18 +0000986 return WRC_Continue;
987 }
988 }
989 /* Fall thru */
drh8abed7b2018-02-26 18:49:05 +0000990 }
dan3bafded2016-11-11 15:49:01 +0000991 case TK_BETWEEN:
drhb29e60c2016-09-05 12:02:34 +0000992 case TK_EQ:
993 case TK_NE:
994 case TK_LT:
995 case TK_LE:
996 case TK_GT:
drh8abed7b2018-02-26 18:49:05 +0000997 case TK_GE: {
drhb29e60c2016-09-05 12:02:34 +0000998 int nLeft, nRight;
999 if( pParse->db->mallocFailed ) break;
drhb29e60c2016-09-05 12:02:34 +00001000 assert( pExpr->pLeft!=0 );
1001 nLeft = sqlite3ExprVectorSize(pExpr->pLeft);
dan3bafded2016-11-11 15:49:01 +00001002 if( pExpr->op==TK_BETWEEN ){
1003 nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[0].pExpr);
1004 if( nRight==nLeft ){
1005 nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[1].pExpr);
1006 }
1007 }else{
1008 assert( pExpr->pRight!=0 );
1009 nRight = sqlite3ExprVectorSize(pExpr->pRight);
1010 }
drhb29e60c2016-09-05 12:02:34 +00001011 if( nLeft!=nRight ){
1012 testcase( pExpr->op==TK_EQ );
1013 testcase( pExpr->op==TK_NE );
1014 testcase( pExpr->op==TK_LT );
1015 testcase( pExpr->op==TK_LE );
1016 testcase( pExpr->op==TK_GT );
1017 testcase( pExpr->op==TK_GE );
1018 testcase( pExpr->op==TK_IS );
1019 testcase( pExpr->op==TK_ISNOT );
dan3bafded2016-11-11 15:49:01 +00001020 testcase( pExpr->op==TK_BETWEEN );
drhb29e60c2016-09-05 12:02:34 +00001021 sqlite3ErrorMsg(pParse, "row value misused");
1022 }
1023 break;
1024 }
drh7d10d5a2008-08-20 16:35:10 +00001025 }
1026 return (pParse->nErr || pParse->db->mallocFailed) ? WRC_Abort : WRC_Continue;
1027}
1028
1029/*
1030** pEList is a list of expressions which are really the result set of the
1031** a SELECT statement. pE is a term in an ORDER BY or GROUP BY clause.
1032** This routine checks to see if pE is a simple identifier which corresponds
1033** to the AS-name of one of the terms of the expression list. If it is,
1034** this routine return an integer between 1 and N where N is the number of
1035** elements in pEList, corresponding to the matching entry. If there is
1036** no match, or if pE is not a simple identifier, then this routine
1037** return 0.
1038**
1039** pEList has been resolved. pE has not.
1040*/
1041static int resolveAsName(
1042 Parse *pParse, /* Parsing context for error messages */
1043 ExprList *pEList, /* List of expressions to scan */
1044 Expr *pE /* Expression we are trying to match */
1045){
1046 int i; /* Loop counter */
1047
shanecf697392009-06-01 16:53:09 +00001048 UNUSED_PARAMETER(pParse);
1049
drh73c0fdc2009-06-15 18:32:36 +00001050 if( pE->op==TK_ID ){
drh33e619f2009-05-28 01:00:55 +00001051 char *zCol = pE->u.zToken;
drh7d10d5a2008-08-20 16:35:10 +00001052 for(i=0; i<pEList->nExpr; i++){
1053 char *zAs = pEList->a[i].zName;
1054 if( zAs!=0 && sqlite3StrICmp(zAs, zCol)==0 ){
drh7d10d5a2008-08-20 16:35:10 +00001055 return i+1;
1056 }
1057 }
drh7d10d5a2008-08-20 16:35:10 +00001058 }
1059 return 0;
1060}
1061
1062/*
1063** pE is a pointer to an expression which is a single term in the
1064** ORDER BY of a compound SELECT. The expression has not been
1065** name resolved.
1066**
1067** At the point this routine is called, we already know that the
1068** ORDER BY term is not an integer index into the result set. That
1069** case is handled by the calling routine.
1070**
1071** Attempt to match pE against result set columns in the left-most
1072** SELECT statement. Return the index i of the matching column,
1073** as an indication to the caller that it should sort by the i-th column.
1074** The left-most column is 1. In other words, the value returned is the
1075** same integer value that would be used in the SQL statement to indicate
1076** the column.
1077**
1078** If there is no match, return 0. Return -1 if an error occurs.
1079*/
1080static int resolveOrderByTermToExprList(
1081 Parse *pParse, /* Parsing context for error messages */
1082 Select *pSelect, /* The SELECT statement with the ORDER BY clause */
1083 Expr *pE /* The specific ORDER BY term */
1084){
1085 int i; /* Loop counter */
1086 ExprList *pEList; /* The columns of the result set */
1087 NameContext nc; /* Name context for resolving pE */
drha7564662010-02-22 19:32:31 +00001088 sqlite3 *db; /* Database connection */
1089 int rc; /* Return code from subprocedures */
1090 u8 savedSuppErr; /* Saved value of db->suppressErr */
drh7d10d5a2008-08-20 16:35:10 +00001091
1092 assert( sqlite3ExprIsInteger(pE, &i)==0 );
1093 pEList = pSelect->pEList;
1094
1095 /* Resolve all names in the ORDER BY term expression
1096 */
1097 memset(&nc, 0, sizeof(nc));
1098 nc.pParse = pParse;
1099 nc.pSrcList = pSelect->pSrc;
drh25c3b8c2018-04-16 10:34:13 +00001100 nc.uNC.pEList = pEList;
1101 nc.ncFlags = NC_AllowAgg|NC_UEList;
drh7d10d5a2008-08-20 16:35:10 +00001102 nc.nErr = 0;
drha7564662010-02-22 19:32:31 +00001103 db = pParse->db;
1104 savedSuppErr = db->suppressErr;
1105 db->suppressErr = 1;
1106 rc = sqlite3ResolveExprNames(&nc, pE);
1107 db->suppressErr = savedSuppErr;
1108 if( rc ) return 0;
drh7d10d5a2008-08-20 16:35:10 +00001109
1110 /* Try to match the ORDER BY expression against an expression
1111 ** in the result set. Return an 1-based index of the matching
1112 ** result-set entry.
1113 */
1114 for(i=0; i<pEList->nExpr; i++){
dan5aa550c2017-06-24 18:10:29 +00001115 if( sqlite3ExprCompare(0, pEList->a[i].pExpr, pE, -1)<2 ){
drh7d10d5a2008-08-20 16:35:10 +00001116 return i+1;
1117 }
1118 }
1119
1120 /* If no match, return 0. */
1121 return 0;
1122}
1123
1124/*
1125** Generate an ORDER BY or GROUP BY term out-of-range error.
1126*/
1127static void resolveOutOfRangeError(
1128 Parse *pParse, /* The error context into which to write the error */
1129 const char *zType, /* "ORDER" or "GROUP" */
1130 int i, /* The index (1-based) of the term out of range */
1131 int mx /* Largest permissible value of i */
1132){
1133 sqlite3ErrorMsg(pParse,
1134 "%r %s BY term out of range - should be "
1135 "between 1 and %d", i, zType, mx);
1136}
1137
1138/*
1139** Analyze the ORDER BY clause in a compound SELECT statement. Modify
1140** each term of the ORDER BY clause is a constant integer between 1
1141** and N where N is the number of columns in the compound SELECT.
1142**
1143** ORDER BY terms that are already an integer between 1 and N are
1144** unmodified. ORDER BY terms that are integers outside the range of
1145** 1 through N generate an error. ORDER BY terms that are expressions
1146** are matched against result set expressions of compound SELECT
1147** beginning with the left-most SELECT and working toward the right.
1148** At the first match, the ORDER BY expression is transformed into
1149** the integer column number.
1150**
1151** Return the number of errors seen.
1152*/
1153static int resolveCompoundOrderBy(
1154 Parse *pParse, /* Parsing context. Leave error messages here */
1155 Select *pSelect /* The SELECT statement containing the ORDER BY */
1156){
1157 int i;
1158 ExprList *pOrderBy;
1159 ExprList *pEList;
1160 sqlite3 *db;
1161 int moreToDo = 1;
1162
1163 pOrderBy = pSelect->pOrderBy;
1164 if( pOrderBy==0 ) return 0;
1165 db = pParse->db;
drh7d10d5a2008-08-20 16:35:10 +00001166 if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
1167 sqlite3ErrorMsg(pParse, "too many terms in ORDER BY clause");
1168 return 1;
1169 }
drh7d10d5a2008-08-20 16:35:10 +00001170 for(i=0; i<pOrderBy->nExpr; i++){
1171 pOrderBy->a[i].done = 0;
1172 }
1173 pSelect->pNext = 0;
1174 while( pSelect->pPrior ){
1175 pSelect->pPrior->pNext = pSelect;
1176 pSelect = pSelect->pPrior;
1177 }
1178 while( pSelect && moreToDo ){
1179 struct ExprList_item *pItem;
1180 moreToDo = 0;
1181 pEList = pSelect->pEList;
drh0a846f92008-08-25 17:23:29 +00001182 assert( pEList!=0 );
drh7d10d5a2008-08-20 16:35:10 +00001183 for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
1184 int iCol = -1;
1185 Expr *pE, *pDup;
1186 if( pItem->done ) continue;
drhbd13d342012-12-07 21:02:47 +00001187 pE = sqlite3ExprSkipCollate(pItem->pExpr);
drh7d10d5a2008-08-20 16:35:10 +00001188 if( sqlite3ExprIsInteger(pE, &iCol) ){
drh73c0fdc2009-06-15 18:32:36 +00001189 if( iCol<=0 || iCol>pEList->nExpr ){
drh7d10d5a2008-08-20 16:35:10 +00001190 resolveOutOfRangeError(pParse, "ORDER", i+1, pEList->nExpr);
1191 return 1;
1192 }
1193 }else{
1194 iCol = resolveAsName(pParse, pEList, pE);
1195 if( iCol==0 ){
dan5e970a82019-01-16 14:58:37 +00001196 /* Now test if expression pE matches one of the values returned
1197 ** by pSelect. In the usual case this is done by duplicating the
1198 ** expression, resolving any symbols in it, and then comparing
1199 ** it against each expression returned by the SELECT statement.
1200 ** Once the comparisons are finished, the duplicate expression
1201 ** is deleted.
1202 **
1203 ** Or, if this is running as part of an ALTER TABLE operation,
1204 ** resolve the symbols in the actual expression, not a duplicate.
1205 ** And, if one of the comparisons is successful, leave the expression
1206 ** as is instead of transforming it to an integer as in the usual
1207 ** case. This allows the code in alter.c to modify column
1208 ** refererences within the ORDER BY expression as required. */
1209 if( IN_RENAME_OBJECT ){
1210 pDup = pE;
1211 }else{
1212 pDup = sqlite3ExprDup(db, pE, 0);
1213 }
drh7d10d5a2008-08-20 16:35:10 +00001214 if( !db->mallocFailed ){
1215 assert(pDup);
1216 iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup);
1217 }
dana5f9f422019-01-23 19:50:46 +00001218 if( !IN_RENAME_OBJECT ){
dan5e970a82019-01-16 14:58:37 +00001219 sqlite3ExprDelete(db, pDup);
1220 }
drh7d10d5a2008-08-20 16:35:10 +00001221 }
drh7d10d5a2008-08-20 16:35:10 +00001222 }
1223 if( iCol>0 ){
drhbd13d342012-12-07 21:02:47 +00001224 /* Convert the ORDER BY term into an integer column number iCol,
1225 ** taking care to preserve the COLLATE clause if it exists */
dana5f9f422019-01-23 19:50:46 +00001226 if( !IN_RENAME_OBJECT ){
1227 Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0);
1228 if( pNew==0 ) return 1;
1229 pNew->flags |= EP_IntValue;
1230 pNew->u.iValue = iCol;
1231 if( pItem->pExpr==pE ){
1232 pItem->pExpr = pNew;
1233 }else{
1234 Expr *pParent = pItem->pExpr;
1235 assert( pParent->op==TK_COLLATE );
1236 while( pParent->pLeft->op==TK_COLLATE ) pParent = pParent->pLeft;
1237 assert( pParent->pLeft==pE );
1238 pParent->pLeft = pNew;
1239 }
1240 sqlite3ExprDelete(db, pE);
1241 pItem->u.x.iOrderByCol = (u16)iCol;
drhbd13d342012-12-07 21:02:47 +00001242 }
drh7d10d5a2008-08-20 16:35:10 +00001243 pItem->done = 1;
1244 }else{
1245 moreToDo = 1;
1246 }
1247 }
1248 pSelect = pSelect->pNext;
1249 }
1250 for(i=0; i<pOrderBy->nExpr; i++){
1251 if( pOrderBy->a[i].done==0 ){
1252 sqlite3ErrorMsg(pParse, "%r ORDER BY term does not match any "
1253 "column in the result set", i+1);
1254 return 1;
1255 }
1256 }
1257 return 0;
1258}
1259
1260/*
1261** Check every term in the ORDER BY or GROUP BY clause pOrderBy of
1262** the SELECT statement pSelect. If any term is reference to a
drhc2acc4e2013-11-15 18:15:19 +00001263** result set expression (as determined by the ExprList.a.u.x.iOrderByCol
1264** field) then convert that term into a copy of the corresponding result set
drh7d10d5a2008-08-20 16:35:10 +00001265** column.
1266**
1267** If any errors are detected, add an error message to pParse and
1268** return non-zero. Return zero if no errors are seen.
1269*/
1270int sqlite3ResolveOrderGroupBy(
1271 Parse *pParse, /* Parsing context. Leave error messages here */
1272 Select *pSelect, /* The SELECT statement containing the clause */
1273 ExprList *pOrderBy, /* The ORDER BY or GROUP BY clause to be processed */
1274 const char *zType /* "ORDER" or "GROUP" */
1275){
1276 int i;
1277 sqlite3 *db = pParse->db;
1278 ExprList *pEList;
1279 struct ExprList_item *pItem;
1280
dan71f059c2019-08-01 10:58:46 +00001281 if( pOrderBy==0 || pParse->db->mallocFailed || IN_RENAME_OBJECT ) return 0;
drh7d10d5a2008-08-20 16:35:10 +00001282 if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
1283 sqlite3ErrorMsg(pParse, "too many terms in %s BY clause", zType);
1284 return 1;
1285 }
drh7d10d5a2008-08-20 16:35:10 +00001286 pEList = pSelect->pEList;
drh0a846f92008-08-25 17:23:29 +00001287 assert( pEList!=0 ); /* sqlite3SelectNew() guarantees this */
drh7d10d5a2008-08-20 16:35:10 +00001288 for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
drhc2acc4e2013-11-15 18:15:19 +00001289 if( pItem->u.x.iOrderByCol ){
1290 if( pItem->u.x.iOrderByCol>pEList->nExpr ){
drh7d10d5a2008-08-20 16:35:10 +00001291 resolveOutOfRangeError(pParse, zType, i+1, pEList->nExpr);
1292 return 1;
1293 }
drh31e71472015-02-09 10:20:19 +00001294 resolveAlias(pParse, pEList, pItem->u.x.iOrderByCol-1, pItem->pExpr,
1295 zType,0);
drh7d10d5a2008-08-20 16:35:10 +00001296 }
1297 }
1298 return 0;
1299}
1300
danf030b372019-02-22 19:24:16 +00001301#ifndef SQLITE_OMIT_WINDOWFUNC
1302/*
dan75b08212019-07-22 16:20:03 +00001303** Walker callback for windowRemoveExprFromSelect().
danf030b372019-02-22 19:24:16 +00001304*/
1305static int resolveRemoveWindowsCb(Walker *pWalker, Expr *pExpr){
drh51755a72019-08-08 19:40:29 +00001306 UNUSED_PARAMETER(pWalker);
danf030b372019-02-22 19:24:16 +00001307 if( ExprHasProperty(pExpr, EP_WinFunc) ){
dan75b08212019-07-22 16:20:03 +00001308 Window *pWin = pExpr->y.pWin;
drhe2094572019-07-22 19:01:38 +00001309 sqlite3WindowUnlinkFromSelect(pWin);
danf030b372019-02-22 19:24:16 +00001310 }
1311 return WRC_Continue;
1312}
1313
1314/*
1315** Remove any Window objects owned by the expression pExpr from the
1316** Select.pWin list of Select object pSelect.
1317*/
dan75b08212019-07-22 16:20:03 +00001318static void windowRemoveExprFromSelect(Select *pSelect, Expr *pExpr){
drhfd15e182019-07-20 21:12:31 +00001319 if( pSelect->pWin ){
1320 Walker sWalker;
1321 memset(&sWalker, 0, sizeof(Walker));
1322 sWalker.xExprCallback = resolveRemoveWindowsCb;
1323 sWalker.u.pSelect = pSelect;
1324 sqlite3WalkExpr(&sWalker, pExpr);
1325 }
danf030b372019-02-22 19:24:16 +00001326}
1327#else
dan75b08212019-07-22 16:20:03 +00001328# define windowRemoveExprFromSelect(a, b)
drhfd15e182019-07-20 21:12:31 +00001329#endif /* SQLITE_OMIT_WINDOWFUNC */
danf030b372019-02-22 19:24:16 +00001330
drh7d10d5a2008-08-20 16:35:10 +00001331/*
1332** pOrderBy is an ORDER BY or GROUP BY clause in SELECT statement pSelect.
1333** The Name context of the SELECT statement is pNC. zType is either
1334** "ORDER" or "GROUP" depending on which type of clause pOrderBy is.
1335**
1336** This routine resolves each term of the clause into an expression.
1337** If the order-by term is an integer I between 1 and N (where N is the
1338** number of columns in the result set of the SELECT) then the expression
1339** in the resolution is a copy of the I-th result-set expression. If
drh26080d92013-08-15 14:27:42 +00001340** the order-by term is an identifier that corresponds to the AS-name of
drh7d10d5a2008-08-20 16:35:10 +00001341** a result-set expression, then the term resolves to a copy of the
1342** result-set expression. Otherwise, the expression is resolved in
1343** the usual way - using sqlite3ResolveExprNames().
1344**
1345** This routine returns the number of errors. If errors occur, then
1346** an appropriate error message might be left in pParse. (OOM errors
1347** excepted.)
1348*/
1349static int resolveOrderGroupBy(
1350 NameContext *pNC, /* The name context of the SELECT statement */
1351 Select *pSelect, /* The SELECT statement holding pOrderBy */
1352 ExprList *pOrderBy, /* An ORDER BY or GROUP BY clause to resolve */
1353 const char *zType /* Either "ORDER" or "GROUP", as appropriate */
1354){
drh70331cd2012-04-27 01:09:06 +00001355 int i, j; /* Loop counters */
drh7d10d5a2008-08-20 16:35:10 +00001356 int iCol; /* Column number */
1357 struct ExprList_item *pItem; /* A term of the ORDER BY clause */
1358 Parse *pParse; /* Parsing context */
1359 int nResult; /* Number of terms in the result set */
1360
1361 if( pOrderBy==0 ) return 0;
1362 nResult = pSelect->pEList->nExpr;
1363 pParse = pNC->pParse;
1364 for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
1365 Expr *pE = pItem->pExpr;
drhe35463b2013-08-15 20:24:27 +00001366 Expr *pE2 = sqlite3ExprSkipCollate(pE);
drh0af16ab2013-08-15 22:40:21 +00001367 if( zType[0]!='G' ){
1368 iCol = resolveAsName(pParse, pSelect->pEList, pE2);
1369 if( iCol>0 ){
1370 /* If an AS-name match is found, mark this ORDER BY column as being
1371 ** a copy of the iCol-th result-set column. The subsequent call to
1372 ** sqlite3ResolveOrderGroupBy() will convert the expression to a
1373 ** copy of the iCol-th result-set expression. */
drhc2acc4e2013-11-15 18:15:19 +00001374 pItem->u.x.iOrderByCol = (u16)iCol;
drh0af16ab2013-08-15 22:40:21 +00001375 continue;
1376 }
drh7d10d5a2008-08-20 16:35:10 +00001377 }
drhe35463b2013-08-15 20:24:27 +00001378 if( sqlite3ExprIsInteger(pE2, &iCol) ){
drh7d10d5a2008-08-20 16:35:10 +00001379 /* The ORDER BY term is an integer constant. Again, set the column
1380 ** number so that sqlite3ResolveOrderGroupBy() will convert the
1381 ** order-by term to a copy of the result-set expression */
drh85d641f2012-12-07 23:23:53 +00001382 if( iCol<1 || iCol>0xffff ){
drh7d10d5a2008-08-20 16:35:10 +00001383 resolveOutOfRangeError(pParse, zType, i+1, nResult);
1384 return 1;
1385 }
drhc2acc4e2013-11-15 18:15:19 +00001386 pItem->u.x.iOrderByCol = (u16)iCol;
drh7d10d5a2008-08-20 16:35:10 +00001387 continue;
1388 }
1389
1390 /* Otherwise, treat the ORDER BY term as an ordinary expression */
drhc2acc4e2013-11-15 18:15:19 +00001391 pItem->u.x.iOrderByCol = 0;
drh7d10d5a2008-08-20 16:35:10 +00001392 if( sqlite3ResolveExprNames(pNC, pE) ){
1393 return 1;
1394 }
drh70331cd2012-04-27 01:09:06 +00001395 for(j=0; j<pSelect->pEList->nExpr; j++){
dan5aa550c2017-06-24 18:10:29 +00001396 if( sqlite3ExprCompare(0, pE, pSelect->pEList->a[j].pExpr, -1)==0 ){
danf030b372019-02-22 19:24:16 +00001397 /* Since this expresion is being changed into a reference
1398 ** to an identical expression in the result set, remove all Window
1399 ** objects belonging to the expression from the Select.pWin list. */
dan75b08212019-07-22 16:20:03 +00001400 windowRemoveExprFromSelect(pSelect, pE);
drhc2acc4e2013-11-15 18:15:19 +00001401 pItem->u.x.iOrderByCol = j+1;
drh70331cd2012-04-27 01:09:06 +00001402 }
1403 }
drh7d10d5a2008-08-20 16:35:10 +00001404 }
1405 return sqlite3ResolveOrderGroupBy(pParse, pSelect, pOrderBy, zType);
1406}
1407
1408/*
peter.d.reid60ec9142014-09-06 16:39:46 +00001409** Resolve names in the SELECT statement p and all of its descendants.
drh7d10d5a2008-08-20 16:35:10 +00001410*/
1411static int resolveSelectStep(Walker *pWalker, Select *p){
1412 NameContext *pOuterNC; /* Context that contains this SELECT */
1413 NameContext sNC; /* Name context of this SELECT */
1414 int isCompound; /* True if p is a compound select */
1415 int nCompound; /* Number of compound terms processed so far */
1416 Parse *pParse; /* Parsing context */
drh7d10d5a2008-08-20 16:35:10 +00001417 int i; /* Loop counter */
1418 ExprList *pGroupBy; /* The GROUP BY clause */
1419 Select *pLeftmost; /* Left-most of SELECT of a compound */
1420 sqlite3 *db; /* Database connection */
1421
1422
drh0a846f92008-08-25 17:23:29 +00001423 assert( p!=0 );
drh7d10d5a2008-08-20 16:35:10 +00001424 if( p->selFlags & SF_Resolved ){
1425 return WRC_Prune;
1426 }
1427 pOuterNC = pWalker->u.pNC;
1428 pParse = pWalker->pParse;
1429 db = pParse->db;
1430
1431 /* Normally sqlite3SelectExpand() will be called first and will have
1432 ** already expanded this SELECT. However, if this is a subquery within
1433 ** an expression, sqlite3ResolveExprNames() will be called without a
1434 ** prior call to sqlite3SelectExpand(). When that happens, let
1435 ** sqlite3SelectPrep() do all of the processing for this SELECT.
1436 ** sqlite3SelectPrep() will invoke both sqlite3SelectExpand() and
1437 ** this routine in the correct order.
1438 */
1439 if( (p->selFlags & SF_Expanded)==0 ){
1440 sqlite3SelectPrep(pParse, p, pOuterNC);
1441 return (pParse->nErr || db->mallocFailed) ? WRC_Abort : WRC_Prune;
1442 }
1443
1444 isCompound = p->pPrior!=0;
1445 nCompound = 0;
1446 pLeftmost = p;
1447 while( p ){
1448 assert( (p->selFlags & SF_Expanded)!=0 );
1449 assert( (p->selFlags & SF_Resolved)==0 );
1450 p->selFlags |= SF_Resolved;
1451
1452 /* Resolve the expressions in the LIMIT and OFFSET clauses. These
1453 ** are not allowed to refer to any names, so pass an empty NameContext.
1454 */
1455 memset(&sNC, 0, sizeof(sNC));
1456 sNC.pParse = pParse;
dane3bf6322018-06-08 20:58:27 +00001457 sNC.pWinSelect = p;
drh8c0833f2017-11-14 23:48:23 +00001458 if( sqlite3ResolveExprNames(&sNC, p->pLimit) ){
drh7d10d5a2008-08-20 16:35:10 +00001459 return WRC_Abort;
1460 }
danb33c50f2015-04-04 16:43:16 +00001461
1462 /* If the SF_Converted flags is set, then this Select object was
1463 ** was created by the convertCompoundSelectToSubquery() function.
1464 ** In this case the ORDER BY clause (p->pOrderBy) should be resolved
1465 ** as if it were part of the sub-query, not the parent. This block
1466 ** moves the pOrderBy down to the sub-query. It will be moved back
1467 ** after the names have been resolved. */
1468 if( p->selFlags & SF_Converted ){
1469 Select *pSub = p->pSrc->a[0].pSelect;
drha43f02e2015-04-15 06:45:13 +00001470 assert( p->pSrc->nSrc==1 && p->pOrderBy );
danb33c50f2015-04-04 16:43:16 +00001471 assert( pSub->pPrior && pSub->pOrderBy==0 );
1472 pSub->pOrderBy = p->pOrderBy;
1473 p->pOrderBy = 0;
1474 }
drh7d10d5a2008-08-20 16:35:10 +00001475
drh7d10d5a2008-08-20 16:35:10 +00001476 /* Recursively resolve names in all subqueries
1477 */
1478 for(i=0; i<p->pSrc->nSrc; i++){
1479 struct SrcList_item *pItem = &p->pSrc->a[i];
dan781b7ac2019-03-22 13:56:49 +00001480 if( pItem->pSelect && (pItem->pSelect->selFlags & SF_Resolved)==0 ){
danda79cf02011-07-08 16:10:54 +00001481 NameContext *pNC; /* Used to iterate name contexts */
1482 int nRef = 0; /* Refcount for pOuterNC and outer contexts */
drh7d10d5a2008-08-20 16:35:10 +00001483 const char *zSavedContext = pParse->zAuthContext;
danda79cf02011-07-08 16:10:54 +00001484
1485 /* Count the total number of references to pOuterNC and all of its
1486 ** parent contexts. After resolving references to expressions in
1487 ** pItem->pSelect, check if this value has changed. If so, then
1488 ** SELECT statement pItem->pSelect must be correlated. Set the
drh8a48b9c2015-08-19 15:20:00 +00001489 ** pItem->fg.isCorrelated flag if this is the case. */
danda79cf02011-07-08 16:10:54 +00001490 for(pNC=pOuterNC; pNC; pNC=pNC->pNext) nRef += pNC->nRef;
1491
drh7d10d5a2008-08-20 16:35:10 +00001492 if( pItem->zName ) pParse->zAuthContext = pItem->zName;
drhcd2b5612008-12-09 14:03:22 +00001493 sqlite3ResolveSelectNames(pParse, pItem->pSelect, pOuterNC);
drh7d10d5a2008-08-20 16:35:10 +00001494 pParse->zAuthContext = zSavedContext;
1495 if( pParse->nErr || db->mallocFailed ) return WRC_Abort;
danda79cf02011-07-08 16:10:54 +00001496
1497 for(pNC=pOuterNC; pNC; pNC=pNC->pNext) nRef -= pNC->nRef;
drh8a48b9c2015-08-19 15:20:00 +00001498 assert( pItem->fg.isCorrelated==0 && nRef<=0 );
1499 pItem->fg.isCorrelated = (nRef!=0);
drh7d10d5a2008-08-20 16:35:10 +00001500 }
1501 }
1502
drh92689d22012-12-18 16:07:08 +00001503 /* Set up the local name-context to pass to sqlite3ResolveExprNames() to
1504 ** resolve the result-set expression list.
1505 */
dan86fb6e12018-05-16 20:58:07 +00001506 sNC.ncFlags = NC_AllowAgg|NC_AllowWin;
drh92689d22012-12-18 16:07:08 +00001507 sNC.pSrcList = p->pSrc;
1508 sNC.pNext = pOuterNC;
1509
1510 /* Resolve names in the result set. */
drh01d230c2015-08-19 17:11:37 +00001511 if( sqlite3ResolveExprListNames(&sNC, p->pEList) ) return WRC_Abort;
dan86fb6e12018-05-16 20:58:07 +00001512 sNC.ncFlags &= ~NC_AllowWin;
drh92689d22012-12-18 16:07:08 +00001513
drh7d10d5a2008-08-20 16:35:10 +00001514 /* If there are no aggregate functions in the result-set, and no GROUP BY
1515 ** expression, do not allow aggregates in any of the other expressions.
1516 */
1517 assert( (p->selFlags & SF_Aggregate)==0 );
1518 pGroupBy = p->pGroupBy;
drha51009b2012-05-21 19:11:25 +00001519 if( pGroupBy || (sNC.ncFlags & NC_HasAgg)!=0 ){
drh9588ad92014-09-15 14:46:02 +00001520 assert( NC_MinMaxAgg==SF_MinMaxAgg );
1521 p->selFlags |= SF_Aggregate | (sNC.ncFlags&NC_MinMaxAgg);
drh7d10d5a2008-08-20 16:35:10 +00001522 }else{
drha51009b2012-05-21 19:11:25 +00001523 sNC.ncFlags &= ~NC_AllowAgg;
drh7d10d5a2008-08-20 16:35:10 +00001524 }
1525
1526 /* If a HAVING clause is present, then there must be a GROUP BY clause.
1527 */
1528 if( p->pHaving && !pGroupBy ){
1529 sqlite3ErrorMsg(pParse, "a GROUP BY clause is required before HAVING");
1530 return WRC_Abort;
1531 }
1532
drh26080d92013-08-15 14:27:42 +00001533 /* Add the output column list to the name-context before parsing the
drh7d10d5a2008-08-20 16:35:10 +00001534 ** other expressions in the SELECT statement. This is so that
1535 ** expressions in the WHERE clause (etc.) can refer to expressions by
1536 ** aliases in the result set.
1537 **
1538 ** Minor point: If this is the case, then the expression will be
1539 ** re-evaluated for each reference to it.
1540 */
drheac9fab2018-04-16 13:00:50 +00001541 assert( (sNC.ncFlags & (NC_UAggInfo|NC_UUpsert))==0 );
drh25c3b8c2018-04-16 10:34:13 +00001542 sNC.uNC.pEList = p->pEList;
1543 sNC.ncFlags |= NC_UEList;
drh58a450c2013-05-16 01:02:45 +00001544 if( sqlite3ResolveExprNames(&sNC, p->pHaving) ) return WRC_Abort;
drha3a5bd92013-04-13 19:59:58 +00001545 if( sqlite3ResolveExprNames(&sNC, p->pWhere) ) return WRC_Abort;
drh7d10d5a2008-08-20 16:35:10 +00001546
drh01d230c2015-08-19 17:11:37 +00001547 /* Resolve names in table-valued-function arguments */
1548 for(i=0; i<p->pSrc->nSrc; i++){
1549 struct SrcList_item *pItem = &p->pSrc->a[i];
1550 if( pItem->fg.isTabFunc
1551 && sqlite3ResolveExprListNames(&sNC, pItem->u1.pFuncArg)
1552 ){
1553 return WRC_Abort;
1554 }
1555 }
1556
drh7d10d5a2008-08-20 16:35:10 +00001557 /* The ORDER BY and GROUP BY clauses may not refer to terms in
1558 ** outer queries
1559 */
1560 sNC.pNext = 0;
dan86fb6e12018-05-16 20:58:07 +00001561 sNC.ncFlags |= NC_AllowAgg|NC_AllowWin;
drh7d10d5a2008-08-20 16:35:10 +00001562
danb33c50f2015-04-04 16:43:16 +00001563 /* If this is a converted compound query, move the ORDER BY clause from
1564 ** the sub-query back to the parent query. At this point each term
1565 ** within the ORDER BY clause has been transformed to an integer value.
1566 ** These integers will be replaced by copies of the corresponding result
1567 ** set expressions by the call to resolveOrderGroupBy() below. */
1568 if( p->selFlags & SF_Converted ){
1569 Select *pSub = p->pSrc->a[0].pSelect;
1570 p->pOrderBy = pSub->pOrderBy;
1571 pSub->pOrderBy = 0;
1572 }
1573
drh7d10d5a2008-08-20 16:35:10 +00001574 /* Process the ORDER BY clause for singleton SELECT statements.
1575 ** The ORDER BY clause for compounds SELECT statements is handled
1576 ** below, after all of the result-sets for all of the elements of
1577 ** the compound have been resolved.
drh7b4da152015-04-17 18:52:37 +00001578 **
1579 ** If there is an ORDER BY clause on a term of a compound-select other
1580 ** than the right-most term, then that is a syntax error. But the error
1581 ** is not detected until much later, and so we need to go ahead and
1582 ** resolve those symbols on the incorrect ORDER BY for consistency.
drh7d10d5a2008-08-20 16:35:10 +00001583 */
drh7b4da152015-04-17 18:52:37 +00001584 if( isCompound<=nCompound /* Defer right-most ORDER BY of a compound */
1585 && resolveOrderGroupBy(&sNC, p, p->pOrderBy, "ORDER")
1586 ){
drh7d10d5a2008-08-20 16:35:10 +00001587 return WRC_Abort;
1588 }
1589 if( db->mallocFailed ){
1590 return WRC_Abort;
1591 }
dan86fb6e12018-05-16 20:58:07 +00001592 sNC.ncFlags &= ~NC_AllowWin;
drh7d10d5a2008-08-20 16:35:10 +00001593
1594 /* Resolve the GROUP BY clause. At the same time, make sure
1595 ** the GROUP BY clause does not contain aggregate functions.
1596 */
1597 if( pGroupBy ){
1598 struct ExprList_item *pItem;
1599
1600 if( resolveOrderGroupBy(&sNC, p, pGroupBy, "GROUP") || db->mallocFailed ){
1601 return WRC_Abort;
1602 }
1603 for(i=0, pItem=pGroupBy->a; i<pGroupBy->nExpr; i++, pItem++){
1604 if( ExprHasProperty(pItem->pExpr, EP_Agg) ){
1605 sqlite3ErrorMsg(pParse, "aggregate functions are not allowed in "
1606 "the GROUP BY clause");
1607 return WRC_Abort;
1608 }
1609 }
1610 }
1611
dan8cd2e4a2019-02-11 11:34:01 +00001612#ifndef SQLITE_OMIT_WINDOWFUNC
dand9995032019-01-23 16:59:24 +00001613 if( IN_RENAME_OBJECT ){
1614 Window *pWin;
1615 for(pWin=p->pWinDefn; pWin; pWin=pWin->pNextWin){
1616 if( sqlite3ResolveExprListNames(&sNC, pWin->pOrderBy)
1617 || sqlite3ResolveExprListNames(&sNC, pWin->pPartition)
1618 ){
1619 return WRC_Abort;
1620 }
1621 }
1622 }
dan8cd2e4a2019-02-11 11:34:01 +00001623#endif
dand9995032019-01-23 16:59:24 +00001624
dan923cadb2015-06-23 12:19:55 +00001625 /* If this is part of a compound SELECT, check that it has the right
1626 ** number of expressions in the select list. */
1627 if( p->pNext && p->pEList->nExpr!=p->pNext->pEList->nExpr ){
1628 sqlite3SelectWrongNumTermsError(pParse, p->pNext);
1629 return WRC_Abort;
1630 }
1631
drh7d10d5a2008-08-20 16:35:10 +00001632 /* Advance to the next term of the compound
1633 */
1634 p = p->pPrior;
1635 nCompound++;
1636 }
1637
1638 /* Resolve the ORDER BY on a compound SELECT after all terms of
1639 ** the compound have been resolved.
1640 */
1641 if( isCompound && resolveCompoundOrderBy(pParse, pLeftmost) ){
1642 return WRC_Abort;
1643 }
1644
1645 return WRC_Prune;
1646}
1647
1648/*
1649** This routine walks an expression tree and resolves references to
1650** table columns and result-set columns. At the same time, do error
1651** checking on function usage and set a flag if any aggregate functions
1652** are seen.
1653**
1654** To resolve table columns references we look for nodes (or subtrees) of the
1655** form X.Y.Z or Y.Z or just Z where
1656**
1657** X: The name of a database. Ex: "main" or "temp" or
1658** the symbolic name assigned to an ATTACH-ed database.
1659**
1660** Y: The name of a table in a FROM clause. Or in a trigger
1661** one of the special names "old" or "new".
1662**
1663** Z: The name of a column in table Y.
1664**
1665** The node at the root of the subtree is modified as follows:
1666**
1667** Expr.op Changed to TK_COLUMN
1668** Expr.pTab Points to the Table object for X.Y
1669** Expr.iColumn The column index in X.Y. -1 for the rowid.
1670** Expr.iTable The VDBE cursor number for X.Y
1671**
1672**
1673** To resolve result-set references, look for expression nodes of the
1674** form Z (with no X and Y prefix) where the Z matches the right-hand
1675** size of an AS clause in the result-set of a SELECT. The Z expression
1676** is replaced by a copy of the left-hand side of the result-set expression.
1677** Table-name and function resolution occurs on the substituted expression
1678** tree. For example, in:
1679**
1680** SELECT a+b AS x, c+d AS y FROM t1 ORDER BY x;
1681**
1682** The "x" term of the order by is replaced by "a+b" to render:
1683**
1684** SELECT a+b AS x, c+d AS y FROM t1 ORDER BY a+b;
1685**
1686** Function calls are checked to make sure that the function is
1687** defined and that the correct number of arguments are specified.
drha51009b2012-05-21 19:11:25 +00001688** If the function is an aggregate function, then the NC_HasAgg flag is
drh7d10d5a2008-08-20 16:35:10 +00001689** set and the opcode is changed from TK_FUNCTION to TK_AGG_FUNCTION.
1690** If an expression contains aggregate functions then the EP_Agg
1691** property on the expression is set.
1692**
1693** An error message is left in pParse if anything is amiss. The number
1694** if errors is returned.
1695*/
1696int sqlite3ResolveExprNames(
1697 NameContext *pNC, /* Namespace to resolve expressions in. */
1698 Expr *pExpr /* The expression to be analyzed. */
1699){
dan0d925712019-05-20 17:14:25 +00001700 int savedHasAgg;
drh7d10d5a2008-08-20 16:35:10 +00001701 Walker w;
1702
drhd03257c2017-05-31 00:49:40 +00001703 if( pExpr==0 ) return SQLITE_OK;
dan4ded26a2019-03-28 16:15:05 +00001704 savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
1705 pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
drh9bfb0242016-01-20 02:21:50 +00001706 w.pParse = pNC->pParse;
drh7d10d5a2008-08-20 16:35:10 +00001707 w.xExprCallback = resolveExprStep;
1708 w.xSelectCallback = resolveSelectStep;
drh9bfb0242016-01-20 02:21:50 +00001709 w.xSelectCallback2 = 0;
drh7d10d5a2008-08-20 16:35:10 +00001710 w.u.pNC = pNC;
drhd03257c2017-05-31 00:49:40 +00001711#if SQLITE_MAX_EXPR_DEPTH>0
1712 w.pParse->nHeight += pExpr->nHeight;
1713 if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){
1714 return SQLITE_ERROR;
1715 }
1716#endif
drh7d10d5a2008-08-20 16:35:10 +00001717 sqlite3WalkExpr(&w, pExpr);
1718#if SQLITE_MAX_EXPR_DEPTH>0
drhd03257c2017-05-31 00:49:40 +00001719 w.pParse->nHeight -= pExpr->nHeight;
drh7d10d5a2008-08-20 16:35:10 +00001720#endif
drhd137f4e2019-03-29 01:15:11 +00001721 assert( EP_Agg==NC_HasAgg );
1722 assert( EP_Win==NC_HasWin );
1723 testcase( pNC->ncFlags & NC_HasAgg );
1724 testcase( pNC->ncFlags & NC_HasWin );
1725 ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) );
drh9588ad92014-09-15 14:46:02 +00001726 pNC->ncFlags |= savedHasAgg;
drhd03257c2017-05-31 00:49:40 +00001727 return pNC->nErr>0 || w.pParse->nErr>0;
drh7d10d5a2008-08-20 16:35:10 +00001728}
drh7d10d5a2008-08-20 16:35:10 +00001729
drh01d230c2015-08-19 17:11:37 +00001730/*
1731** Resolve all names for all expression in an expression list. This is
1732** just like sqlite3ResolveExprNames() except that it works for an expression
1733** list rather than a single expression.
1734*/
1735int sqlite3ResolveExprListNames(
1736 NameContext *pNC, /* Namespace to resolve expressions in. */
1737 ExprList *pList /* The expression list to be analyzed. */
1738){
drhd8b1bfc2015-08-20 23:21:34 +00001739 int i;
drh20292312015-11-21 13:24:46 +00001740 if( pList ){
1741 for(i=0; i<pList->nExpr; i++){
1742 if( sqlite3ResolveExprNames(pNC, pList->a[i].pExpr) ) return WRC_Abort;
1743 }
drh01d230c2015-08-19 17:11:37 +00001744 }
1745 return WRC_Continue;
1746}
drh7d10d5a2008-08-20 16:35:10 +00001747
1748/*
1749** Resolve all names in all expressions of a SELECT and in all
1750** decendents of the SELECT, including compounds off of p->pPrior,
1751** subqueries in expressions, and subqueries used as FROM clause
1752** terms.
1753**
1754** See sqlite3ResolveExprNames() for a description of the kinds of
1755** transformations that occur.
1756**
1757** All SELECT statements should have been expanded using
1758** sqlite3SelectExpand() prior to invoking this routine.
1759*/
1760void sqlite3ResolveSelectNames(
1761 Parse *pParse, /* The parser context */
1762 Select *p, /* The SELECT statement being coded. */
1763 NameContext *pOuterNC /* Name context for parent SELECT statement */
1764){
1765 Walker w;
1766
drh0a846f92008-08-25 17:23:29 +00001767 assert( p!=0 );
1768 w.xExprCallback = resolveExprStep;
1769 w.xSelectCallback = resolveSelectStep;
drh979dd1b2017-05-29 14:26:07 +00001770 w.xSelectCallback2 = 0;
drh0a846f92008-08-25 17:23:29 +00001771 w.pParse = pParse;
1772 w.u.pNC = pOuterNC;
1773 sqlite3WalkSelect(&w, p);
drh7d10d5a2008-08-20 16:35:10 +00001774}
drh3780be12013-07-31 19:05:22 +00001775
1776/*
drhee751fa2019-01-02 14:34:46 +00001777** Resolve names in expressions that can only reference a single table
1778** or which cannot reference any tables at all. Examples:
drh3780be12013-07-31 19:05:22 +00001779**
drhee751fa2019-01-02 14:34:46 +00001780** (1) CHECK constraints
1781** (2) WHERE clauses on partial indices
1782** (3) Expressions in indexes on expressions
1783** (4) Expression arguments to VACUUM INTO.
drh3780be12013-07-31 19:05:22 +00001784**
drhee751fa2019-01-02 14:34:46 +00001785** In all cases except (4), the Expr.iTable value for Expr.op==TK_COLUMN
1786** nodes of the expression is set to -1 and the Expr.iColumn value is
1787** set to the column number. In case (4), TK_COLUMN nodes cause an error.
drh3780be12013-07-31 19:05:22 +00001788**
1789** Any errors cause an error message to be set in pParse.
1790*/
drhee751fa2019-01-02 14:34:46 +00001791int sqlite3ResolveSelfReference(
drh3780be12013-07-31 19:05:22 +00001792 Parse *pParse, /* Parsing context */
drhee751fa2019-01-02 14:34:46 +00001793 Table *pTab, /* The table being referenced, or NULL */
1794 int type, /* NC_IsCheck or NC_PartIdx or NC_IdxExpr, or 0 */
drh3780be12013-07-31 19:05:22 +00001795 Expr *pExpr, /* Expression to resolve. May be NULL. */
drh4357e222018-04-12 20:21:42 +00001796 ExprList *pList /* Expression list to resolve. May be NULL. */
drh3780be12013-07-31 19:05:22 +00001797){
1798 SrcList sSrc; /* Fake SrcList for pParse->pNewTable */
1799 NameContext sNC; /* Name context for pParse->pNewTable */
drhee751fa2019-01-02 14:34:46 +00001800 int rc;
drh3780be12013-07-31 19:05:22 +00001801
drhee751fa2019-01-02 14:34:46 +00001802 assert( type==0 || pTab!=0 );
1803 assert( type==NC_IsCheck || type==NC_PartIdx || type==NC_IdxExpr || pTab==0 );
drh3780be12013-07-31 19:05:22 +00001804 memset(&sNC, 0, sizeof(sNC));
1805 memset(&sSrc, 0, sizeof(sSrc));
drhee751fa2019-01-02 14:34:46 +00001806 if( pTab ){
1807 sSrc.nSrc = 1;
1808 sSrc.a[0].zName = pTab->zName;
1809 sSrc.a[0].pTab = pTab;
1810 sSrc.a[0].iCursor = -1;
1811 }
drh3780be12013-07-31 19:05:22 +00001812 sNC.pParse = pParse;
1813 sNC.pSrcList = &sSrc;
drhd0ff6012019-06-17 13:56:11 +00001814 sNC.ncFlags = type | NC_IsDDL;
drhee751fa2019-01-02 14:34:46 +00001815 if( (rc = sqlite3ResolveExprNames(&sNC, pExpr))!=SQLITE_OK ) return rc;
1816 if( pList ) rc = sqlite3ResolveExprListNames(&sNC, pList);
1817 return rc;
drh3780be12013-07-31 19:05:22 +00001818}