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 while( pNC
&& cnt
==0 ){
234 SrcList
*pSrcList
= pNC
->pSrcList
;
237 for(i
=0, pItem
=pSrcList
->a
; i
<pSrcList
->nSrc
; i
++, pItem
++){
239 assert( pTab
!=0 && pTab
->zName
!=0 );
240 assert( pTab
->nCol
>0 );
241 if( pItem
->pSelect
&& (pItem
->pSelect
->selFlags
& SF_NestedFrom
)!=0 ){
243 pEList
= pItem
->pSelect
->pEList
;
244 for(j
=0; j
<pEList
->nExpr
; j
++){
245 if( sqlite3MatchSpanName(pEList
->a
[j
].zSpan
, zCol
, zTab
, zDb
) ){
253 if( hit
|| zTab
==0 ) continue;
255 if( zDb
&& pTab
->pSchema
!=pSchema
){
259 const char *zTabName
= pItem
->zAlias
? pItem
->zAlias
: pTab
->zName
;
260 assert( zTabName
!=0 );
261 if( sqlite3StrICmp(zTabName
, zTab
)!=0 ){
268 for(j
=0, pCol
=pTab
->aCol
; j
<pTab
->nCol
; j
++, pCol
++){
269 if( sqlite3StrICmp(pCol
->zName
, zCol
)==0 ){
270 /* If there has been exactly one prior match and this match
271 ** is for the right-hand table of a NATURAL JOIN or is in a
272 ** USING clause, then skip this match.
275 if( pItem
->fg
.jointype
& JT_NATURAL
) continue;
276 if( nameInUsingClause(pItem
->pUsing
, zCol
) ) continue;
280 /* Substitute the rowid (column -1) for the INTEGER PRIMARY KEY */
281 pExpr
->iColumn
= j
==pTab
->iPKey
? -1 : (i16
)j
;
287 pExpr
->iTable
= pMatch
->iCursor
;
288 pExpr
->pTab
= pMatch
->pTab
;
289 /* RIGHT JOIN not (yet) supported */
290 assert( (pMatch
->fg
.jointype
& JT_RIGHT
)==0 );
291 if( (pMatch
->fg
.jointype
& JT_LEFT
)!=0 ){
292 ExprSetProperty(pExpr
, EP_CanBeNull
);
294 pSchema
= pExpr
->pTab
->pSchema
;
296 } /* if( pSrcList ) */
298 #ifndef SQLITE_OMIT_TRIGGER
299 /* If we have not already resolved the name, then maybe
300 ** it is a new.* or old.* trigger argument reference
302 if( zDb
==0 && zTab
!=0 && cntTab
==0 && pParse
->pTriggerTab
!=0 ){
303 int op
= pParse
->eTriggerOp
;
304 assert( op
==TK_DELETE
|| op
==TK_UPDATE
|| op
==TK_INSERT
);
305 if( op
!=TK_DELETE
&& sqlite3StrICmp("new",zTab
) == 0 ){
307 pTab
= pParse
->pTriggerTab
;
308 }else if( op
!=TK_INSERT
&& sqlite3StrICmp("old",zTab
)==0 ){
310 pTab
= pParse
->pTriggerTab
;
317 pSchema
= pTab
->pSchema
;
319 for(iCol
=0, pCol
=pTab
->aCol
; iCol
<pTab
->nCol
; iCol
++, pCol
++){
320 if( sqlite3StrICmp(pCol
->zName
, zCol
)==0 ){
321 if( iCol
==pTab
->iPKey
){
327 if( iCol
>=pTab
->nCol
&& sqlite3IsRowid(zCol
) && VisibleRowid(pTab
) ){
328 /* IMP: R-51414-32910 */
331 if( iCol
<pTab
->nCol
){
334 pExpr
->affinity
= SQLITE_AFF_INTEGER
;
335 }else if( pExpr
->iTable
==0 ){
336 testcase( iCol
==31 );
337 testcase( iCol
==32 );
338 pParse
->oldmask
|= (iCol
>=32 ? 0xffffffff : (((u32
)1)<<iCol
));
340 testcase( iCol
==31 );
341 testcase( iCol
==32 );
342 pParse
->newmask
|= (iCol
>=32 ? 0xffffffff : (((u32
)1)<<iCol
));
344 pExpr
->iColumn
= (i16
)iCol
;
350 #endif /* !defined(SQLITE_OMIT_TRIGGER) */
353 ** Perhaps the name is a reference to the ROWID
358 && (pNC
->ncFlags
& NC_IdxExpr
)==0
359 && sqlite3IsRowid(zCol
)
360 && VisibleRowid(pMatch
->pTab
)
364 pExpr
->affinity
= SQLITE_AFF_INTEGER
;
368 ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z
369 ** might refer to an result-set alias. This happens, for example, when
370 ** we are resolving names in the WHERE clause of the following command:
372 ** SELECT a+b AS x FROM table WHERE x<10;
374 ** In cases like this, replace pExpr with a copy of the expression that
375 ** forms the result set entry ("a+b" in the example) and return immediately.
376 ** Note that the expression in the result set should have already been
377 ** resolved by the time the WHERE clause is resolved.
379 ** The ability to use an output result-set column in the WHERE, GROUP BY,
380 ** or HAVING clauses, or as part of a larger expression in the ORDER BY
381 ** clause is not standard SQL. This is a (goofy) SQLite extension, that
382 ** is supported for backwards compatibility only. Hence, we issue a warning
383 ** on sqlite3_log() whenever the capability is used.
385 if( (pEList
= pNC
->pEList
)!=0
389 for(j
=0; j
<pEList
->nExpr
; j
++){
390 char *zAs
= pEList
->a
[j
].zName
;
391 if( zAs
!=0 && sqlite3StrICmp(zAs
, zCol
)==0 ){
393 assert( pExpr
->pLeft
==0 && pExpr
->pRight
==0 );
394 assert( pExpr
->x
.pList
==0 );
395 assert( pExpr
->x
.pSelect
==0 );
396 pOrig
= pEList
->a
[j
].pExpr
;
397 if( (pNC
->ncFlags
&NC_AllowAgg
)==0 && ExprHasProperty(pOrig
, EP_Agg
) ){
398 sqlite3ErrorMsg(pParse
, "misuse of aliased aggregate %s", zAs
);
401 if( sqlite3ExprVectorSize(pOrig
)!=1 ){
402 sqlite3ErrorMsg(pParse
, "row value misused");
405 resolveAlias(pParse
, pEList
, j
, pExpr
, "", nSubquery
);
408 assert( zTab
==0 && zDb
==0 );
414 /* Advance to the next name context. The loop will exit when either
415 ** we have a match (cnt>0) or when we run out of name contexts.
424 ** If X and Y are NULL (in other words if only the column name Z is
425 ** supplied) and the value of Z is enclosed in double-quotes, then
426 ** Z is a string literal if it doesn't match any column names. In that
427 ** case, we need to return right away and not make any changes to
430 ** Because no reference was made to outer contexts, the pNC->nRef
431 ** fields are not changed in any context.
433 if( cnt
==0 && zTab
==0 && ExprHasProperty(pExpr
,EP_DblQuoted
) ){
434 pExpr
->op
= TK_STRING
;
440 ** cnt==0 means there was not match. cnt>1 means there were two or
441 ** more matches. Either way, we have an error.
445 zErr
= cnt
==0 ? "no such column" : "ambiguous column name";
447 sqlite3ErrorMsg(pParse
, "%s: %s.%s.%s", zErr
, zDb
, zTab
, zCol
);
449 sqlite3ErrorMsg(pParse
, "%s: %s.%s", zErr
, zTab
, zCol
);
451 sqlite3ErrorMsg(pParse
, "%s: %s", zErr
, zCol
);
453 pParse
->checkSchema
= 1;
457 /* If a column from a table in pSrcList is referenced, then record
458 ** this fact in the pSrcList.a[].colUsed bitmask. Column 0 causes
459 ** bit 0 to be set. Column 1 sets bit 1. And so forth. If the
460 ** column number is greater than the number of bits in the bitmask
461 ** then set the high-order bit of the bitmask.
463 if( pExpr
->iColumn
>=0 && pMatch
!=0 ){
464 int n
= pExpr
->iColumn
;
465 testcase( n
==BMS
-1 );
469 assert( pMatch
->iCursor
==pExpr
->iTable
);
470 pMatch
->colUsed
|= ((Bitmask
)1)<<n
;
473 /* Clean up and return
475 sqlite3ExprDelete(db
, pExpr
->pLeft
);
477 sqlite3ExprDelete(db
, pExpr
->pRight
);
479 pExpr
->op
= (isTrigger
? TK_TRIGGER
: TK_COLUMN
);
483 if( !ExprHasProperty(pExpr
, EP_Alias
) ){
484 sqlite3AuthRead(pParse
, pExpr
, pSchema
, pNC
->pSrcList
);
486 /* Increment the nRef value on all name contexts from TopNC up to
487 ** the point where the name matched. */
491 if( pTopNC
==pNC
) break;
492 pTopNC
= pTopNC
->pNext
;
501 ** Allocate and return a pointer to an expression to load the column iCol
502 ** from datasource iSrc in SrcList pSrc.
504 Expr
*sqlite3CreateColumnExpr(sqlite3
*db
, SrcList
*pSrc
, int iSrc
, int iCol
){
505 Expr
*p
= sqlite3ExprAlloc(db
, TK_COLUMN
, 0, 0);
507 struct SrcList_item
*pItem
= &pSrc
->a
[iSrc
];
508 p
->pTab
= pItem
->pTab
;
509 p
->iTable
= pItem
->iCursor
;
510 if( p
->pTab
->iPKey
==iCol
){
513 p
->iColumn
= (ynVar
)iCol
;
514 testcase( iCol
==BMS
);
515 testcase( iCol
==BMS
-1 );
516 pItem
->colUsed
|= ((Bitmask
)1)<<(iCol
>=BMS
? BMS
-1 : iCol
);
518 ExprSetProperty(p
, EP_Resolved
);
524 ** Report an error that an expression is not valid for some set of
525 ** pNC->ncFlags values determined by validMask.
527 static void notValid(
528 Parse
*pParse
, /* Leave error message here */
529 NameContext
*pNC
, /* The name context */
530 const char *zMsg
, /* Type of error */
531 int validMask
/* Set of contexts for which prohibited */
533 assert( (validMask
&~(NC_IsCheck
|NC_PartIdx
|NC_IdxExpr
))==0 );
534 if( (pNC
->ncFlags
& validMask
)!=0 ){
535 const char *zIn
= "partial index WHERE clauses";
536 if( pNC
->ncFlags
& NC_IdxExpr
) zIn
= "index expressions";
537 #ifndef SQLITE_OMIT_CHECK
538 else if( pNC
->ncFlags
& NC_IsCheck
) zIn
= "CHECK constraints";
540 sqlite3ErrorMsg(pParse
, "%s prohibited in %s", zMsg
, zIn
);
545 ** Expression p should encode a floating point value between 1.0 and 0.0.
546 ** Return 1024 times this value. Or return -1 if p is not a floating point
547 ** value between 1.0 and 0.0.
549 static int exprProbability(Expr
*p
){
551 if( p
->op
!=TK_FLOAT
) return -1;
552 sqlite3AtoF(p
->u
.zToken
, &r
, sqlite3Strlen30(p
->u
.zToken
), SQLITE_UTF8
);
554 if( r
>1.0 ) return -1;
555 return (int)(r
*134217728.0);
559 ** This routine is callback for sqlite3WalkExpr().
561 ** Resolve symbolic names into TK_COLUMN operators for the current
562 ** node in the expression tree. Return 0 to continue the search down
563 ** the tree or 2 to abort the tree walk.
565 ** This routine also does error checking and name resolution for
566 ** function names. The operator for aggregate functions is changed
567 ** to TK_AGG_FUNCTION.
569 static int resolveExprStep(Walker
*pWalker
, Expr
*pExpr
){
573 pNC
= pWalker
->u
.pNC
;
575 pParse
= pNC
->pParse
;
576 assert( pParse
==pWalker
->pParse
);
578 if( ExprHasProperty(pExpr
, EP_Resolved
) ) return WRC_Prune
;
579 ExprSetProperty(pExpr
, EP_Resolved
);
581 if( pNC
->pSrcList
&& pNC
->pSrcList
->nAlloc
>0 ){
582 SrcList
*pSrcList
= pNC
->pSrcList
;
584 for(i
=0; i
<pNC
->pSrcList
->nSrc
; i
++){
585 assert( pSrcList
->a
[i
].iCursor
>=0 && pSrcList
->a
[i
].iCursor
<pParse
->nTab
);
591 #if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY)
592 /* The special operator TK_ROW means use the rowid for the first
593 ** column in the FROM clause. This is used by the LIMIT and ORDER BY
594 ** clause processing on UPDATE and DELETE statements.
597 SrcList
*pSrcList
= pNC
->pSrcList
;
598 struct SrcList_item
*pItem
;
599 assert( pSrcList
&& pSrcList
->nSrc
==1 );
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) */
611 /* A lone identifier is the name of a column.
614 return lookupName(pParse
, 0, 0, pExpr
->u
.zToken
, pNC
, pExpr
);
617 /* A table name and column name: ID.ID
618 ** Or a database, table and column: ID.ID.ID
626 /* if( pSrcList==0 ) break; */
627 notValid(pParse
, pNC
, "the \".\" operator", NC_IdxExpr
);
628 pRight
= pExpr
->pRight
;
629 if( pRight
->op
==TK_ID
){
631 zTable
= pExpr
->pLeft
->u
.zToken
;
632 zColumn
= pRight
->u
.zToken
;
634 assert( pRight
->op
==TK_DOT
);
635 zDb
= pExpr
->pLeft
->u
.zToken
;
636 zTable
= pRight
->pLeft
->u
.zToken
;
637 zColumn
= pRight
->pRight
->u
.zToken
;
639 return lookupName(pParse
, zDb
, zTable
, zColumn
, pNC
, pExpr
);
642 /* Resolve function names
645 ExprList
*pList
= pExpr
->x
.pList
; /* The argument list */
646 int n
= pList
? pList
->nExpr
: 0; /* Number of arguments */
647 int no_such_func
= 0; /* True if no such function exists */
648 int wrong_num_args
= 0; /* True if wrong number of arguments */
649 int is_agg
= 0; /* True if is an aggregate function */
650 int nId
; /* Number of characters in function name */
651 const char *zId
; /* The function name. */
652 FuncDef
*pDef
; /* Information about the function */
653 u8 enc
= ENC(pParse
->db
); /* The database encoding */
655 assert( !ExprHasProperty(pExpr
, EP_xIsSelect
) );
656 zId
= pExpr
->u
.zToken
;
657 nId
= sqlite3Strlen30(zId
);
658 pDef
= sqlite3FindFunction(pParse
->db
, zId
, n
, enc
, 0);
660 pDef
= sqlite3FindFunction(pParse
->db
, zId
, -2, enc
, 0);
667 is_agg
= pDef
->xFinalize
!=0;
668 if( pDef
->funcFlags
& SQLITE_FUNC_UNLIKELY
){
669 ExprSetProperty(pExpr
, EP_Unlikely
|EP_Skip
);
671 pExpr
->iTable
= exprProbability(pList
->a
[1].pExpr
);
672 if( pExpr
->iTable
<0 ){
673 sqlite3ErrorMsg(pParse
,
674 "second argument to likelihood() must be a "
675 "constant between 0.0 and 1.0");
679 /* EVIDENCE-OF: R-61304-29449 The unlikely(X) function is
680 ** equivalent to likelihood(X, 0.0625).
681 ** EVIDENCE-OF: R-01283-11636 The unlikely(X) function is
682 ** short-hand for likelihood(X,0.0625).
683 ** EVIDENCE-OF: R-36850-34127 The likely(X) function is short-hand
684 ** for likelihood(X,0.9375).
685 ** EVIDENCE-OF: R-53436-40973 The likely(X) function is equivalent
686 ** to likelihood(X,0.9375). */
687 /* TUNING: unlikely() probability is 0.0625. likely() is 0.9375 */
688 pExpr
->iTable
= pDef
->zName
[0]=='u' ? 8388608 : 125829120;
691 #ifndef SQLITE_OMIT_AUTHORIZATION
693 int auth
= sqlite3AuthCheck(pParse
, SQLITE_FUNCTION
, 0,pDef
->zName
,0);
694 if( auth
!=SQLITE_OK
){
695 if( auth
==SQLITE_DENY
){
696 sqlite3ErrorMsg(pParse
, "not authorized to use function: %s",
705 if( pDef
->funcFlags
& (SQLITE_FUNC_CONSTANT
|SQLITE_FUNC_SLOCHNG
) ){
706 /* For the purposes of the EP_ConstFunc flag, date and time
707 ** functions and other functions that change slowly are considered
708 ** constant because they are constant for the duration of one query */
709 ExprSetProperty(pExpr
,EP_ConstFunc
);
711 if( (pDef
->funcFlags
& SQLITE_FUNC_CONSTANT
)==0 ){
712 /* Date/time functions that use 'now', and other functions like
713 ** sqlite_version() that might change over time cannot be used
715 notValid(pParse
, pNC
, "non-deterministic functions",
716 NC_IdxExpr
|NC_PartIdx
);
719 if( is_agg
&& (pNC
->ncFlags
& NC_AllowAgg
)==0 ){
720 sqlite3ErrorMsg(pParse
, "misuse of aggregate function %.*s()", nId
,zId
);
723 }else if( no_such_func
&& pParse
->db
->init
.busy
==0
724 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
725 && pParse
->explain
==0
728 sqlite3ErrorMsg(pParse
, "no such function: %.*s", nId
, zId
);
730 }else if( wrong_num_args
){
731 sqlite3ErrorMsg(pParse
,"wrong number of arguments to function %.*s()",
735 if( is_agg
) pNC
->ncFlags
&= ~NC_AllowAgg
;
736 sqlite3WalkExprList(pWalker
, pList
);
738 NameContext
*pNC2
= pNC
;
739 pExpr
->op
= TK_AGG_FUNCTION
;
741 while( pNC2
&& !sqlite3FunctionUsesThisSrc(pExpr
, pNC2
->pSrcList
) ){
747 assert( SQLITE_FUNC_MINMAX
==NC_MinMaxAgg
);
748 testcase( (pDef
->funcFlags
& SQLITE_FUNC_MINMAX
)!=0 );
749 pNC2
->ncFlags
|= NC_HasAgg
| (pDef
->funcFlags
& SQLITE_FUNC_MINMAX
);
752 pNC
->ncFlags
|= NC_AllowAgg
;
754 /* FIX ME: Compute pExpr->affinity based on the expected return
755 ** type of the function
759 #ifndef SQLITE_OMIT_SUBQUERY
761 case TK_EXISTS
: testcase( pExpr
->op
==TK_EXISTS
);
764 testcase( pExpr
->op
==TK_IN
);
765 if( ExprHasProperty(pExpr
, EP_xIsSelect
) ){
766 int nRef
= pNC
->nRef
;
767 notValid(pParse
, pNC
, "subqueries", NC_IsCheck
|NC_PartIdx
|NC_IdxExpr
);
768 sqlite3WalkSelect(pWalker
, pExpr
->x
.pSelect
);
769 assert( pNC
->nRef
>=nRef
);
770 if( nRef
!=pNC
->nRef
){
771 ExprSetProperty(pExpr
, EP_VarSelect
);
772 pNC
->ncFlags
|= NC_VarSelect
;
778 notValid(pParse
, pNC
, "parameters", NC_IsCheck
|NC_PartIdx
|NC_IdxExpr
);
791 if( pParse
->db
->mallocFailed
) break;
792 assert( pExpr
->pLeft
!=0 );
793 nLeft
= sqlite3ExprVectorSize(pExpr
->pLeft
);
794 if( pExpr
->op
==TK_BETWEEN
){
795 nRight
= sqlite3ExprVectorSize(pExpr
->x
.pList
->a
[0].pExpr
);
797 nRight
= sqlite3ExprVectorSize(pExpr
->x
.pList
->a
[1].pExpr
);
800 assert( pExpr
->pRight
!=0 );
801 nRight
= sqlite3ExprVectorSize(pExpr
->pRight
);
804 testcase( pExpr
->op
==TK_EQ
);
805 testcase( pExpr
->op
==TK_NE
);
806 testcase( pExpr
->op
==TK_LT
);
807 testcase( pExpr
->op
==TK_LE
);
808 testcase( pExpr
->op
==TK_GT
);
809 testcase( pExpr
->op
==TK_GE
);
810 testcase( pExpr
->op
==TK_IS
);
811 testcase( pExpr
->op
==TK_ISNOT
);
812 testcase( pExpr
->op
==TK_BETWEEN
);
813 sqlite3ErrorMsg(pParse
, "row value misused");
818 return (pParse
->nErr
|| pParse
->db
->mallocFailed
) ? WRC_Abort
: WRC_Continue
;
822 ** pEList is a list of expressions which are really the result set of the
823 ** a SELECT statement. pE is a term in an ORDER BY or GROUP BY clause.
824 ** This routine checks to see if pE is a simple identifier which corresponds
825 ** to the AS-name of one of the terms of the expression list. If it is,
826 ** this routine return an integer between 1 and N where N is the number of
827 ** elements in pEList, corresponding to the matching entry. If there is
828 ** no match, or if pE is not a simple identifier, then this routine
831 ** pEList has been resolved. pE has not.
833 static int resolveAsName(
834 Parse
*pParse
, /* Parsing context for error messages */
835 ExprList
*pEList
, /* List of expressions to scan */
836 Expr
*pE
/* Expression we are trying to match */
838 int i
; /* Loop counter */
840 UNUSED_PARAMETER(pParse
);
843 char *zCol
= pE
->u
.zToken
;
844 for(i
=0; i
<pEList
->nExpr
; i
++){
845 char *zAs
= pEList
->a
[i
].zName
;
846 if( zAs
!=0 && sqlite3StrICmp(zAs
, zCol
)==0 ){
855 ** pE is a pointer to an expression which is a single term in the
856 ** ORDER BY of a compound SELECT. The expression has not been
859 ** At the point this routine is called, we already know that the
860 ** ORDER BY term is not an integer index into the result set. That
861 ** case is handled by the calling routine.
863 ** Attempt to match pE against result set columns in the left-most
864 ** SELECT statement. Return the index i of the matching column,
865 ** as an indication to the caller that it should sort by the i-th column.
866 ** The left-most column is 1. In other words, the value returned is the
867 ** same integer value that would be used in the SQL statement to indicate
870 ** If there is no match, return 0. Return -1 if an error occurs.
872 static int resolveOrderByTermToExprList(
873 Parse
*pParse
, /* Parsing context for error messages */
874 Select
*pSelect
, /* The SELECT statement with the ORDER BY clause */
875 Expr
*pE
/* The specific ORDER BY term */
877 int i
; /* Loop counter */
878 ExprList
*pEList
; /* The columns of the result set */
879 NameContext nc
; /* Name context for resolving pE */
880 sqlite3
*db
; /* Database connection */
881 int rc
; /* Return code from subprocedures */
882 u8 savedSuppErr
; /* Saved value of db->suppressErr */
884 assert( sqlite3ExprIsInteger(pE
, &i
)==0 );
885 pEList
= pSelect
->pEList
;
887 /* Resolve all names in the ORDER BY term expression
889 memset(&nc
, 0, sizeof(nc
));
891 nc
.pSrcList
= pSelect
->pSrc
;
893 nc
.ncFlags
= NC_AllowAgg
;
896 savedSuppErr
= db
->suppressErr
;
898 rc
= sqlite3ResolveExprNames(&nc
, pE
);
899 db
->suppressErr
= savedSuppErr
;
902 /* Try to match the ORDER BY expression against an expression
903 ** in the result set. Return an 1-based index of the matching
906 for(i
=0; i
<pEList
->nExpr
; i
++){
907 if( sqlite3ExprCompare(pEList
->a
[i
].pExpr
, pE
, -1)<2 ){
912 /* If no match, return 0. */
917 ** Generate an ORDER BY or GROUP BY term out-of-range error.
919 static void resolveOutOfRangeError(
920 Parse
*pParse
, /* The error context into which to write the error */
921 const char *zType
, /* "ORDER" or "GROUP" */
922 int i
, /* The index (1-based) of the term out of range */
923 int mx
/* Largest permissible value of i */
925 sqlite3ErrorMsg(pParse
,
926 "%r %s BY term out of range - should be "
927 "between 1 and %d", i
, zType
, mx
);
931 ** Analyze the ORDER BY clause in a compound SELECT statement. Modify
932 ** each term of the ORDER BY clause is a constant integer between 1
933 ** and N where N is the number of columns in the compound SELECT.
935 ** ORDER BY terms that are already an integer between 1 and N are
936 ** unmodified. ORDER BY terms that are integers outside the range of
937 ** 1 through N generate an error. ORDER BY terms that are expressions
938 ** are matched against result set expressions of compound SELECT
939 ** beginning with the left-most SELECT and working toward the right.
940 ** At the first match, the ORDER BY expression is transformed into
941 ** the integer column number.
943 ** Return the number of errors seen.
945 static int resolveCompoundOrderBy(
946 Parse
*pParse
, /* Parsing context. Leave error messages here */
947 Select
*pSelect
/* The SELECT statement containing the ORDER BY */
955 pOrderBy
= pSelect
->pOrderBy
;
956 if( pOrderBy
==0 ) return 0;
958 #if SQLITE_MAX_COLUMN
959 if( pOrderBy
->nExpr
>db
->aLimit
[SQLITE_LIMIT_COLUMN
] ){
960 sqlite3ErrorMsg(pParse
, "too many terms in ORDER BY clause");
964 for(i
=0; i
<pOrderBy
->nExpr
; i
++){
965 pOrderBy
->a
[i
].done
= 0;
968 while( pSelect
->pPrior
){
969 pSelect
->pPrior
->pNext
= pSelect
;
970 pSelect
= pSelect
->pPrior
;
972 while( pSelect
&& moreToDo
){
973 struct ExprList_item
*pItem
;
975 pEList
= pSelect
->pEList
;
977 for(i
=0, pItem
=pOrderBy
->a
; i
<pOrderBy
->nExpr
; i
++, pItem
++){
980 if( pItem
->done
) continue;
981 pE
= sqlite3ExprSkipCollate(pItem
->pExpr
);
982 if( sqlite3ExprIsInteger(pE
, &iCol
) ){
983 if( iCol
<=0 || iCol
>pEList
->nExpr
){
984 resolveOutOfRangeError(pParse
, "ORDER", i
+1, pEList
->nExpr
);
988 iCol
= resolveAsName(pParse
, pEList
, pE
);
990 pDup
= sqlite3ExprDup(db
, pE
, 0);
991 if( !db
->mallocFailed
){
993 iCol
= resolveOrderByTermToExprList(pParse
, pSelect
, pDup
);
995 sqlite3ExprDelete(db
, pDup
);
999 /* Convert the ORDER BY term into an integer column number iCol,
1000 ** taking care to preserve the COLLATE clause if it exists */
1001 Expr
*pNew
= sqlite3Expr(db
, TK_INTEGER
, 0);
1002 if( pNew
==0 ) return 1;
1003 pNew
->flags
|= EP_IntValue
;
1004 pNew
->u
.iValue
= iCol
;
1005 if( pItem
->pExpr
==pE
){
1006 pItem
->pExpr
= pNew
;
1008 Expr
*pParent
= pItem
->pExpr
;
1009 assert( pParent
->op
==TK_COLLATE
);
1010 while( pParent
->pLeft
->op
==TK_COLLATE
) pParent
= pParent
->pLeft
;
1011 assert( pParent
->pLeft
==pE
);
1012 pParent
->pLeft
= pNew
;
1014 sqlite3ExprDelete(db
, pE
);
1015 pItem
->u
.x
.iOrderByCol
= (u16
)iCol
;
1021 pSelect
= pSelect
->pNext
;
1023 for(i
=0; i
<pOrderBy
->nExpr
; i
++){
1024 if( pOrderBy
->a
[i
].done
==0 ){
1025 sqlite3ErrorMsg(pParse
, "%r ORDER BY term does not match any "
1026 "column in the result set", i
+1);
1034 ** Check every term in the ORDER BY or GROUP BY clause pOrderBy of
1035 ** the SELECT statement pSelect. If any term is reference to a
1036 ** result set expression (as determined by the ExprList.a.u.x.iOrderByCol
1037 ** field) then convert that term into a copy of the corresponding result set
1040 ** If any errors are detected, add an error message to pParse and
1041 ** return non-zero. Return zero if no errors are seen.
1043 int sqlite3ResolveOrderGroupBy(
1044 Parse
*pParse
, /* Parsing context. Leave error messages here */
1045 Select
*pSelect
, /* The SELECT statement containing the clause */
1046 ExprList
*pOrderBy
, /* The ORDER BY or GROUP BY clause to be processed */
1047 const char *zType
/* "ORDER" or "GROUP" */
1050 sqlite3
*db
= pParse
->db
;
1052 struct ExprList_item
*pItem
;
1054 if( pOrderBy
==0 || pParse
->db
->mallocFailed
) return 0;
1055 #if SQLITE_MAX_COLUMN
1056 if( pOrderBy
->nExpr
>db
->aLimit
[SQLITE_LIMIT_COLUMN
] ){
1057 sqlite3ErrorMsg(pParse
, "too many terms in %s BY clause", zType
);
1061 pEList
= pSelect
->pEList
;
1062 assert( pEList
!=0 ); /* sqlite3SelectNew() guarantees this */
1063 for(i
=0, pItem
=pOrderBy
->a
; i
<pOrderBy
->nExpr
; i
++, pItem
++){
1064 if( pItem
->u
.x
.iOrderByCol
){
1065 if( pItem
->u
.x
.iOrderByCol
>pEList
->nExpr
){
1066 resolveOutOfRangeError(pParse
, zType
, i
+1, pEList
->nExpr
);
1069 resolveAlias(pParse
, pEList
, pItem
->u
.x
.iOrderByCol
-1, pItem
->pExpr
,
1077 ** pOrderBy is an ORDER BY or GROUP BY clause in SELECT statement pSelect.
1078 ** The Name context of the SELECT statement is pNC. zType is either
1079 ** "ORDER" or "GROUP" depending on which type of clause pOrderBy is.
1081 ** This routine resolves each term of the clause into an expression.
1082 ** If the order-by term is an integer I between 1 and N (where N is the
1083 ** number of columns in the result set of the SELECT) then the expression
1084 ** in the resolution is a copy of the I-th result-set expression. If
1085 ** the order-by term is an identifier that corresponds to the AS-name of
1086 ** a result-set expression, then the term resolves to a copy of the
1087 ** result-set expression. Otherwise, the expression is resolved in
1088 ** the usual way - using sqlite3ResolveExprNames().
1090 ** This routine returns the number of errors. If errors occur, then
1091 ** an appropriate error message might be left in pParse. (OOM errors
1094 static int resolveOrderGroupBy(
1095 NameContext
*pNC
, /* The name context of the SELECT statement */
1096 Select
*pSelect
, /* The SELECT statement holding pOrderBy */
1097 ExprList
*pOrderBy
, /* An ORDER BY or GROUP BY clause to resolve */
1098 const char *zType
/* Either "ORDER" or "GROUP", as appropriate */
1100 int i
, j
; /* Loop counters */
1101 int iCol
; /* Column number */
1102 struct ExprList_item
*pItem
; /* A term of the ORDER BY clause */
1103 Parse
*pParse
; /* Parsing context */
1104 int nResult
; /* Number of terms in the result set */
1106 if( pOrderBy
==0 ) return 0;
1107 nResult
= pSelect
->pEList
->nExpr
;
1108 pParse
= pNC
->pParse
;
1109 for(i
=0, pItem
=pOrderBy
->a
; i
<pOrderBy
->nExpr
; i
++, pItem
++){
1110 Expr
*pE
= pItem
->pExpr
;
1111 Expr
*pE2
= sqlite3ExprSkipCollate(pE
);
1112 if( zType
[0]!='G' ){
1113 iCol
= resolveAsName(pParse
, pSelect
->pEList
, pE2
);
1115 /* If an AS-name match is found, mark this ORDER BY column as being
1116 ** a copy of the iCol-th result-set column. The subsequent call to
1117 ** sqlite3ResolveOrderGroupBy() will convert the expression to a
1118 ** copy of the iCol-th result-set expression. */
1119 pItem
->u
.x
.iOrderByCol
= (u16
)iCol
;
1123 if( sqlite3ExprIsInteger(pE2
, &iCol
) ){
1124 /* The ORDER BY term is an integer constant. Again, set the column
1125 ** number so that sqlite3ResolveOrderGroupBy() will convert the
1126 ** order-by term to a copy of the result-set expression */
1127 if( iCol
<1 || iCol
>0xffff ){
1128 resolveOutOfRangeError(pParse
, zType
, i
+1, nResult
);
1131 pItem
->u
.x
.iOrderByCol
= (u16
)iCol
;
1135 /* Otherwise, treat the ORDER BY term as an ordinary expression */
1136 pItem
->u
.x
.iOrderByCol
= 0;
1137 if( sqlite3ResolveExprNames(pNC
, pE
) ){
1140 for(j
=0; j
<pSelect
->pEList
->nExpr
; j
++){
1141 if( sqlite3ExprCompare(pE
, pSelect
->pEList
->a
[j
].pExpr
, -1)==0 ){
1142 pItem
->u
.x
.iOrderByCol
= j
+1;
1146 return sqlite3ResolveOrderGroupBy(pParse
, pSelect
, pOrderBy
, zType
);
1150 ** Resolve names in the SELECT statement p and all of its descendants.
1152 static int resolveSelectStep(Walker
*pWalker
, Select
*p
){
1153 NameContext
*pOuterNC
; /* Context that contains this SELECT */
1154 NameContext sNC
; /* Name context of this SELECT */
1155 int isCompound
; /* True if p is a compound select */
1156 int nCompound
; /* Number of compound terms processed so far */
1157 Parse
*pParse
; /* Parsing context */
1158 int i
; /* Loop counter */
1159 ExprList
*pGroupBy
; /* The GROUP BY clause */
1160 Select
*pLeftmost
; /* Left-most of SELECT of a compound */
1161 sqlite3
*db
; /* Database connection */
1165 if( p
->selFlags
& SF_Resolved
){
1168 pOuterNC
= pWalker
->u
.pNC
;
1169 pParse
= pWalker
->pParse
;
1172 /* Normally sqlite3SelectExpand() will be called first and will have
1173 ** already expanded this SELECT. However, if this is a subquery within
1174 ** an expression, sqlite3ResolveExprNames() will be called without a
1175 ** prior call to sqlite3SelectExpand(). When that happens, let
1176 ** sqlite3SelectPrep() do all of the processing for this SELECT.
1177 ** sqlite3SelectPrep() will invoke both sqlite3SelectExpand() and
1178 ** this routine in the correct order.
1180 if( (p
->selFlags
& SF_Expanded
)==0 ){
1181 sqlite3SelectPrep(pParse
, p
, pOuterNC
);
1182 return (pParse
->nErr
|| db
->mallocFailed
) ? WRC_Abort
: WRC_Prune
;
1185 isCompound
= p
->pPrior
!=0;
1189 assert( (p
->selFlags
& SF_Expanded
)!=0 );
1190 assert( (p
->selFlags
& SF_Resolved
)==0 );
1191 p
->selFlags
|= SF_Resolved
;
1193 /* Resolve the expressions in the LIMIT and OFFSET clauses. These
1194 ** are not allowed to refer to any names, so pass an empty NameContext.
1196 memset(&sNC
, 0, sizeof(sNC
));
1197 sNC
.pParse
= pParse
;
1198 if( sqlite3ResolveExprNames(&sNC
, p
->pLimit
) ||
1199 sqlite3ResolveExprNames(&sNC
, p
->pOffset
) ){
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 0;
1428 #if SQLITE_MAX_EXPR_DEPTH>0
1430 Parse
*pParse
= pNC
->pParse
;
1431 if( sqlite3ExprCheckHeight(pParse
, pExpr
->nHeight
+pNC
->pParse
->nHeight
) ){
1434 pParse
->nHeight
+= pExpr
->nHeight
;
1437 savedHasAgg
= pNC
->ncFlags
& (NC_HasAgg
|NC_MinMaxAgg
);
1438 pNC
->ncFlags
&= ~(NC_HasAgg
|NC_MinMaxAgg
);
1439 w
.pParse
= pNC
->pParse
;
1440 w
.xExprCallback
= resolveExprStep
;
1441 w
.xSelectCallback
= resolveSelectStep
;
1442 w
.xSelectCallback2
= 0;
1446 sqlite3WalkExpr(&w
, pExpr
);
1447 #if SQLITE_MAX_EXPR_DEPTH>0
1448 pNC
->pParse
->nHeight
-= pExpr
->nHeight
;
1450 if( pNC
->nErr
>0 || w
.pParse
->nErr
>0 ){
1451 ExprSetProperty(pExpr
, EP_Error
);
1453 if( pNC
->ncFlags
& NC_HasAgg
){
1454 ExprSetProperty(pExpr
, EP_Agg
);
1456 pNC
->ncFlags
|= savedHasAgg
;
1457 return ExprHasProperty(pExpr
, EP_Error
);
1461 ** Resolve all names for all expression in an expression list. This is
1462 ** just like sqlite3ResolveExprNames() except that it works for an expression
1463 ** list rather than a single expression.
1465 int sqlite3ResolveExprListNames(
1466 NameContext
*pNC
, /* Namespace to resolve expressions in. */
1467 ExprList
*pList
/* The expression list to be analyzed. */
1471 for(i
=0; i
<pList
->nExpr
; i
++){
1472 if( sqlite3ResolveExprNames(pNC
, pList
->a
[i
].pExpr
) ) return WRC_Abort
;
1475 return WRC_Continue
;
1479 ** Resolve all names in all expressions of a SELECT and in all
1480 ** decendents of the SELECT, including compounds off of p->pPrior,
1481 ** subqueries in expressions, and subqueries used as FROM clause
1484 ** See sqlite3ResolveExprNames() for a description of the kinds of
1485 ** transformations that occur.
1487 ** All SELECT statements should have been expanded using
1488 ** sqlite3SelectExpand() prior to invoking this routine.
1490 void sqlite3ResolveSelectNames(
1491 Parse
*pParse
, /* The parser context */
1492 Select
*p
, /* The SELECT statement being coded. */
1493 NameContext
*pOuterNC
/* Name context for parent SELECT statement */
1498 memset(&w
, 0, sizeof(w
));
1499 w
.xExprCallback
= resolveExprStep
;
1500 w
.xSelectCallback
= resolveSelectStep
;
1503 sqlite3WalkSelect(&w
, p
);
1507 ** Resolve names in expressions that can only reference a single table:
1509 ** * CHECK constraints
1510 ** * WHERE clauses on partial indices
1512 ** The Expr.iTable value for Expr.op==TK_COLUMN nodes of the expression
1513 ** is set to -1 and the Expr.iColumn value is set to the column number.
1515 ** Any errors cause an error message to be set in pParse.
1517 void sqlite3ResolveSelfReference(
1518 Parse
*pParse
, /* Parsing context */
1519 Table
*pTab
, /* The table being referenced */
1520 int type
, /* NC_IsCheck or NC_PartIdx or NC_IdxExpr */
1521 Expr
*pExpr
, /* Expression to resolve. May be NULL. */
1522 ExprList
*pList
/* Expression list to resolve. May be NUL. */
1524 SrcList sSrc
; /* Fake SrcList for pParse->pNewTable */
1525 NameContext sNC
; /* Name context for pParse->pNewTable */
1527 assert( type
==NC_IsCheck
|| type
==NC_PartIdx
|| type
==NC_IdxExpr
);
1528 memset(&sNC
, 0, sizeof(sNC
));
1529 memset(&sSrc
, 0, sizeof(sSrc
));
1531 sSrc
.a
[0].zName
= pTab
->zName
;
1532 sSrc
.a
[0].pTab
= pTab
;
1533 sSrc
.a
[0].iCursor
= -1;
1534 sNC
.pParse
= pParse
;
1535 sNC
.pSrcList
= &sSrc
;
1537 if( sqlite3ResolveExprNames(&sNC
, pExpr
) ) return;
1538 if( pList
) sqlite3ResolveExprListNames(&sNC
, pList
);