4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
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.
11 *************************************************************************
13 ** This file contains routines used for walking the parser tree and
14 ** resolve all identifiers by associating them with a particular
17 #include "sqliteInt.h"
20 ** Walk the expression tree pExpr and increase the aggregate function
21 ** depth (the Expr.op2 field) by N on every TK_AGG_FUNCTION node.
22 ** This needs to occur when copying a TK_AGG_FUNCTION node from an
23 ** outer query into an inner subquery.
25 ** incrAggFunctionDepth(pExpr,n) is the main routine. incrAggDepth(..)
26 ** is a helper function - a callback for the tree walker.
28 static int incrAggDepth(Walker
*pWalker
, Expr
*pExpr
){
29 if( pExpr
->op
==TK_AGG_FUNCTION
) pExpr
->op2
+= pWalker
->u
.n
;
32 static void incrAggFunctionDepth(Expr
*pExpr
, int N
){
35 memset(&w
, 0, sizeof(w
));
36 w
.xExprCallback
= incrAggDepth
;
38 sqlite3WalkExpr(&w
, pExpr
);
43 ** Turn the pExpr expression into an alias for the iCol-th column of the
44 ** result set in pEList.
46 ** If the reference is followed by a COLLATE operator, then make sure
47 ** the COLLATE operator is preserved. For example:
49 ** SELECT a+b, c+d FROM t1 ORDER BY 1 COLLATE nocase;
51 ** Should be transformed into:
53 ** SELECT a+b, c+d FROM t1 ORDER BY (a+b) COLLATE nocase;
55 ** The nSubquery parameter specifies how many levels of subquery the
56 ** alias is removed from the original expression. The usual value is
57 ** zero but it might be more if the alias is contained within a subquery
58 ** of the original expression. The Expr.op2 field of TK_AGG_FUNCTION
59 ** structures must be increased by the nSubquery amount.
61 static void resolveAlias(
62 Parse
*pParse
, /* Parsing context */
63 ExprList
*pEList
, /* A result set */
64 int iCol
, /* A column in the result set. 0..pEList->nExpr-1 */
65 Expr
*pExpr
, /* Transform this into an alias to the result set */
66 const char *zType
, /* "GROUP" or "ORDER" or "" */
67 int nSubquery
/* Number of subqueries that the label is moving */
69 Expr
*pOrig
; /* The iCol-th column of the result set */
70 Expr
*pDup
; /* Copy of pOrig */
71 sqlite3
*db
; /* The database connection */
73 assert( iCol
>=0 && iCol
<pEList
->nExpr
);
74 pOrig
= pEList
->a
[iCol
].pExpr
;
77 pDup
= sqlite3ExprDup(db
, pOrig
, 0);
79 if( zType
[0]!='G' ) incrAggFunctionDepth(pDup
, nSubquery
);
80 if( pExpr
->op
==TK_COLLATE
){
81 pDup
= sqlite3ExprAddCollateString(pParse
, pDup
, pExpr
->u
.zToken
);
83 ExprSetProperty(pDup
, EP_Alias
);
85 /* Before calling sqlite3ExprDelete(), set the EP_Static flag. This
86 ** prevents ExprDelete() from deleting the Expr structure itself,
87 ** allowing it to be repopulated by the memcpy() on the following line.
88 ** The pExpr->u.zToken might point into memory that will be freed by the
89 ** sqlite3DbFree(db, pDup) on the last line of this block, so be sure to
90 ** make a copy of the token before doing the sqlite3DbFree().
92 ExprSetProperty(pExpr
, EP_Static
);
93 sqlite3ExprDelete(db
, pExpr
);
94 memcpy(pExpr
, pDup
, sizeof(*pExpr
));
95 if( !ExprHasProperty(pExpr
, EP_IntValue
) && pExpr
->u
.zToken
!=0 ){
96 assert( (pExpr
->flags
& (EP_Reduced
|EP_TokenOnly
))==0 );
97 pExpr
->u
.zToken
= sqlite3DbStrDup(db
, pExpr
->u
.zToken
);
98 pExpr
->flags
|= EP_MemToken
;
100 sqlite3DbFree(db
, pDup
);
105 ** Return TRUE if the name zCol occurs anywhere in the USING clause.
107 ** Return FALSE if the USING clause is NULL or if it does not contain
110 static int nameInUsingClause(IdList
*pUsing
, const char *zCol
){
113 for(k
=0; k
<pUsing
->nId
; k
++){
114 if( sqlite3StrICmp(pUsing
->a
[k
].zName
, zCol
)==0 ) return 1;
121 ** Subqueries stores the original database, table and column names for their
122 ** result sets in ExprList.a[].zSpan, in the form "DATABASE.TABLE.COLUMN".
123 ** Check to see if the zSpan given to this routine matches the zDb, zTab,
124 ** and zCol. If any of zDb, zTab, and zCol are NULL then those fields will
127 int sqlite3MatchSpanName(
134 for(n
=0; ALWAYS(zSpan
[n
]) && zSpan
[n
]!='.'; n
++){}
135 if( zDb
&& (sqlite3StrNICmp(zSpan
, zDb
, n
)!=0 || zDb
[n
]!=0) ){
139 for(n
=0; ALWAYS(zSpan
[n
]) && zSpan
[n
]!='.'; n
++){}
140 if( zTab
&& (sqlite3StrNICmp(zSpan
, zTab
, n
)!=0 || zTab
[n
]!=0) ){
144 if( zCol
&& sqlite3StrICmp(zSpan
, zCol
)!=0 ){
151 ** Given the name of a column of the form X.Y.Z or Y.Z or just Z, look up
152 ** that name in the set of source tables in pSrcList and make the pExpr
153 ** expression node refer back to that source column. The following changes
154 ** are made to pExpr:
156 ** pExpr->iDb Set the index in db->aDb[] of the database X
157 ** (even if X is implied).
158 ** pExpr->iTable Set to the cursor number for the table obtained
160 ** pExpr->pTab Points to the Table structure of X.Y (even if
161 ** X and/or Y are implied.)
162 ** pExpr->iColumn Set to the column number within the table.
163 ** pExpr->op Set to TK_COLUMN.
164 ** pExpr->pLeft Any expression this points to is deleted
165 ** pExpr->pRight Any expression this points to is deleted.
167 ** The zDb variable is the name of the database (the "X"). This value may be
168 ** NULL meaning that name is of the form Y.Z or Z. Any available database
169 ** can be used. The zTable variable is the name of the table (the "Y"). This
170 ** value can be NULL if zDb is also NULL. If zTable is NULL it
171 ** means that the form of the name is Z and that columns from any table
174 ** If the name cannot be resolved unambiguously, leave an error message
175 ** in pParse and return WRC_Abort. Return WRC_Prune on success.
177 static int lookupName(
178 Parse
*pParse
, /* The parsing context */
179 const char *zDb
, /* Name of the database containing table, or NULL */
180 const char *zTab
, /* Name of table containing column, or NULL */
181 const char *zCol
, /* Name of the column. */
182 NameContext
*pNC
, /* The name context used to resolve the name */
183 Expr
*pExpr
/* Make this EXPR node point to the selected column */
185 int i
, j
; /* Loop counters */
186 int cnt
= 0; /* Number of matching column names */
187 int cntTab
= 0; /* Number of matching table names */
188 int nSubquery
= 0; /* How many levels of subquery */
189 sqlite3
*db
= pParse
->db
; /* The database connection */
190 struct SrcList_item
*pItem
; /* Use for looping over pSrcList items */
191 struct SrcList_item
*pMatch
= 0; /* The matching pSrcList item */
192 NameContext
*pTopNC
= pNC
; /* First namecontext in the list */
193 Schema
*pSchema
= 0; /* Schema of the expression */
194 int isTrigger
= 0; /* True if resolved to a trigger column */
195 Table
*pTab
= 0; /* Table hold the row */
196 Column
*pCol
; /* A column of pTab */
198 assert( pNC
); /* the name context cannot be NULL. */
199 assert( zCol
); /* The Z in X.Y.Z cannot be NULL */
200 assert( !ExprHasProperty(pExpr
, EP_TokenOnly
|EP_Reduced
) );
202 /* Initialize the node to no-match */
205 ExprSetVVAProperty(pExpr
, EP_NoReduce
);
207 /* Translate the schema name in zDb into a pointer to the corresponding
208 ** schema. If not found, pSchema will remain NULL and nothing will match
209 ** resulting in an appropriate error message toward the end of this routine
212 testcase( pNC
->ncFlags
& NC_PartIdx
);
213 testcase( pNC
->ncFlags
& NC_IsCheck
);
214 if( (pNC
->ncFlags
& (NC_PartIdx
|NC_IsCheck
))!=0 ){
215 /* Silently ignore database qualifiers inside CHECK constraints and
216 ** partial indices. Do not raise errors because that might break
217 ** legacy and because it does not hurt anything to just ignore the
221 for(i
=0; i
<db
->nDb
; i
++){
222 assert( db
->aDb
[i
].zDbSName
);
223 if( sqlite3StrICmp(db
->aDb
[i
].zDbSName
,zDb
)==0 ){
224 pSchema
= db
->aDb
[i
].pSchema
;
231 /* Start at the inner-most context and move outward until a match is found */
232 assert( pNC
&& cnt
==0 );
235 SrcList
*pSrcList
= pNC
->pSrcList
;
238 for(i
=0, pItem
=pSrcList
->a
; i
<pSrcList
->nSrc
; i
++, pItem
++){
240 assert( pTab
!=0 && pTab
->zName
!=0 );
241 assert( pTab
->nCol
>0 );
242 if( pItem
->pSelect
&& (pItem
->pSelect
->selFlags
& SF_NestedFrom
)!=0 ){
244 pEList
= pItem
->pSelect
->pEList
;
245 for(j
=0; j
<pEList
->nExpr
; j
++){
246 if( sqlite3MatchSpanName(pEList
->a
[j
].zSpan
, zCol
, zTab
, zDb
) ){
254 if( hit
|| zTab
==0 ) continue;
256 if( zDb
&& pTab
->pSchema
!=pSchema
){
260 const char *zTabName
= pItem
->zAlias
? pItem
->zAlias
: pTab
->zName
;
261 assert( zTabName
!=0 );
262 if( sqlite3StrICmp(zTabName
, zTab
)!=0 ){
269 for(j
=0, pCol
=pTab
->aCol
; j
<pTab
->nCol
; j
++, pCol
++){
270 if( sqlite3StrICmp(pCol
->zName
, zCol
)==0 ){
271 /* If there has been exactly one prior match and this match
272 ** is for the right-hand table of a NATURAL JOIN or is in a
273 ** USING clause, then skip this match.
276 if( pItem
->fg
.jointype
& JT_NATURAL
) continue;
277 if( nameInUsingClause(pItem
->pUsing
, zCol
) ) continue;
281 /* Substitute the rowid (column -1) for the INTEGER PRIMARY KEY */
282 pExpr
->iColumn
= j
==pTab
->iPKey
? -1 : (i16
)j
;
288 pExpr
->iTable
= pMatch
->iCursor
;
289 pExpr
->pTab
= pMatch
->pTab
;
290 /* RIGHT JOIN not (yet) supported */
291 assert( (pMatch
->fg
.jointype
& JT_RIGHT
)==0 );
292 if( (pMatch
->fg
.jointype
& JT_LEFT
)!=0 ){
293 ExprSetProperty(pExpr
, EP_CanBeNull
);
295 pSchema
= pExpr
->pTab
->pSchema
;
297 } /* if( pSrcList ) */
299 #ifndef SQLITE_OMIT_TRIGGER
300 /* If we have not already resolved the name, then maybe
301 ** it is a new.* or old.* trigger argument reference
303 if( zDb
==0 && zTab
!=0 && cntTab
==0 && pParse
->pTriggerTab
!=0 ){
304 int op
= pParse
->eTriggerOp
;
305 assert( op
==TK_DELETE
|| op
==TK_UPDATE
|| op
==TK_INSERT
);
306 if( op
!=TK_DELETE
&& sqlite3StrICmp("new",zTab
) == 0 ){
308 pTab
= pParse
->pTriggerTab
;
309 }else if( op
!=TK_INSERT
&& sqlite3StrICmp("old",zTab
)==0 ){
311 pTab
= pParse
->pTriggerTab
;
318 pSchema
= pTab
->pSchema
;
320 for(iCol
=0, pCol
=pTab
->aCol
; iCol
<pTab
->nCol
; iCol
++, pCol
++){
321 if( sqlite3StrICmp(pCol
->zName
, zCol
)==0 ){
322 if( iCol
==pTab
->iPKey
){
328 if( iCol
>=pTab
->nCol
&& sqlite3IsRowid(zCol
) && VisibleRowid(pTab
) ){
329 /* IMP: R-51414-32910 */
332 if( iCol
<pTab
->nCol
){
335 pExpr
->affinity
= SQLITE_AFF_INTEGER
;
336 }else if( pExpr
->iTable
==0 ){
337 testcase( iCol
==31 );
338 testcase( iCol
==32 );
339 pParse
->oldmask
|= (iCol
>=32 ? 0xffffffff : (((u32
)1)<<iCol
));
341 testcase( iCol
==31 );
342 testcase( iCol
==32 );
343 pParse
->newmask
|= (iCol
>=32 ? 0xffffffff : (((u32
)1)<<iCol
));
345 pExpr
->iColumn
= (i16
)iCol
;
351 #endif /* !defined(SQLITE_OMIT_TRIGGER) */
354 ** Perhaps the name is a reference to the ROWID
359 && (pNC
->ncFlags
& NC_IdxExpr
)==0
360 && sqlite3IsRowid(zCol
)
361 && VisibleRowid(pMatch
->pTab
)
365 pExpr
->affinity
= SQLITE_AFF_INTEGER
;
369 ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z
370 ** might refer to an result-set alias. This happens, for example, when
371 ** we are resolving names in the WHERE clause of the following command:
373 ** SELECT a+b AS x FROM table WHERE x<10;
375 ** In cases like this, replace pExpr with a copy of the expression that
376 ** forms the result set entry ("a+b" in the example) and return immediately.
377 ** Note that the expression in the result set should have already been
378 ** resolved by the time the WHERE clause is resolved.
380 ** The ability to use an output result-set column in the WHERE, GROUP BY,
381 ** or HAVING clauses, or as part of a larger expression in the ORDER BY
382 ** clause is not standard SQL. This is a (goofy) SQLite extension, that
383 ** is supported for backwards compatibility only. Hence, we issue a warning
384 ** on sqlite3_log() whenever the capability is used.
386 if( (pEList
= pNC
->pEList
)!=0
390 for(j
=0; j
<pEList
->nExpr
; j
++){
391 char *zAs
= pEList
->a
[j
].zName
;
392 if( zAs
!=0 && sqlite3StrICmp(zAs
, zCol
)==0 ){
394 assert( pExpr
->pLeft
==0 && pExpr
->pRight
==0 );
395 assert( pExpr
->x
.pList
==0 );
396 assert( pExpr
->x
.pSelect
==0 );
397 pOrig
= pEList
->a
[j
].pExpr
;
398 if( (pNC
->ncFlags
&NC_AllowAgg
)==0 && ExprHasProperty(pOrig
, EP_Agg
) ){
399 sqlite3ErrorMsg(pParse
, "misuse of aliased aggregate %s", zAs
);
402 if( sqlite3ExprVectorSize(pOrig
)!=1 ){
403 sqlite3ErrorMsg(pParse
, "row value misused");
406 resolveAlias(pParse
, pEList
, j
, pExpr
, "", nSubquery
);
409 assert( zTab
==0 && zDb
==0 );
415 /* Advance to the next name context. The loop will exit when either
416 ** we have a match (cnt>0) or when we run out of name contexts.
425 ** If X and Y are NULL (in other words if only the column name Z is
426 ** supplied) and the value of Z is enclosed in double-quotes, then
427 ** Z is a string literal if it doesn't match any column names. In that
428 ** case, we need to return right away and not make any changes to
431 ** Because no reference was made to outer contexts, the pNC->nRef
432 ** fields are not changed in any context.
434 if( cnt
==0 && zTab
==0 && ExprHasProperty(pExpr
,EP_DblQuoted
) ){
435 pExpr
->op
= TK_STRING
;
441 ** cnt==0 means there was not match. cnt>1 means there were two or
442 ** more matches. Either way, we have an error.
446 zErr
= cnt
==0 ? "no such column" : "ambiguous column name";
448 sqlite3ErrorMsg(pParse
, "%s: %s.%s.%s", zErr
, zDb
, zTab
, zCol
);
450 sqlite3ErrorMsg(pParse
, "%s: %s.%s", zErr
, zTab
, zCol
);
452 sqlite3ErrorMsg(pParse
, "%s: %s", zErr
, zCol
);
454 pParse
->checkSchema
= 1;
458 /* If a column from a table in pSrcList is referenced, then record
459 ** this fact in the pSrcList.a[].colUsed bitmask. Column 0 causes
460 ** bit 0 to be set. Column 1 sets bit 1. And so forth. If the
461 ** column number is greater than the number of bits in the bitmask
462 ** then set the high-order bit of the bitmask.
464 if( pExpr
->iColumn
>=0 && pMatch
!=0 ){
465 int n
= pExpr
->iColumn
;
466 testcase( n
==BMS
-1 );
470 assert( pMatch
->iCursor
==pExpr
->iTable
);
471 pMatch
->colUsed
|= ((Bitmask
)1)<<n
;
474 /* Clean up and return
476 sqlite3ExprDelete(db
, pExpr
->pLeft
);
478 sqlite3ExprDelete(db
, pExpr
->pRight
);
480 pExpr
->op
= (isTrigger
? TK_TRIGGER
: TK_COLUMN
);
481 ExprSetProperty(pExpr
, EP_Leaf
);
485 if( !ExprHasProperty(pExpr
, EP_Alias
) ){
486 sqlite3AuthRead(pParse
, pExpr
, pSchema
, pNC
->pSrcList
);
488 /* Increment the nRef value on all name contexts from TopNC up to
489 ** the point where the name matched. */
493 if( pTopNC
==pNC
) break;
494 pTopNC
= pTopNC
->pNext
;
503 ** Allocate and return a pointer to an expression to load the column iCol
504 ** from datasource iSrc in SrcList pSrc.
506 Expr
*sqlite3CreateColumnExpr(sqlite3
*db
, SrcList
*pSrc
, int iSrc
, int iCol
){
507 Expr
*p
= sqlite3ExprAlloc(db
, TK_COLUMN
, 0, 0);
509 struct SrcList_item
*pItem
= &pSrc
->a
[iSrc
];
510 p
->pTab
= pItem
->pTab
;
511 p
->iTable
= pItem
->iCursor
;
512 if( p
->pTab
->iPKey
==iCol
){
515 p
->iColumn
= (ynVar
)iCol
;
516 testcase( iCol
==BMS
);
517 testcase( iCol
==BMS
-1 );
518 pItem
->colUsed
|= ((Bitmask
)1)<<(iCol
>=BMS
? BMS
-1 : iCol
);
525 ** Report an error that an expression is not valid for some set of
526 ** pNC->ncFlags values determined by validMask.
528 static void notValid(
529 Parse
*pParse
, /* Leave error message here */
530 NameContext
*pNC
, /* The name context */
531 const char *zMsg
, /* Type of error */
532 int validMask
/* Set of contexts for which prohibited */
534 assert( (validMask
&~(NC_IsCheck
|NC_PartIdx
|NC_IdxExpr
))==0 );
535 if( (pNC
->ncFlags
& validMask
)!=0 ){
536 const char *zIn
= "partial index WHERE clauses";
537 if( pNC
->ncFlags
& NC_IdxExpr
) zIn
= "index expressions";
538 #ifndef SQLITE_OMIT_CHECK
539 else if( pNC
->ncFlags
& NC_IsCheck
) zIn
= "CHECK constraints";
541 sqlite3ErrorMsg(pParse
, "%s prohibited in %s", zMsg
, zIn
);
546 ** Expression p should encode a floating point value between 1.0 and 0.0.
547 ** Return 1024 times this value. Or return -1 if p is not a floating point
548 ** value between 1.0 and 0.0.
550 static int exprProbability(Expr
*p
){
552 if( p
->op
!=TK_FLOAT
) return -1;
553 sqlite3AtoF(p
->u
.zToken
, &r
, sqlite3Strlen30(p
->u
.zToken
), SQLITE_UTF8
);
555 if( r
>1.0 ) return -1;
556 return (int)(r
*134217728.0);
560 ** This routine is callback for sqlite3WalkExpr().
562 ** Resolve symbolic names into TK_COLUMN operators for the current
563 ** node in the expression tree. Return 0 to continue the search down
564 ** the tree or 2 to abort the tree walk.
566 ** This routine also does error checking and name resolution for
567 ** function names. The operator for aggregate functions is changed
568 ** to TK_AGG_FUNCTION.
570 static int resolveExprStep(Walker
*pWalker
, Expr
*pExpr
){
574 pNC
= pWalker
->u
.pNC
;
576 pParse
= pNC
->pParse
;
577 assert( pParse
==pWalker
->pParse
);
580 if( pNC
->pSrcList
&& pNC
->pSrcList
->nAlloc
>0 ){
581 SrcList
*pSrcList
= pNC
->pSrcList
;
583 for(i
=0; i
<pNC
->pSrcList
->nSrc
; i
++){
584 assert( pSrcList
->a
[i
].iCursor
>=0 && pSrcList
->a
[i
].iCursor
<pParse
->nTab
);
590 #if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY)
591 /* The special operator TK_ROW means use the rowid for the first
592 ** column in the FROM clause. This is used by the LIMIT and ORDER BY
593 ** clause processing on UPDATE and DELETE statements.
596 SrcList
*pSrcList
= pNC
->pSrcList
;
597 struct SrcList_item
*pItem
;
598 assert( pSrcList
&& pSrcList
->nSrc
==1 );
600 assert( HasRowid(pItem
->pTab
) && pItem
->pTab
->pSelect
==0 );
601 pExpr
->op
= TK_COLUMN
;
602 pExpr
->pTab
= pItem
->pTab
;
603 pExpr
->iTable
= pItem
->iCursor
;
605 pExpr
->affinity
= SQLITE_AFF_INTEGER
;
608 #endif /* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT)
609 && !defined(SQLITE_OMIT_SUBQUERY) */
612 ** Or table name and column name: ID.ID
613 ** Or a database, table and column: ID.ID.ID
615 ** The TK_ID and TK_OUT cases are combined so that there will only
616 ** be one call to lookupName(). Then the compiler will in-line
617 ** lookupName() for a size reduction and performance increase.
626 if( pExpr
->op
==TK_ID
){
629 zColumn
= pExpr
->u
.zToken
;
631 notValid(pParse
, pNC
, "the \".\" operator", NC_IdxExpr
);
632 pRight
= pExpr
->pRight
;
633 if( pRight
->op
==TK_ID
){
635 zTable
= pExpr
->pLeft
->u
.zToken
;
636 zColumn
= pRight
->u
.zToken
;
638 assert( pRight
->op
==TK_DOT
);
639 zDb
= pExpr
->pLeft
->u
.zToken
;
640 zTable
= pRight
->pLeft
->u
.zToken
;
641 zColumn
= pRight
->pRight
->u
.zToken
;
644 return lookupName(pParse
, zDb
, zTable
, zColumn
, pNC
, pExpr
);
647 /* Resolve function names
650 ExprList
*pList
= pExpr
->x
.pList
; /* The argument list */
651 int n
= pList
? pList
->nExpr
: 0; /* Number of arguments */
652 int no_such_func
= 0; /* True if no such function exists */
653 int wrong_num_args
= 0; /* True if wrong number of arguments */
654 int is_agg
= 0; /* True if is an aggregate function */
655 int nId
; /* Number of characters in function name */
656 const char *zId
; /* The function name. */
657 FuncDef
*pDef
; /* Information about the function */
658 u8 enc
= ENC(pParse
->db
); /* The database encoding */
660 assert( !ExprHasProperty(pExpr
, EP_xIsSelect
) );
661 zId
= pExpr
->u
.zToken
;
662 nId
= sqlite3Strlen30(zId
);
663 pDef
= sqlite3FindFunction(pParse
->db
, zId
, n
, enc
, 0);
665 pDef
= sqlite3FindFunction(pParse
->db
, zId
, -2, enc
, 0);
672 is_agg
= pDef
->xFinalize
!=0;
673 if( pDef
->funcFlags
& SQLITE_FUNC_UNLIKELY
){
674 ExprSetProperty(pExpr
, EP_Unlikely
|EP_Skip
);
676 pExpr
->iTable
= exprProbability(pList
->a
[1].pExpr
);
677 if( pExpr
->iTable
<0 ){
678 sqlite3ErrorMsg(pParse
,
679 "second argument to likelihood() must be a "
680 "constant between 0.0 and 1.0");
684 /* EVIDENCE-OF: R-61304-29449 The unlikely(X) function is
685 ** equivalent to likelihood(X, 0.0625).
686 ** EVIDENCE-OF: R-01283-11636 The unlikely(X) function is
687 ** short-hand for likelihood(X,0.0625).
688 ** EVIDENCE-OF: R-36850-34127 The likely(X) function is short-hand
689 ** for likelihood(X,0.9375).
690 ** EVIDENCE-OF: R-53436-40973 The likely(X) function is equivalent
691 ** to likelihood(X,0.9375). */
692 /* TUNING: unlikely() probability is 0.0625. likely() is 0.9375 */
693 pExpr
->iTable
= pDef
->zName
[0]=='u' ? 8388608 : 125829120;
696 #ifndef SQLITE_OMIT_AUTHORIZATION
698 int auth
= sqlite3AuthCheck(pParse
, SQLITE_FUNCTION
, 0,pDef
->zName
,0);
699 if( auth
!=SQLITE_OK
){
700 if( auth
==SQLITE_DENY
){
701 sqlite3ErrorMsg(pParse
, "not authorized to use function: %s",
710 if( pDef
->funcFlags
& (SQLITE_FUNC_CONSTANT
|SQLITE_FUNC_SLOCHNG
) ){
711 /* For the purposes of the EP_ConstFunc flag, date and time
712 ** functions and other functions that change slowly are considered
713 ** constant because they are constant for the duration of one query */
714 ExprSetProperty(pExpr
,EP_ConstFunc
);
716 if( (pDef
->funcFlags
& SQLITE_FUNC_CONSTANT
)==0 ){
717 /* Date/time functions that use 'now', and other functions like
718 ** sqlite_version() that might change over time cannot be used
720 notValid(pParse
, pNC
, "non-deterministic functions",
721 NC_IdxExpr
|NC_PartIdx
);
724 if( is_agg
&& (pNC
->ncFlags
& NC_AllowAgg
)==0 ){
725 sqlite3ErrorMsg(pParse
, "misuse of aggregate function %.*s()", nId
,zId
);
728 }else if( no_such_func
&& pParse
->db
->init
.busy
==0
729 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
730 && pParse
->explain
==0
733 sqlite3ErrorMsg(pParse
, "no such function: %.*s", nId
, zId
);
735 }else if( wrong_num_args
){
736 sqlite3ErrorMsg(pParse
,"wrong number of arguments to function %.*s()",
740 if( is_agg
) pNC
->ncFlags
&= ~NC_AllowAgg
;
741 sqlite3WalkExprList(pWalker
, pList
);
743 NameContext
*pNC2
= pNC
;
744 pExpr
->op
= TK_AGG_FUNCTION
;
746 while( pNC2
&& !sqlite3FunctionUsesThisSrc(pExpr
, pNC2
->pSrcList
) ){
752 assert( SQLITE_FUNC_MINMAX
==NC_MinMaxAgg
);
753 testcase( (pDef
->funcFlags
& SQLITE_FUNC_MINMAX
)!=0 );
754 pNC2
->ncFlags
|= NC_HasAgg
| (pDef
->funcFlags
& SQLITE_FUNC_MINMAX
);
757 pNC
->ncFlags
|= NC_AllowAgg
;
759 /* FIX ME: Compute pExpr->affinity based on the expected return
760 ** type of the function
764 #ifndef SQLITE_OMIT_SUBQUERY
766 case TK_EXISTS
: testcase( pExpr
->op
==TK_EXISTS
);
769 testcase( pExpr
->op
==TK_IN
);
770 if( ExprHasProperty(pExpr
, EP_xIsSelect
) ){
771 int nRef
= pNC
->nRef
;
772 notValid(pParse
, pNC
, "subqueries", NC_IsCheck
|NC_PartIdx
|NC_IdxExpr
);
773 sqlite3WalkSelect(pWalker
, pExpr
->x
.pSelect
);
774 assert( pNC
->nRef
>=nRef
);
775 if( nRef
!=pNC
->nRef
){
776 ExprSetProperty(pExpr
, EP_VarSelect
);
777 pNC
->ncFlags
|= NC_VarSelect
;
783 notValid(pParse
, pNC
, "parameters", NC_IsCheck
|NC_PartIdx
|NC_IdxExpr
);
796 if( pParse
->db
->mallocFailed
) break;
797 assert( pExpr
->pLeft
!=0 );
798 nLeft
= sqlite3ExprVectorSize(pExpr
->pLeft
);
799 if( pExpr
->op
==TK_BETWEEN
){
800 nRight
= sqlite3ExprVectorSize(pExpr
->x
.pList
->a
[0].pExpr
);
802 nRight
= sqlite3ExprVectorSize(pExpr
->x
.pList
->a
[1].pExpr
);
805 assert( pExpr
->pRight
!=0 );
806 nRight
= sqlite3ExprVectorSize(pExpr
->pRight
);
809 testcase( pExpr
->op
==TK_EQ
);
810 testcase( pExpr
->op
==TK_NE
);
811 testcase( pExpr
->op
==TK_LT
);
812 testcase( pExpr
->op
==TK_LE
);
813 testcase( pExpr
->op
==TK_GT
);
814 testcase( pExpr
->op
==TK_GE
);
815 testcase( pExpr
->op
==TK_IS
);
816 testcase( pExpr
->op
==TK_ISNOT
);
817 testcase( pExpr
->op
==TK_BETWEEN
);
818 sqlite3ErrorMsg(pParse
, "row value misused");
823 return (pParse
->nErr
|| pParse
->db
->mallocFailed
) ? WRC_Abort
: WRC_Continue
;
827 ** pEList is a list of expressions which are really the result set of the
828 ** a SELECT statement. pE is a term in an ORDER BY or GROUP BY clause.
829 ** This routine checks to see if pE is a simple identifier which corresponds
830 ** to the AS-name of one of the terms of the expression list. If it is,
831 ** this routine return an integer between 1 and N where N is the number of
832 ** elements in pEList, corresponding to the matching entry. If there is
833 ** no match, or if pE is not a simple identifier, then this routine
836 ** pEList has been resolved. pE has not.
838 static int resolveAsName(
839 Parse
*pParse
, /* Parsing context for error messages */
840 ExprList
*pEList
, /* List of expressions to scan */
841 Expr
*pE
/* Expression we are trying to match */
843 int i
; /* Loop counter */
845 UNUSED_PARAMETER(pParse
);
848 char *zCol
= pE
->u
.zToken
;
849 for(i
=0; i
<pEList
->nExpr
; i
++){
850 char *zAs
= pEList
->a
[i
].zName
;
851 if( zAs
!=0 && sqlite3StrICmp(zAs
, zCol
)==0 ){
860 ** pE is a pointer to an expression which is a single term in the
861 ** ORDER BY of a compound SELECT. The expression has not been
864 ** At the point this routine is called, we already know that the
865 ** ORDER BY term is not an integer index into the result set. That
866 ** case is handled by the calling routine.
868 ** Attempt to match pE against result set columns in the left-most
869 ** SELECT statement. Return the index i of the matching column,
870 ** as an indication to the caller that it should sort by the i-th column.
871 ** The left-most column is 1. In other words, the value returned is the
872 ** same integer value that would be used in the SQL statement to indicate
875 ** If there is no match, return 0. Return -1 if an error occurs.
877 static int resolveOrderByTermToExprList(
878 Parse
*pParse
, /* Parsing context for error messages */
879 Select
*pSelect
, /* The SELECT statement with the ORDER BY clause */
880 Expr
*pE
/* The specific ORDER BY term */
882 int i
; /* Loop counter */
883 ExprList
*pEList
; /* The columns of the result set */
884 NameContext nc
; /* Name context for resolving pE */
885 sqlite3
*db
; /* Database connection */
886 int rc
; /* Return code from subprocedures */
887 u8 savedSuppErr
; /* Saved value of db->suppressErr */
889 assert( sqlite3ExprIsInteger(pE
, &i
)==0 );
890 pEList
= pSelect
->pEList
;
892 /* Resolve all names in the ORDER BY term expression
894 memset(&nc
, 0, sizeof(nc
));
896 nc
.pSrcList
= pSelect
->pSrc
;
898 nc
.ncFlags
= NC_AllowAgg
;
901 savedSuppErr
= db
->suppressErr
;
903 rc
= sqlite3ResolveExprNames(&nc
, pE
);
904 db
->suppressErr
= savedSuppErr
;
907 /* Try to match the ORDER BY expression against an expression
908 ** in the result set. Return an 1-based index of the matching
911 for(i
=0; i
<pEList
->nExpr
; i
++){
912 if( sqlite3ExprCompare(0, pEList
->a
[i
].pExpr
, pE
, -1)<2 ){
917 /* If no match, return 0. */
922 ** Generate an ORDER BY or GROUP BY term out-of-range error.
924 static void resolveOutOfRangeError(
925 Parse
*pParse
, /* The error context into which to write the error */
926 const char *zType
, /* "ORDER" or "GROUP" */
927 int i
, /* The index (1-based) of the term out of range */
928 int mx
/* Largest permissible value of i */
930 sqlite3ErrorMsg(pParse
,
931 "%r %s BY term out of range - should be "
932 "between 1 and %d", i
, zType
, mx
);
936 ** Analyze the ORDER BY clause in a compound SELECT statement. Modify
937 ** each term of the ORDER BY clause is a constant integer between 1
938 ** and N where N is the number of columns in the compound SELECT.
940 ** ORDER BY terms that are already an integer between 1 and N are
941 ** unmodified. ORDER BY terms that are integers outside the range of
942 ** 1 through N generate an error. ORDER BY terms that are expressions
943 ** are matched against result set expressions of compound SELECT
944 ** beginning with the left-most SELECT and working toward the right.
945 ** At the first match, the ORDER BY expression is transformed into
946 ** the integer column number.
948 ** Return the number of errors seen.
950 static int resolveCompoundOrderBy(
951 Parse
*pParse
, /* Parsing context. Leave error messages here */
952 Select
*pSelect
/* The SELECT statement containing the ORDER BY */
960 pOrderBy
= pSelect
->pOrderBy
;
961 if( pOrderBy
==0 ) return 0;
963 if( pOrderBy
->nExpr
>db
->aLimit
[SQLITE_LIMIT_COLUMN
] ){
964 sqlite3ErrorMsg(pParse
, "too many terms in ORDER BY clause");
967 for(i
=0; i
<pOrderBy
->nExpr
; i
++){
968 pOrderBy
->a
[i
].done
= 0;
971 while( pSelect
->pPrior
){
972 pSelect
->pPrior
->pNext
= pSelect
;
973 pSelect
= pSelect
->pPrior
;
975 while( pSelect
&& moreToDo
){
976 struct ExprList_item
*pItem
;
978 pEList
= pSelect
->pEList
;
980 for(i
=0, pItem
=pOrderBy
->a
; i
<pOrderBy
->nExpr
; i
++, pItem
++){
983 if( pItem
->done
) continue;
984 pE
= sqlite3ExprSkipCollate(pItem
->pExpr
);
985 if( sqlite3ExprIsInteger(pE
, &iCol
) ){
986 if( iCol
<=0 || iCol
>pEList
->nExpr
){
987 resolveOutOfRangeError(pParse
, "ORDER", i
+1, pEList
->nExpr
);
991 iCol
= resolveAsName(pParse
, pEList
, pE
);
993 pDup
= sqlite3ExprDup(db
, pE
, 0);
994 if( !db
->mallocFailed
){
996 iCol
= resolveOrderByTermToExprList(pParse
, pSelect
, pDup
);
998 sqlite3ExprDelete(db
, pDup
);
1002 /* Convert the ORDER BY term into an integer column number iCol,
1003 ** taking care to preserve the COLLATE clause if it exists */
1004 Expr
*pNew
= sqlite3Expr(db
, TK_INTEGER
, 0);
1005 if( pNew
==0 ) return 1;
1006 pNew
->flags
|= EP_IntValue
;
1007 pNew
->u
.iValue
= iCol
;
1008 if( pItem
->pExpr
==pE
){
1009 pItem
->pExpr
= pNew
;
1011 Expr
*pParent
= pItem
->pExpr
;
1012 assert( pParent
->op
==TK_COLLATE
);
1013 while( pParent
->pLeft
->op
==TK_COLLATE
) pParent
= pParent
->pLeft
;
1014 assert( pParent
->pLeft
==pE
);
1015 pParent
->pLeft
= pNew
;
1017 sqlite3ExprDelete(db
, pE
);
1018 pItem
->u
.x
.iOrderByCol
= (u16
)iCol
;
1024 pSelect
= pSelect
->pNext
;
1026 for(i
=0; i
<pOrderBy
->nExpr
; i
++){
1027 if( pOrderBy
->a
[i
].done
==0 ){
1028 sqlite3ErrorMsg(pParse
, "%r ORDER BY term does not match any "
1029 "column in the result set", i
+1);
1037 ** Check every term in the ORDER BY or GROUP BY clause pOrderBy of
1038 ** the SELECT statement pSelect. If any term is reference to a
1039 ** result set expression (as determined by the ExprList.a.u.x.iOrderByCol
1040 ** field) then convert that term into a copy of the corresponding result set
1043 ** If any errors are detected, add an error message to pParse and
1044 ** return non-zero. Return zero if no errors are seen.
1046 int sqlite3ResolveOrderGroupBy(
1047 Parse
*pParse
, /* Parsing context. Leave error messages here */
1048 Select
*pSelect
, /* The SELECT statement containing the clause */
1049 ExprList
*pOrderBy
, /* The ORDER BY or GROUP BY clause to be processed */
1050 const char *zType
/* "ORDER" or "GROUP" */
1053 sqlite3
*db
= pParse
->db
;
1055 struct ExprList_item
*pItem
;
1057 if( pOrderBy
==0 || pParse
->db
->mallocFailed
) return 0;
1058 if( pOrderBy
->nExpr
>db
->aLimit
[SQLITE_LIMIT_COLUMN
] ){
1059 sqlite3ErrorMsg(pParse
, "too many terms in %s BY clause", zType
);
1062 pEList
= pSelect
->pEList
;
1063 assert( pEList
!=0 ); /* sqlite3SelectNew() guarantees this */
1064 for(i
=0, pItem
=pOrderBy
->a
; i
<pOrderBy
->nExpr
; i
++, pItem
++){
1065 if( pItem
->u
.x
.iOrderByCol
){
1066 if( pItem
->u
.x
.iOrderByCol
>pEList
->nExpr
){
1067 resolveOutOfRangeError(pParse
, zType
, i
+1, pEList
->nExpr
);
1070 resolveAlias(pParse
, pEList
, pItem
->u
.x
.iOrderByCol
-1, pItem
->pExpr
,
1078 ** pOrderBy is an ORDER BY or GROUP BY clause in SELECT statement pSelect.
1079 ** The Name context of the SELECT statement is pNC. zType is either
1080 ** "ORDER" or "GROUP" depending on which type of clause pOrderBy is.
1082 ** This routine resolves each term of the clause into an expression.
1083 ** If the order-by term is an integer I between 1 and N (where N is the
1084 ** number of columns in the result set of the SELECT) then the expression
1085 ** in the resolution is a copy of the I-th result-set expression. If
1086 ** the order-by term is an identifier that corresponds to the AS-name of
1087 ** a result-set expression, then the term resolves to a copy of the
1088 ** result-set expression. Otherwise, the expression is resolved in
1089 ** the usual way - using sqlite3ResolveExprNames().
1091 ** This routine returns the number of errors. If errors occur, then
1092 ** an appropriate error message might be left in pParse. (OOM errors
1095 static int resolveOrderGroupBy(
1096 NameContext
*pNC
, /* The name context of the SELECT statement */
1097 Select
*pSelect
, /* The SELECT statement holding pOrderBy */
1098 ExprList
*pOrderBy
, /* An ORDER BY or GROUP BY clause to resolve */
1099 const char *zType
/* Either "ORDER" or "GROUP", as appropriate */
1101 int i
, j
; /* Loop counters */
1102 int iCol
; /* Column number */
1103 struct ExprList_item
*pItem
; /* A term of the ORDER BY clause */
1104 Parse
*pParse
; /* Parsing context */
1105 int nResult
; /* Number of terms in the result set */
1107 if( pOrderBy
==0 ) return 0;
1108 nResult
= pSelect
->pEList
->nExpr
;
1109 pParse
= pNC
->pParse
;
1110 for(i
=0, pItem
=pOrderBy
->a
; i
<pOrderBy
->nExpr
; i
++, pItem
++){
1111 Expr
*pE
= pItem
->pExpr
;
1112 Expr
*pE2
= sqlite3ExprSkipCollate(pE
);
1113 if( zType
[0]!='G' ){
1114 iCol
= resolveAsName(pParse
, pSelect
->pEList
, pE2
);
1116 /* If an AS-name match is found, mark this ORDER BY column as being
1117 ** a copy of the iCol-th result-set column. The subsequent call to
1118 ** sqlite3ResolveOrderGroupBy() will convert the expression to a
1119 ** copy of the iCol-th result-set expression. */
1120 pItem
->u
.x
.iOrderByCol
= (u16
)iCol
;
1124 if( sqlite3ExprIsInteger(pE2
, &iCol
) ){
1125 /* The ORDER BY term is an integer constant. Again, set the column
1126 ** number so that sqlite3ResolveOrderGroupBy() will convert the
1127 ** order-by term to a copy of the result-set expression */
1128 if( iCol
<1 || iCol
>0xffff ){
1129 resolveOutOfRangeError(pParse
, zType
, i
+1, nResult
);
1132 pItem
->u
.x
.iOrderByCol
= (u16
)iCol
;
1136 /* Otherwise, treat the ORDER BY term as an ordinary expression */
1137 pItem
->u
.x
.iOrderByCol
= 0;
1138 if( sqlite3ResolveExprNames(pNC
, pE
) ){
1141 for(j
=0; j
<pSelect
->pEList
->nExpr
; j
++){
1142 if( sqlite3ExprCompare(0, pE
, pSelect
->pEList
->a
[j
].pExpr
, -1)==0 ){
1143 pItem
->u
.x
.iOrderByCol
= j
+1;
1147 return sqlite3ResolveOrderGroupBy(pParse
, pSelect
, pOrderBy
, zType
);
1151 ** Resolve names in the SELECT statement p and all of its descendants.
1153 static int resolveSelectStep(Walker
*pWalker
, Select
*p
){
1154 NameContext
*pOuterNC
; /* Context that contains this SELECT */
1155 NameContext sNC
; /* Name context of this SELECT */
1156 int isCompound
; /* True if p is a compound select */
1157 int nCompound
; /* Number of compound terms processed so far */
1158 Parse
*pParse
; /* Parsing context */
1159 int i
; /* Loop counter */
1160 ExprList
*pGroupBy
; /* The GROUP BY clause */
1161 Select
*pLeftmost
; /* Left-most of SELECT of a compound */
1162 sqlite3
*db
; /* Database connection */
1166 if( p
->selFlags
& SF_Resolved
){
1169 pOuterNC
= pWalker
->u
.pNC
;
1170 pParse
= pWalker
->pParse
;
1173 /* Normally sqlite3SelectExpand() will be called first and will have
1174 ** already expanded this SELECT. However, if this is a subquery within
1175 ** an expression, sqlite3ResolveExprNames() will be called without a
1176 ** prior call to sqlite3SelectExpand(). When that happens, let
1177 ** sqlite3SelectPrep() do all of the processing for this SELECT.
1178 ** sqlite3SelectPrep() will invoke both sqlite3SelectExpand() and
1179 ** this routine in the correct order.
1181 if( (p
->selFlags
& SF_Expanded
)==0 ){
1182 sqlite3SelectPrep(pParse
, p
, pOuterNC
);
1183 return (pParse
->nErr
|| db
->mallocFailed
) ? WRC_Abort
: WRC_Prune
;
1186 isCompound
= p
->pPrior
!=0;
1190 assert( (p
->selFlags
& SF_Expanded
)!=0 );
1191 assert( (p
->selFlags
& SF_Resolved
)==0 );
1192 p
->selFlags
|= SF_Resolved
;
1194 /* Resolve the expressions in the LIMIT and OFFSET clauses. These
1195 ** are not allowed to refer to any names, so pass an empty NameContext.
1197 memset(&sNC
, 0, sizeof(sNC
));
1198 sNC
.pParse
= pParse
;
1199 if( sqlite3ResolveExprNames(&sNC
, p
->pLimit
) ){
1203 /* If the SF_Converted flags is set, then this Select object was
1204 ** was created by the convertCompoundSelectToSubquery() function.
1205 ** In this case the ORDER BY clause (p->pOrderBy) should be resolved
1206 ** as if it were part of the sub-query, not the parent. This block
1207 ** moves the pOrderBy down to the sub-query. It will be moved back
1208 ** after the names have been resolved. */
1209 if( p
->selFlags
& SF_Converted
){
1210 Select
*pSub
= p
->pSrc
->a
[0].pSelect
;
1211 assert( p
->pSrc
->nSrc
==1 && p
->pOrderBy
);
1212 assert( pSub
->pPrior
&& pSub
->pOrderBy
==0 );
1213 pSub
->pOrderBy
= p
->pOrderBy
;
1217 /* Recursively resolve names in all subqueries
1219 for(i
=0; i
<p
->pSrc
->nSrc
; i
++){
1220 struct SrcList_item
*pItem
= &p
->pSrc
->a
[i
];
1221 if( pItem
->pSelect
){
1222 NameContext
*pNC
; /* Used to iterate name contexts */
1223 int nRef
= 0; /* Refcount for pOuterNC and outer contexts */
1224 const char *zSavedContext
= pParse
->zAuthContext
;
1226 /* Count the total number of references to pOuterNC and all of its
1227 ** parent contexts. After resolving references to expressions in
1228 ** pItem->pSelect, check if this value has changed. If so, then
1229 ** SELECT statement pItem->pSelect must be correlated. Set the
1230 ** pItem->fg.isCorrelated flag if this is the case. */
1231 for(pNC
=pOuterNC
; pNC
; pNC
=pNC
->pNext
) nRef
+= pNC
->nRef
;
1233 if( pItem
->zName
) pParse
->zAuthContext
= pItem
->zName
;
1234 sqlite3ResolveSelectNames(pParse
, pItem
->pSelect
, pOuterNC
);
1235 pParse
->zAuthContext
= zSavedContext
;
1236 if( pParse
->nErr
|| db
->mallocFailed
) return WRC_Abort
;
1238 for(pNC
=pOuterNC
; pNC
; pNC
=pNC
->pNext
) nRef
-= pNC
->nRef
;
1239 assert( pItem
->fg
.isCorrelated
==0 && nRef
<=0 );
1240 pItem
->fg
.isCorrelated
= (nRef
!=0);
1244 /* Set up the local name-context to pass to sqlite3ResolveExprNames() to
1245 ** resolve the result-set expression list.
1247 sNC
.ncFlags
= NC_AllowAgg
;
1248 sNC
.pSrcList
= p
->pSrc
;
1249 sNC
.pNext
= pOuterNC
;
1251 /* Resolve names in the result set. */
1252 if( sqlite3ResolveExprListNames(&sNC
, p
->pEList
) ) return WRC_Abort
;
1254 /* If there are no aggregate functions in the result-set, and no GROUP BY
1255 ** expression, do not allow aggregates in any of the other expressions.
1257 assert( (p
->selFlags
& SF_Aggregate
)==0 );
1258 pGroupBy
= p
->pGroupBy
;
1259 if( pGroupBy
|| (sNC
.ncFlags
& NC_HasAgg
)!=0 ){
1260 assert( NC_MinMaxAgg
==SF_MinMaxAgg
);
1261 p
->selFlags
|= SF_Aggregate
| (sNC
.ncFlags
&NC_MinMaxAgg
);
1263 sNC
.ncFlags
&= ~NC_AllowAgg
;
1266 /* If a HAVING clause is present, then there must be a GROUP BY clause.
1268 if( p
->pHaving
&& !pGroupBy
){
1269 sqlite3ErrorMsg(pParse
, "a GROUP BY clause is required before HAVING");
1273 /* Add the output column list to the name-context before parsing the
1274 ** other expressions in the SELECT statement. This is so that
1275 ** expressions in the WHERE clause (etc.) can refer to expressions by
1276 ** aliases in the result set.
1278 ** Minor point: If this is the case, then the expression will be
1279 ** re-evaluated for each reference to it.
1281 sNC
.pEList
= p
->pEList
;
1282 if( sqlite3ResolveExprNames(&sNC
, p
->pHaving
) ) return WRC_Abort
;
1283 if( sqlite3ResolveExprNames(&sNC
, p
->pWhere
) ) return WRC_Abort
;
1285 /* Resolve names in table-valued-function arguments */
1286 for(i
=0; i
<p
->pSrc
->nSrc
; i
++){
1287 struct SrcList_item
*pItem
= &p
->pSrc
->a
[i
];
1288 if( pItem
->fg
.isTabFunc
1289 && sqlite3ResolveExprListNames(&sNC
, pItem
->u1
.pFuncArg
)
1295 /* The ORDER BY and GROUP BY clauses may not refer to terms in
1299 sNC
.ncFlags
|= NC_AllowAgg
;
1301 /* If this is a converted compound query, move the ORDER BY clause from
1302 ** the sub-query back to the parent query. At this point each term
1303 ** within the ORDER BY clause has been transformed to an integer value.
1304 ** These integers will be replaced by copies of the corresponding result
1305 ** set expressions by the call to resolveOrderGroupBy() below. */
1306 if( p
->selFlags
& SF_Converted
){
1307 Select
*pSub
= p
->pSrc
->a
[0].pSelect
;
1308 p
->pOrderBy
= pSub
->pOrderBy
;
1312 /* Process the ORDER BY clause for singleton SELECT statements.
1313 ** The ORDER BY clause for compounds SELECT statements is handled
1314 ** below, after all of the result-sets for all of the elements of
1315 ** the compound have been resolved.
1317 ** If there is an ORDER BY clause on a term of a compound-select other
1318 ** than the right-most term, then that is a syntax error. But the error
1319 ** is not detected until much later, and so we need to go ahead and
1320 ** resolve those symbols on the incorrect ORDER BY for consistency.
1322 if( isCompound
<=nCompound
/* Defer right-most ORDER BY of a compound */
1323 && resolveOrderGroupBy(&sNC
, p
, p
->pOrderBy
, "ORDER")
1327 if( db
->mallocFailed
){
1331 /* Resolve the GROUP BY clause. At the same time, make sure
1332 ** the GROUP BY clause does not contain aggregate functions.
1335 struct ExprList_item
*pItem
;
1337 if( resolveOrderGroupBy(&sNC
, p
, pGroupBy
, "GROUP") || db
->mallocFailed
){
1340 for(i
=0, pItem
=pGroupBy
->a
; i
<pGroupBy
->nExpr
; i
++, pItem
++){
1341 if( ExprHasProperty(pItem
->pExpr
, EP_Agg
) ){
1342 sqlite3ErrorMsg(pParse
, "aggregate functions are not allowed in "
1343 "the GROUP BY clause");
1349 /* If this is part of a compound SELECT, check that it has the right
1350 ** number of expressions in the select list. */
1351 if( p
->pNext
&& p
->pEList
->nExpr
!=p
->pNext
->pEList
->nExpr
){
1352 sqlite3SelectWrongNumTermsError(pParse
, p
->pNext
);
1356 /* Advance to the next term of the compound
1362 /* Resolve the ORDER BY on a compound SELECT after all terms of
1363 ** the compound have been resolved.
1365 if( isCompound
&& resolveCompoundOrderBy(pParse
, pLeftmost
) ){
1373 ** This routine walks an expression tree and resolves references to
1374 ** table columns and result-set columns. At the same time, do error
1375 ** checking on function usage and set a flag if any aggregate functions
1378 ** To resolve table columns references we look for nodes (or subtrees) of the
1379 ** form X.Y.Z or Y.Z or just Z where
1381 ** X: The name of a database. Ex: "main" or "temp" or
1382 ** the symbolic name assigned to an ATTACH-ed database.
1384 ** Y: The name of a table in a FROM clause. Or in a trigger
1385 ** one of the special names "old" or "new".
1387 ** Z: The name of a column in table Y.
1389 ** The node at the root of the subtree is modified as follows:
1391 ** Expr.op Changed to TK_COLUMN
1392 ** Expr.pTab Points to the Table object for X.Y
1393 ** Expr.iColumn The column index in X.Y. -1 for the rowid.
1394 ** Expr.iTable The VDBE cursor number for X.Y
1397 ** To resolve result-set references, look for expression nodes of the
1398 ** form Z (with no X and Y prefix) where the Z matches the right-hand
1399 ** size of an AS clause in the result-set of a SELECT. The Z expression
1400 ** is replaced by a copy of the left-hand side of the result-set expression.
1401 ** Table-name and function resolution occurs on the substituted expression
1402 ** tree. For example, in:
1404 ** SELECT a+b AS x, c+d AS y FROM t1 ORDER BY x;
1406 ** The "x" term of the order by is replaced by "a+b" to render:
1408 ** SELECT a+b AS x, c+d AS y FROM t1 ORDER BY a+b;
1410 ** Function calls are checked to make sure that the function is
1411 ** defined and that the correct number of arguments are specified.
1412 ** If the function is an aggregate function, then the NC_HasAgg flag is
1413 ** set and the opcode is changed from TK_FUNCTION to TK_AGG_FUNCTION.
1414 ** If an expression contains aggregate functions then the EP_Agg
1415 ** property on the expression is set.
1417 ** An error message is left in pParse if anything is amiss. The number
1418 ** if errors is returned.
1420 int sqlite3ResolveExprNames(
1421 NameContext
*pNC
, /* Namespace to resolve expressions in. */
1422 Expr
*pExpr
/* The expression to be analyzed. */
1427 if( pExpr
==0 ) return SQLITE_OK
;
1428 savedHasAgg
= pNC
->ncFlags
& (NC_HasAgg
|NC_MinMaxAgg
);
1429 pNC
->ncFlags
&= ~(NC_HasAgg
|NC_MinMaxAgg
);
1430 w
.pParse
= pNC
->pParse
;
1431 w
.xExprCallback
= resolveExprStep
;
1432 w
.xSelectCallback
= resolveSelectStep
;
1433 w
.xSelectCallback2
= 0;
1435 #if SQLITE_MAX_EXPR_DEPTH>0
1436 w
.pParse
->nHeight
+= pExpr
->nHeight
;
1437 if( sqlite3ExprCheckHeight(w
.pParse
, w
.pParse
->nHeight
) ){
1438 return SQLITE_ERROR
;
1441 sqlite3WalkExpr(&w
, pExpr
);
1442 #if SQLITE_MAX_EXPR_DEPTH>0
1443 w
.pParse
->nHeight
-= pExpr
->nHeight
;
1445 if( pNC
->ncFlags
& NC_HasAgg
){
1446 ExprSetProperty(pExpr
, EP_Agg
);
1448 pNC
->ncFlags
|= savedHasAgg
;
1449 return pNC
->nErr
>0 || w
.pParse
->nErr
>0;
1453 ** Resolve all names for all expression in an expression list. This is
1454 ** just like sqlite3ResolveExprNames() except that it works for an expression
1455 ** list rather than a single expression.
1457 int sqlite3ResolveExprListNames(
1458 NameContext
*pNC
, /* Namespace to resolve expressions in. */
1459 ExprList
*pList
/* The expression list to be analyzed. */
1463 for(i
=0; i
<pList
->nExpr
; i
++){
1464 if( sqlite3ResolveExprNames(pNC
, pList
->a
[i
].pExpr
) ) return WRC_Abort
;
1467 return WRC_Continue
;
1471 ** Resolve all names in all expressions of a SELECT and in all
1472 ** decendents of the SELECT, including compounds off of p->pPrior,
1473 ** subqueries in expressions, and subqueries used as FROM clause
1476 ** See sqlite3ResolveExprNames() for a description of the kinds of
1477 ** transformations that occur.
1479 ** All SELECT statements should have been expanded using
1480 ** sqlite3SelectExpand() prior to invoking this routine.
1482 void sqlite3ResolveSelectNames(
1483 Parse
*pParse
, /* The parser context */
1484 Select
*p
, /* The SELECT statement being coded. */
1485 NameContext
*pOuterNC
/* Name context for parent SELECT statement */
1490 w
.xExprCallback
= resolveExprStep
;
1491 w
.xSelectCallback
= resolveSelectStep
;
1492 w
.xSelectCallback2
= 0;
1495 sqlite3WalkSelect(&w
, p
);
1499 ** Resolve names in expressions that can only reference a single table:
1501 ** * CHECK constraints
1502 ** * WHERE clauses on partial indices
1504 ** The Expr.iTable value for Expr.op==TK_COLUMN nodes of the expression
1505 ** is set to -1 and the Expr.iColumn value is set to the column number.
1507 ** Any errors cause an error message to be set in pParse.
1509 void sqlite3ResolveSelfReference(
1510 Parse
*pParse
, /* Parsing context */
1511 Table
*pTab
, /* The table being referenced */
1512 int type
, /* NC_IsCheck or NC_PartIdx or NC_IdxExpr */
1513 Expr
*pExpr
, /* Expression to resolve. May be NULL. */
1514 ExprList
*pList
/* Expression list to resolve. May be NUL. */
1516 SrcList sSrc
; /* Fake SrcList for pParse->pNewTable */
1517 NameContext sNC
; /* Name context for pParse->pNewTable */
1519 assert( type
==NC_IsCheck
|| type
==NC_PartIdx
|| type
==NC_IdxExpr
);
1520 memset(&sNC
, 0, sizeof(sNC
));
1521 memset(&sSrc
, 0, sizeof(sSrc
));
1523 sSrc
.a
[0].zName
= pTab
->zName
;
1524 sSrc
.a
[0].pTab
= pTab
;
1525 sSrc
.a
[0].iCursor
= -1;
1526 sNC
.pParse
= pParse
;
1527 sNC
.pSrcList
= &sSrc
;
1529 if( sqlite3ResolveExprNames(&sNC
, pExpr
) ) return;
1530 if( pList
) sqlite3ResolveExprListNames(&sNC
, pList
);