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