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 eNewExprOp
= TK_COLUMN
; /* New value for pExpr->op on success */
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 #if !defined(SQLITE_OMIT_TRIGGER) || !defined(SQLITE_OMIT_UPSERT)
300 /* If we have not already resolved the name, then maybe
301 ** it is a new.* or old.* trigger argument reference. Or
302 ** maybe it is an excluded.* from an upsert.
304 if( zDb
==0 && zTab
!=0 && cntTab
==0 ){
306 #ifndef SQLITE_OMIT_TRIGGER
307 if( pParse
->pTriggerTab
!=0 ){
308 int op
= pParse
->eTriggerOp
;
309 assert( op
==TK_DELETE
|| op
==TK_UPDATE
|| op
==TK_INSERT
);
310 if( op
!=TK_DELETE
&& sqlite3StrICmp("new",zTab
) == 0 ){
312 pTab
= pParse
->pTriggerTab
;
313 }else if( op
!=TK_INSERT
&& sqlite3StrICmp("old",zTab
)==0 ){
315 pTab
= pParse
->pTriggerTab
;
318 #endif /* SQLITE_OMIT_TRIGGER */
319 #ifndef SQLITE_OMIT_UPSERT
320 if( (pNC
->ncFlags
& NC_UUpsert
)!=0 ){
321 Upsert
*pUpsert
= pNC
->uNC
.pUpsert
;
322 if( pUpsert
&& sqlite3StrICmp("excluded",zTab
)==0 ){
323 pTab
= pUpsert
->pUpsertSrc
->a
[0].pTab
;
327 #endif /* SQLITE_OMIT_UPSERT */
331 pSchema
= pTab
->pSchema
;
333 for(iCol
=0, pCol
=pTab
->aCol
; iCol
<pTab
->nCol
; iCol
++, pCol
++){
334 if( sqlite3StrICmp(pCol
->zName
, zCol
)==0 ){
335 if( iCol
==pTab
->iPKey
){
341 if( iCol
>=pTab
->nCol
&& sqlite3IsRowid(zCol
) && VisibleRowid(pTab
) ){
342 /* IMP: R-51414-32910 */
345 if( iCol
<pTab
->nCol
){
347 #ifndef SQLITE_OMIT_UPSERT
348 if( pExpr
->iTable
==2 ){
349 testcase( iCol
==(-1) );
350 pExpr
->iTable
= pNC
->uNC
.pUpsert
->regData
+ iCol
;
351 eNewExprOp
= TK_REGISTER
;
353 #endif /* SQLITE_OMIT_UPSERT */
355 #ifndef SQLITE_OMIT_TRIGGER
357 pExpr
->affinity
= SQLITE_AFF_INTEGER
;
358 }else if( pExpr
->iTable
==0 ){
359 testcase( iCol
==31 );
360 testcase( iCol
==32 );
361 pParse
->oldmask
|= (iCol
>=32 ? 0xffffffff : (((u32
)1)<<iCol
));
363 testcase( iCol
==31 );
364 testcase( iCol
==32 );
365 pParse
->newmask
|= (iCol
>=32 ? 0xffffffff : (((u32
)1)<<iCol
));
368 pExpr
->iColumn
= (i16
)iCol
;
369 eNewExprOp
= TK_TRIGGER
;
370 #endif /* SQLITE_OMIT_TRIGGER */
375 #endif /* !defined(SQLITE_OMIT_TRIGGER) || !defined(SQLITE_OMIT_UPSERT) */
378 ** Perhaps the name is a reference to the ROWID
383 && (pNC
->ncFlags
& NC_IdxExpr
)==0
384 && sqlite3IsRowid(zCol
)
385 && VisibleRowid(pMatch
->pTab
)
389 pExpr
->affinity
= SQLITE_AFF_INTEGER
;
393 ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z
394 ** might refer to an result-set alias. This happens, for example, when
395 ** we are resolving names in the WHERE clause of the following command:
397 ** SELECT a+b AS x FROM table WHERE x<10;
399 ** In cases like this, replace pExpr with a copy of the expression that
400 ** forms the result set entry ("a+b" in the example) and return immediately.
401 ** Note that the expression in the result set should have already been
402 ** resolved by the time the WHERE clause is resolved.
404 ** The ability to use an output result-set column in the WHERE, GROUP BY,
405 ** or HAVING clauses, or as part of a larger expression in the ORDER BY
406 ** clause is not standard SQL. This is a (goofy) SQLite extension, that
407 ** is supported for backwards compatibility only. Hence, we issue a warning
408 ** on sqlite3_log() whenever the capability is used.
410 if( (pNC
->ncFlags
& NC_UEList
)!=0
414 pEList
= pNC
->uNC
.pEList
;
416 for(j
=0; j
<pEList
->nExpr
; j
++){
417 char *zAs
= pEList
->a
[j
].zName
;
418 if( zAs
!=0 && sqlite3StrICmp(zAs
, zCol
)==0 ){
420 assert( pExpr
->pLeft
==0 && pExpr
->pRight
==0 );
421 assert( pExpr
->x
.pList
==0 );
422 assert( pExpr
->x
.pSelect
==0 );
423 pOrig
= pEList
->a
[j
].pExpr
;
424 if( (pNC
->ncFlags
&NC_AllowAgg
)==0 && ExprHasProperty(pOrig
, EP_Agg
) ){
425 sqlite3ErrorMsg(pParse
, "misuse of aliased aggregate %s", zAs
);
428 if( sqlite3ExprVectorSize(pOrig
)!=1 ){
429 sqlite3ErrorMsg(pParse
, "row value misused");
432 resolveAlias(pParse
, pEList
, j
, pExpr
, "", nSubquery
);
435 assert( zTab
==0 && zDb
==0 );
441 /* Advance to the next name context. The loop will exit when either
442 ** we have a match (cnt>0) or when we run out of name contexts.
451 ** If X and Y are NULL (in other words if only the column name Z is
452 ** supplied) and the value of Z is enclosed in double-quotes, then
453 ** Z is a string literal if it doesn't match any column names. In that
454 ** case, we need to return right away and not make any changes to
457 ** Because no reference was made to outer contexts, the pNC->nRef
458 ** fields are not changed in any context.
460 if( cnt
==0 && zTab
==0 ){
461 assert( pExpr
->op
==TK_ID
);
462 if( ExprHasProperty(pExpr
,EP_DblQuoted
) ){
463 pExpr
->op
= TK_STRING
;
467 if( sqlite3ExprIdToTrueFalse(pExpr
) ){
473 ** cnt==0 means there was not match. cnt>1 means there were two or
474 ** more matches. Either way, we have an error.
478 zErr
= cnt
==0 ? "no such column" : "ambiguous column name";
480 sqlite3ErrorMsg(pParse
, "%s: %s.%s.%s", zErr
, zDb
, zTab
, zCol
);
482 sqlite3ErrorMsg(pParse
, "%s: %s.%s", zErr
, zTab
, zCol
);
484 sqlite3ErrorMsg(pParse
, "%s: %s", zErr
, zCol
);
486 pParse
->checkSchema
= 1;
490 /* If a column from a table in pSrcList is referenced, then record
491 ** this fact in the pSrcList.a[].colUsed bitmask. Column 0 causes
492 ** bit 0 to be set. Column 1 sets bit 1. And so forth. If the
493 ** column number is greater than the number of bits in the bitmask
494 ** then set the high-order bit of the bitmask.
496 if( pExpr
->iColumn
>=0 && pMatch
!=0 ){
497 int n
= pExpr
->iColumn
;
498 testcase( n
==BMS
-1 );
502 assert( pMatch
->iCursor
==pExpr
->iTable
);
503 pMatch
->colUsed
|= ((Bitmask
)1)<<n
;
506 /* Clean up and return
508 sqlite3ExprDelete(db
, pExpr
->pLeft
);
510 sqlite3ExprDelete(db
, pExpr
->pRight
);
512 pExpr
->op
= eNewExprOp
;
513 ExprSetProperty(pExpr
, EP_Leaf
);
517 if( !ExprHasProperty(pExpr
, EP_Alias
) ){
518 sqlite3AuthRead(pParse
, pExpr
, pSchema
, pNC
->pSrcList
);
520 /* Increment the nRef value on all name contexts from TopNC up to
521 ** the point where the name matched. */
525 if( pTopNC
==pNC
) break;
526 pTopNC
= pTopNC
->pNext
;
535 ** Allocate and return a pointer to an expression to load the column iCol
536 ** from datasource iSrc in SrcList pSrc.
538 Expr
*sqlite3CreateColumnExpr(sqlite3
*db
, SrcList
*pSrc
, int iSrc
, int iCol
){
539 Expr
*p
= sqlite3ExprAlloc(db
, TK_COLUMN
, 0, 0);
541 struct SrcList_item
*pItem
= &pSrc
->a
[iSrc
];
542 p
->pTab
= pItem
->pTab
;
543 p
->iTable
= pItem
->iCursor
;
544 if( p
->pTab
->iPKey
==iCol
){
547 p
->iColumn
= (ynVar
)iCol
;
548 testcase( iCol
==BMS
);
549 testcase( iCol
==BMS
-1 );
550 pItem
->colUsed
|= ((Bitmask
)1)<<(iCol
>=BMS
? BMS
-1 : iCol
);
557 ** Report an error that an expression is not valid for some set of
558 ** pNC->ncFlags values determined by validMask.
560 static void notValid(
561 Parse
*pParse
, /* Leave error message here */
562 NameContext
*pNC
, /* The name context */
563 const char *zMsg
, /* Type of error */
564 int validMask
/* Set of contexts for which prohibited */
566 assert( (validMask
&~(NC_IsCheck
|NC_PartIdx
|NC_IdxExpr
))==0 );
567 if( (pNC
->ncFlags
& validMask
)!=0 ){
568 const char *zIn
= "partial index WHERE clauses";
569 if( pNC
->ncFlags
& NC_IdxExpr
) zIn
= "index expressions";
570 #ifndef SQLITE_OMIT_CHECK
571 else if( pNC
->ncFlags
& NC_IsCheck
) zIn
= "CHECK constraints";
573 sqlite3ErrorMsg(pParse
, "%s prohibited in %s", zMsg
, zIn
);
578 ** Expression p should encode a floating point value between 1.0 and 0.0.
579 ** Return 1024 times this value. Or return -1 if p is not a floating point
580 ** value between 1.0 and 0.0.
582 static int exprProbability(Expr
*p
){
584 if( p
->op
!=TK_FLOAT
) return -1;
585 sqlite3AtoF(p
->u
.zToken
, &r
, sqlite3Strlen30(p
->u
.zToken
), SQLITE_UTF8
);
587 if( r
>1.0 ) return -1;
588 return (int)(r
*134217728.0);
592 ** This routine is callback for sqlite3WalkExpr().
594 ** Resolve symbolic names into TK_COLUMN operators for the current
595 ** node in the expression tree. Return 0 to continue the search down
596 ** the tree or 2 to abort the tree walk.
598 ** This routine also does error checking and name resolution for
599 ** function names. The operator for aggregate functions is changed
600 ** to TK_AGG_FUNCTION.
602 static int resolveExprStep(Walker
*pWalker
, Expr
*pExpr
){
606 pNC
= pWalker
->u
.pNC
;
608 pParse
= pNC
->pParse
;
609 assert( pParse
==pWalker
->pParse
);
612 if( pNC
->pSrcList
&& pNC
->pSrcList
->nAlloc
>0 ){
613 SrcList
*pSrcList
= pNC
->pSrcList
;
615 for(i
=0; i
<pNC
->pSrcList
->nSrc
; i
++){
616 assert( pSrcList
->a
[i
].iCursor
>=0 && pSrcList
->a
[i
].iCursor
<pParse
->nTab
);
622 #if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY)
623 /* The special operator TK_ROW means use the rowid for the first
624 ** column in the FROM clause. This is used by the LIMIT and ORDER BY
625 ** clause processing on UPDATE and DELETE statements.
628 SrcList
*pSrcList
= pNC
->pSrcList
;
629 struct SrcList_item
*pItem
;
630 assert( pSrcList
&& pSrcList
->nSrc
==1 );
632 assert( HasRowid(pItem
->pTab
) && pItem
->pTab
->pSelect
==0 );
633 pExpr
->op
= TK_COLUMN
;
634 pExpr
->pTab
= pItem
->pTab
;
635 pExpr
->iTable
= pItem
->iCursor
;
637 pExpr
->affinity
= SQLITE_AFF_INTEGER
;
640 #endif /* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT)
641 && !defined(SQLITE_OMIT_SUBQUERY) */
644 ** Or table name and column name: ID.ID
645 ** Or a database, table and column: ID.ID.ID
647 ** The TK_ID and TK_OUT cases are combined so that there will only
648 ** be one call to lookupName(). Then the compiler will in-line
649 ** lookupName() for a size reduction and performance increase.
658 if( pExpr
->op
==TK_ID
){
661 zColumn
= pExpr
->u
.zToken
;
663 notValid(pParse
, pNC
, "the \".\" operator", NC_IdxExpr
);
664 pRight
= pExpr
->pRight
;
665 if( pRight
->op
==TK_ID
){
667 zTable
= pExpr
->pLeft
->u
.zToken
;
668 zColumn
= pRight
->u
.zToken
;
670 assert( pRight
->op
==TK_DOT
);
671 zDb
= pExpr
->pLeft
->u
.zToken
;
672 zTable
= pRight
->pLeft
->u
.zToken
;
673 zColumn
= pRight
->pRight
->u
.zToken
;
676 return lookupName(pParse
, zDb
, zTable
, zColumn
, pNC
, pExpr
);
679 /* Resolve function names
682 ExprList
*pList
= pExpr
->x
.pList
; /* The argument list */
683 int n
= pList
? pList
->nExpr
: 0; /* Number of arguments */
684 int no_such_func
= 0; /* True if no such function exists */
685 int wrong_num_args
= 0; /* True if wrong number of arguments */
686 int is_agg
= 0; /* True if is an aggregate function */
687 int nId
; /* Number of characters in function name */
688 const char *zId
; /* The function name. */
689 FuncDef
*pDef
; /* Information about the function */
690 u8 enc
= ENC(pParse
->db
); /* The database encoding */
692 assert( !ExprHasProperty(pExpr
, EP_xIsSelect
) );
693 zId
= pExpr
->u
.zToken
;
694 nId
= sqlite3Strlen30(zId
);
695 pDef
= sqlite3FindFunction(pParse
->db
, zId
, n
, enc
, 0);
697 pDef
= sqlite3FindFunction(pParse
->db
, zId
, -2, enc
, 0);
704 is_agg
= pDef
->xFinalize
!=0;
705 if( pDef
->funcFlags
& SQLITE_FUNC_UNLIKELY
){
706 ExprSetProperty(pExpr
, EP_Unlikely
|EP_Skip
);
708 pExpr
->iTable
= exprProbability(pList
->a
[1].pExpr
);
709 if( pExpr
->iTable
<0 ){
710 sqlite3ErrorMsg(pParse
,
711 "second argument to likelihood() must be a "
712 "constant between 0.0 and 1.0");
716 /* EVIDENCE-OF: R-61304-29449 The unlikely(X) function is
717 ** equivalent to likelihood(X, 0.0625).
718 ** EVIDENCE-OF: R-01283-11636 The unlikely(X) function is
719 ** short-hand for likelihood(X,0.0625).
720 ** EVIDENCE-OF: R-36850-34127 The likely(X) function is short-hand
721 ** for likelihood(X,0.9375).
722 ** EVIDENCE-OF: R-53436-40973 The likely(X) function is equivalent
723 ** to likelihood(X,0.9375). */
724 /* TUNING: unlikely() probability is 0.0625. likely() is 0.9375 */
725 pExpr
->iTable
= pDef
->zName
[0]=='u' ? 8388608 : 125829120;
728 #ifndef SQLITE_OMIT_AUTHORIZATION
730 int auth
= sqlite3AuthCheck(pParse
, SQLITE_FUNCTION
, 0,pDef
->zName
,0);
731 if( auth
!=SQLITE_OK
){
732 if( auth
==SQLITE_DENY
){
733 sqlite3ErrorMsg(pParse
, "not authorized to use function: %s",
742 if( pDef
->funcFlags
& (SQLITE_FUNC_CONSTANT
|SQLITE_FUNC_SLOCHNG
) ){
743 /* For the purposes of the EP_ConstFunc flag, date and time
744 ** functions and other functions that change slowly are considered
745 ** constant because they are constant for the duration of one query */
746 ExprSetProperty(pExpr
,EP_ConstFunc
);
748 if( (pDef
->funcFlags
& SQLITE_FUNC_CONSTANT
)==0 ){
749 /* Date/time functions that use 'now', and other functions like
750 ** sqlite_version() that might change over time cannot be used
752 notValid(pParse
, pNC
, "non-deterministic functions",
753 NC_IdxExpr
|NC_PartIdx
);
756 if( (is_agg
&& (pNC
->ncFlags
& NC_AllowAgg
)==0)
757 || (pExpr
->pWin
&& (pNC
->ncFlags
& NC_AllowWin
)==0)
759 const char *zType
= pExpr
->pWin
? "window" : "aggregate";
760 sqlite3ErrorMsg(pParse
, "misuse of %s function %.*s()",zType
,nId
,zId
);
763 }else if( no_such_func
&& pParse
->db
->init
.busy
==0
764 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
765 && pParse
->explain
==0
768 sqlite3ErrorMsg(pParse
, "no such function: %.*s", nId
, zId
);
770 }else if( wrong_num_args
){
771 sqlite3ErrorMsg(pParse
,"wrong number of arguments to function %.*s()",
775 if( is_agg
) pNC
->ncFlags
&= ~NC_AllowAgg
;
776 sqlite3WalkExprList(pWalker
, pList
);
779 sqlite3WindowUpdate(pParse
, pExpr
->pWin
, pDef
);
781 || 0==sqlite3WindowCompare(pParse
, pNC
->pWin
, pExpr
->pWin
)
783 pExpr
->pWin
->pNextWin
= pNC
->pWin
;
784 pNC
->pWin
= pExpr
->pWin
;
786 pExpr
->pWin
->pFunc
= pDef
;
787 pExpr
->pWin
->nArg
= (pExpr
->x
.pList
? pExpr
->x
.pList
->nExpr
: 0);
789 NameContext
*pNC2
= pNC
;
790 pExpr
->op
= TK_AGG_FUNCTION
;
792 while( pNC2
&& !sqlite3FunctionUsesThisSrc(pExpr
, pNC2
->pSrcList
) ){
798 assert( SQLITE_FUNC_MINMAX
==NC_MinMaxAgg
);
799 testcase( (pDef
->funcFlags
& SQLITE_FUNC_MINMAX
)!=0 );
800 pNC2
->ncFlags
|= NC_HasAgg
| (pDef
->funcFlags
& SQLITE_FUNC_MINMAX
);
804 pNC
->ncFlags
|= NC_AllowAgg
;
806 /* FIX ME: Compute pExpr->affinity based on the expected return
807 ** type of the function
811 #ifndef SQLITE_OMIT_SUBQUERY
813 case TK_EXISTS
: testcase( pExpr
->op
==TK_EXISTS
);
816 testcase( pExpr
->op
==TK_IN
);
817 if( ExprHasProperty(pExpr
, EP_xIsSelect
) ){
818 int nRef
= pNC
->nRef
;
819 notValid(pParse
, pNC
, "subqueries", NC_IsCheck
|NC_PartIdx
|NC_IdxExpr
);
820 sqlite3WalkSelect(pWalker
, pExpr
->x
.pSelect
);
821 assert( pNC
->nRef
>=nRef
);
822 if( nRef
!=pNC
->nRef
){
823 ExprSetProperty(pExpr
, EP_VarSelect
);
824 pNC
->ncFlags
|= NC_VarSelect
;
830 notValid(pParse
, pNC
, "parameters", NC_IsCheck
|NC_PartIdx
|NC_IdxExpr
);
836 assert( !ExprHasProperty(pExpr
, EP_Reduced
) );
837 /* Handle special cases of "x IS TRUE", "x IS FALSE", "x IS NOT TRUE",
838 ** and "x IS NOT FALSE". */
839 if( (pRight
= pExpr
->pRight
)->op
==TK_ID
){
840 int rc
= resolveExprStep(pWalker
, pRight
);
841 if( rc
==WRC_Abort
) return WRC_Abort
;
842 if( pRight
->op
==TK_TRUEFALSE
){
843 pExpr
->op2
= pExpr
->op
;
844 pExpr
->op
= TK_TRUTH
;
858 if( pParse
->db
->mallocFailed
) break;
859 assert( pExpr
->pLeft
!=0 );
860 nLeft
= sqlite3ExprVectorSize(pExpr
->pLeft
);
861 if( pExpr
->op
==TK_BETWEEN
){
862 nRight
= sqlite3ExprVectorSize(pExpr
->x
.pList
->a
[0].pExpr
);
864 nRight
= sqlite3ExprVectorSize(pExpr
->x
.pList
->a
[1].pExpr
);
867 assert( pExpr
->pRight
!=0 );
868 nRight
= sqlite3ExprVectorSize(pExpr
->pRight
);
871 testcase( pExpr
->op
==TK_EQ
);
872 testcase( pExpr
->op
==TK_NE
);
873 testcase( pExpr
->op
==TK_LT
);
874 testcase( pExpr
->op
==TK_LE
);
875 testcase( pExpr
->op
==TK_GT
);
876 testcase( pExpr
->op
==TK_GE
);
877 testcase( pExpr
->op
==TK_IS
);
878 testcase( pExpr
->op
==TK_ISNOT
);
879 testcase( pExpr
->op
==TK_BETWEEN
);
880 sqlite3ErrorMsg(pParse
, "row value misused");
885 return (pParse
->nErr
|| pParse
->db
->mallocFailed
) ? WRC_Abort
: WRC_Continue
;
889 ** pEList is a list of expressions which are really the result set of the
890 ** a SELECT statement. pE is a term in an ORDER BY or GROUP BY clause.
891 ** This routine checks to see if pE is a simple identifier which corresponds
892 ** to the AS-name of one of the terms of the expression list. If it is,
893 ** this routine return an integer between 1 and N where N is the number of
894 ** elements in pEList, corresponding to the matching entry. If there is
895 ** no match, or if pE is not a simple identifier, then this routine
898 ** pEList has been resolved. pE has not.
900 static int resolveAsName(
901 Parse
*pParse
, /* Parsing context for error messages */
902 ExprList
*pEList
, /* List of expressions to scan */
903 Expr
*pE
/* Expression we are trying to match */
905 int i
; /* Loop counter */
907 UNUSED_PARAMETER(pParse
);
910 char *zCol
= pE
->u
.zToken
;
911 for(i
=0; i
<pEList
->nExpr
; i
++){
912 char *zAs
= pEList
->a
[i
].zName
;
913 if( zAs
!=0 && sqlite3StrICmp(zAs
, zCol
)==0 ){
922 ** pE is a pointer to an expression which is a single term in the
923 ** ORDER BY of a compound SELECT. The expression has not been
926 ** At the point this routine is called, we already know that the
927 ** ORDER BY term is not an integer index into the result set. That
928 ** case is handled by the calling routine.
930 ** Attempt to match pE against result set columns in the left-most
931 ** SELECT statement. Return the index i of the matching column,
932 ** as an indication to the caller that it should sort by the i-th column.
933 ** The left-most column is 1. In other words, the value returned is the
934 ** same integer value that would be used in the SQL statement to indicate
937 ** If there is no match, return 0. Return -1 if an error occurs.
939 static int resolveOrderByTermToExprList(
940 Parse
*pParse
, /* Parsing context for error messages */
941 Select
*pSelect
, /* The SELECT statement with the ORDER BY clause */
942 Expr
*pE
/* The specific ORDER BY term */
944 int i
; /* Loop counter */
945 ExprList
*pEList
; /* The columns of the result set */
946 NameContext nc
; /* Name context for resolving pE */
947 sqlite3
*db
; /* Database connection */
948 int rc
; /* Return code from subprocedures */
949 u8 savedSuppErr
; /* Saved value of db->suppressErr */
951 assert( sqlite3ExprIsInteger(pE
, &i
)==0 );
952 pEList
= pSelect
->pEList
;
954 /* Resolve all names in the ORDER BY term expression
956 memset(&nc
, 0, sizeof(nc
));
958 nc
.pSrcList
= pSelect
->pSrc
;
959 nc
.uNC
.pEList
= pEList
;
960 nc
.ncFlags
= NC_AllowAgg
|NC_UEList
;
963 savedSuppErr
= db
->suppressErr
;
965 rc
= sqlite3ResolveExprNames(&nc
, pE
);
966 db
->suppressErr
= savedSuppErr
;
969 /* Try to match the ORDER BY expression against an expression
970 ** in the result set. Return an 1-based index of the matching
973 for(i
=0; i
<pEList
->nExpr
; i
++){
974 if( sqlite3ExprCompare(0, pEList
->a
[i
].pExpr
, pE
, -1)<2 ){
979 /* If no match, return 0. */
984 ** Generate an ORDER BY or GROUP BY term out-of-range error.
986 static void resolveOutOfRangeError(
987 Parse
*pParse
, /* The error context into which to write the error */
988 const char *zType
, /* "ORDER" or "GROUP" */
989 int i
, /* The index (1-based) of the term out of range */
990 int mx
/* Largest permissible value of i */
992 sqlite3ErrorMsg(pParse
,
993 "%r %s BY term out of range - should be "
994 "between 1 and %d", i
, zType
, mx
);
998 ** Analyze the ORDER BY clause in a compound SELECT statement. Modify
999 ** each term of the ORDER BY clause is a constant integer between 1
1000 ** and N where N is the number of columns in the compound SELECT.
1002 ** ORDER BY terms that are already an integer between 1 and N are
1003 ** unmodified. ORDER BY terms that are integers outside the range of
1004 ** 1 through N generate an error. ORDER BY terms that are expressions
1005 ** are matched against result set expressions of compound SELECT
1006 ** beginning with the left-most SELECT and working toward the right.
1007 ** At the first match, the ORDER BY expression is transformed into
1008 ** the integer column number.
1010 ** Return the number of errors seen.
1012 static int resolveCompoundOrderBy(
1013 Parse
*pParse
, /* Parsing context. Leave error messages here */
1014 Select
*pSelect
/* The SELECT statement containing the ORDER BY */
1022 pOrderBy
= pSelect
->pOrderBy
;
1023 if( pOrderBy
==0 ) return 0;
1025 if( pOrderBy
->nExpr
>db
->aLimit
[SQLITE_LIMIT_COLUMN
] ){
1026 sqlite3ErrorMsg(pParse
, "too many terms in ORDER BY clause");
1029 for(i
=0; i
<pOrderBy
->nExpr
; i
++){
1030 pOrderBy
->a
[i
].done
= 0;
1033 while( pSelect
->pPrior
){
1034 pSelect
->pPrior
->pNext
= pSelect
;
1035 pSelect
= pSelect
->pPrior
;
1037 while( pSelect
&& moreToDo
){
1038 struct ExprList_item
*pItem
;
1040 pEList
= pSelect
->pEList
;
1041 assert( pEList
!=0 );
1042 for(i
=0, pItem
=pOrderBy
->a
; i
<pOrderBy
->nExpr
; i
++, pItem
++){
1045 if( pItem
->done
) continue;
1046 pE
= sqlite3ExprSkipCollate(pItem
->pExpr
);
1047 if( sqlite3ExprIsInteger(pE
, &iCol
) ){
1048 if( iCol
<=0 || iCol
>pEList
->nExpr
){
1049 resolveOutOfRangeError(pParse
, "ORDER", i
+1, pEList
->nExpr
);
1053 iCol
= resolveAsName(pParse
, pEList
, pE
);
1055 pDup
= sqlite3ExprDup(db
, pE
, 0);
1056 if( !db
->mallocFailed
){
1058 iCol
= resolveOrderByTermToExprList(pParse
, pSelect
, pDup
);
1060 sqlite3ExprDelete(db
, pDup
);
1064 /* Convert the ORDER BY term into an integer column number iCol,
1065 ** taking care to preserve the COLLATE clause if it exists */
1066 Expr
*pNew
= sqlite3Expr(db
, TK_INTEGER
, 0);
1067 if( pNew
==0 ) return 1;
1068 pNew
->flags
|= EP_IntValue
;
1069 pNew
->u
.iValue
= iCol
;
1070 if( pItem
->pExpr
==pE
){
1071 pItem
->pExpr
= pNew
;
1073 Expr
*pParent
= pItem
->pExpr
;
1074 assert( pParent
->op
==TK_COLLATE
);
1075 while( pParent
->pLeft
->op
==TK_COLLATE
) pParent
= pParent
->pLeft
;
1076 assert( pParent
->pLeft
==pE
);
1077 pParent
->pLeft
= pNew
;
1079 sqlite3ExprDelete(db
, pE
);
1080 pItem
->u
.x
.iOrderByCol
= (u16
)iCol
;
1086 pSelect
= pSelect
->pNext
;
1088 for(i
=0; i
<pOrderBy
->nExpr
; i
++){
1089 if( pOrderBy
->a
[i
].done
==0 ){
1090 sqlite3ErrorMsg(pParse
, "%r ORDER BY term does not match any "
1091 "column in the result set", i
+1);
1099 ** Check every term in the ORDER BY or GROUP BY clause pOrderBy of
1100 ** the SELECT statement pSelect. If any term is reference to a
1101 ** result set expression (as determined by the ExprList.a.u.x.iOrderByCol
1102 ** field) then convert that term into a copy of the corresponding result set
1105 ** If any errors are detected, add an error message to pParse and
1106 ** return non-zero. Return zero if no errors are seen.
1108 int sqlite3ResolveOrderGroupBy(
1109 Parse
*pParse
, /* Parsing context. Leave error messages here */
1110 Select
*pSelect
, /* The SELECT statement containing the clause */
1111 ExprList
*pOrderBy
, /* The ORDER BY or GROUP BY clause to be processed */
1112 const char *zType
/* "ORDER" or "GROUP" */
1115 sqlite3
*db
= pParse
->db
;
1117 struct ExprList_item
*pItem
;
1119 if( pOrderBy
==0 || pParse
->db
->mallocFailed
) return 0;
1120 if( pOrderBy
->nExpr
>db
->aLimit
[SQLITE_LIMIT_COLUMN
] ){
1121 sqlite3ErrorMsg(pParse
, "too many terms in %s BY clause", zType
);
1124 pEList
= pSelect
->pEList
;
1125 assert( pEList
!=0 ); /* sqlite3SelectNew() guarantees this */
1126 for(i
=0, pItem
=pOrderBy
->a
; i
<pOrderBy
->nExpr
; i
++, pItem
++){
1127 if( pItem
->u
.x
.iOrderByCol
){
1128 if( pItem
->u
.x
.iOrderByCol
>pEList
->nExpr
){
1129 resolveOutOfRangeError(pParse
, zType
, i
+1, pEList
->nExpr
);
1132 resolveAlias(pParse
, pEList
, pItem
->u
.x
.iOrderByCol
-1, pItem
->pExpr
,
1140 ** pOrderBy is an ORDER BY or GROUP BY clause in SELECT statement pSelect.
1141 ** The Name context of the SELECT statement is pNC. zType is either
1142 ** "ORDER" or "GROUP" depending on which type of clause pOrderBy is.
1144 ** This routine resolves each term of the clause into an expression.
1145 ** If the order-by term is an integer I between 1 and N (where N is the
1146 ** number of columns in the result set of the SELECT) then the expression
1147 ** in the resolution is a copy of the I-th result-set expression. If
1148 ** the order-by term is an identifier that corresponds to the AS-name of
1149 ** a result-set expression, then the term resolves to a copy of the
1150 ** result-set expression. Otherwise, the expression is resolved in
1151 ** the usual way - using sqlite3ResolveExprNames().
1153 ** This routine returns the number of errors. If errors occur, then
1154 ** an appropriate error message might be left in pParse. (OOM errors
1157 static int resolveOrderGroupBy(
1158 NameContext
*pNC
, /* The name context of the SELECT statement */
1159 Select
*pSelect
, /* The SELECT statement holding pOrderBy */
1160 ExprList
*pOrderBy
, /* An ORDER BY or GROUP BY clause to resolve */
1161 const char *zType
/* Either "ORDER" or "GROUP", as appropriate */
1163 int i
, j
; /* Loop counters */
1164 int iCol
; /* Column number */
1165 struct ExprList_item
*pItem
; /* A term of the ORDER BY clause */
1166 Parse
*pParse
; /* Parsing context */
1167 int nResult
; /* Number of terms in the result set */
1169 if( pOrderBy
==0 ) return 0;
1170 nResult
= pSelect
->pEList
->nExpr
;
1171 pParse
= pNC
->pParse
;
1172 for(i
=0, pItem
=pOrderBy
->a
; i
<pOrderBy
->nExpr
; i
++, pItem
++){
1173 Expr
*pE
= pItem
->pExpr
;
1174 Expr
*pE2
= sqlite3ExprSkipCollate(pE
);
1175 if( zType
[0]!='G' ){
1176 iCol
= resolveAsName(pParse
, pSelect
->pEList
, pE2
);
1178 /* If an AS-name match is found, mark this ORDER BY column as being
1179 ** a copy of the iCol-th result-set column. The subsequent call to
1180 ** sqlite3ResolveOrderGroupBy() will convert the expression to a
1181 ** copy of the iCol-th result-set expression. */
1182 pItem
->u
.x
.iOrderByCol
= (u16
)iCol
;
1186 if( sqlite3ExprIsInteger(pE2
, &iCol
) ){
1187 /* The ORDER BY term is an integer constant. Again, set the column
1188 ** number so that sqlite3ResolveOrderGroupBy() will convert the
1189 ** order-by term to a copy of the result-set expression */
1190 if( iCol
<1 || iCol
>0xffff ){
1191 resolveOutOfRangeError(pParse
, zType
, i
+1, nResult
);
1194 pItem
->u
.x
.iOrderByCol
= (u16
)iCol
;
1198 /* Otherwise, treat the ORDER BY term as an ordinary expression */
1199 pItem
->u
.x
.iOrderByCol
= 0;
1200 if( sqlite3ResolveExprNames(pNC
, pE
) ){
1203 for(j
=0; j
<pSelect
->pEList
->nExpr
; j
++){
1204 if( sqlite3ExprCompare(0, pE
, pSelect
->pEList
->a
[j
].pExpr
, -1)==0 ){
1205 pItem
->u
.x
.iOrderByCol
= j
+1;
1209 return sqlite3ResolveOrderGroupBy(pParse
, pSelect
, pOrderBy
, zType
);
1213 ** Resolve names in the SELECT statement p and all of its descendants.
1215 static int resolveSelectStep(Walker
*pWalker
, Select
*p
){
1216 NameContext
*pOuterNC
; /* Context that contains this SELECT */
1217 NameContext sNC
; /* Name context of this SELECT */
1218 int isCompound
; /* True if p is a compound select */
1219 int nCompound
; /* Number of compound terms processed so far */
1220 Parse
*pParse
; /* Parsing context */
1221 int i
; /* Loop counter */
1222 ExprList
*pGroupBy
; /* The GROUP BY clause */
1223 Select
*pLeftmost
; /* Left-most of SELECT of a compound */
1224 sqlite3
*db
; /* Database connection */
1228 if( p
->selFlags
& SF_Resolved
){
1231 pOuterNC
= pWalker
->u
.pNC
;
1232 pParse
= pWalker
->pParse
;
1235 /* Normally sqlite3SelectExpand() will be called first and will have
1236 ** already expanded this SELECT. However, if this is a subquery within
1237 ** an expression, sqlite3ResolveExprNames() will be called without a
1238 ** prior call to sqlite3SelectExpand(). When that happens, let
1239 ** sqlite3SelectPrep() do all of the processing for this SELECT.
1240 ** sqlite3SelectPrep() will invoke both sqlite3SelectExpand() and
1241 ** this routine in the correct order.
1243 if( (p
->selFlags
& SF_Expanded
)==0 ){
1244 sqlite3SelectPrep(pParse
, p
, pOuterNC
);
1245 return (pParse
->nErr
|| db
->mallocFailed
) ? WRC_Abort
: WRC_Prune
;
1248 isCompound
= p
->pPrior
!=0;
1252 assert( p
->pWin
==0 );
1253 assert( (p
->selFlags
& SF_Expanded
)!=0 );
1254 assert( (p
->selFlags
& SF_Resolved
)==0 );
1255 p
->selFlags
|= SF_Resolved
;
1257 /* Resolve the expressions in the LIMIT and OFFSET clauses. These
1258 ** are not allowed to refer to any names, so pass an empty NameContext.
1260 memset(&sNC
, 0, sizeof(sNC
));
1261 sNC
.pParse
= pParse
;
1262 if( sqlite3ResolveExprNames(&sNC
, p
->pLimit
) ){
1266 /* If the SF_Converted flags is set, then this Select object was
1267 ** was created by the convertCompoundSelectToSubquery() function.
1268 ** In this case the ORDER BY clause (p->pOrderBy) should be resolved
1269 ** as if it were part of the sub-query, not the parent. This block
1270 ** moves the pOrderBy down to the sub-query. It will be moved back
1271 ** after the names have been resolved. */
1272 if( p
->selFlags
& SF_Converted
){
1273 Select
*pSub
= p
->pSrc
->a
[0].pSelect
;
1274 assert( p
->pSrc
->nSrc
==1 && p
->pOrderBy
);
1275 assert( pSub
->pPrior
&& pSub
->pOrderBy
==0 );
1276 pSub
->pOrderBy
= p
->pOrderBy
;
1280 /* Recursively resolve names in all subqueries
1282 for(i
=0; i
<p
->pSrc
->nSrc
; i
++){
1283 struct SrcList_item
*pItem
= &p
->pSrc
->a
[i
];
1284 if( pItem
->pSelect
){
1285 NameContext
*pNC
; /* Used to iterate name contexts */
1286 int nRef
= 0; /* Refcount for pOuterNC and outer contexts */
1287 const char *zSavedContext
= pParse
->zAuthContext
;
1289 /* Count the total number of references to pOuterNC and all of its
1290 ** parent contexts. After resolving references to expressions in
1291 ** pItem->pSelect, check if this value has changed. If so, then
1292 ** SELECT statement pItem->pSelect must be correlated. Set the
1293 ** pItem->fg.isCorrelated flag if this is the case. */
1294 for(pNC
=pOuterNC
; pNC
; pNC
=pNC
->pNext
) nRef
+= pNC
->nRef
;
1296 if( pItem
->zName
) pParse
->zAuthContext
= pItem
->zName
;
1297 sqlite3ResolveSelectNames(pParse
, pItem
->pSelect
, pOuterNC
);
1298 pParse
->zAuthContext
= zSavedContext
;
1299 if( pParse
->nErr
|| db
->mallocFailed
) return WRC_Abort
;
1301 for(pNC
=pOuterNC
; pNC
; pNC
=pNC
->pNext
) nRef
-= pNC
->nRef
;
1302 assert( pItem
->fg
.isCorrelated
==0 && nRef
<=0 );
1303 pItem
->fg
.isCorrelated
= (nRef
!=0);
1307 /* Set up the local name-context to pass to sqlite3ResolveExprNames() to
1308 ** resolve the result-set expression list.
1310 sNC
.ncFlags
= NC_AllowAgg
|NC_AllowWin
;
1311 sNC
.pSrcList
= p
->pSrc
;
1312 sNC
.pNext
= pOuterNC
;
1314 /* Resolve names in the result set. */
1315 if( sqlite3ResolveExprListNames(&sNC
, p
->pEList
) ) return WRC_Abort
;
1316 sNC
.ncFlags
&= ~NC_AllowWin
;
1318 /* If there are no aggregate functions in the result-set, and no GROUP BY
1319 ** expression, do not allow aggregates in any of the other expressions.
1321 assert( (p
->selFlags
& SF_Aggregate
)==0 );
1322 pGroupBy
= p
->pGroupBy
;
1323 if( pGroupBy
|| (sNC
.ncFlags
& NC_HasAgg
)!=0 ){
1324 assert( NC_MinMaxAgg
==SF_MinMaxAgg
);
1325 p
->selFlags
|= SF_Aggregate
| (sNC
.ncFlags
&NC_MinMaxAgg
);
1327 sNC
.ncFlags
&= ~NC_AllowAgg
;
1330 /* If a HAVING clause is present, then there must be a GROUP BY clause.
1332 if( p
->pHaving
&& !pGroupBy
){
1333 sqlite3ErrorMsg(pParse
, "a GROUP BY clause is required before HAVING");
1337 /* Add the output column list to the name-context before parsing the
1338 ** other expressions in the SELECT statement. This is so that
1339 ** expressions in the WHERE clause (etc.) can refer to expressions by
1340 ** aliases in the result set.
1342 ** Minor point: If this is the case, then the expression will be
1343 ** re-evaluated for each reference to it.
1345 assert( (sNC
.ncFlags
& (NC_UAggInfo
|NC_UUpsert
))==0 );
1346 sNC
.uNC
.pEList
= p
->pEList
;
1347 sNC
.ncFlags
|= NC_UEList
;
1348 if( sqlite3ResolveExprNames(&sNC
, p
->pHaving
) ) return WRC_Abort
;
1349 if( sqlite3ResolveExprNames(&sNC
, p
->pWhere
) ) return WRC_Abort
;
1351 /* Resolve names in table-valued-function arguments */
1352 for(i
=0; i
<p
->pSrc
->nSrc
; i
++){
1353 struct SrcList_item
*pItem
= &p
->pSrc
->a
[i
];
1354 if( pItem
->fg
.isTabFunc
1355 && sqlite3ResolveExprListNames(&sNC
, pItem
->u1
.pFuncArg
)
1361 /* The ORDER BY and GROUP BY clauses may not refer to terms in
1365 sNC
.ncFlags
|= NC_AllowAgg
|NC_AllowWin
;
1367 /* If this is a converted compound query, move the ORDER BY clause from
1368 ** the sub-query back to the parent query. At this point each term
1369 ** within the ORDER BY clause has been transformed to an integer value.
1370 ** These integers will be replaced by copies of the corresponding result
1371 ** set expressions by the call to resolveOrderGroupBy() below. */
1372 if( p
->selFlags
& SF_Converted
){
1373 Select
*pSub
= p
->pSrc
->a
[0].pSelect
;
1374 p
->pOrderBy
= pSub
->pOrderBy
;
1378 /* Process the ORDER BY clause for singleton SELECT statements.
1379 ** The ORDER BY clause for compounds SELECT statements is handled
1380 ** below, after all of the result-sets for all of the elements of
1381 ** the compound have been resolved.
1383 ** If there is an ORDER BY clause on a term of a compound-select other
1384 ** than the right-most term, then that is a syntax error. But the error
1385 ** is not detected until much later, and so we need to go ahead and
1386 ** resolve those symbols on the incorrect ORDER BY for consistency.
1388 if( isCompound
<=nCompound
/* Defer right-most ORDER BY of a compound */
1389 && resolveOrderGroupBy(&sNC
, p
, p
->pOrderBy
, "ORDER")
1393 if( db
->mallocFailed
){
1396 sNC
.ncFlags
&= ~NC_AllowWin
;
1398 /* Resolve the GROUP BY clause. At the same time, make sure
1399 ** the GROUP BY clause does not contain aggregate functions.
1402 struct ExprList_item
*pItem
;
1404 if( resolveOrderGroupBy(&sNC
, p
, pGroupBy
, "GROUP") || db
->mallocFailed
){
1407 for(i
=0, pItem
=pGroupBy
->a
; i
<pGroupBy
->nExpr
; i
++, pItem
++){
1408 if( ExprHasProperty(pItem
->pExpr
, EP_Agg
) ){
1409 sqlite3ErrorMsg(pParse
, "aggregate functions are not allowed in "
1410 "the GROUP BY clause");
1416 /* If this is part of a compound SELECT, check that it has the right
1417 ** number of expressions in the select list. */
1418 if( p
->pNext
&& p
->pEList
->nExpr
!=p
->pNext
->pEList
->nExpr
){
1419 sqlite3SelectWrongNumTermsError(pParse
, p
->pNext
);
1426 /* Advance to the next term of the compound
1432 /* Resolve the ORDER BY on a compound SELECT after all terms of
1433 ** the compound have been resolved.
1435 if( isCompound
&& resolveCompoundOrderBy(pParse
, pLeftmost
) ){
1443 ** This routine walks an expression tree and resolves references to
1444 ** table columns and result-set columns. At the same time, do error
1445 ** checking on function usage and set a flag if any aggregate functions
1448 ** To resolve table columns references we look for nodes (or subtrees) of the
1449 ** form X.Y.Z or Y.Z or just Z where
1451 ** X: The name of a database. Ex: "main" or "temp" or
1452 ** the symbolic name assigned to an ATTACH-ed database.
1454 ** Y: The name of a table in a FROM clause. Or in a trigger
1455 ** one of the special names "old" or "new".
1457 ** Z: The name of a column in table Y.
1459 ** The node at the root of the subtree is modified as follows:
1461 ** Expr.op Changed to TK_COLUMN
1462 ** Expr.pTab Points to the Table object for X.Y
1463 ** Expr.iColumn The column index in X.Y. -1 for the rowid.
1464 ** Expr.iTable The VDBE cursor number for X.Y
1467 ** To resolve result-set references, look for expression nodes of the
1468 ** form Z (with no X and Y prefix) where the Z matches the right-hand
1469 ** size of an AS clause in the result-set of a SELECT. The Z expression
1470 ** is replaced by a copy of the left-hand side of the result-set expression.
1471 ** Table-name and function resolution occurs on the substituted expression
1472 ** tree. For example, in:
1474 ** SELECT a+b AS x, c+d AS y FROM t1 ORDER BY x;
1476 ** The "x" term of the order by is replaced by "a+b" to render:
1478 ** SELECT a+b AS x, c+d AS y FROM t1 ORDER BY a+b;
1480 ** Function calls are checked to make sure that the function is
1481 ** defined and that the correct number of arguments are specified.
1482 ** If the function is an aggregate function, then the NC_HasAgg flag is
1483 ** set and the opcode is changed from TK_FUNCTION to TK_AGG_FUNCTION.
1484 ** If an expression contains aggregate functions then the EP_Agg
1485 ** property on the expression is set.
1487 ** An error message is left in pParse if anything is amiss. The number
1488 ** if errors is returned.
1490 int sqlite3ResolveExprNames(
1491 NameContext
*pNC
, /* Namespace to resolve expressions in. */
1492 Expr
*pExpr
/* The expression to be analyzed. */
1497 if( pExpr
==0 ) return SQLITE_OK
;
1498 savedHasAgg
= pNC
->ncFlags
& (NC_HasAgg
|NC_MinMaxAgg
);
1499 pNC
->ncFlags
&= ~(NC_HasAgg
|NC_MinMaxAgg
);
1500 w
.pParse
= pNC
->pParse
;
1501 w
.xExprCallback
= resolveExprStep
;
1502 w
.xSelectCallback
= resolveSelectStep
;
1503 w
.xSelectCallback2
= 0;
1505 #if SQLITE_MAX_EXPR_DEPTH>0
1506 w
.pParse
->nHeight
+= pExpr
->nHeight
;
1507 if( sqlite3ExprCheckHeight(w
.pParse
, w
.pParse
->nHeight
) ){
1508 return SQLITE_ERROR
;
1511 sqlite3WalkExpr(&w
, pExpr
);
1512 #if SQLITE_MAX_EXPR_DEPTH>0
1513 w
.pParse
->nHeight
-= pExpr
->nHeight
;
1515 if( pNC
->ncFlags
& NC_HasAgg
){
1516 ExprSetProperty(pExpr
, EP_Agg
);
1518 pNC
->ncFlags
|= savedHasAgg
;
1519 return pNC
->nErr
>0 || w
.pParse
->nErr
>0;
1523 ** Resolve all names for all expression in an expression list. This is
1524 ** just like sqlite3ResolveExprNames() except that it works for an expression
1525 ** list rather than a single expression.
1527 int sqlite3ResolveExprListNames(
1528 NameContext
*pNC
, /* Namespace to resolve expressions in. */
1529 ExprList
*pList
/* The expression list to be analyzed. */
1533 for(i
=0; i
<pList
->nExpr
; i
++){
1534 if( sqlite3ResolveExprNames(pNC
, pList
->a
[i
].pExpr
) ) return WRC_Abort
;
1537 return WRC_Continue
;
1541 ** Resolve all names in all expressions of a SELECT and in all
1542 ** decendents of the SELECT, including compounds off of p->pPrior,
1543 ** subqueries in expressions, and subqueries used as FROM clause
1546 ** See sqlite3ResolveExprNames() for a description of the kinds of
1547 ** transformations that occur.
1549 ** All SELECT statements should have been expanded using
1550 ** sqlite3SelectExpand() prior to invoking this routine.
1552 void sqlite3ResolveSelectNames(
1553 Parse
*pParse
, /* The parser context */
1554 Select
*p
, /* The SELECT statement being coded. */
1555 NameContext
*pOuterNC
/* Name context for parent SELECT statement */
1560 w
.xExprCallback
= resolveExprStep
;
1561 w
.xSelectCallback
= resolveSelectStep
;
1562 w
.xSelectCallback2
= 0;
1565 sqlite3WalkSelect(&w
, p
);
1569 ** Resolve names in expressions that can only reference a single table:
1571 ** * CHECK constraints
1572 ** * WHERE clauses on partial indices
1574 ** The Expr.iTable value for Expr.op==TK_COLUMN nodes of the expression
1575 ** is set to -1 and the Expr.iColumn value is set to the column number.
1577 ** Any errors cause an error message to be set in pParse.
1579 void sqlite3ResolveSelfReference(
1580 Parse
*pParse
, /* Parsing context */
1581 Table
*pTab
, /* The table being referenced */
1582 int type
, /* NC_IsCheck or NC_PartIdx or NC_IdxExpr */
1583 Expr
*pExpr
, /* Expression to resolve. May be NULL. */
1584 ExprList
*pList
/* Expression list to resolve. May be NULL. */
1586 SrcList sSrc
; /* Fake SrcList for pParse->pNewTable */
1587 NameContext sNC
; /* Name context for pParse->pNewTable */
1589 assert( type
==NC_IsCheck
|| type
==NC_PartIdx
|| type
==NC_IdxExpr
);
1590 memset(&sNC
, 0, sizeof(sNC
));
1591 memset(&sSrc
, 0, sizeof(sSrc
));
1593 sSrc
.a
[0].zName
= pTab
->zName
;
1594 sSrc
.a
[0].pTab
= pTab
;
1595 sSrc
.a
[0].iCursor
= -1;
1596 sNC
.pParse
= pParse
;
1597 sNC
.pSrcList
= &sSrc
;
1599 if( sqlite3ResolveExprNames(&sNC
, pExpr
) ) return;
1600 if( pList
) sqlite3ResolveExprListNames(&sNC
, pList
);