blob: 7045c32b26314176a77112b096166b7d5c74bae9 [file] [log] [blame]
drhcce7d172000-05-31 15:34:51 +00001/*
drhb19a2bc2001-09-16 00:13:26 +00002** 2001 September 15
drhcce7d172000-05-31 15:34:51 +00003**
drhb19a2bc2001-09-16 00:13:26 +00004** The author disclaims copyright to this source code. In place of
5** a legal notice, here is a blessing:
drhcce7d172000-05-31 15:34:51 +00006**
drhb19a2bc2001-09-16 00:13:26 +00007** 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.
drhcce7d172000-05-31 15:34:51 +000010**
11*************************************************************************
12** This file contains C code routines that are called by the parser
drhb19a2bc2001-09-16 00:13:26 +000013** to handle SELECT statements in SQLite.
drhcce7d172000-05-31 15:34:51 +000014**
drh0acb7e42008-06-25 00:12:41 +000015** $Id: select.c,v 1.436 2008/06/25 00:12:41 drh Exp $
drhcce7d172000-05-31 15:34:51 +000016*/
17#include "sqliteInt.h"
18
drh315555c2002-10-20 15:53:03 +000019
drhcce7d172000-05-31 15:34:51 +000020/*
drheda639e2006-01-22 00:42:09 +000021** Delete all the content of a Select structure but do not deallocate
22** the select structure itself.
23*/
danielk1977f0113002006-01-24 12:09:17 +000024static void clearSelect(Select *p){
drheda639e2006-01-22 00:42:09 +000025 sqlite3ExprListDelete(p->pEList);
26 sqlite3SrcListDelete(p->pSrc);
27 sqlite3ExprDelete(p->pWhere);
28 sqlite3ExprListDelete(p->pGroupBy);
29 sqlite3ExprDelete(p->pHaving);
30 sqlite3ExprListDelete(p->pOrderBy);
31 sqlite3SelectDelete(p->pPrior);
32 sqlite3ExprDelete(p->pLimit);
33 sqlite3ExprDelete(p->pOffset);
34}
35
drh1013c932008-01-06 00:25:21 +000036/*
37** Initialize a SelectDest structure.
38*/
39void sqlite3SelectDestInit(SelectDest *pDest, int eDest, int iParm){
40 pDest->eDest = eDest;
41 pDest->iParm = iParm;
42 pDest->affinity = 0;
43 pDest->iMem = 0;
drhad27e762008-03-26 12:46:23 +000044 pDest->nMem = 0;
drh1013c932008-01-06 00:25:21 +000045}
46
drheda639e2006-01-22 00:42:09 +000047
48/*
drh9bb61fe2000-06-05 16:01:39 +000049** Allocate a new Select structure and return a pointer to that
50** structure.
drhcce7d172000-05-31 15:34:51 +000051*/
danielk19774adee202004-05-08 08:23:19 +000052Select *sqlite3SelectNew(
drh17435752007-08-16 04:30:38 +000053 Parse *pParse, /* Parsing context */
drhdaffd0e2001-04-11 14:28:42 +000054 ExprList *pEList, /* which columns to include in the result */
drhad3cab52002-05-24 02:04:32 +000055 SrcList *pSrc, /* the FROM clause -- which tables to scan */
drhdaffd0e2001-04-11 14:28:42 +000056 Expr *pWhere, /* the WHERE clause */
57 ExprList *pGroupBy, /* the GROUP BY clause */
58 Expr *pHaving, /* the HAVING clause */
59 ExprList *pOrderBy, /* the ORDER BY clause */
drh9bbca4c2001-11-06 04:00:18 +000060 int isDistinct, /* true if the DISTINCT keyword is present */
danielk1977a2dc3b12005-02-05 12:48:48 +000061 Expr *pLimit, /* LIMIT value. NULL means not used */
62 Expr *pOffset /* OFFSET value. NULL means no offset */
drh9bb61fe2000-06-05 16:01:39 +000063){
64 Select *pNew;
drheda639e2006-01-22 00:42:09 +000065 Select standin;
drh17435752007-08-16 04:30:38 +000066 sqlite3 *db = pParse->db;
67 pNew = sqlite3DbMallocZero(db, sizeof(*pNew) );
danielk1977a2dc3b12005-02-05 12:48:48 +000068 assert( !pOffset || pLimit ); /* Can't have OFFSET without LIMIT. */
drhdaffd0e2001-04-11 14:28:42 +000069 if( pNew==0 ){
drheda639e2006-01-22 00:42:09 +000070 pNew = &standin;
71 memset(pNew, 0, sizeof(*pNew));
72 }
73 if( pEList==0 ){
danielk1977a1644fd2007-08-29 12:31:25 +000074 pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db,TK_ALL,0,0,0), 0);
drheda639e2006-01-22 00:42:09 +000075 }
76 pNew->pEList = pEList;
77 pNew->pSrc = pSrc;
78 pNew->pWhere = pWhere;
79 pNew->pGroupBy = pGroupBy;
80 pNew->pHaving = pHaving;
81 pNew->pOrderBy = pOrderBy;
82 pNew->isDistinct = isDistinct;
83 pNew->op = TK_SELECT;
drh8103b7d2007-02-24 13:23:51 +000084 assert( pOffset==0 || pLimit!=0 );
drheda639e2006-01-22 00:42:09 +000085 pNew->pLimit = pLimit;
86 pNew->pOffset = pOffset;
drhb9bb7c12006-06-11 23:41:55 +000087 pNew->addrOpenEphm[0] = -1;
88 pNew->addrOpenEphm[1] = -1;
89 pNew->addrOpenEphm[2] = -1;
drheda639e2006-01-22 00:42:09 +000090 if( pNew==&standin) {
91 clearSelect(pNew);
92 pNew = 0;
drhdaffd0e2001-04-11 14:28:42 +000093 }
drh9bb61fe2000-06-05 16:01:39 +000094 return pNew;
95}
96
97/*
drheda639e2006-01-22 00:42:09 +000098** Delete the given Select structure and all of its substructures.
99*/
100void sqlite3SelectDelete(Select *p){
101 if( p ){
102 clearSelect(p);
drh17435752007-08-16 04:30:38 +0000103 sqlite3_free(p);
drheda639e2006-01-22 00:42:09 +0000104 }
105}
106
107/*
drh01f3f252002-05-24 16:14:15 +0000108** Given 1 to 3 identifiers preceeding the JOIN keyword, determine the
109** type of join. Return an integer constant that expresses that type
110** in terms of the following bit values:
111**
112** JT_INNER
drh3dec2232005-09-10 15:28:09 +0000113** JT_CROSS
drh01f3f252002-05-24 16:14:15 +0000114** JT_OUTER
115** JT_NATURAL
116** JT_LEFT
117** JT_RIGHT
118**
119** A full outer join is the combination of JT_LEFT and JT_RIGHT.
120**
121** If an illegal or unsupported join type is seen, then still return
122** a join type, but put an error in the pParse structure.
123*/
danielk19774adee202004-05-08 08:23:19 +0000124int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){
drh01f3f252002-05-24 16:14:15 +0000125 int jointype = 0;
126 Token *apAll[3];
127 Token *p;
drh57196282004-10-06 15:41:16 +0000128 static const struct {
drhc182d162005-08-14 20:47:16 +0000129 const char zKeyword[8];
drh290c1942004-08-21 17:54:45 +0000130 u8 nChar;
131 u8 code;
drh01f3f252002-05-24 16:14:15 +0000132 } keywords[] = {
133 { "natural", 7, JT_NATURAL },
drh195e6962002-05-25 00:18:20 +0000134 { "left", 4, JT_LEFT|JT_OUTER },
135 { "right", 5, JT_RIGHT|JT_OUTER },
136 { "full", 4, JT_LEFT|JT_RIGHT|JT_OUTER },
drh01f3f252002-05-24 16:14:15 +0000137 { "outer", 5, JT_OUTER },
138 { "inner", 5, JT_INNER },
drh3dec2232005-09-10 15:28:09 +0000139 { "cross", 5, JT_INNER|JT_CROSS },
drh01f3f252002-05-24 16:14:15 +0000140 };
141 int i, j;
142 apAll[0] = pA;
143 apAll[1] = pB;
144 apAll[2] = pC;
drh195e6962002-05-25 00:18:20 +0000145 for(i=0; i<3 && apAll[i]; i++){
drh01f3f252002-05-24 16:14:15 +0000146 p = apAll[i];
147 for(j=0; j<sizeof(keywords)/sizeof(keywords[0]); j++){
148 if( p->n==keywords[j].nChar
drh2646da72005-12-09 20:02:05 +0000149 && sqlite3StrNICmp((char*)p->z, keywords[j].zKeyword, p->n)==0 ){
drh01f3f252002-05-24 16:14:15 +0000150 jointype |= keywords[j].code;
151 break;
152 }
153 }
154 if( j>=sizeof(keywords)/sizeof(keywords[0]) ){
155 jointype |= JT_ERROR;
156 break;
157 }
158 }
drhad2d8302002-05-24 20:31:36 +0000159 if(
160 (jointype & (JT_INNER|JT_OUTER))==(JT_INNER|JT_OUTER) ||
drh195e6962002-05-25 00:18:20 +0000161 (jointype & JT_ERROR)!=0
drhad2d8302002-05-24 20:31:36 +0000162 ){
drhae29ffb2004-09-25 14:39:18 +0000163 const char *zSp1 = " ";
164 const char *zSp2 = " ";
165 if( pB==0 ){ zSp1++; }
166 if( pC==0 ){ zSp2++; }
167 sqlite3ErrorMsg(pParse, "unknown or unsupported join type: "
168 "%T%s%T%s%T", pA, zSp1, pB, zSp2, pC);
drh01f3f252002-05-24 16:14:15 +0000169 jointype = JT_INNER;
drh195e6962002-05-25 00:18:20 +0000170 }else if( jointype & JT_RIGHT ){
danielk19774adee202004-05-08 08:23:19 +0000171 sqlite3ErrorMsg(pParse,
drhda93d232003-03-31 02:12:46 +0000172 "RIGHT and FULL OUTER JOINs are not currently supported");
drh195e6962002-05-25 00:18:20 +0000173 jointype = JT_INNER;
drh01f3f252002-05-24 16:14:15 +0000174 }
175 return jointype;
176}
177
178/*
drhad2d8302002-05-24 20:31:36 +0000179** Return the index of a column in a table. Return -1 if the column
180** is not contained in the table.
181*/
182static int columnIndex(Table *pTab, const char *zCol){
183 int i;
184 for(i=0; i<pTab->nCol; i++){
danielk19774adee202004-05-08 08:23:19 +0000185 if( sqlite3StrICmp(pTab->aCol[i].zName, zCol)==0 ) return i;
drhad2d8302002-05-24 20:31:36 +0000186 }
187 return -1;
188}
189
190/*
drh91bb0ee2004-09-01 03:06:34 +0000191** Set the value of a token to a '\000'-terminated string.
192*/
193static void setToken(Token *p, const char *z){
drh2646da72005-12-09 20:02:05 +0000194 p->z = (u8*)z;
danielk1977261919c2005-12-06 12:52:59 +0000195 p->n = z ? strlen(z) : 0;
drh91bb0ee2004-09-01 03:06:34 +0000196 p->dyn = 0;
197}
198
drhc182d162005-08-14 20:47:16 +0000199/*
danielk1977f3b863e2007-06-24 06:32:17 +0000200** Set the token to the double-quoted and escaped version of the string pointed
201** to by z. For example;
202**
203** {a"bc} -> {"a""bc"}
204*/
danielk19771e536952007-08-16 10:09:01 +0000205static void setQuotedToken(Parse *pParse, Token *p, const char *z){
danielk1977a686bfc2008-03-31 17:41:18 +0000206
207 /* Check if the string contains any " characters. If it does, then
208 ** this function will malloc space to create a quoted version of
209 ** the string in. Otherwise, save a call to sqlite3MPrintf() by
210 ** just copying the pointer to the string.
211 */
212 const char *z2 = z;
213 while( *z2 ){
214 if( *z2=='"' ) break;
215 z2++;
216 }
217
218 if( *z2 ){
219 /* String contains " characters - copy and quote the string. */
220 p->z = (u8 *)sqlite3MPrintf(pParse->db, "\"%w\"", z);
221 if( p->z ){
222 p->n = strlen((char *)p->z);
223 p->dyn = 1;
224 }
danielk19771e536952007-08-16 10:09:01 +0000225 }else{
danielk1977a686bfc2008-03-31 17:41:18 +0000226 /* String contains no " characters - copy the pointer. */
227 p->z = (u8*)z;
228 p->n = (z2 - z);
229 p->dyn = 0;
danielk1977f3b863e2007-06-24 06:32:17 +0000230 }
231}
232
233/*
drhc182d162005-08-14 20:47:16 +0000234** Create an expression node for an identifier with the name of zName
235*/
drh17435752007-08-16 04:30:38 +0000236Expr *sqlite3CreateIdExpr(Parse *pParse, const char *zName){
drhc182d162005-08-14 20:47:16 +0000237 Token dummy;
238 setToken(&dummy, zName);
drh17435752007-08-16 04:30:38 +0000239 return sqlite3PExpr(pParse, TK_ID, 0, 0, &dummy);
drhc182d162005-08-14 20:47:16 +0000240}
241
drh91bb0ee2004-09-01 03:06:34 +0000242/*
drhad2d8302002-05-24 20:31:36 +0000243** Add a term to the WHERE expression in *ppExpr that requires the
244** zCol column to be equal in the two tables pTab1 and pTab2.
245*/
246static void addWhereTerm(
drh17435752007-08-16 04:30:38 +0000247 Parse *pParse, /* Parsing context */
drhad2d8302002-05-24 20:31:36 +0000248 const char *zCol, /* Name of the column */
249 const Table *pTab1, /* First table */
drh030530d2005-01-18 17:40:04 +0000250 const char *zAlias1, /* Alias for first table. May be NULL */
drhad2d8302002-05-24 20:31:36 +0000251 const Table *pTab2, /* Second table */
drh030530d2005-01-18 17:40:04 +0000252 const char *zAlias2, /* Alias for second table. May be NULL */
drh22d6a532005-09-19 21:05:48 +0000253 int iRightJoinTable, /* VDBE cursor for the right table */
drhad27e762008-03-26 12:46:23 +0000254 Expr **ppExpr, /* Add the equality term to this expression */
255 int isOuterJoin /* True if dealing with an OUTER join */
drhad2d8302002-05-24 20:31:36 +0000256){
drhad2d8302002-05-24 20:31:36 +0000257 Expr *pE1a, *pE1b, *pE1c;
258 Expr *pE2a, *pE2b, *pE2c;
259 Expr *pE;
260
drh17435752007-08-16 04:30:38 +0000261 pE1a = sqlite3CreateIdExpr(pParse, zCol);
262 pE2a = sqlite3CreateIdExpr(pParse, zCol);
drh030530d2005-01-18 17:40:04 +0000263 if( zAlias1==0 ){
264 zAlias1 = pTab1->zName;
265 }
drh17435752007-08-16 04:30:38 +0000266 pE1b = sqlite3CreateIdExpr(pParse, zAlias1);
drh030530d2005-01-18 17:40:04 +0000267 if( zAlias2==0 ){
268 zAlias2 = pTab2->zName;
269 }
drh17435752007-08-16 04:30:38 +0000270 pE2b = sqlite3CreateIdExpr(pParse, zAlias2);
271 pE1c = sqlite3PExpr(pParse, TK_DOT, pE1b, pE1a, 0);
272 pE2c = sqlite3PExpr(pParse, TK_DOT, pE2b, pE2a, 0);
danielk19771e536952007-08-16 10:09:01 +0000273 pE = sqlite3PExpr(pParse, TK_EQ, pE1c, pE2c, 0);
drhad27e762008-03-26 12:46:23 +0000274 if( pE && isOuterJoin ){
drh206f3d92006-07-11 13:15:08 +0000275 ExprSetProperty(pE, EP_FromJoin);
276 pE->iRightJoinTable = iRightJoinTable;
277 }
drhf4ce8ed2007-11-23 13:42:51 +0000278 *ppExpr = sqlite3ExprAnd(pParse->db,*ppExpr, pE);
drhad2d8302002-05-24 20:31:36 +0000279}
280
281/*
drh1f162302002-10-27 19:35:33 +0000282** Set the EP_FromJoin property on all terms of the given expression.
drh22d6a532005-09-19 21:05:48 +0000283** And set the Expr.iRightJoinTable to iTable for every term in the
284** expression.
drh1cc093c2002-06-24 22:01:57 +0000285**
drhe78e8282003-01-19 03:59:45 +0000286** The EP_FromJoin property is used on terms of an expression to tell
drh1cc093c2002-06-24 22:01:57 +0000287** the LEFT OUTER JOIN processing logic that this term is part of the
drh1f162302002-10-27 19:35:33 +0000288** join restriction specified in the ON or USING clause and not a part
289** of the more general WHERE clause. These terms are moved over to the
290** WHERE clause during join processing but we need to remember that they
291** originated in the ON or USING clause.
drh22d6a532005-09-19 21:05:48 +0000292**
293** The Expr.iRightJoinTable tells the WHERE clause processing that the
294** expression depends on table iRightJoinTable even if that table is not
295** explicitly mentioned in the expression. That information is needed
296** for cases like this:
297**
298** SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.b AND t1.x=5
299**
300** The where clause needs to defer the handling of the t1.x=5
301** term until after the t2 loop of the join. In that way, a
302** NULL t2 row will be inserted whenever t1.x!=5. If we do not
303** defer the handling of t1.x=5, it will be processed immediately
304** after the t1 loop and rows with t1.x!=5 will never appear in
305** the output, which is incorrect.
drh1cc093c2002-06-24 22:01:57 +0000306*/
drh22d6a532005-09-19 21:05:48 +0000307static void setJoinExpr(Expr *p, int iTable){
drh1cc093c2002-06-24 22:01:57 +0000308 while( p ){
drh1f162302002-10-27 19:35:33 +0000309 ExprSetProperty(p, EP_FromJoin);
drh22d6a532005-09-19 21:05:48 +0000310 p->iRightJoinTable = iTable;
311 setJoinExpr(p->pLeft, iTable);
drh1cc093c2002-06-24 22:01:57 +0000312 p = p->pRight;
313 }
314}
315
316/*
drhad2d8302002-05-24 20:31:36 +0000317** This routine processes the join information for a SELECT statement.
318** ON and USING clauses are converted into extra terms of the WHERE clause.
319** NATURAL joins also create extra WHERE clause terms.
320**
drh91bb0ee2004-09-01 03:06:34 +0000321** The terms of a FROM clause are contained in the Select.pSrc structure.
322** The left most table is the first entry in Select.pSrc. The right-most
323** table is the last entry. The join operator is held in the entry to
324** the left. Thus entry 0 contains the join operator for the join between
325** entries 0 and 1. Any ON or USING clauses associated with the join are
326** also attached to the left entry.
327**
drhad2d8302002-05-24 20:31:36 +0000328** This routine returns the number of errors encountered.
329*/
330static int sqliteProcessJoin(Parse *pParse, Select *p){
drh91bb0ee2004-09-01 03:06:34 +0000331 SrcList *pSrc; /* All tables in the FROM clause */
332 int i, j; /* Loop counters */
333 struct SrcList_item *pLeft; /* Left table being joined */
334 struct SrcList_item *pRight; /* Right table being joined */
drhad2d8302002-05-24 20:31:36 +0000335
drh91bb0ee2004-09-01 03:06:34 +0000336 pSrc = p->pSrc;
337 pLeft = &pSrc->a[0];
338 pRight = &pLeft[1];
339 for(i=0; i<pSrc->nSrc-1; i++, pRight++, pLeft++){
340 Table *pLeftTab = pLeft->pTab;
341 Table *pRightTab = pRight->pTab;
drhad27e762008-03-26 12:46:23 +0000342 int isOuter;
drh91bb0ee2004-09-01 03:06:34 +0000343
344 if( pLeftTab==0 || pRightTab==0 ) continue;
drhad27e762008-03-26 12:46:23 +0000345 isOuter = (pRight->jointype & JT_OUTER)!=0;
drhad2d8302002-05-24 20:31:36 +0000346
347 /* When the NATURAL keyword is present, add WHERE clause terms for
348 ** every column that the two tables have in common.
349 */
drh61dfc312006-12-16 16:25:15 +0000350 if( pRight->jointype & JT_NATURAL ){
351 if( pRight->pOn || pRight->pUsing ){
danielk19774adee202004-05-08 08:23:19 +0000352 sqlite3ErrorMsg(pParse, "a NATURAL join may not have "
drhad2d8302002-05-24 20:31:36 +0000353 "an ON or USING clause", 0);
drhad2d8302002-05-24 20:31:36 +0000354 return 1;
355 }
drh91bb0ee2004-09-01 03:06:34 +0000356 for(j=0; j<pLeftTab->nCol; j++){
357 char *zName = pLeftTab->aCol[j].zName;
358 if( columnIndex(pRightTab, zName)>=0 ){
danielk19771e536952007-08-16 10:09:01 +0000359 addWhereTerm(pParse, zName, pLeftTab, pLeft->zAlias,
drh22d6a532005-09-19 21:05:48 +0000360 pRightTab, pRight->zAlias,
drhad27e762008-03-26 12:46:23 +0000361 pRight->iCursor, &p->pWhere, isOuter);
drh22d6a532005-09-19 21:05:48 +0000362
drhad2d8302002-05-24 20:31:36 +0000363 }
364 }
365 }
366
367 /* Disallow both ON and USING clauses in the same join
368 */
drh61dfc312006-12-16 16:25:15 +0000369 if( pRight->pOn && pRight->pUsing ){
danielk19774adee202004-05-08 08:23:19 +0000370 sqlite3ErrorMsg(pParse, "cannot have both ON and USING "
drhda93d232003-03-31 02:12:46 +0000371 "clauses in the same join");
drhad2d8302002-05-24 20:31:36 +0000372 return 1;
373 }
374
375 /* Add the ON clause to the end of the WHERE clause, connected by
drh91bb0ee2004-09-01 03:06:34 +0000376 ** an AND operator.
drhad2d8302002-05-24 20:31:36 +0000377 */
drh61dfc312006-12-16 16:25:15 +0000378 if( pRight->pOn ){
drhad27e762008-03-26 12:46:23 +0000379 if( isOuter ) setJoinExpr(pRight->pOn, pRight->iCursor);
drh17435752007-08-16 04:30:38 +0000380 p->pWhere = sqlite3ExprAnd(pParse->db, p->pWhere, pRight->pOn);
drh61dfc312006-12-16 16:25:15 +0000381 pRight->pOn = 0;
drhad2d8302002-05-24 20:31:36 +0000382 }
383
384 /* Create extra terms on the WHERE clause for each column named
385 ** in the USING clause. Example: If the two tables to be joined are
386 ** A and B and the USING clause names X, Y, and Z, then add this
387 ** to the WHERE clause: A.X=B.X AND A.Y=B.Y AND A.Z=B.Z
388 ** Report an error if any column mentioned in the USING clause is
389 ** not contained in both tables to be joined.
390 */
drh61dfc312006-12-16 16:25:15 +0000391 if( pRight->pUsing ){
392 IdList *pList = pRight->pUsing;
drhad2d8302002-05-24 20:31:36 +0000393 for(j=0; j<pList->nId; j++){
drh91bb0ee2004-09-01 03:06:34 +0000394 char *zName = pList->a[j].zName;
395 if( columnIndex(pLeftTab, zName)<0 || columnIndex(pRightTab, zName)<0 ){
danielk19774adee202004-05-08 08:23:19 +0000396 sqlite3ErrorMsg(pParse, "cannot join using column %s - column "
drh91bb0ee2004-09-01 03:06:34 +0000397 "not present in both tables", zName);
drhad2d8302002-05-24 20:31:36 +0000398 return 1;
399 }
danielk19771e536952007-08-16 10:09:01 +0000400 addWhereTerm(pParse, zName, pLeftTab, pLeft->zAlias,
drh22d6a532005-09-19 21:05:48 +0000401 pRightTab, pRight->zAlias,
drhad27e762008-03-26 12:46:23 +0000402 pRight->iCursor, &p->pWhere, isOuter);
drhad2d8302002-05-24 20:31:36 +0000403 }
404 }
405 }
406 return 0;
407}
408
409/*
drhc926afb2002-06-20 03:38:26 +0000410** Insert code into "v" that will push the record on the top of the
411** stack into the sorter.
412*/
drhd59ba6c2006-01-08 05:02:54 +0000413static void pushOntoSorter(
414 Parse *pParse, /* Parser context */
415 ExprList *pOrderBy, /* The ORDER BY clause */
drhb7654112008-01-12 12:48:07 +0000416 Select *pSelect, /* The whole SELECT statement */
417 int regData /* Register holding data to be sorted */
drhd59ba6c2006-01-08 05:02:54 +0000418){
419 Vdbe *v = pParse->pVdbe;
drh892d3172008-01-10 03:46:36 +0000420 int nExpr = pOrderBy->nExpr;
421 int regBase = sqlite3GetTempRange(pParse, nExpr+2);
422 int regRecord = sqlite3GetTempReg(pParse);
drh191b54c2008-04-15 12:14:21 +0000423 sqlite3ExprCodeExprList(pParse, pOrderBy, regBase, 0);
drh892d3172008-01-10 03:46:36 +0000424 sqlite3VdbeAddOp2(v, OP_Sequence, pOrderBy->iECursor, regBase+nExpr);
drhb21e7c72008-06-22 12:37:57 +0000425 sqlite3ExprCodeMove(pParse, regData, regBase+nExpr+1, 1);
drh1db639c2008-01-17 02:36:28 +0000426 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nExpr + 2, regRecord);
drh892d3172008-01-10 03:46:36 +0000427 sqlite3VdbeAddOp2(v, OP_IdxInsert, pOrderBy->iECursor, regRecord);
428 sqlite3ReleaseTempReg(pParse, regRecord);
429 sqlite3ReleaseTempRange(pParse, regBase, nExpr+2);
drh92b01d52008-06-24 00:32:35 +0000430 if( pSelect->iLimit ){
drh15007a92006-01-08 18:10:17 +0000431 int addr1, addr2;
drhb7654112008-01-12 12:48:07 +0000432 int iLimit;
drh0acb7e42008-06-25 00:12:41 +0000433 if( pSelect->iOffset ){
drhb7654112008-01-12 12:48:07 +0000434 iLimit = pSelect->iOffset+1;
435 }else{
436 iLimit = pSelect->iLimit;
437 }
438 addr1 = sqlite3VdbeAddOp1(v, OP_IfZero, iLimit);
439 sqlite3VdbeAddOp2(v, OP_AddImm, iLimit, -1);
drh3c84ddf2008-01-09 02:15:38 +0000440 addr2 = sqlite3VdbeAddOp0(v, OP_Goto);
drhd59ba6c2006-01-08 05:02:54 +0000441 sqlite3VdbeJumpHere(v, addr1);
drh3c84ddf2008-01-09 02:15:38 +0000442 sqlite3VdbeAddOp1(v, OP_Last, pOrderBy->iECursor);
443 sqlite3VdbeAddOp1(v, OP_Delete, pOrderBy->iECursor);
drh15007a92006-01-08 18:10:17 +0000444 sqlite3VdbeJumpHere(v, addr2);
drh92b01d52008-06-24 00:32:35 +0000445 pSelect->iLimit = 0;
drhd59ba6c2006-01-08 05:02:54 +0000446 }
drhc926afb2002-06-20 03:38:26 +0000447}
448
449/*
drhec7429a2005-10-06 16:53:14 +0000450** Add code to implement the OFFSET
drhea48eb22004-07-19 23:16:38 +0000451*/
drhec7429a2005-10-06 16:53:14 +0000452static void codeOffset(
drhbab39e12004-07-19 23:38:11 +0000453 Vdbe *v, /* Generate code into this VM */
drhea48eb22004-07-19 23:16:38 +0000454 Select *p, /* The SELECT statement being coded */
drhb7654112008-01-12 12:48:07 +0000455 int iContinue /* Jump here to skip the current record */
drhea48eb22004-07-19 23:16:38 +0000456){
drh92b01d52008-06-24 00:32:35 +0000457 if( p->iOffset && iContinue!=0 ){
drh15007a92006-01-08 18:10:17 +0000458 int addr;
drh8558cde2008-01-05 05:20:10 +0000459 sqlite3VdbeAddOp2(v, OP_AddImm, p->iOffset, -1);
drh3c84ddf2008-01-09 02:15:38 +0000460 addr = sqlite3VdbeAddOp1(v, OP_IfNeg, p->iOffset);
drh66a51672008-01-03 00:01:23 +0000461 sqlite3VdbeAddOp2(v, OP_Goto, 0, iContinue);
drhd4e70eb2008-01-02 00:34:36 +0000462 VdbeComment((v, "skip OFFSET records"));
drh15007a92006-01-08 18:10:17 +0000463 sqlite3VdbeJumpHere(v, addr);
drhea48eb22004-07-19 23:16:38 +0000464 }
drhea48eb22004-07-19 23:16:38 +0000465}
466
467/*
drh98757152008-01-09 23:04:12 +0000468** Add code that will check to make sure the N registers starting at iMem
469** form a distinct entry. iTab is a sorting index that holds previously
drha2a49dc2008-01-02 14:28:13 +0000470** seen combinations of the N values. A new entry is made in iTab
471** if the current N values are new.
472**
473** A jump to addrRepeat is made and the N+1 values are popped from the
474** stack if the top N elements are not distinct.
475*/
476static void codeDistinct(
drh2dcef112008-01-12 19:03:48 +0000477 Parse *pParse, /* Parsing and code generating context */
drha2a49dc2008-01-02 14:28:13 +0000478 int iTab, /* A sorting index used to test for distinctness */
479 int addrRepeat, /* Jump to here if not distinct */
drh477df4b2008-01-05 18:48:24 +0000480 int N, /* Number of elements */
drha2a49dc2008-01-02 14:28:13 +0000481 int iMem /* First element */
482){
drh2dcef112008-01-12 19:03:48 +0000483 Vdbe *v;
484 int r1;
485
486 v = pParse->pVdbe;
487 r1 = sqlite3GetTempReg(pParse);
drh1db639c2008-01-17 02:36:28 +0000488 sqlite3VdbeAddOp3(v, OP_MakeRecord, iMem, N, r1);
drh2dcef112008-01-12 19:03:48 +0000489 sqlite3VdbeAddOp3(v, OP_Found, iTab, addrRepeat, r1);
490 sqlite3VdbeAddOp2(v, OP_IdxInsert, iTab, r1);
491 sqlite3ReleaseTempReg(pParse, r1);
drha2a49dc2008-01-02 14:28:13 +0000492}
493
494/*
drhe305f432007-05-09 22:56:39 +0000495** Generate an error message when a SELECT is used within a subexpression
496** (example: "a IN (SELECT * FROM table)") but it has more than 1 result
497** column. We do this in a subroutine because the error occurs in multiple
498** places.
499*/
danielk19776c8c8ce2008-01-02 16:27:09 +0000500static int checkForMultiColumnSelectError(
501 Parse *pParse, /* Parse context. */
502 SelectDest *pDest, /* Destination of SELECT results */
503 int nExpr /* Number of result columns returned by SELECT */
504){
505 int eDest = pDest->eDest;
drhe305f432007-05-09 22:56:39 +0000506 if( nExpr>1 && (eDest==SRT_Mem || eDest==SRT_Set) ){
507 sqlite3ErrorMsg(pParse, "only a single result allowed for "
508 "a SELECT that is part of an expression");
509 return 1;
510 }else{
511 return 0;
512 }
513}
drhc99130f2005-09-11 11:56:27 +0000514
515/*
drh22827922000-06-06 17:27:05 +0000516** This routine generates the code for the inside of the inner loop
517** of a SELECT.
drh82c3d632000-06-06 21:56:07 +0000518**
drh38640e12002-07-05 21:42:36 +0000519** If srcTab and nColumn are both zero, then the pEList expressions
520** are evaluated in order to get the data for this row. If nColumn>0
521** then data is pulled from srcTab and pEList is used only to get the
522** datatypes for each column.
drh22827922000-06-06 17:27:05 +0000523*/
drhd2b3e232008-01-23 14:51:49 +0000524static void selectInnerLoop(
drh22827922000-06-06 17:27:05 +0000525 Parse *pParse, /* The parser context */
drhdf199a22002-06-14 22:38:41 +0000526 Select *p, /* The complete select statement being coded */
drh22827922000-06-06 17:27:05 +0000527 ExprList *pEList, /* List of values being extracted */
drh82c3d632000-06-06 21:56:07 +0000528 int srcTab, /* Pull data from this table */
drh967e8b72000-06-21 13:59:10 +0000529 int nColumn, /* Number of columns in the source table */
drh22827922000-06-06 17:27:05 +0000530 ExprList *pOrderBy, /* If not NULL, sort results using this key */
531 int distinct, /* If >=0, make sure results are distinct */
danielk19776c8c8ce2008-01-02 16:27:09 +0000532 SelectDest *pDest, /* How to dispose of the results */
drh22827922000-06-06 17:27:05 +0000533 int iContinue, /* Jump here to continue with next row */
danielk197784ac9d02004-05-18 09:58:06 +0000534 int iBreak, /* Jump here to break out of the inner loop */
535 char *aff /* affinity string if eDest is SRT_Union */
drh22827922000-06-06 17:27:05 +0000536){
537 Vdbe *v = pParse->pVdbe;
drhd847eaa2008-01-17 17:15:56 +0000538 int i;
drhea48eb22004-07-19 23:16:38 +0000539 int hasDistinct; /* True if the DISTINCT keyword is present */
drhd847eaa2008-01-17 17:15:56 +0000540 int regResult; /* Start of memory holding result set */
541 int eDest = pDest->eDest; /* How to dispose of results */
542 int iParm = pDest->iParm; /* First argument to disposal method */
543 int nResultCol; /* Number of result columns */
drh38640e12002-07-05 21:42:36 +0000544
drhd2b3e232008-01-23 14:51:49 +0000545 if( v==0 ) return;
drh38640e12002-07-05 21:42:36 +0000546 assert( pEList!=0 );
drh22827922000-06-06 17:27:05 +0000547
drhdf199a22002-06-14 22:38:41 +0000548 /* If there was a LIMIT clause on the SELECT statement, then do the check
549 ** to see if this row should be output.
550 */
drheda639e2006-01-22 00:42:09 +0000551 hasDistinct = distinct>=0 && pEList->nExpr>0;
drhea48eb22004-07-19 23:16:38 +0000552 if( pOrderBy==0 && !hasDistinct ){
drhb7654112008-01-12 12:48:07 +0000553 codeOffset(v, p, iContinue);
drhdf199a22002-06-14 22:38:41 +0000554 }
555
drh967e8b72000-06-21 13:59:10 +0000556 /* Pull the requested columns.
drh22827922000-06-06 17:27:05 +0000557 */
drh38640e12002-07-05 21:42:36 +0000558 if( nColumn>0 ){
drhd847eaa2008-01-17 17:15:56 +0000559 nResultCol = nColumn;
drha2a49dc2008-01-02 14:28:13 +0000560 }else{
drhd847eaa2008-01-17 17:15:56 +0000561 nResultCol = pEList->nExpr;
drha2a49dc2008-01-02 14:28:13 +0000562 }
drh1ece7322008-02-06 23:52:36 +0000563 if( pDest->iMem==0 ){
drh0acb7e42008-06-25 00:12:41 +0000564 pDest->iMem = pParse->nMem+1;
drhad27e762008-03-26 12:46:23 +0000565 pDest->nMem = nResultCol;
drh0acb7e42008-06-25 00:12:41 +0000566 pParse->nMem += nResultCol;
drhad27e762008-03-26 12:46:23 +0000567 }else if( pDest->nMem!=nResultCol ){
drh995ae272008-03-26 12:50:14 +0000568 /* This happens when two SELECTs of a compound SELECT have differing
569 ** numbers of result columns. The error message will be generated by
570 ** a higher-level routine. */
drhad27e762008-03-26 12:46:23 +0000571 return;
drh1013c932008-01-06 00:25:21 +0000572 }
drh1ece7322008-02-06 23:52:36 +0000573 regResult = pDest->iMem;
drha2a49dc2008-01-02 14:28:13 +0000574 if( nColumn>0 ){
drh967e8b72000-06-21 13:59:10 +0000575 for(i=0; i<nColumn; i++){
drhd847eaa2008-01-17 17:15:56 +0000576 sqlite3VdbeAddOp3(v, OP_Column, srcTab, i, regResult+i);
drh82c3d632000-06-06 21:56:07 +0000577 }
danielk19779ed1dfa2008-01-02 17:11:14 +0000578 }else if( eDest!=SRT_Exists ){
579 /* If the destination is an EXISTS(...) expression, the actual
580 ** values returned by the SELECT are not required.
581 */
drh191b54c2008-04-15 12:14:21 +0000582 sqlite3ExprCodeExprList(pParse, pEList, regResult, eDest==SRT_Callback);
drh22827922000-06-06 17:27:05 +0000583 }
drhd847eaa2008-01-17 17:15:56 +0000584 nColumn = nResultCol;
drh22827922000-06-06 17:27:05 +0000585
drhdaffd0e2001-04-11 14:28:42 +0000586 /* If the DISTINCT keyword was present on the SELECT statement
587 ** and this row has been seen before, then do not make this row
588 ** part of the result.
drh22827922000-06-06 17:27:05 +0000589 */
drhea48eb22004-07-19 23:16:38 +0000590 if( hasDistinct ){
drhf8875402006-03-17 13:56:34 +0000591 assert( pEList!=0 );
592 assert( pEList->nExpr==nColumn );
drhd847eaa2008-01-17 17:15:56 +0000593 codeDistinct(pParse, distinct, iContinue, nColumn, regResult);
drhea48eb22004-07-19 23:16:38 +0000594 if( pOrderBy==0 ){
drhb7654112008-01-12 12:48:07 +0000595 codeOffset(v, p, iContinue);
drhea48eb22004-07-19 23:16:38 +0000596 }
drh22827922000-06-06 17:27:05 +0000597 }
drh82c3d632000-06-06 21:56:07 +0000598
danielk19776c8c8ce2008-01-02 16:27:09 +0000599 if( checkForMultiColumnSelectError(pParse, pDest, pEList->nExpr) ){
drhd2b3e232008-01-23 14:51:49 +0000600 return;
drhe305f432007-05-09 22:56:39 +0000601 }
602
drhc926afb2002-06-20 03:38:26 +0000603 switch( eDest ){
604 /* In this mode, write each query result to the key of the temporary
605 ** table iParm.
606 */
drh13449892005-09-07 21:22:45 +0000607#ifndef SQLITE_OMIT_COMPOUND_SELECT
drhc926afb2002-06-20 03:38:26 +0000608 case SRT_Union: {
drh9cbf3422008-01-17 16:22:13 +0000609 int r1;
610 r1 = sqlite3GetTempReg(pParse);
drhd847eaa2008-01-17 17:15:56 +0000611 sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nColumn, r1);
drh13449892005-09-07 21:22:45 +0000612 if( aff ){
drh66a51672008-01-03 00:01:23 +0000613 sqlite3VdbeChangeP4(v, -1, aff, P4_STATIC);
drh13449892005-09-07 21:22:45 +0000614 }
drh9cbf3422008-01-17 16:22:13 +0000615 sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, r1);
616 sqlite3ReleaseTempReg(pParse, r1);
drhc926afb2002-06-20 03:38:26 +0000617 break;
drh22827922000-06-06 17:27:05 +0000618 }
drh22827922000-06-06 17:27:05 +0000619
drhc926afb2002-06-20 03:38:26 +0000620 /* Construct a record from the query result, but instead of
621 ** saving that record, use it as a key to delete elements from
622 ** the temporary table iParm.
623 */
624 case SRT_Except: {
drhe14006d2008-03-25 17:23:32 +0000625 sqlite3VdbeAddOp3(v, OP_IdxDelete, iParm, regResult, nColumn);
drhc926afb2002-06-20 03:38:26 +0000626 break;
627 }
danielk19775338a5f2005-01-20 13:03:10 +0000628#endif
629
630 /* Store the result as data using a unique key.
631 */
632 case SRT_Table:
drhb9bb7c12006-06-11 23:41:55 +0000633 case SRT_EphemTab: {
drhb7654112008-01-12 12:48:07 +0000634 int r1 = sqlite3GetTempReg(pParse);
drhd847eaa2008-01-17 17:15:56 +0000635 sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nColumn, r1);
danielk19775338a5f2005-01-20 13:03:10 +0000636 if( pOrderBy ){
drhb7654112008-01-12 12:48:07 +0000637 pushOntoSorter(pParse, pOrderBy, p, r1);
danielk19775338a5f2005-01-20 13:03:10 +0000638 }else{
drhb7654112008-01-12 12:48:07 +0000639 int r2 = sqlite3GetTempReg(pParse);
640 sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, r2);
641 sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, r2);
642 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
643 sqlite3ReleaseTempReg(pParse, r2);
danielk19775338a5f2005-01-20 13:03:10 +0000644 }
drhb7654112008-01-12 12:48:07 +0000645 sqlite3ReleaseTempReg(pParse, r1);
danielk19775338a5f2005-01-20 13:03:10 +0000646 break;
647 }
drh5974a302000-06-07 14:42:26 +0000648
danielk197793758c82005-01-21 08:13:14 +0000649#ifndef SQLITE_OMIT_SUBQUERY
drhc926afb2002-06-20 03:38:26 +0000650 /* If we are creating a set for an "expr IN (SELECT ...)" construct,
651 ** then there should be a single item on the stack. Write this
652 ** item into the set table with bogus data.
653 */
654 case SRT_Set: {
drh52b36ca2004-01-14 13:38:54 +0000655 int addr2;
danielk1977e014a832004-05-17 10:48:57 +0000656
drhc926afb2002-06-20 03:38:26 +0000657 assert( nColumn==1 );
drhd847eaa2008-01-17 17:15:56 +0000658 addr2 = sqlite3VdbeAddOp1(v, OP_IsNull, regResult);
danielk19776c8c8ce2008-01-02 16:27:09 +0000659 p->affinity = sqlite3CompareAffinity(pEList->a[0].pExpr, pDest->affinity);
drhc926afb2002-06-20 03:38:26 +0000660 if( pOrderBy ){
drhde941c62005-08-28 01:34:21 +0000661 /* At first glance you would think we could optimize out the
662 ** ORDER BY in this case since the order of entries in the set
663 ** does not matter. But there might be a LIMIT clause, in which
664 ** case the order does matter */
drhd847eaa2008-01-17 17:15:56 +0000665 pushOntoSorter(pParse, pOrderBy, p, regResult);
drhc926afb2002-06-20 03:38:26 +0000666 }else{
drhb7654112008-01-12 12:48:07 +0000667 int r1 = sqlite3GetTempReg(pParse);
drhd847eaa2008-01-17 17:15:56 +0000668 sqlite3VdbeAddOp4(v, OP_MakeRecord, regResult, 1, r1, &p->affinity, 1);
drhda250ea2008-04-01 05:07:14 +0000669 sqlite3ExprCacheAffinityChange(pParse, regResult, 1);
drhb7654112008-01-12 12:48:07 +0000670 sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, r1);
671 sqlite3ReleaseTempReg(pParse, r1);
drhc926afb2002-06-20 03:38:26 +0000672 }
drhd654be82005-09-20 17:42:23 +0000673 sqlite3VdbeJumpHere(v, addr2);
drhc926afb2002-06-20 03:38:26 +0000674 break;
675 }
drh22827922000-06-06 17:27:05 +0000676
drh504b6982006-01-22 21:52:56 +0000677 /* If any row exist in the result set, record that fact and abort.
drhec7429a2005-10-06 16:53:14 +0000678 */
679 case SRT_Exists: {
drh4c583122008-01-04 22:01:03 +0000680 sqlite3VdbeAddOp2(v, OP_Integer, 1, iParm);
drhec7429a2005-10-06 16:53:14 +0000681 /* The LIMIT clause will terminate the loop for us */
682 break;
683 }
684
drhc926afb2002-06-20 03:38:26 +0000685 /* If this is a scalar select that is part of an expression, then
686 ** store the results in the appropriate memory cell and break out
687 ** of the scan loop.
688 */
689 case SRT_Mem: {
690 assert( nColumn==1 );
691 if( pOrderBy ){
drhd847eaa2008-01-17 17:15:56 +0000692 pushOntoSorter(pParse, pOrderBy, p, regResult);
drhc926afb2002-06-20 03:38:26 +0000693 }else{
drhb21e7c72008-06-22 12:37:57 +0000694 sqlite3ExprCodeMove(pParse, regResult, iParm, 1);
drhec7429a2005-10-06 16:53:14 +0000695 /* The LIMIT clause will jump out of the loop for us */
drhc926afb2002-06-20 03:38:26 +0000696 }
697 break;
698 }
danielk197793758c82005-01-21 08:13:14 +0000699#endif /* #ifndef SQLITE_OMIT_SUBQUERY */
drh22827922000-06-06 17:27:05 +0000700
drhc182d162005-08-14 20:47:16 +0000701 /* Send the data to the callback function or to a subroutine. In the
702 ** case of a subroutine, the subroutine itself is responsible for
703 ** popping the data from the stack.
drhf46f9052002-06-22 02:33:38 +0000704 */
drhe00ee6e2008-06-20 15:24:01 +0000705 case SRT_Coroutine:
drh9d2985c2005-09-08 01:58:42 +0000706 case SRT_Callback: {
drhf46f9052002-06-22 02:33:38 +0000707 if( pOrderBy ){
drhb7654112008-01-12 12:48:07 +0000708 int r1 = sqlite3GetTempReg(pParse);
drhd847eaa2008-01-17 17:15:56 +0000709 sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nColumn, r1);
drhb7654112008-01-12 12:48:07 +0000710 pushOntoSorter(pParse, pOrderBy, p, r1);
711 sqlite3ReleaseTempReg(pParse, r1);
drhe00ee6e2008-06-20 15:24:01 +0000712 }else if( eDest==SRT_Coroutine ){
drh92b01d52008-06-24 00:32:35 +0000713 sqlite3VdbeAddOp1(v, OP_Yield, pDest->iParm);
drhc182d162005-08-14 20:47:16 +0000714 }else{
drhd847eaa2008-01-17 17:15:56 +0000715 sqlite3VdbeAddOp2(v, OP_ResultRow, regResult, nColumn);
drhda250ea2008-04-01 05:07:14 +0000716 sqlite3ExprCacheAffinityChange(pParse, regResult, nColumn);
drhac82fcf2002-09-08 17:23:41 +0000717 }
drh142e30d2002-08-28 03:00:58 +0000718 break;
719 }
720
danielk19776a67fe82005-02-04 04:07:16 +0000721#if !defined(SQLITE_OMIT_TRIGGER)
drhc926afb2002-06-20 03:38:26 +0000722 /* Discard the results. This is used for SELECT statements inside
723 ** the body of a TRIGGER. The purpose of such selects is to call
724 ** user-defined functions that have side effects. We do not care
725 ** about the actual results of the select.
726 */
drhc926afb2002-06-20 03:38:26 +0000727 default: {
drhf46f9052002-06-22 02:33:38 +0000728 assert( eDest==SRT_Discard );
drhc926afb2002-06-20 03:38:26 +0000729 break;
730 }
danielk197793758c82005-01-21 08:13:14 +0000731#endif
drh82c3d632000-06-06 21:56:07 +0000732 }
drhec7429a2005-10-06 16:53:14 +0000733
734 /* Jump to the end of the loop if the LIMIT is reached.
735 */
drh92b01d52008-06-24 00:32:35 +0000736 if( p->iLimit && pOrderBy==0 ){
drh8558cde2008-01-05 05:20:10 +0000737 sqlite3VdbeAddOp2(v, OP_AddImm, p->iLimit, -1);
drh3c84ddf2008-01-09 02:15:38 +0000738 sqlite3VdbeAddOp2(v, OP_IfZero, p->iLimit, iBreak);
drhec7429a2005-10-06 16:53:14 +0000739 }
drh82c3d632000-06-06 21:56:07 +0000740}
741
742/*
drhdece1a82005-08-31 18:20:00 +0000743** Given an expression list, generate a KeyInfo structure that records
744** the collating sequence for each expression in that expression list.
745**
drh0342b1f2005-09-01 03:07:44 +0000746** If the ExprList is an ORDER BY or GROUP BY clause then the resulting
747** KeyInfo structure is appropriate for initializing a virtual index to
748** implement that clause. If the ExprList is the result set of a SELECT
749** then the KeyInfo structure is appropriate for initializing a virtual
750** index to implement a DISTINCT test.
751**
drhdece1a82005-08-31 18:20:00 +0000752** Space to hold the KeyInfo structure is obtain from malloc. The calling
753** function is responsible for seeing that this structure is eventually
drh66a51672008-01-03 00:01:23 +0000754** freed. Add the KeyInfo structure to the P4 field of an opcode using
755** P4_KEYINFO_HANDOFF is the usual way of dealing with this.
drhdece1a82005-08-31 18:20:00 +0000756*/
757static KeyInfo *keyInfoFromExprList(Parse *pParse, ExprList *pList){
758 sqlite3 *db = pParse->db;
759 int nExpr;
760 KeyInfo *pInfo;
761 struct ExprList_item *pItem;
762 int i;
763
764 nExpr = pList->nExpr;
drh17435752007-08-16 04:30:38 +0000765 pInfo = sqlite3DbMallocZero(db, sizeof(*pInfo) + nExpr*(sizeof(CollSeq*)+1) );
drhdece1a82005-08-31 18:20:00 +0000766 if( pInfo ){
drh2646da72005-12-09 20:02:05 +0000767 pInfo->aSortOrder = (u8*)&pInfo->aColl[nExpr];
drhdece1a82005-08-31 18:20:00 +0000768 pInfo->nField = nExpr;
danielk197714db2662006-01-09 16:12:04 +0000769 pInfo->enc = ENC(db);
drhdece1a82005-08-31 18:20:00 +0000770 for(i=0, pItem=pList->a; i<nExpr; i++, pItem++){
771 CollSeq *pColl;
772 pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
773 if( !pColl ){
774 pColl = db->pDfltColl;
775 }
776 pInfo->aColl[i] = pColl;
777 pInfo->aSortOrder[i] = pItem->sortOrder;
778 }
779 }
780 return pInfo;
781}
782
783
784/*
drhd8bc7082000-06-07 23:51:50 +0000785** If the inner loop was generated using a non-null pOrderBy argument,
786** then the results were placed in a sorter. After the loop is terminated
787** we need to run the sorter and output the results. The following
788** routine generates the code needed to do that.
789*/
drhc926afb2002-06-20 03:38:26 +0000790static void generateSortTail(
danielk19776c8c8ce2008-01-02 16:27:09 +0000791 Parse *pParse, /* Parsing context */
792 Select *p, /* The SELECT statement */
793 Vdbe *v, /* Generate code into this VDBE */
794 int nColumn, /* Number of columns of data */
795 SelectDest *pDest /* Write the sorted results here */
drhc926afb2002-06-20 03:38:26 +0000796){
drh0342b1f2005-09-01 03:07:44 +0000797 int brk = sqlite3VdbeMakeLabel(v);
798 int cont = sqlite3VdbeMakeLabel(v);
drhd8bc7082000-06-07 23:51:50 +0000799 int addr;
drh0342b1f2005-09-01 03:07:44 +0000800 int iTab;
drh61fc5952007-04-01 23:49:51 +0000801 int pseudoTab = 0;
drh0342b1f2005-09-01 03:07:44 +0000802 ExprList *pOrderBy = p->pOrderBy;
drhffbc3082004-05-21 01:29:06 +0000803
danielk19776c8c8ce2008-01-02 16:27:09 +0000804 int eDest = pDest->eDest;
805 int iParm = pDest->iParm;
806
drh2d401ab2008-01-10 23:50:11 +0000807 int regRow;
808 int regRowid;
809
drh9d2985c2005-09-08 01:58:42 +0000810 iTab = pOrderBy->iECursor;
drhe00ee6e2008-06-20 15:24:01 +0000811 if( eDest==SRT_Callback || eDest==SRT_Coroutine ){
drhcdd536f2006-03-17 00:04:03 +0000812 pseudoTab = pParse->nTab++;
danielk1977cd3e8f72008-03-25 09:47:35 +0000813 sqlite3VdbeAddOp2(v, OP_SetNumColumns, 0, nColumn);
danielk19779882d992008-03-27 17:59:01 +0000814 sqlite3VdbeAddOp2(v, OP_OpenPseudo, pseudoTab, eDest==SRT_Callback);
drhcdd536f2006-03-17 00:04:03 +0000815 }
drh66a51672008-01-03 00:01:23 +0000816 addr = 1 + sqlite3VdbeAddOp2(v, OP_Sort, iTab, brk);
drhb7654112008-01-12 12:48:07 +0000817 codeOffset(v, p, cont);
drh2d401ab2008-01-10 23:50:11 +0000818 regRow = sqlite3GetTempReg(pParse);
819 regRowid = sqlite3GetTempReg(pParse);
820 sqlite3VdbeAddOp3(v, OP_Column, iTab, pOrderBy->nExpr + 1, regRow);
drhc926afb2002-06-20 03:38:26 +0000821 switch( eDest ){
drhc926afb2002-06-20 03:38:26 +0000822 case SRT_Table:
drhb9bb7c12006-06-11 23:41:55 +0000823 case SRT_EphemTab: {
drh2d401ab2008-01-10 23:50:11 +0000824 sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, regRowid);
825 sqlite3VdbeAddOp3(v, OP_Insert, iParm, regRow, regRowid);
826 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
drhc926afb2002-06-20 03:38:26 +0000827 break;
828 }
danielk197793758c82005-01-21 08:13:14 +0000829#ifndef SQLITE_OMIT_SUBQUERY
drhc926afb2002-06-20 03:38:26 +0000830 case SRT_Set: {
drh2d401ab2008-01-10 23:50:11 +0000831 int j1;
drhc926afb2002-06-20 03:38:26 +0000832 assert( nColumn==1 );
drh2d401ab2008-01-10 23:50:11 +0000833 j1 = sqlite3VdbeAddOp1(v, OP_IsNull, regRow);
danielk1977a7a8e142008-02-13 18:25:27 +0000834 sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, 1, regRowid, &p->affinity, 1);
drhda250ea2008-04-01 05:07:14 +0000835 sqlite3ExprCacheAffinityChange(pParse, regRow, 1);
danielk1977a7a8e142008-02-13 18:25:27 +0000836 sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, regRowid);
drh6a288a32008-01-07 19:20:24 +0000837 sqlite3VdbeJumpHere(v, j1);
drhc926afb2002-06-20 03:38:26 +0000838 break;
839 }
840 case SRT_Mem: {
841 assert( nColumn==1 );
drhb21e7c72008-06-22 12:37:57 +0000842 sqlite3ExprCodeMove(pParse, regRow, iParm, 1);
drhec7429a2005-10-06 16:53:14 +0000843 /* The LIMIT clause will terminate the loop for us */
drhc926afb2002-06-20 03:38:26 +0000844 break;
845 }
danielk197793758c82005-01-21 08:13:14 +0000846#endif
drhce665cf2004-05-21 03:01:58 +0000847 case SRT_Callback:
drhe00ee6e2008-06-20 15:24:01 +0000848 case SRT_Coroutine: {
drhac82fcf2002-09-08 17:23:41 +0000849 int i;
drh2d401ab2008-01-10 23:50:11 +0000850 sqlite3VdbeAddOp2(v, OP_Integer, 1, regRowid);
851 sqlite3VdbeAddOp3(v, OP_Insert, pseudoTab, regRow, regRowid);
drhac82fcf2002-09-08 17:23:41 +0000852 for(i=0; i<nColumn; i++){
danielk19779882d992008-03-27 17:59:01 +0000853 assert( regRow!=pDest->iMem+i );
drh1013c932008-01-06 00:25:21 +0000854 sqlite3VdbeAddOp3(v, OP_Column, pseudoTab, i, pDest->iMem+i);
drhac82fcf2002-09-08 17:23:41 +0000855 }
drhce665cf2004-05-21 03:01:58 +0000856 if( eDest==SRT_Callback ){
drh1013c932008-01-06 00:25:21 +0000857 sqlite3VdbeAddOp2(v, OP_ResultRow, pDest->iMem, nColumn);
drhda250ea2008-04-01 05:07:14 +0000858 sqlite3ExprCacheAffinityChange(pParse, pDest->iMem, nColumn);
drhe00ee6e2008-06-20 15:24:01 +0000859 }else if( eDest==SRT_Coroutine ){
drh92b01d52008-06-24 00:32:35 +0000860 sqlite3VdbeAddOp1(v, OP_Yield, pDest->iParm);
drhce665cf2004-05-21 03:01:58 +0000861 }
drhac82fcf2002-09-08 17:23:41 +0000862 break;
863 }
drhc926afb2002-06-20 03:38:26 +0000864 default: {
drhf46f9052002-06-22 02:33:38 +0000865 /* Do nothing */
drhc926afb2002-06-20 03:38:26 +0000866 break;
867 }
868 }
drh2d401ab2008-01-10 23:50:11 +0000869 sqlite3ReleaseTempReg(pParse, regRow);
870 sqlite3ReleaseTempReg(pParse, regRowid);
drhec7429a2005-10-06 16:53:14 +0000871
872 /* Jump to the end of the loop when the LIMIT is reached
873 */
drh92b01d52008-06-24 00:32:35 +0000874 if( p->iLimit ){
drh8558cde2008-01-05 05:20:10 +0000875 sqlite3VdbeAddOp2(v, OP_AddImm, p->iLimit, -1);
drh3c84ddf2008-01-09 02:15:38 +0000876 sqlite3VdbeAddOp2(v, OP_IfZero, p->iLimit, brk);
drhec7429a2005-10-06 16:53:14 +0000877 }
878
879 /* The bottom of the loop
880 */
drh0342b1f2005-09-01 03:07:44 +0000881 sqlite3VdbeResolveLabel(v, cont);
drh66a51672008-01-03 00:01:23 +0000882 sqlite3VdbeAddOp2(v, OP_Next, iTab, addr);
drh0342b1f2005-09-01 03:07:44 +0000883 sqlite3VdbeResolveLabel(v, brk);
drhe00ee6e2008-06-20 15:24:01 +0000884 if( eDest==SRT_Callback || eDest==SRT_Coroutine ){
drh66a51672008-01-03 00:01:23 +0000885 sqlite3VdbeAddOp2(v, OP_Close, pseudoTab, 0);
drhcdd536f2006-03-17 00:04:03 +0000886 }
887
drhd8bc7082000-06-07 23:51:50 +0000888}
889
890/*
danielk1977517eb642004-06-07 10:00:31 +0000891** Return a pointer to a string containing the 'declaration type' of the
892** expression pExpr. The string may be treated as static by the caller.
drhe78e8282003-01-19 03:59:45 +0000893**
danielk1977955de522006-02-10 02:27:42 +0000894** The declaration type is the exact datatype definition extracted from the
895** original CREATE TABLE statement if the expression is a column. The
896** declaration type for a ROWID field is INTEGER. Exactly when an expression
897** is considered a column can be complex in the presence of subqueries. The
898** result-set expression in all of the following SELECT statements is
899** considered a column by this function.
900**
901** SELECT col FROM tbl;
902** SELECT (SELECT col FROM tbl;
903** SELECT (SELECT col FROM tbl);
904** SELECT abc FROM (SELECT col AS abc FROM tbl);
danielk1977517eb642004-06-07 10:00:31 +0000905**
danielk1977955de522006-02-10 02:27:42 +0000906** The declaration type for any expression other than a column is NULL.
danielk1977517eb642004-06-07 10:00:31 +0000907*/
danielk1977955de522006-02-10 02:27:42 +0000908static const char *columnType(
909 NameContext *pNC,
910 Expr *pExpr,
911 const char **pzOriginDb,
912 const char **pzOriginTab,
913 const char **pzOriginCol
914){
915 char const *zType = 0;
916 char const *zOriginDb = 0;
917 char const *zOriginTab = 0;
918 char const *zOriginCol = 0;
danielk1977517eb642004-06-07 10:00:31 +0000919 int j;
danielk1977b3bce662005-01-29 08:32:43 +0000920 if( pExpr==0 || pNC->pSrcList==0 ) return 0;
danielk19775338a5f2005-01-20 13:03:10 +0000921
danielk197700e279d2004-06-21 07:36:32 +0000922 switch( pExpr->op ){
drh30bcf5d2006-04-07 13:50:37 +0000923 case TK_AGG_COLUMN:
danielk197700e279d2004-06-21 07:36:32 +0000924 case TK_COLUMN: {
danielk1977955de522006-02-10 02:27:42 +0000925 /* The expression is a column. Locate the table the column is being
926 ** extracted from in NameContext.pSrcList. This table may be real
927 ** database table or a subquery.
928 */
929 Table *pTab = 0; /* Table structure column is extracted from */
930 Select *pS = 0; /* Select the column is extracted from */
931 int iCol = pExpr->iColumn; /* Index of column in pTab */
danielk1977b3bce662005-01-29 08:32:43 +0000932 while( pNC && !pTab ){
933 SrcList *pTabList = pNC->pSrcList;
934 for(j=0;j<pTabList->nSrc && pTabList->a[j].iCursor!=pExpr->iTable;j++);
935 if( j<pTabList->nSrc ){
936 pTab = pTabList->a[j].pTab;
danielk1977955de522006-02-10 02:27:42 +0000937 pS = pTabList->a[j].pSelect;
danielk1977b3bce662005-01-29 08:32:43 +0000938 }else{
939 pNC = pNC->pNext;
940 }
941 }
danielk1977955de522006-02-10 02:27:42 +0000942
drh7e627792005-04-29 02:10:00 +0000943 if( pTab==0 ){
944 /* FIX ME:
945 ** This can occurs if you have something like "SELECT new.x;" inside
946 ** a trigger. In other words, if you reference the special "new"
947 ** table in the result set of a select. We do not have a good way
948 ** to find the actual table type, so call it "TEXT". This is really
949 ** something of a bug, but I do not know how to fix it.
950 **
951 ** This code does not produce the correct answer - it just prevents
952 ** a segfault. See ticket #1229.
953 */
954 zType = "TEXT";
955 break;
956 }
danielk1977955de522006-02-10 02:27:42 +0000957
danielk1977b3bce662005-01-29 08:32:43 +0000958 assert( pTab );
danielk1977955de522006-02-10 02:27:42 +0000959 if( pS ){
960 /* The "table" is actually a sub-select or a view in the FROM clause
961 ** of the SELECT statement. Return the declaration type and origin
962 ** data for the result-set column of the sub-select.
963 */
964 if( iCol>=0 && iCol<pS->pEList->nExpr ){
965 /* If iCol is less than zero, then the expression requests the
966 ** rowid of the sub-select or view. This expression is legal (see
967 ** test case misc2.2.2) - it always evaluates to NULL.
968 */
969 NameContext sNC;
970 Expr *p = pS->pEList->a[iCol].pExpr;
971 sNC.pSrcList = pS->pSrc;
972 sNC.pNext = 0;
973 sNC.pParse = pNC->pParse;
974 zType = columnType(&sNC, p, &zOriginDb, &zOriginTab, &zOriginCol);
975 }
danielk19774b2688a2006-06-20 11:01:07 +0000976 }else if( pTab->pSchema ){
danielk1977955de522006-02-10 02:27:42 +0000977 /* A real table */
978 assert( !pS );
979 if( iCol<0 ) iCol = pTab->iPKey;
980 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
981 if( iCol<0 ){
982 zType = "INTEGER";
983 zOriginCol = "rowid";
984 }else{
985 zType = pTab->aCol[iCol].zType;
986 zOriginCol = pTab->aCol[iCol].zName;
987 }
988 zOriginTab = pTab->zName;
989 if( pNC->pParse ){
990 int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema);
991 zOriginDb = pNC->pParse->db->aDb[iDb].zName;
992 }
danielk197700e279d2004-06-21 07:36:32 +0000993 }
994 break;
danielk1977517eb642004-06-07 10:00:31 +0000995 }
danielk197793758c82005-01-21 08:13:14 +0000996#ifndef SQLITE_OMIT_SUBQUERY
danielk197700e279d2004-06-21 07:36:32 +0000997 case TK_SELECT: {
danielk1977955de522006-02-10 02:27:42 +0000998 /* The expression is a sub-select. Return the declaration type and
999 ** origin info for the single column in the result set of the SELECT
1000 ** statement.
1001 */
danielk1977b3bce662005-01-29 08:32:43 +00001002 NameContext sNC;
danielk197700e279d2004-06-21 07:36:32 +00001003 Select *pS = pExpr->pSelect;
danielk1977955de522006-02-10 02:27:42 +00001004 Expr *p = pS->pEList->a[0].pExpr;
1005 sNC.pSrcList = pS->pSrc;
danielk1977b3bce662005-01-29 08:32:43 +00001006 sNC.pNext = pNC;
danielk1977955de522006-02-10 02:27:42 +00001007 sNC.pParse = pNC->pParse;
1008 zType = columnType(&sNC, p, &zOriginDb, &zOriginTab, &zOriginCol);
danielk197700e279d2004-06-21 07:36:32 +00001009 break;
danielk1977517eb642004-06-07 10:00:31 +00001010 }
danielk197793758c82005-01-21 08:13:14 +00001011#endif
danielk1977517eb642004-06-07 10:00:31 +00001012 }
danielk197700e279d2004-06-21 07:36:32 +00001013
danielk1977955de522006-02-10 02:27:42 +00001014 if( pzOriginDb ){
1015 assert( pzOriginTab && pzOriginCol );
1016 *pzOriginDb = zOriginDb;
1017 *pzOriginTab = zOriginTab;
1018 *pzOriginCol = zOriginCol;
1019 }
danielk1977517eb642004-06-07 10:00:31 +00001020 return zType;
1021}
1022
1023/*
1024** Generate code that will tell the VDBE the declaration types of columns
1025** in the result set.
drhfcb78a42003-01-18 20:11:05 +00001026*/
1027static void generateColumnTypes(
1028 Parse *pParse, /* Parser context */
drhfcb78a42003-01-18 20:11:05 +00001029 SrcList *pTabList, /* List of tables */
1030 ExprList *pEList /* Expressions defining the result set */
1031){
drh3f913572008-03-22 01:07:17 +00001032#ifndef SQLITE_OMIT_DECLTYPE
drhfcb78a42003-01-18 20:11:05 +00001033 Vdbe *v = pParse->pVdbe;
danielk1977517eb642004-06-07 10:00:31 +00001034 int i;
danielk1977b3bce662005-01-29 08:32:43 +00001035 NameContext sNC;
1036 sNC.pSrcList = pTabList;
danielk1977955de522006-02-10 02:27:42 +00001037 sNC.pParse = pParse;
drhfcb78a42003-01-18 20:11:05 +00001038 for(i=0; i<pEList->nExpr; i++){
1039 Expr *p = pEList->a[i].pExpr;
drh3f913572008-03-22 01:07:17 +00001040 const char *zType;
1041#ifdef SQLITE_ENABLE_COLUMN_METADATA
danielk1977955de522006-02-10 02:27:42 +00001042 const char *zOrigDb = 0;
1043 const char *zOrigTab = 0;
1044 const char *zOrigCol = 0;
drh3f913572008-03-22 01:07:17 +00001045 zType = columnType(&sNC, p, &zOrigDb, &zOrigTab, &zOrigCol);
danielk1977955de522006-02-10 02:27:42 +00001046
drh85b623f2007-12-13 21:54:09 +00001047 /* The vdbe must make its own copy of the column-type and other
danielk19774b1ae992006-02-10 03:06:10 +00001048 ** column specific strings, in case the schema is reset before this
1049 ** virtual machine is deleted.
danielk1977fbcd5852004-06-15 02:44:18 +00001050 */
drh66a51672008-01-03 00:01:23 +00001051 sqlite3VdbeSetColName(v, i, COLNAME_DATABASE, zOrigDb, P4_TRANSIENT);
1052 sqlite3VdbeSetColName(v, i, COLNAME_TABLE, zOrigTab, P4_TRANSIENT);
1053 sqlite3VdbeSetColName(v, i, COLNAME_COLUMN, zOrigCol, P4_TRANSIENT);
drh3f913572008-03-22 01:07:17 +00001054#else
1055 zType = columnType(&sNC, p, 0, 0, 0);
1056#endif
1057 sqlite3VdbeSetColName(v, i, COLNAME_DECLTYPE, zType, P4_TRANSIENT);
drhfcb78a42003-01-18 20:11:05 +00001058 }
drh3f913572008-03-22 01:07:17 +00001059#endif /* SQLITE_OMIT_DECLTYPE */
drhfcb78a42003-01-18 20:11:05 +00001060}
1061
1062/*
1063** Generate code that will tell the VDBE the names of columns
1064** in the result set. This information is used to provide the
drhfcabd462004-02-20 14:50:58 +00001065** azCol[] values in the callback.
drh82c3d632000-06-06 21:56:07 +00001066*/
drh832508b2002-03-02 17:04:07 +00001067static void generateColumnNames(
1068 Parse *pParse, /* Parser context */
drhad3cab52002-05-24 02:04:32 +00001069 SrcList *pTabList, /* List of tables */
drh832508b2002-03-02 17:04:07 +00001070 ExprList *pEList /* Expressions defining the result set */
1071){
drhd8bc7082000-06-07 23:51:50 +00001072 Vdbe *v = pParse->pVdbe;
drh6a3ea0e2003-05-02 14:32:12 +00001073 int i, j;
drh9bb575f2004-09-06 17:24:11 +00001074 sqlite3 *db = pParse->db;
drhfcabd462004-02-20 14:50:58 +00001075 int fullNames, shortNames;
1076
drhfe2093d2005-01-20 22:48:47 +00001077#ifndef SQLITE_OMIT_EXPLAIN
danielk19773cf86062004-05-26 10:11:05 +00001078 /* If this is an EXPLAIN, skip this step */
1079 if( pParse->explain ){
danielk197761de0d12004-05-27 23:56:16 +00001080 return;
danielk19773cf86062004-05-26 10:11:05 +00001081 }
danielk19775338a5f2005-01-20 13:03:10 +00001082#endif
danielk19773cf86062004-05-26 10:11:05 +00001083
drhd6502752004-02-16 03:44:01 +00001084 assert( v!=0 );
drh17435752007-08-16 04:30:38 +00001085 if( pParse->colNamesSet || v==0 || db->mallocFailed ) return;
drhd8bc7082000-06-07 23:51:50 +00001086 pParse->colNamesSet = 1;
drhfcabd462004-02-20 14:50:58 +00001087 fullNames = (db->flags & SQLITE_FullColNames)!=0;
1088 shortNames = (db->flags & SQLITE_ShortColNames)!=0;
danielk197722322fd2004-05-25 23:35:17 +00001089 sqlite3VdbeSetNumCols(v, pEList->nExpr);
drh82c3d632000-06-06 21:56:07 +00001090 for(i=0; i<pEList->nExpr; i++){
1091 Expr *p;
drh5a387052003-01-11 14:19:51 +00001092 p = pEList->a[i].pExpr;
1093 if( p==0 ) continue;
drh82c3d632000-06-06 21:56:07 +00001094 if( pEList->a[i].zName ){
1095 char *zName = pEList->a[i].zName;
danielk1977955de522006-02-10 02:27:42 +00001096 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, strlen(zName));
drh82c3d632000-06-06 21:56:07 +00001097 continue;
1098 }
drhfa173a72002-07-10 21:26:00 +00001099 if( p->op==TK_COLUMN && pTabList ){
drh6a3ea0e2003-05-02 14:32:12 +00001100 Table *pTab;
drh97665872002-02-13 23:22:53 +00001101 char *zCol;
drh8aff1012001-12-22 14:49:24 +00001102 int iCol = p->iColumn;
drh6a3ea0e2003-05-02 14:32:12 +00001103 for(j=0; j<pTabList->nSrc && pTabList->a[j].iCursor!=p->iTable; j++){}
1104 assert( j<pTabList->nSrc );
1105 pTab = pTabList->a[j].pTab;
drh8aff1012001-12-22 14:49:24 +00001106 if( iCol<0 ) iCol = pTab->iPKey;
drh97665872002-02-13 23:22:53 +00001107 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
drhb1363202002-06-26 02:45:03 +00001108 if( iCol<0 ){
drh47a6db22005-01-18 16:02:40 +00001109 zCol = "rowid";
drhb1363202002-06-26 02:45:03 +00001110 }else{
1111 zCol = pTab->aCol[iCol].zName;
drhb1363202002-06-26 02:45:03 +00001112 }
drhfcabd462004-02-20 14:50:58 +00001113 if( !shortNames && !fullNames && p->span.z && p->span.z[0] ){
danielk1977955de522006-02-10 02:27:42 +00001114 sqlite3VdbeSetColName(v, i, COLNAME_NAME, (char*)p->span.z, p->span.n);
drhfcabd462004-02-20 14:50:58 +00001115 }else if( fullNames || (!shortNames && pTabList->nSrc>1) ){
drh82c3d632000-06-06 21:56:07 +00001116 char *zName = 0;
drh82c3d632000-06-06 21:56:07 +00001117 char *zTab;
1118
drh6a3ea0e2003-05-02 14:32:12 +00001119 zTab = pTabList->a[j].zAlias;
drhfcabd462004-02-20 14:50:58 +00001120 if( fullNames || zTab==0 ) zTab = pTab->zName;
drhf93339d2006-01-03 15:16:26 +00001121 sqlite3SetString(&zName, zTab, ".", zCol, (char*)0);
drh66a51672008-01-03 00:01:23 +00001122 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, P4_DYNAMIC);
drh82c3d632000-06-06 21:56:07 +00001123 }else{
danielk1977955de522006-02-10 02:27:42 +00001124 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zCol, strlen(zCol));
drh82c3d632000-06-06 21:56:07 +00001125 }
drh6977fea2002-10-22 23:38:04 +00001126 }else if( p->span.z && p->span.z[0] ){
danielk1977955de522006-02-10 02:27:42 +00001127 sqlite3VdbeSetColName(v, i, COLNAME_NAME, (char*)p->span.z, p->span.n);
danielk19773cf86062004-05-26 10:11:05 +00001128 /* sqlite3VdbeCompressSpace(v, addr); */
drh1bee3d72001-10-15 00:44:35 +00001129 }else{
1130 char zName[30];
1131 assert( p->op!=TK_COLUMN || pTabList==0 );
drh5bb3eb92007-05-04 13:15:55 +00001132 sqlite3_snprintf(sizeof(zName), zName, "column%d", i+1);
danielk1977955de522006-02-10 02:27:42 +00001133 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, 0);
drh82c3d632000-06-06 21:56:07 +00001134 }
1135 }
danielk197776d505b2004-05-28 13:13:02 +00001136 generateColumnTypes(pParse, pTabList, pEList);
drh82c3d632000-06-06 21:56:07 +00001137}
1138
danielk197793758c82005-01-21 08:13:14 +00001139#ifndef SQLITE_OMIT_COMPOUND_SELECT
drh82c3d632000-06-06 21:56:07 +00001140/*
drhd8bc7082000-06-07 23:51:50 +00001141** Name of the connection operator, used for error messages.
1142*/
1143static const char *selectOpName(int id){
1144 char *z;
1145 switch( id ){
1146 case TK_ALL: z = "UNION ALL"; break;
1147 case TK_INTERSECT: z = "INTERSECT"; break;
1148 case TK_EXCEPT: z = "EXCEPT"; break;
1149 default: z = "UNION"; break;
1150 }
1151 return z;
1152}
danielk197793758c82005-01-21 08:13:14 +00001153#endif /* SQLITE_OMIT_COMPOUND_SELECT */
drhd8bc7082000-06-07 23:51:50 +00001154
1155/*
drh315555c2002-10-20 15:53:03 +00001156** Forward declaration
1157*/
drh9b3187e2005-01-18 14:45:47 +00001158static int prepSelectStmt(Parse*, Select*);
drh315555c2002-10-20 15:53:03 +00001159
1160/*
drh22f70c32002-02-18 01:17:00 +00001161** Given a SELECT statement, generate a Table structure that describes
1162** the result set of that SELECT.
1163*/
danielk19774adee202004-05-08 08:23:19 +00001164Table *sqlite3ResultSetOfSelect(Parse *pParse, char *zTabName, Select *pSelect){
drh22f70c32002-02-18 01:17:00 +00001165 Table *pTab;
drhb733d032004-01-24 20:18:12 +00001166 int i, j;
drh22f70c32002-02-18 01:17:00 +00001167 ExprList *pEList;
drh290c1942004-08-21 17:54:45 +00001168 Column *aCol, *pCol;
drh17435752007-08-16 04:30:38 +00001169 sqlite3 *db = pParse->db;
drh22f70c32002-02-18 01:17:00 +00001170
drh92378252006-03-26 01:21:22 +00001171 while( pSelect->pPrior ) pSelect = pSelect->pPrior;
drh9b3187e2005-01-18 14:45:47 +00001172 if( prepSelectStmt(pParse, pSelect) ){
drh22f70c32002-02-18 01:17:00 +00001173 return 0;
1174 }
danielk1977142bdf42005-01-30 11:11:44 +00001175 if( sqlite3SelectResolve(pParse, pSelect, 0) ){
1176 return 0;
1177 }
drh17435752007-08-16 04:30:38 +00001178 pTab = sqlite3DbMallocZero(db, sizeof(Table) );
drh22f70c32002-02-18 01:17:00 +00001179 if( pTab==0 ){
1180 return 0;
1181 }
drhed8a3bb2005-06-06 21:19:56 +00001182 pTab->nRef = 1;
drh17435752007-08-16 04:30:38 +00001183 pTab->zName = zTabName ? sqlite3DbStrDup(db, zTabName) : 0;
drh22f70c32002-02-18 01:17:00 +00001184 pEList = pSelect->pEList;
1185 pTab->nCol = pEList->nExpr;
drh417be792002-03-03 18:59:40 +00001186 assert( pTab->nCol>0 );
drh17435752007-08-16 04:30:38 +00001187 pTab->aCol = aCol = sqlite3DbMallocZero(db, sizeof(pTab->aCol[0])*pTab->nCol);
drh290c1942004-08-21 17:54:45 +00001188 for(i=0, pCol=aCol; i<pTab->nCol; i++, pCol++){
drh79d5f632005-01-18 17:20:10 +00001189 Expr *p, *pR;
danielk1977517eb642004-06-07 10:00:31 +00001190 char *zType;
drh91bb0ee2004-09-01 03:06:34 +00001191 char *zName;
drh2564ef92006-09-29 14:01:04 +00001192 int nName;
danielk1977b3bf5562006-01-10 17:58:23 +00001193 CollSeq *pColl;
drh79d5f632005-01-18 17:20:10 +00001194 int cnt;
danielk1977b3bce662005-01-29 08:32:43 +00001195 NameContext sNC;
drh79d5f632005-01-18 17:20:10 +00001196
1197 /* Get an appropriate name for the column
1198 */
1199 p = pEList->a[i].pExpr;
drh290c1942004-08-21 17:54:45 +00001200 assert( p->pRight==0 || p->pRight->token.z==0 || p->pRight->token.z[0]!=0 );
drh91bb0ee2004-09-01 03:06:34 +00001201 if( (zName = pEList->a[i].zName)!=0 ){
drh79d5f632005-01-18 17:20:10 +00001202 /* If the column contains an "AS <name>" phrase, use <name> as the name */
drh17435752007-08-16 04:30:38 +00001203 zName = sqlite3DbStrDup(db, zName);
danielk1977517eb642004-06-07 10:00:31 +00001204 }else if( p->op==TK_DOT
drh79d5f632005-01-18 17:20:10 +00001205 && (pR=p->pRight)!=0 && pR->token.z && pR->token.z[0] ){
1206 /* For columns of the from A.B use B as the name */
drh17435752007-08-16 04:30:38 +00001207 zName = sqlite3MPrintf(db, "%T", &pR->token);
drhb733d032004-01-24 20:18:12 +00001208 }else if( p->span.z && p->span.z[0] ){
drh79d5f632005-01-18 17:20:10 +00001209 /* Use the original text of the column expression as its name */
drh17435752007-08-16 04:30:38 +00001210 zName = sqlite3MPrintf(db, "%T", &p->span);
drh22f70c32002-02-18 01:17:00 +00001211 }else{
drh79d5f632005-01-18 17:20:10 +00001212 /* If all else fails, make up a name */
drh17435752007-08-16 04:30:38 +00001213 zName = sqlite3MPrintf(db, "column%d", i+1);
drh22f70c32002-02-18 01:17:00 +00001214 }
danielk197777519402007-08-30 11:48:31 +00001215 if( !zName || db->mallocFailed ){
1216 db->mallocFailed = 1;
drh17435752007-08-16 04:30:38 +00001217 sqlite3_free(zName);
danielk1977a04a34f2007-04-16 15:06:25 +00001218 sqlite3DeleteTable(pTab);
drhdd5b2fa2005-03-28 03:39:55 +00001219 return 0;
1220 }
danielk197777519402007-08-30 11:48:31 +00001221 sqlite3Dequote(zName);
drh79d5f632005-01-18 17:20:10 +00001222
1223 /* Make sure the column name is unique. If the name is not unique,
1224 ** append a integer to the name so that it becomes unique.
1225 */
drh2564ef92006-09-29 14:01:04 +00001226 nName = strlen(zName);
drh79d5f632005-01-18 17:20:10 +00001227 for(j=cnt=0; j<i; j++){
1228 if( sqlite3StrICmp(aCol[j].zName, zName)==0 ){
drh2564ef92006-09-29 14:01:04 +00001229 zName[nName] = 0;
danielk19771e536952007-08-16 10:09:01 +00001230 zName = sqlite3MPrintf(db, "%z:%d", zName, ++cnt);
drh79d5f632005-01-18 17:20:10 +00001231 j = -1;
drhdd5b2fa2005-03-28 03:39:55 +00001232 if( zName==0 ) break;
drh79d5f632005-01-18 17:20:10 +00001233 }
1234 }
drh91bb0ee2004-09-01 03:06:34 +00001235 pCol->zName = zName;
danielk1977517eb642004-06-07 10:00:31 +00001236
drh79d5f632005-01-18 17:20:10 +00001237 /* Get the typename, type affinity, and collating sequence for the
1238 ** column.
1239 */
drhc43e8be2005-05-16 22:37:54 +00001240 memset(&sNC, 0, sizeof(sNC));
danielk1977b3bce662005-01-29 08:32:43 +00001241 sNC.pSrcList = pSelect->pSrc;
drh17435752007-08-16 04:30:38 +00001242 zType = sqlite3DbStrDup(db, columnType(&sNC, p, 0, 0, 0));
drh290c1942004-08-21 17:54:45 +00001243 pCol->zType = zType;
danielk1977c60e9b82005-01-31 12:42:29 +00001244 pCol->affinity = sqlite3ExprAffinity(p);
danielk1977b3bf5562006-01-10 17:58:23 +00001245 pColl = sqlite3ExprCollSeq(pParse, p);
1246 if( pColl ){
drh17435752007-08-16 04:30:38 +00001247 pCol->zColl = sqlite3DbStrDup(db, pColl->zName);
danielk19770202b292004-06-09 09:55:16 +00001248 }
drh22f70c32002-02-18 01:17:00 +00001249 }
1250 pTab->iPKey = -1;
1251 return pTab;
1252}
1253
1254/*
drh9b3187e2005-01-18 14:45:47 +00001255** Prepare a SELECT statement for processing by doing the following
1256** things:
drhd8bc7082000-06-07 23:51:50 +00001257**
drh9b3187e2005-01-18 14:45:47 +00001258** (1) Make sure VDBE cursor numbers have been assigned to every
1259** element of the FROM clause.
1260**
1261** (2) Fill in the pTabList->a[].pTab fields in the SrcList that
1262** defines FROM clause. When views appear in the FROM clause,
drh63eb5f22003-04-29 16:20:44 +00001263** fill pTabList->a[].pSelect with a copy of the SELECT statement
1264** that implements the view. A copy is made of the view's SELECT
1265** statement so that we can freely modify or delete that statement
1266** without worrying about messing up the presistent representation
1267** of the view.
drhd8bc7082000-06-07 23:51:50 +00001268**
drh9b3187e2005-01-18 14:45:47 +00001269** (3) Add terms to the WHERE clause to accomodate the NATURAL keyword
drhad2d8302002-05-24 20:31:36 +00001270** on joins and the ON and USING clause of joins.
1271**
drh9b3187e2005-01-18 14:45:47 +00001272** (4) Scan the list of columns in the result set (pEList) looking
drh54473222002-04-04 02:10:55 +00001273** for instances of the "*" operator or the TABLE.* operator.
1274** If found, expand each "*" to be every column in every table
1275** and TABLE.* to be every column in TABLE.
drhd8bc7082000-06-07 23:51:50 +00001276**
1277** Return 0 on success. If there are problems, leave an error message
1278** in pParse and return non-zero.
1279*/
drh9b3187e2005-01-18 14:45:47 +00001280static int prepSelectStmt(Parse *pParse, Select *p){
drh54473222002-04-04 02:10:55 +00001281 int i, j, k, rc;
drhad3cab52002-05-24 02:04:32 +00001282 SrcList *pTabList;
drhdaffd0e2001-04-11 14:28:42 +00001283 ExprList *pEList;
drh290c1942004-08-21 17:54:45 +00001284 struct SrcList_item *pFrom;
drh17435752007-08-16 04:30:38 +00001285 sqlite3 *db = pParse->db;
drhdaffd0e2001-04-11 14:28:42 +00001286
drh17435752007-08-16 04:30:38 +00001287 if( p==0 || p->pSrc==0 || db->mallocFailed ){
drh6f7adc82006-01-11 21:41:20 +00001288 return 1;
1289 }
drhdaffd0e2001-04-11 14:28:42 +00001290 pTabList = p->pSrc;
1291 pEList = p->pEList;
drhd8bc7082000-06-07 23:51:50 +00001292
drh9b3187e2005-01-18 14:45:47 +00001293 /* Make sure cursor numbers have been assigned to all entries in
1294 ** the FROM clause of the SELECT statement.
1295 */
1296 sqlite3SrcListAssignCursors(pParse, p->pSrc);
1297
1298 /* Look up every table named in the FROM clause of the select. If
1299 ** an entry of the FROM clause is a subquery instead of a table or view,
1300 ** then create a transient table structure to describe the subquery.
drhd8bc7082000-06-07 23:51:50 +00001301 */
drh290c1942004-08-21 17:54:45 +00001302 for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
danielk1977f0113002006-01-24 12:09:17 +00001303 Table *pTab;
drh9b3187e2005-01-18 14:45:47 +00001304 if( pFrom->pTab!=0 ){
1305 /* This statement has already been prepared. There is no need
1306 ** to go further. */
1307 assert( i==0 );
drhd8bc7082000-06-07 23:51:50 +00001308 return 0;
1309 }
drh290c1942004-08-21 17:54:45 +00001310 if( pFrom->zName==0 ){
danielk197793758c82005-01-21 08:13:14 +00001311#ifndef SQLITE_OMIT_SUBQUERY
drh22f70c32002-02-18 01:17:00 +00001312 /* A sub-query in the FROM clause of a SELECT */
drh290c1942004-08-21 17:54:45 +00001313 assert( pFrom->pSelect!=0 );
1314 if( pFrom->zAlias==0 ){
drh91bb0ee2004-09-01 03:06:34 +00001315 pFrom->zAlias =
danielk19771e536952007-08-16 10:09:01 +00001316 sqlite3MPrintf(db, "sqlite_subquery_%p_", (void*)pFrom->pSelect);
drhad2d8302002-05-24 20:31:36 +00001317 }
drhed8a3bb2005-06-06 21:19:56 +00001318 assert( pFrom->pTab==0 );
drh290c1942004-08-21 17:54:45 +00001319 pFrom->pTab = pTab =
1320 sqlite3ResultSetOfSelect(pParse, pFrom->zAlias, pFrom->pSelect);
drh22f70c32002-02-18 01:17:00 +00001321 if( pTab==0 ){
1322 return 1;
1323 }
drhb9bb7c12006-06-11 23:41:55 +00001324 /* The isEphem flag indicates that the Table structure has been
drh5cf590c2003-04-24 01:45:04 +00001325 ** dynamically allocated and may be freed at any time. In other words,
1326 ** pTab is not pointing to a persistent table structure that defines
1327 ** part of the schema. */
drhb9bb7c12006-06-11 23:41:55 +00001328 pTab->isEphem = 1;
danielk197793758c82005-01-21 08:13:14 +00001329#endif
drh22f70c32002-02-18 01:17:00 +00001330 }else{
drha76b5df2002-02-23 02:32:10 +00001331 /* An ordinary table or view name in the FROM clause */
drhed8a3bb2005-06-06 21:19:56 +00001332 assert( pFrom->pTab==0 );
drh290c1942004-08-21 17:54:45 +00001333 pFrom->pTab = pTab =
drhca424112008-01-25 15:04:48 +00001334 sqlite3LocateTable(pParse,0,pFrom->zName,pFrom->zDatabase);
drha76b5df2002-02-23 02:32:10 +00001335 if( pTab==0 ){
drh22f70c32002-02-18 01:17:00 +00001336 return 1;
1337 }
drhed8a3bb2005-06-06 21:19:56 +00001338 pTab->nRef++;
danielk197793626f42006-06-20 13:07:27 +00001339#if !defined(SQLITE_OMIT_VIEW) || !defined (SQLITE_OMIT_VIRTUALTABLE)
1340 if( pTab->pSelect || IsVirtual(pTab) ){
drh63eb5f22003-04-29 16:20:44 +00001341 /* We reach here if the named table is a really a view */
danielk19774adee202004-05-08 08:23:19 +00001342 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
drh417be792002-03-03 18:59:40 +00001343 return 1;
1344 }
drh290c1942004-08-21 17:54:45 +00001345 /* If pFrom->pSelect!=0 it means we are dealing with a
drh63eb5f22003-04-29 16:20:44 +00001346 ** view within a view. The SELECT structure has already been
1347 ** copied by the outer view so we can skip the copy step here
1348 ** in the inner view.
1349 */
drh290c1942004-08-21 17:54:45 +00001350 if( pFrom->pSelect==0 ){
drh17435752007-08-16 04:30:38 +00001351 pFrom->pSelect = sqlite3SelectDup(db, pTab->pSelect);
drh63eb5f22003-04-29 16:20:44 +00001352 }
drha76b5df2002-02-23 02:32:10 +00001353 }
danielk197793758c82005-01-21 08:13:14 +00001354#endif
drhd8bc7082000-06-07 23:51:50 +00001355 }
1356 }
1357
drhad2d8302002-05-24 20:31:36 +00001358 /* Process NATURAL keywords, and ON and USING clauses of joins.
1359 */
1360 if( sqliteProcessJoin(pParse, p) ) return 1;
1361
drh7c917d12001-12-16 20:05:05 +00001362 /* For every "*" that occurs in the column list, insert the names of
drh54473222002-04-04 02:10:55 +00001363 ** all columns in all tables. And for every TABLE.* insert the names
1364 ** of all columns in TABLE. The parser inserted a special expression
drh7c917d12001-12-16 20:05:05 +00001365 ** with the TK_ALL operator for each "*" that it found in the column list.
1366 ** The following code just has to locate the TK_ALL expressions and expand
1367 ** each one to the list of all columns in all tables.
drh54473222002-04-04 02:10:55 +00001368 **
1369 ** The first loop just checks to see if there are any "*" operators
1370 ** that need expanding.
drhd8bc7082000-06-07 23:51:50 +00001371 */
drh7c917d12001-12-16 20:05:05 +00001372 for(k=0; k<pEList->nExpr; k++){
drh54473222002-04-04 02:10:55 +00001373 Expr *pE = pEList->a[k].pExpr;
1374 if( pE->op==TK_ALL ) break;
1375 if( pE->op==TK_DOT && pE->pRight && pE->pRight->op==TK_ALL
1376 && pE->pLeft && pE->pLeft->op==TK_ID ) break;
drh7c917d12001-12-16 20:05:05 +00001377 }
drh54473222002-04-04 02:10:55 +00001378 rc = 0;
drh7c917d12001-12-16 20:05:05 +00001379 if( k<pEList->nExpr ){
drh54473222002-04-04 02:10:55 +00001380 /*
1381 ** If we get here it means the result set contains one or more "*"
1382 ** operators that need to be expanded. Loop through each expression
1383 ** in the result set and expand them one by one.
1384 */
drh7c917d12001-12-16 20:05:05 +00001385 struct ExprList_item *a = pEList->a;
1386 ExprList *pNew = 0;
drhd70dc522005-06-06 16:34:33 +00001387 int flags = pParse->db->flags;
1388 int longNames = (flags & SQLITE_FullColNames)!=0 &&
1389 (flags & SQLITE_ShortColNames)==0;
1390
drh7c917d12001-12-16 20:05:05 +00001391 for(k=0; k<pEList->nExpr; k++){
drh54473222002-04-04 02:10:55 +00001392 Expr *pE = a[k].pExpr;
1393 if( pE->op!=TK_ALL &&
1394 (pE->op!=TK_DOT || pE->pRight==0 || pE->pRight->op!=TK_ALL) ){
1395 /* This particular expression does not need to be expanded.
1396 */
drh17435752007-08-16 04:30:38 +00001397 pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr, 0);
danielk1977261919c2005-12-06 12:52:59 +00001398 if( pNew ){
1399 pNew->a[pNew->nExpr-1].zName = a[k].zName;
1400 }else{
1401 rc = 1;
1402 }
drh7c917d12001-12-16 20:05:05 +00001403 a[k].pExpr = 0;
1404 a[k].zName = 0;
1405 }else{
drh54473222002-04-04 02:10:55 +00001406 /* This expression is a "*" or a "TABLE.*" and needs to be
1407 ** expanded. */
1408 int tableSeen = 0; /* Set to 1 when TABLE matches */
drhcf55b7a2004-07-20 01:45:19 +00001409 char *zTName; /* text of name of TABLE */
drh54473222002-04-04 02:10:55 +00001410 if( pE->op==TK_DOT && pE->pLeft ){
drh17435752007-08-16 04:30:38 +00001411 zTName = sqlite3NameFromToken(db, &pE->pLeft->token);
drh54473222002-04-04 02:10:55 +00001412 }else{
drhcf55b7a2004-07-20 01:45:19 +00001413 zTName = 0;
drh54473222002-04-04 02:10:55 +00001414 }
drh290c1942004-08-21 17:54:45 +00001415 for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
1416 Table *pTab = pFrom->pTab;
1417 char *zTabName = pFrom->zAlias;
drh54473222002-04-04 02:10:55 +00001418 if( zTabName==0 || zTabName[0]==0 ){
1419 zTabName = pTab->zName;
1420 }
drhcf55b7a2004-07-20 01:45:19 +00001421 if( zTName && (zTabName==0 || zTabName[0]==0 ||
1422 sqlite3StrICmp(zTName, zTabName)!=0) ){
drh54473222002-04-04 02:10:55 +00001423 continue;
1424 }
1425 tableSeen = 1;
drh7c917d12001-12-16 20:05:05 +00001426 for(j=0; j<pTab->nCol; j++){
danielk1977f0113002006-01-24 12:09:17 +00001427 Expr *pExpr, *pRight;
drhad2d8302002-05-24 20:31:36 +00001428 char *zName = pTab->aCol[j].zName;
1429
danielk1977034ca142007-06-26 10:38:54 +00001430 /* If a column is marked as 'hidden' (currently only possible
1431 ** for virtual tables), do not include it in the expanded
1432 ** result-set list.
1433 */
1434 if( IsHiddenColumn(&pTab->aCol[j]) ){
1435 assert(IsVirtual(pTab));
1436 continue;
1437 }
1438
drh91bb0ee2004-09-01 03:06:34 +00001439 if( i>0 ){
1440 struct SrcList_item *pLeft = &pTabList->a[i-1];
drh61dfc312006-12-16 16:25:15 +00001441 if( (pLeft[1].jointype & JT_NATURAL)!=0 &&
drh91bb0ee2004-09-01 03:06:34 +00001442 columnIndex(pLeft->pTab, zName)>=0 ){
1443 /* In a NATURAL join, omit the join columns from the
1444 ** table on the right */
1445 continue;
1446 }
drh61dfc312006-12-16 16:25:15 +00001447 if( sqlite3IdListIndex(pLeft[1].pUsing, zName)>=0 ){
drh91bb0ee2004-09-01 03:06:34 +00001448 /* In a join with a USING clause, omit columns in the
1449 ** using clause from the table on the right. */
1450 continue;
1451 }
drhad2d8302002-05-24 20:31:36 +00001452 }
danielk1977a1644fd2007-08-29 12:31:25 +00001453 pRight = sqlite3PExpr(pParse, TK_ID, 0, 0, 0);
drh22f70c32002-02-18 01:17:00 +00001454 if( pRight==0 ) break;
danielk19771e536952007-08-16 10:09:01 +00001455 setQuotedToken(pParse, &pRight->token, zName);
drhd70dc522005-06-06 16:34:33 +00001456 if( zTabName && (longNames || pTabList->nSrc>1) ){
danielk1977a1644fd2007-08-29 12:31:25 +00001457 Expr *pLeft = sqlite3PExpr(pParse, TK_ID, 0, 0, 0);
1458 pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight, 0);
drh22f70c32002-02-18 01:17:00 +00001459 if( pExpr==0 ) break;
danielk19771e536952007-08-16 10:09:01 +00001460 setQuotedToken(pParse, &pLeft->token, zTabName);
1461 setToken(&pExpr->span,
1462 sqlite3MPrintf(db, "%s.%s", zTabName, zName));
drh6977fea2002-10-22 23:38:04 +00001463 pExpr->span.dyn = 1;
1464 pExpr->token.z = 0;
1465 pExpr->token.n = 0;
1466 pExpr->token.dyn = 0;
drh7c917d12001-12-16 20:05:05 +00001467 }else{
drh22f70c32002-02-18 01:17:00 +00001468 pExpr = pRight;
drh6977fea2002-10-22 23:38:04 +00001469 pExpr->span = pExpr->token;
danielk1977f3b863e2007-06-24 06:32:17 +00001470 pExpr->span.dyn = 0;
drh7c917d12001-12-16 20:05:05 +00001471 }
drhd70dc522005-06-06 16:34:33 +00001472 if( longNames ){
drh17435752007-08-16 04:30:38 +00001473 pNew = sqlite3ExprListAppend(pParse, pNew, pExpr, &pExpr->span);
drhd70dc522005-06-06 16:34:33 +00001474 }else{
drh17435752007-08-16 04:30:38 +00001475 pNew = sqlite3ExprListAppend(pParse, pNew, pExpr, &pRight->token);
drhd70dc522005-06-06 16:34:33 +00001476 }
drh7c917d12001-12-16 20:05:05 +00001477 }
drh17e24df2001-11-06 14:10:41 +00001478 }
drh54473222002-04-04 02:10:55 +00001479 if( !tableSeen ){
drhcf55b7a2004-07-20 01:45:19 +00001480 if( zTName ){
1481 sqlite3ErrorMsg(pParse, "no such table: %s", zTName);
drhf5db2d32002-06-06 23:42:27 +00001482 }else{
danielk19774adee202004-05-08 08:23:19 +00001483 sqlite3ErrorMsg(pParse, "no tables specified");
drhf5db2d32002-06-06 23:42:27 +00001484 }
drh54473222002-04-04 02:10:55 +00001485 rc = 1;
1486 }
drh17435752007-08-16 04:30:38 +00001487 sqlite3_free(zTName);
drhd8bc7082000-06-07 23:51:50 +00001488 }
1489 }
danielk19774adee202004-05-08 08:23:19 +00001490 sqlite3ExprListDelete(pEList);
drh7c917d12001-12-16 20:05:05 +00001491 p->pEList = pNew;
drhd8bc7082000-06-07 23:51:50 +00001492 }
drhbb4957f2008-03-20 14:03:29 +00001493#if SQLITE_MAX_COLUMN
1494 if( p->pEList && p->pEList->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
drhe5c941b2007-05-08 13:58:26 +00001495 sqlite3ErrorMsg(pParse, "too many columns in result set");
1496 rc = SQLITE_ERROR;
1497 }
drhbb4957f2008-03-20 14:03:29 +00001498#endif
drh17435752007-08-16 04:30:38 +00001499 if( db->mallocFailed ){
danielk1977f3b863e2007-06-24 06:32:17 +00001500 rc = SQLITE_NOMEM;
1501 }
drh54473222002-04-04 02:10:55 +00001502 return rc;
drhd8bc7082000-06-07 23:51:50 +00001503}
1504
drhff78bd22002-02-27 01:47:11 +00001505/*
drh9a993342007-12-13 02:45:31 +00001506** pE is a pointer to an expression which is a single term in
1507** ORDER BY or GROUP BY clause.
drhd8bc7082000-06-07 23:51:50 +00001508**
drh92b01d52008-06-24 00:32:35 +00001509** At the point this routine is called, we already know that the
1510** ORDER BY term is not an integer index into the result set. That
1511** casee is handled by the calling routine.
drh9a993342007-12-13 02:45:31 +00001512**
1513** If pE is a well-formed expression and the SELECT statement
1514** is not compound, then return 0. This indicates to the
1515** caller that it should sort by the value of the ORDER BY
1516** expression.
1517**
1518** If the SELECT is compound, then attempt to match pE against
1519** result set columns in the left-most SELECT statement. Return
1520** the index i of the matching column, as an indication to the
1521** caller that it should sort by the i-th column. If there is
1522** no match, return -1 and leave an error message in pParse.
drhd8bc7082000-06-07 23:51:50 +00001523*/
drh9a993342007-12-13 02:45:31 +00001524static int matchOrderByTermToExprList(
1525 Parse *pParse, /* Parsing context for error messages */
1526 Select *pSelect, /* The SELECT statement with the ORDER BY clause */
1527 Expr *pE, /* The specific ORDER BY term */
1528 int idx, /* When ORDER BY term is this */
1529 int isCompound, /* True if this is a compound SELECT */
1530 u8 *pHasAgg /* True if expression contains aggregate functions */
drhd8bc7082000-06-07 23:51:50 +00001531){
drh9a993342007-12-13 02:45:31 +00001532 int i; /* Loop counter */
1533 ExprList *pEList; /* The columns of the result set */
1534 NameContext nc; /* Name context for resolving pE */
drhd8bc7082000-06-07 23:51:50 +00001535
drh92b01d52008-06-24 00:32:35 +00001536 assert( sqlite3ExprIsInteger(pE, &i)==0 );
drh9a993342007-12-13 02:45:31 +00001537 pEList = pSelect->pEList;
drh9a993342007-12-13 02:45:31 +00001538
1539 /* If the term is a simple identifier that try to match that identifier
1540 ** against a column name in the result set.
1541 */
1542 if( pE->op==TK_ID || (pE->op==TK_STRING && pE->token.z[0]!='\'') ){
1543 sqlite3 *db = pParse->db;
1544 char *zCol = sqlite3NameFromToken(db, &pE->token);
drhef0bea92007-12-14 16:11:09 +00001545 if( zCol==0 ){
drh9a993342007-12-13 02:45:31 +00001546 return -1;
1547 }
1548 for(i=0; i<pEList->nExpr; i++){
1549 char *zAs = pEList->a[i].zName;
1550 if( zAs!=0 && sqlite3StrICmp(zAs, zCol)==0 ){
1551 sqlite3_free(zCol);
1552 return i+1;
1553 }
1554 }
1555 sqlite3_free(zCol);
1556 }
1557
1558 /* Resolve all names in the ORDER BY term expression
1559 */
1560 memset(&nc, 0, sizeof(nc));
1561 nc.pParse = pParse;
1562 nc.pSrcList = pSelect->pSrc;
1563 nc.pEList = pEList;
1564 nc.allowAgg = 1;
1565 nc.nErr = 0;
1566 if( sqlite3ExprResolveNames(&nc, pE) ){
drh1e281292007-12-13 03:45:07 +00001567 if( isCompound ){
1568 sqlite3ErrorClear(pParse);
1569 return 0;
1570 }else{
1571 return -1;
1572 }
drh9a993342007-12-13 02:45:31 +00001573 }
1574 if( nc.hasAgg && pHasAgg ){
1575 *pHasAgg = 1;
1576 }
1577
1578 /* For a compound SELECT, we need to try to match the ORDER BY
1579 ** expression against an expression in the result set
1580 */
1581 if( isCompound ){
1582 for(i=0; i<pEList->nExpr; i++){
1583 if( sqlite3ExprCompare(pEList->a[i].pExpr, pE) ){
1584 return i+1;
1585 }
1586 }
drh9a993342007-12-13 02:45:31 +00001587 }
drh1e281292007-12-13 03:45:07 +00001588 return 0;
drh9a993342007-12-13 02:45:31 +00001589}
1590
1591
1592/*
1593** Analyze and ORDER BY or GROUP BY clause in a simple SELECT statement.
1594** Return the number of errors seen.
1595**
1596** Every term of the ORDER BY or GROUP BY clause needs to be an
1597** expression. If any expression is an integer constant, then
1598** that expression is replaced by the corresponding
1599** expression from the result set.
1600*/
1601static int processOrderGroupBy(
1602 Parse *pParse, /* Parsing context. Leave error messages here */
1603 Select *pSelect, /* The SELECT statement containing the clause */
1604 ExprList *pOrderBy, /* The ORDER BY or GROUP BY clause to be processed */
1605 int isOrder, /* 1 for ORDER BY. 0 for GROUP BY */
1606 u8 *pHasAgg /* Set to TRUE if any term contains an aggregate */
1607){
1608 int i;
1609 sqlite3 *db = pParse->db;
1610 ExprList *pEList;
1611
danielk197715cdbeb2008-01-23 15:44:51 +00001612 if( pOrderBy==0 || pParse->db->mallocFailed ) return 0;
drhbb4957f2008-03-20 14:03:29 +00001613#if SQLITE_MAX_COLUMN
1614 if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
drh9a993342007-12-13 02:45:31 +00001615 const char *zType = isOrder ? "ORDER" : "GROUP";
1616 sqlite3ErrorMsg(pParse, "too many terms in %s BY clause", zType);
drh4c774312007-12-08 21:10:20 +00001617 return 1;
1618 }
drhbb4957f2008-03-20 14:03:29 +00001619#endif
drh9a993342007-12-13 02:45:31 +00001620 pEList = pSelect->pEList;
1621 if( pEList==0 ){
1622 return 0;
1623 }
1624 for(i=0; i<pOrderBy->nExpr; i++){
1625 int iCol;
drhd8bc7082000-06-07 23:51:50 +00001626 Expr *pE = pOrderBy->a[i].pExpr;
drh92b01d52008-06-24 00:32:35 +00001627 if( sqlite3ExprIsInteger(pE, &iCol) ){
1628 if( iCol<=0 || iCol>pEList->nExpr ){
1629 const char *zType = isOrder ? "ORDER" : "GROUP";
1630 sqlite3ErrorMsg(pParse,
1631 "%r %s BY term out of range - should be "
1632 "between 1 and %d", i+1, zType, pEList->nExpr);
1633 return 1;
1634 }
1635 }else{
1636 iCol = matchOrderByTermToExprList(pParse, pSelect, pE, i+1, 0, pHasAgg);
1637 if( iCol<0 ){
1638 return 1;
1639 }
drh9a993342007-12-13 02:45:31 +00001640 }
1641 if( iCol>0 ){
1642 CollSeq *pColl = pE->pColl;
1643 int flags = pE->flags & EP_ExpCollate;
1644 sqlite3ExprDelete(pE);
1645 pE = sqlite3ExprDup(db, pEList->a[iCol-1].pExpr);
1646 pOrderBy->a[i].pExpr = pE;
danielk197715cdbeb2008-01-23 15:44:51 +00001647 if( pE && pColl && flags ){
drh9a993342007-12-13 02:45:31 +00001648 pE->pColl = pColl;
1649 pE->flags |= flags;
1650 }
drhd8bc7082000-06-07 23:51:50 +00001651 }
1652 }
drh9a993342007-12-13 02:45:31 +00001653 return 0;
drhd8bc7082000-06-07 23:51:50 +00001654}
drh9a993342007-12-13 02:45:31 +00001655
1656/*
1657** Analyze and ORDER BY or GROUP BY clause in a SELECT statement. Return
1658** the number of errors seen.
1659**
drh92b01d52008-06-24 00:32:35 +00001660** If iTable>0 then make the N-th term of the ORDER BY clause refer to
1661** the N-th column of table iTable.
1662**
1663** If iTable==0 then transform each term of the ORDER BY clause to refer
1664** to a column of the result set by number.
drh9a993342007-12-13 02:45:31 +00001665*/
1666static int processCompoundOrderBy(
1667 Parse *pParse, /* Parsing context. Leave error messages here */
1668 Select *pSelect, /* The SELECT statement containing the ORDER BY */
1669 int iTable /* Output table for compound SELECT statements */
1670){
1671 int i;
1672 ExprList *pOrderBy;
1673 ExprList *pEList;
drh1e281292007-12-13 03:45:07 +00001674 sqlite3 *db;
1675 int moreToDo = 1;
drh9a993342007-12-13 02:45:31 +00001676
1677 pOrderBy = pSelect->pOrderBy;
1678 if( pOrderBy==0 ) return 0;
drhbb4957f2008-03-20 14:03:29 +00001679 db = pParse->db;
1680#if SQLITE_MAX_COLUMN
1681 if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
drh9a993342007-12-13 02:45:31 +00001682 sqlite3ErrorMsg(pParse, "too many terms in ORDER BY clause");
1683 return 1;
1684 }
drhbb4957f2008-03-20 14:03:29 +00001685#endif
drh1e281292007-12-13 03:45:07 +00001686 for(i=0; i<pOrderBy->nExpr; i++){
1687 pOrderBy->a[i].done = 0;
1688 }
drh9a993342007-12-13 02:45:31 +00001689 while( pSelect->pPrior ){
1690 pSelect = pSelect->pPrior;
1691 }
drh1e281292007-12-13 03:45:07 +00001692 while( pSelect && moreToDo ){
1693 moreToDo = 0;
drh92b01d52008-06-24 00:32:35 +00001694 pEList = pSelect->pEList;
1695 if( pEList==0 ){
1696 return 1;
1697 }
drh1e281292007-12-13 03:45:07 +00001698 for(i=0; i<pOrderBy->nExpr; i++){
danielk1977ac559262008-01-23 17:13:40 +00001699 int iCol = -1;
drh8f0ecaa2007-12-14 17:24:39 +00001700 Expr *pE, *pDup;
drh1e281292007-12-13 03:45:07 +00001701 if( pOrderBy->a[i].done ) continue;
1702 pE = pOrderBy->a[i].pExpr;
drh92b01d52008-06-24 00:32:35 +00001703 if( sqlite3ExprIsInteger(pE, &iCol) ){
1704 if( iCol<0 || iCol>pEList->nExpr ){
1705 sqlite3ErrorMsg(pParse,
1706 "%r ORDER BY term out of range - should be "
1707 "between 1 and %d", i+1, pEList->nExpr);
1708 return 1;
1709 }
1710 }else{
1711 pDup = sqlite3ExprDup(db, pE);
1712 if( !db->mallocFailed ){
1713 assert(pDup);
1714 iCol = matchOrderByTermToExprList(pParse, pSelect, pDup, i+1, 1, 0);
1715 }
1716 sqlite3ExprDelete(pDup);
1717 if( iCol<0 ){
1718 return 1;
1719 }
drh1e281292007-12-13 03:45:07 +00001720 }
1721 if( iCol>0 ){
drh92b01d52008-06-24 00:32:35 +00001722 if( iTable ){
1723 pE->op = TK_COLUMN;
1724 pE->iTable = iTable;
1725 pE->iAgg = -1;
1726 pE->iColumn = iCol-1;
1727 pE->pTab = 0;
1728 }else{
1729 pE->op = TK_INTEGER;
1730 pE->flags |= EP_IntValue;
1731 pE->iTable = iCol;
1732 }
drh1e281292007-12-13 03:45:07 +00001733 pOrderBy->a[i].done = 1;
1734 }else{
1735 moreToDo = 1;
1736 }
1737 }
1738 pSelect = pSelect->pNext;
drh9a993342007-12-13 02:45:31 +00001739 }
1740 for(i=0; i<pOrderBy->nExpr; i++){
drh1e281292007-12-13 03:45:07 +00001741 if( pOrderBy->a[i].done==0 ){
1742 sqlite3ErrorMsg(pParse, "%r ORDER BY term does not match any "
1743 "column in the result set", i+1);
drh9a993342007-12-13 02:45:31 +00001744 return 1;
1745 }
drh9a993342007-12-13 02:45:31 +00001746 }
1747 return 0;
1748}
drhd8bc7082000-06-07 23:51:50 +00001749
1750/*
1751** Get a VDBE for the given parser context. Create a new one if necessary.
1752** If an error occurs, return NULL and leave a message in pParse.
1753*/
danielk19774adee202004-05-08 08:23:19 +00001754Vdbe *sqlite3GetVdbe(Parse *pParse){
drhd8bc7082000-06-07 23:51:50 +00001755 Vdbe *v = pParse->pVdbe;
1756 if( v==0 ){
danielk19774adee202004-05-08 08:23:19 +00001757 v = pParse->pVdbe = sqlite3VdbeCreate(pParse->db);
drh949f9cd2008-01-12 21:35:57 +00001758#ifndef SQLITE_OMIT_TRACE
1759 if( v ){
1760 sqlite3VdbeAddOp0(v, OP_Trace);
1761 }
1762#endif
drhd8bc7082000-06-07 23:51:50 +00001763 }
drhd8bc7082000-06-07 23:51:50 +00001764 return v;
1765}
drhfcb78a42003-01-18 20:11:05 +00001766
drh15007a92006-01-08 18:10:17 +00001767
drhd8bc7082000-06-07 23:51:50 +00001768/*
drh7b58dae2003-07-20 01:16:46 +00001769** Compute the iLimit and iOffset fields of the SELECT based on the
drhec7429a2005-10-06 16:53:14 +00001770** pLimit and pOffset expressions. pLimit and pOffset hold the expressions
drh7b58dae2003-07-20 01:16:46 +00001771** that appear in the original SQL statement after the LIMIT and OFFSET
danielk1977a2dc3b12005-02-05 12:48:48 +00001772** keywords. Or NULL if those keywords are omitted. iLimit and iOffset
1773** are the integer memory register numbers for counters used to compute
1774** the limit and offset. If there is no limit and/or offset, then
1775** iLimit and iOffset are negative.
drh7b58dae2003-07-20 01:16:46 +00001776**
drhd59ba6c2006-01-08 05:02:54 +00001777** This routine changes the values of iLimit and iOffset only if
drhec7429a2005-10-06 16:53:14 +00001778** a limit or offset is defined by pLimit and pOffset. iLimit and
drh7b58dae2003-07-20 01:16:46 +00001779** iOffset should have been preset to appropriate default values
1780** (usually but not always -1) prior to calling this routine.
drhec7429a2005-10-06 16:53:14 +00001781** Only if pLimit!=0 or pOffset!=0 do the limit registers get
drh7b58dae2003-07-20 01:16:46 +00001782** redefined. The UNION ALL operator uses this property to force
1783** the reuse of the same limit and offset registers across multiple
1784** SELECT statements.
1785*/
drhec7429a2005-10-06 16:53:14 +00001786static void computeLimitRegisters(Parse *pParse, Select *p, int iBreak){
drh02afc862006-01-20 18:10:57 +00001787 Vdbe *v = 0;
1788 int iLimit = 0;
drh15007a92006-01-08 18:10:17 +00001789 int iOffset;
drhb7654112008-01-12 12:48:07 +00001790 int addr1;
drh0acb7e42008-06-25 00:12:41 +00001791 if( p->iLimit ) return;
drh15007a92006-01-08 18:10:17 +00001792
drh7b58dae2003-07-20 01:16:46 +00001793 /*
drh7b58dae2003-07-20 01:16:46 +00001794 ** "LIMIT -1" always shows all rows. There is some
1795 ** contraversy about what the correct behavior should be.
1796 ** The current implementation interprets "LIMIT 0" to mean
1797 ** no rows.
1798 */
danielk1977a2dc3b12005-02-05 12:48:48 +00001799 if( p->pLimit ){
drh0a07c102008-01-03 18:03:08 +00001800 p->iLimit = iLimit = ++pParse->nMem;
drh15007a92006-01-08 18:10:17 +00001801 v = sqlite3GetVdbe(pParse);
drh7b58dae2003-07-20 01:16:46 +00001802 if( v==0 ) return;
drhb7654112008-01-12 12:48:07 +00001803 sqlite3ExprCode(pParse, p->pLimit, iLimit);
1804 sqlite3VdbeAddOp1(v, OP_MustBeInt, iLimit);
drhd4e70eb2008-01-02 00:34:36 +00001805 VdbeComment((v, "LIMIT counter"));
drh3c84ddf2008-01-09 02:15:38 +00001806 sqlite3VdbeAddOp2(v, OP_IfZero, iLimit, iBreak);
drh7b58dae2003-07-20 01:16:46 +00001807 }
danielk1977a2dc3b12005-02-05 12:48:48 +00001808 if( p->pOffset ){
drh0a07c102008-01-03 18:03:08 +00001809 p->iOffset = iOffset = ++pParse->nMem;
drhb7654112008-01-12 12:48:07 +00001810 if( p->pLimit ){
1811 pParse->nMem++; /* Allocate an extra register for limit+offset */
1812 }
drh15007a92006-01-08 18:10:17 +00001813 v = sqlite3GetVdbe(pParse);
drh7b58dae2003-07-20 01:16:46 +00001814 if( v==0 ) return;
drhb7654112008-01-12 12:48:07 +00001815 sqlite3ExprCode(pParse, p->pOffset, iOffset);
1816 sqlite3VdbeAddOp1(v, OP_MustBeInt, iOffset);
drhd4e70eb2008-01-02 00:34:36 +00001817 VdbeComment((v, "OFFSET counter"));
drh3c84ddf2008-01-09 02:15:38 +00001818 addr1 = sqlite3VdbeAddOp1(v, OP_IfPos, iOffset);
drhb7654112008-01-12 12:48:07 +00001819 sqlite3VdbeAddOp2(v, OP_Integer, 0, iOffset);
drh15007a92006-01-08 18:10:17 +00001820 sqlite3VdbeJumpHere(v, addr1);
drhd59ba6c2006-01-08 05:02:54 +00001821 if( p->pLimit ){
drhb7654112008-01-12 12:48:07 +00001822 sqlite3VdbeAddOp3(v, OP_Add, iLimit, iOffset, iOffset+1);
1823 VdbeComment((v, "LIMIT+OFFSET"));
1824 addr1 = sqlite3VdbeAddOp1(v, OP_IfPos, iLimit);
1825 sqlite3VdbeAddOp2(v, OP_Integer, -1, iOffset+1);
1826 sqlite3VdbeJumpHere(v, addr1);
drhd59ba6c2006-01-08 05:02:54 +00001827 }
drh7b58dae2003-07-20 01:16:46 +00001828 }
1829}
1830
1831/*
drh0342b1f2005-09-01 03:07:44 +00001832** Allocate a virtual index to use for sorting.
drhd3d39e92004-05-20 22:16:29 +00001833*/
drh4db38a72005-09-01 12:16:28 +00001834static void createSortingIndex(Parse *pParse, Select *p, ExprList *pOrderBy){
drh0342b1f2005-09-01 03:07:44 +00001835 if( pOrderBy ){
1836 int addr;
drh9d2985c2005-09-08 01:58:42 +00001837 assert( pOrderBy->iECursor==0 );
1838 pOrderBy->iECursor = pParse->nTab++;
drh66a51672008-01-03 00:01:23 +00001839 addr = sqlite3VdbeAddOp2(pParse->pVdbe, OP_OpenEphemeral,
drh9d2985c2005-09-08 01:58:42 +00001840 pOrderBy->iECursor, pOrderBy->nExpr+1);
drhb9bb7c12006-06-11 23:41:55 +00001841 assert( p->addrOpenEphm[2] == -1 );
1842 p->addrOpenEphm[2] = addr;
drh736c22b2004-05-21 02:14:24 +00001843 }
danielk1977dc1bdc42004-06-11 10:51:27 +00001844}
1845
drhb7f91642004-10-31 02:22:47 +00001846#ifndef SQLITE_OMIT_COMPOUND_SELECT
drhfbc4ee72004-08-29 01:31:05 +00001847/*
drhfbc4ee72004-08-29 01:31:05 +00001848** Return the appropriate collating sequence for the iCol-th column of
1849** the result set for the compound-select statement "p". Return NULL if
1850** the column has no default collating sequence.
1851**
1852** The collating sequence for the compound select is taken from the
1853** left-most term of the select that has a collating sequence.
1854*/
danielk1977dc1bdc42004-06-11 10:51:27 +00001855static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){
drhfbc4ee72004-08-29 01:31:05 +00001856 CollSeq *pRet;
danielk1977dc1bdc42004-06-11 10:51:27 +00001857 if( p->pPrior ){
1858 pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
drhfbc4ee72004-08-29 01:31:05 +00001859 }else{
1860 pRet = 0;
danielk1977dc1bdc42004-06-11 10:51:27 +00001861 }
drhfbc4ee72004-08-29 01:31:05 +00001862 if( pRet==0 ){
danielk1977dc1bdc42004-06-11 10:51:27 +00001863 pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
1864 }
1865 return pRet;
drhd3d39e92004-05-20 22:16:29 +00001866}
drhb7f91642004-10-31 02:22:47 +00001867#endif /* SQLITE_OMIT_COMPOUND_SELECT */
drhd3d39e92004-05-20 22:16:29 +00001868
drhb21e7c72008-06-22 12:37:57 +00001869/* Forward reference */
1870static int multiSelectOrderBy(
1871 Parse *pParse, /* Parsing context */
1872 Select *p, /* The right-most of SELECTs to be coded */
1873 SelectDest *pDest, /* What to do with query results */
1874 char *aff /* If eDest is SRT_Union, the affinity string */
1875);
1876
1877
drhb7f91642004-10-31 02:22:47 +00001878#ifndef SQLITE_OMIT_COMPOUND_SELECT
drhd3d39e92004-05-20 22:16:29 +00001879/*
drh16ee60f2008-06-20 18:13:25 +00001880** This routine is called to process a compound query form from
1881** two or more separate queries using UNION, UNION ALL, EXCEPT, or
1882** INTERSECT
drhc926afb2002-06-20 03:38:26 +00001883**
drhe78e8282003-01-19 03:59:45 +00001884** "p" points to the right-most of the two queries. the query on the
1885** left is p->pPrior. The left query could also be a compound query
1886** in which case this routine will be called recursively.
1887**
1888** The results of the total query are to be written into a destination
1889** of type eDest with parameter iParm.
1890**
1891** Example 1: Consider a three-way compound SQL statement.
1892**
1893** SELECT a FROM t1 UNION SELECT b FROM t2 UNION SELECT c FROM t3
1894**
1895** This statement is parsed up as follows:
1896**
1897** SELECT c FROM t3
1898** |
1899** `-----> SELECT b FROM t2
1900** |
jplyon4b11c6d2004-01-19 04:57:53 +00001901** `------> SELECT a FROM t1
drhe78e8282003-01-19 03:59:45 +00001902**
1903** The arrows in the diagram above represent the Select.pPrior pointer.
1904** So if this routine is called with p equal to the t3 query, then
1905** pPrior will be the t2 query. p->op will be TK_UNION in this case.
1906**
1907** Notice that because of the way SQLite parses compound SELECTs, the
1908** individual selects always group from left to right.
drh82c3d632000-06-06 21:56:07 +00001909*/
danielk197784ac9d02004-05-18 09:58:06 +00001910static int multiSelect(
drhfbc4ee72004-08-29 01:31:05 +00001911 Parse *pParse, /* Parsing context */
1912 Select *p, /* The right-most of SELECTs to be coded */
danielk19776c8c8ce2008-01-02 16:27:09 +00001913 SelectDest *pDest, /* What to do with query results */
drhfbc4ee72004-08-29 01:31:05 +00001914 char *aff /* If eDest is SRT_Union, the affinity string */
danielk197784ac9d02004-05-18 09:58:06 +00001915){
drhfbc4ee72004-08-29 01:31:05 +00001916 int rc = SQLITE_OK; /* Success code from a subroutine */
1917 Select *pPrior; /* Another SELECT immediately to our left */
1918 Vdbe *v; /* Generate code to this VDBE */
drh8cdbf832004-08-29 16:25:03 +00001919 int nCol; /* Number of columns in the result set */
drh0342b1f2005-09-01 03:07:44 +00001920 ExprList *pOrderBy; /* The ORDER BY clause on p */
1921 int aSetP2[2]; /* Set P2 value of these op to number of columns */
1922 int nSetP2 = 0; /* Number of slots in aSetP2[] used */
drh1013c932008-01-06 00:25:21 +00001923 SelectDest dest; /* Alternative data destination */
drh82c3d632000-06-06 21:56:07 +00001924
drh7b58dae2003-07-20 01:16:46 +00001925 /* Make sure there is no ORDER BY or LIMIT clause on prior SELECTs. Only
drhfbc4ee72004-08-29 01:31:05 +00001926 ** the last (right-most) SELECT in the series may have an ORDER BY or LIMIT.
drh82c3d632000-06-06 21:56:07 +00001927 */
danielk197784ac9d02004-05-18 09:58:06 +00001928 if( p==0 || p->pPrior==0 ){
1929 rc = 1;
1930 goto multi_select_end;
1931 }
drhd8bc7082000-06-07 23:51:50 +00001932 pPrior = p->pPrior;
drh0342b1f2005-09-01 03:07:44 +00001933 assert( pPrior->pRightmost!=pPrior );
1934 assert( pPrior->pRightmost==p->pRightmost );
drhd8bc7082000-06-07 23:51:50 +00001935 if( pPrior->pOrderBy ){
danielk19774adee202004-05-08 08:23:19 +00001936 sqlite3ErrorMsg(pParse,"ORDER BY clause should come after %s not before",
drhda93d232003-03-31 02:12:46 +00001937 selectOpName(p->op));
danielk197784ac9d02004-05-18 09:58:06 +00001938 rc = 1;
1939 goto multi_select_end;
drh82c3d632000-06-06 21:56:07 +00001940 }
danielk1977a2dc3b12005-02-05 12:48:48 +00001941 if( pPrior->pLimit ){
danielk19774adee202004-05-08 08:23:19 +00001942 sqlite3ErrorMsg(pParse,"LIMIT clause should come after %s not before",
drh7b58dae2003-07-20 01:16:46 +00001943 selectOpName(p->op));
danielk197784ac9d02004-05-18 09:58:06 +00001944 rc = 1;
1945 goto multi_select_end;
drh7b58dae2003-07-20 01:16:46 +00001946 }
drh82c3d632000-06-06 21:56:07 +00001947
drhd8bc7082000-06-07 23:51:50 +00001948 /* Make sure we have a valid query engine. If not, create a new one.
1949 */
danielk19774adee202004-05-08 08:23:19 +00001950 v = sqlite3GetVdbe(pParse);
danielk197784ac9d02004-05-18 09:58:06 +00001951 if( v==0 ){
1952 rc = 1;
1953 goto multi_select_end;
1954 }
drhd8bc7082000-06-07 23:51:50 +00001955
drh1cc3d752002-03-23 00:31:29 +00001956 /* Create the destination temporary table if necessary
1957 */
drhb21e7c72008-06-22 12:37:57 +00001958 dest = *pDest;
danielk19776c8c8ce2008-01-02 16:27:09 +00001959 if( dest.eDest==SRT_EphemTab ){
danielk1977b4964b72004-05-18 01:23:38 +00001960 assert( p->pEList );
drhf6e369a2008-06-24 12:46:30 +00001961 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, dest.iParm, p->pEList->nExpr);
danielk19776c8c8ce2008-01-02 16:27:09 +00001962 dest.eDest = SRT_Table;
drh1cc3d752002-03-23 00:31:29 +00001963 }
1964
drhf6e369a2008-06-24 12:46:30 +00001965 /* Make sure all SELECTs in the statement have the same number of elements
1966 ** in their result sets.
1967 */
1968 assert( p->pEList && pPrior->pEList );
1969 if( p->pEList->nExpr!=pPrior->pEList->nExpr ){
1970 sqlite3ErrorMsg(pParse, "SELECTs to the left and right of %s"
1971 " do not have the same number of result columns", selectOpName(p->op));
1972 rc = 1;
1973 goto multi_select_end;
1974 }
1975
drh0acb7e42008-06-25 00:12:41 +00001976#if 1
drhf6e369a2008-06-24 12:46:30 +00001977 if( p->pOrderBy ){
1978 return multiSelectOrderBy(pParse, p, pDest, aff);
1979 }
1980#endif
1981
drhf46f9052002-06-22 02:33:38 +00001982 /* Generate code for the left and right SELECT statements.
drhd8bc7082000-06-07 23:51:50 +00001983 */
drh0342b1f2005-09-01 03:07:44 +00001984 pOrderBy = p->pOrderBy;
drh82c3d632000-06-06 21:56:07 +00001985 switch( p->op ){
drhf46f9052002-06-22 02:33:38 +00001986 case TK_ALL: {
drh0342b1f2005-09-01 03:07:44 +00001987 if( pOrderBy==0 ){
drhec7429a2005-10-06 16:53:14 +00001988 int addr = 0;
danielk1977a2dc3b12005-02-05 12:48:48 +00001989 assert( !pPrior->pLimit );
1990 pPrior->pLimit = p->pLimit;
1991 pPrior->pOffset = p->pOffset;
danielk19776c8c8ce2008-01-02 16:27:09 +00001992 rc = sqlite3Select(pParse, pPrior, &dest, 0, 0, 0, aff);
danielk1977ad68cb62006-01-05 14:22:33 +00001993 p->pLimit = 0;
1994 p->pOffset = 0;
danielk197784ac9d02004-05-18 09:58:06 +00001995 if( rc ){
1996 goto multi_select_end;
1997 }
drhf46f9052002-06-22 02:33:38 +00001998 p->pPrior = 0;
drh7b58dae2003-07-20 01:16:46 +00001999 p->iLimit = pPrior->iLimit;
2000 p->iOffset = pPrior->iOffset;
drh92b01d52008-06-24 00:32:35 +00002001 if( p->iLimit ){
drh3c84ddf2008-01-09 02:15:38 +00002002 addr = sqlite3VdbeAddOp1(v, OP_IfZero, p->iLimit);
drhd4e70eb2008-01-02 00:34:36 +00002003 VdbeComment((v, "Jump ahead if LIMIT reached"));
drhec7429a2005-10-06 16:53:14 +00002004 }
danielk19776c8c8ce2008-01-02 16:27:09 +00002005 rc = sqlite3Select(pParse, p, &dest, 0, 0, 0, aff);
drhf46f9052002-06-22 02:33:38 +00002006 p->pPrior = pPrior;
danielk197784ac9d02004-05-18 09:58:06 +00002007 if( rc ){
2008 goto multi_select_end;
2009 }
drhec7429a2005-10-06 16:53:14 +00002010 if( addr ){
2011 sqlite3VdbeJumpHere(v, addr);
2012 }
drhf46f9052002-06-22 02:33:38 +00002013 break;
2014 }
2015 /* For UNION ALL ... ORDER BY fall through to the next case */
2016 }
drh82c3d632000-06-06 21:56:07 +00002017 case TK_EXCEPT:
2018 case TK_UNION: {
drhd8bc7082000-06-07 23:51:50 +00002019 int unionTab; /* Cursor number of the temporary table holding result */
danielk1977742f9472004-06-16 12:02:43 +00002020 int op = 0; /* One of the SRT_ operations to apply to self */
drhd8bc7082000-06-07 23:51:50 +00002021 int priorOp; /* The SRT_ operation to apply to prior selects */
danielk1977a2dc3b12005-02-05 12:48:48 +00002022 Expr *pLimit, *pOffset; /* Saved values of p->nLimit and p->nOffset */
danielk1977dc1bdc42004-06-11 10:51:27 +00002023 int addr;
danielk19776c8c8ce2008-01-02 16:27:09 +00002024 SelectDest uniondest;
drh82c3d632000-06-06 21:56:07 +00002025
drhd8bc7082000-06-07 23:51:50 +00002026 priorOp = p->op==TK_ALL ? SRT_Table : SRT_Union;
danielk19776c8c8ce2008-01-02 16:27:09 +00002027 if( dest.eDest==priorOp && pOrderBy==0 && !p->pLimit && !p->pOffset ){
drhd8bc7082000-06-07 23:51:50 +00002028 /* We can reuse a temporary table generated by a SELECT to our
drhc926afb2002-06-20 03:38:26 +00002029 ** right.
drhd8bc7082000-06-07 23:51:50 +00002030 */
danielk19776c8c8ce2008-01-02 16:27:09 +00002031 unionTab = dest.iParm;
drh82c3d632000-06-06 21:56:07 +00002032 }else{
drhd8bc7082000-06-07 23:51:50 +00002033 /* We will need to create our own temporary table to hold the
2034 ** intermediate results.
2035 */
2036 unionTab = pParse->nTab++;
drh9a993342007-12-13 02:45:31 +00002037 if( processCompoundOrderBy(pParse, p, unionTab) ){
danielk197784ac9d02004-05-18 09:58:06 +00002038 rc = 1;
2039 goto multi_select_end;
drhd8bc7082000-06-07 23:51:50 +00002040 }
drh66a51672008-01-03 00:01:23 +00002041 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, unionTab, 0);
drh0342b1f2005-09-01 03:07:44 +00002042 if( priorOp==SRT_Table ){
2043 assert( nSetP2<sizeof(aSetP2)/sizeof(aSetP2[0]) );
2044 aSetP2[nSetP2++] = addr;
2045 }else{
drhb9bb7c12006-06-11 23:41:55 +00002046 assert( p->addrOpenEphm[0] == -1 );
2047 p->addrOpenEphm[0] = addr;
2048 p->pRightmost->usesEphm = 1;
drhd8bc7082000-06-07 23:51:50 +00002049 }
drh0342b1f2005-09-01 03:07:44 +00002050 createSortingIndex(pParse, p, pOrderBy);
danielk197784ac9d02004-05-18 09:58:06 +00002051 assert( p->pEList );
drh82c3d632000-06-06 21:56:07 +00002052 }
drhd8bc7082000-06-07 23:51:50 +00002053
2054 /* Code the SELECT statements to our left
2055 */
danielk1977b3bce662005-01-29 08:32:43 +00002056 assert( !pPrior->pOrderBy );
drh1013c932008-01-06 00:25:21 +00002057 sqlite3SelectDestInit(&uniondest, priorOp, unionTab);
danielk19776c8c8ce2008-01-02 16:27:09 +00002058 rc = sqlite3Select(pParse, pPrior, &uniondest, 0, 0, 0, aff);
danielk197784ac9d02004-05-18 09:58:06 +00002059 if( rc ){
2060 goto multi_select_end;
2061 }
drhd8bc7082000-06-07 23:51:50 +00002062
2063 /* Code the current SELECT statement
2064 */
2065 switch( p->op ){
2066 case TK_EXCEPT: op = SRT_Except; break;
2067 case TK_UNION: op = SRT_Union; break;
2068 case TK_ALL: op = SRT_Table; break;
2069 }
drh82c3d632000-06-06 21:56:07 +00002070 p->pPrior = 0;
drhc926afb2002-06-20 03:38:26 +00002071 p->pOrderBy = 0;
drh4b14b4d2005-09-19 17:35:53 +00002072 p->disallowOrderBy = pOrderBy!=0;
danielk1977a2dc3b12005-02-05 12:48:48 +00002073 pLimit = p->pLimit;
2074 p->pLimit = 0;
2075 pOffset = p->pOffset;
2076 p->pOffset = 0;
danielk19776c8c8ce2008-01-02 16:27:09 +00002077 uniondest.eDest = op;
2078 rc = sqlite3Select(pParse, p, &uniondest, 0, 0, 0, aff);
drh5bd1bf22007-06-15 15:31:49 +00002079 /* Query flattening in sqlite3Select() might refill p->pOrderBy.
2080 ** Be sure to delete p->pOrderBy, therefore, to avoid a memory leak. */
2081 sqlite3ExprListDelete(p->pOrderBy);
drh82c3d632000-06-06 21:56:07 +00002082 p->pPrior = pPrior;
drhc926afb2002-06-20 03:38:26 +00002083 p->pOrderBy = pOrderBy;
danielk1977a2dc3b12005-02-05 12:48:48 +00002084 sqlite3ExprDelete(p->pLimit);
2085 p->pLimit = pLimit;
2086 p->pOffset = pOffset;
drh92b01d52008-06-24 00:32:35 +00002087 p->iLimit = 0;
2088 p->iOffset = 0;
danielk197784ac9d02004-05-18 09:58:06 +00002089 if( rc ){
2090 goto multi_select_end;
2091 }
2092
drhd8bc7082000-06-07 23:51:50 +00002093
2094 /* Convert the data in the temporary table into whatever form
2095 ** it is that we currently need.
2096 */
danielk19776c8c8ce2008-01-02 16:27:09 +00002097 if( dest.eDest!=priorOp || unionTab!=dest.iParm ){
drh6b563442001-11-07 16:48:26 +00002098 int iCont, iBreak, iStart;
drh82c3d632000-06-06 21:56:07 +00002099 assert( p->pEList );
danielk19776c8c8ce2008-01-02 16:27:09 +00002100 if( dest.eDest==SRT_Callback ){
drh92378252006-03-26 01:21:22 +00002101 Select *pFirst = p;
2102 while( pFirst->pPrior ) pFirst = pFirst->pPrior;
2103 generateColumnNames(pParse, 0, pFirst->pEList);
drh41202cc2002-04-23 17:10:18 +00002104 }
danielk19774adee202004-05-08 08:23:19 +00002105 iBreak = sqlite3VdbeMakeLabel(v);
2106 iCont = sqlite3VdbeMakeLabel(v);
drhec7429a2005-10-06 16:53:14 +00002107 computeLimitRegisters(pParse, p, iBreak);
drh66a51672008-01-03 00:01:23 +00002108 sqlite3VdbeAddOp2(v, OP_Rewind, unionTab, iBreak);
danielk19774adee202004-05-08 08:23:19 +00002109 iStart = sqlite3VdbeCurrentAddr(v);
drhd2b3e232008-01-23 14:51:49 +00002110 selectInnerLoop(pParse, p, p->pEList, unionTab, p->pEList->nExpr,
2111 pOrderBy, -1, &dest, iCont, iBreak, 0);
danielk19774adee202004-05-08 08:23:19 +00002112 sqlite3VdbeResolveLabel(v, iCont);
drh66a51672008-01-03 00:01:23 +00002113 sqlite3VdbeAddOp2(v, OP_Next, unionTab, iStart);
danielk19774adee202004-05-08 08:23:19 +00002114 sqlite3VdbeResolveLabel(v, iBreak);
drh66a51672008-01-03 00:01:23 +00002115 sqlite3VdbeAddOp2(v, OP_Close, unionTab, 0);
drh82c3d632000-06-06 21:56:07 +00002116 }
2117 break;
2118 }
2119 case TK_INTERSECT: {
2120 int tab1, tab2;
drh6b563442001-11-07 16:48:26 +00002121 int iCont, iBreak, iStart;
danielk1977a2dc3b12005-02-05 12:48:48 +00002122 Expr *pLimit, *pOffset;
danielk1977dc1bdc42004-06-11 10:51:27 +00002123 int addr;
drh1013c932008-01-06 00:25:21 +00002124 SelectDest intersectdest;
drh9cbf3422008-01-17 16:22:13 +00002125 int r1;
drh82c3d632000-06-06 21:56:07 +00002126
drhd8bc7082000-06-07 23:51:50 +00002127 /* INTERSECT is different from the others since it requires
drh6206d502000-06-19 19:09:08 +00002128 ** two temporary tables. Hence it has its own case. Begin
drhd8bc7082000-06-07 23:51:50 +00002129 ** by allocating the tables we will need.
2130 */
drh82c3d632000-06-06 21:56:07 +00002131 tab1 = pParse->nTab++;
2132 tab2 = pParse->nTab++;
drh9a993342007-12-13 02:45:31 +00002133 if( processCompoundOrderBy(pParse, p, tab1) ){
danielk197784ac9d02004-05-18 09:58:06 +00002134 rc = 1;
2135 goto multi_select_end;
drhd8bc7082000-06-07 23:51:50 +00002136 }
drh0342b1f2005-09-01 03:07:44 +00002137 createSortingIndex(pParse, p, pOrderBy);
danielk1977dc1bdc42004-06-11 10:51:27 +00002138
drh66a51672008-01-03 00:01:23 +00002139 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab1, 0);
drhb9bb7c12006-06-11 23:41:55 +00002140 assert( p->addrOpenEphm[0] == -1 );
2141 p->addrOpenEphm[0] = addr;
2142 p->pRightmost->usesEphm = 1;
danielk197784ac9d02004-05-18 09:58:06 +00002143 assert( p->pEList );
drhd8bc7082000-06-07 23:51:50 +00002144
2145 /* Code the SELECTs to our left into temporary table "tab1".
2146 */
drh1013c932008-01-06 00:25:21 +00002147 sqlite3SelectDestInit(&intersectdest, SRT_Union, tab1);
danielk19776c8c8ce2008-01-02 16:27:09 +00002148 rc = sqlite3Select(pParse, pPrior, &intersectdest, 0, 0, 0, aff);
danielk197784ac9d02004-05-18 09:58:06 +00002149 if( rc ){
2150 goto multi_select_end;
2151 }
drhd8bc7082000-06-07 23:51:50 +00002152
2153 /* Code the current SELECT into temporary table "tab2"
2154 */
drh66a51672008-01-03 00:01:23 +00002155 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab2, 0);
drhb9bb7c12006-06-11 23:41:55 +00002156 assert( p->addrOpenEphm[1] == -1 );
2157 p->addrOpenEphm[1] = addr;
drh82c3d632000-06-06 21:56:07 +00002158 p->pPrior = 0;
danielk1977a2dc3b12005-02-05 12:48:48 +00002159 pLimit = p->pLimit;
2160 p->pLimit = 0;
2161 pOffset = p->pOffset;
2162 p->pOffset = 0;
danielk19776c8c8ce2008-01-02 16:27:09 +00002163 intersectdest.iParm = tab2;
2164 rc = sqlite3Select(pParse, p, &intersectdest, 0, 0, 0, aff);
drh82c3d632000-06-06 21:56:07 +00002165 p->pPrior = pPrior;
danielk1977a2dc3b12005-02-05 12:48:48 +00002166 sqlite3ExprDelete(p->pLimit);
2167 p->pLimit = pLimit;
2168 p->pOffset = pOffset;
danielk197784ac9d02004-05-18 09:58:06 +00002169 if( rc ){
2170 goto multi_select_end;
2171 }
drhd8bc7082000-06-07 23:51:50 +00002172
2173 /* Generate code to take the intersection of the two temporary
2174 ** tables.
2175 */
drh82c3d632000-06-06 21:56:07 +00002176 assert( p->pEList );
danielk19776c8c8ce2008-01-02 16:27:09 +00002177 if( dest.eDest==SRT_Callback ){
drh92378252006-03-26 01:21:22 +00002178 Select *pFirst = p;
2179 while( pFirst->pPrior ) pFirst = pFirst->pPrior;
2180 generateColumnNames(pParse, 0, pFirst->pEList);
drh41202cc2002-04-23 17:10:18 +00002181 }
danielk19774adee202004-05-08 08:23:19 +00002182 iBreak = sqlite3VdbeMakeLabel(v);
2183 iCont = sqlite3VdbeMakeLabel(v);
drhec7429a2005-10-06 16:53:14 +00002184 computeLimitRegisters(pParse, p, iBreak);
drh66a51672008-01-03 00:01:23 +00002185 sqlite3VdbeAddOp2(v, OP_Rewind, tab1, iBreak);
drh9cbf3422008-01-17 16:22:13 +00002186 r1 = sqlite3GetTempReg(pParse);
2187 iStart = sqlite3VdbeAddOp2(v, OP_RowKey, tab1, r1);
2188 sqlite3VdbeAddOp3(v, OP_NotFound, tab2, iCont, r1);
2189 sqlite3ReleaseTempReg(pParse, r1);
drhd2b3e232008-01-23 14:51:49 +00002190 selectInnerLoop(pParse, p, p->pEList, tab1, p->pEList->nExpr,
2191 pOrderBy, -1, &dest, iCont, iBreak, 0);
danielk19774adee202004-05-08 08:23:19 +00002192 sqlite3VdbeResolveLabel(v, iCont);
drh66a51672008-01-03 00:01:23 +00002193 sqlite3VdbeAddOp2(v, OP_Next, tab1, iStart);
danielk19774adee202004-05-08 08:23:19 +00002194 sqlite3VdbeResolveLabel(v, iBreak);
drh66a51672008-01-03 00:01:23 +00002195 sqlite3VdbeAddOp2(v, OP_Close, tab2, 0);
2196 sqlite3VdbeAddOp2(v, OP_Close, tab1, 0);
drh82c3d632000-06-06 21:56:07 +00002197 break;
2198 }
2199 }
drh8cdbf832004-08-29 16:25:03 +00002200
drh8cdbf832004-08-29 16:25:03 +00002201 /* Set the number of columns in temporary tables
2202 */
2203 nCol = p->pEList->nExpr;
drh0342b1f2005-09-01 03:07:44 +00002204 while( nSetP2 ){
2205 sqlite3VdbeChangeP2(v, aSetP2[--nSetP2], nCol);
drh8cdbf832004-08-29 16:25:03 +00002206 }
2207
drhfbc4ee72004-08-29 01:31:05 +00002208 /* Compute collating sequences used by either the ORDER BY clause or
2209 ** by any temporary tables needed to implement the compound select.
2210 ** Attach the KeyInfo structure to all temporary tables. Invoke the
2211 ** ORDER BY processing if there is an ORDER BY clause.
drh8cdbf832004-08-29 16:25:03 +00002212 **
2213 ** This section is run by the right-most SELECT statement only.
2214 ** SELECT statements to the left always skip this part. The right-most
2215 ** SELECT might also skip this part if it has no ORDER BY clause and
2216 ** no temp tables are required.
drhfbc4ee72004-08-29 01:31:05 +00002217 */
drhb9bb7c12006-06-11 23:41:55 +00002218 if( pOrderBy || p->usesEphm ){
drhfbc4ee72004-08-29 01:31:05 +00002219 int i; /* Loop counter */
2220 KeyInfo *pKeyInfo; /* Collating sequence for the result set */
drh0342b1f2005-09-01 03:07:44 +00002221 Select *pLoop; /* For looping through SELECT statements */
drh1e31e0b2006-08-11 19:08:27 +00002222 int nKeyCol; /* Number of entries in pKeyInfo->aCol[] */
drhf68d7d12007-05-03 13:02:26 +00002223 CollSeq **apColl; /* For looping through pKeyInfo->aColl[] */
2224 CollSeq **aCopy; /* A copy of pKeyInfo->aColl[] */
drhfbc4ee72004-08-29 01:31:05 +00002225
drh0342b1f2005-09-01 03:07:44 +00002226 assert( p->pRightmost==p );
drh1e31e0b2006-08-11 19:08:27 +00002227 nKeyCol = nCol + (pOrderBy ? pOrderBy->nExpr : 0);
drh17435752007-08-16 04:30:38 +00002228 pKeyInfo = sqlite3DbMallocZero(pParse->db,
2229 sizeof(*pKeyInfo)+nKeyCol*(sizeof(CollSeq*) + 1));
danielk1977dc1bdc42004-06-11 10:51:27 +00002230 if( !pKeyInfo ){
2231 rc = SQLITE_NOMEM;
2232 goto multi_select_end;
2233 }
2234
danielk197714db2662006-01-09 16:12:04 +00002235 pKeyInfo->enc = ENC(pParse->db);
danielk1977dc1bdc42004-06-11 10:51:27 +00002236 pKeyInfo->nField = nCol;
2237
drh0342b1f2005-09-01 03:07:44 +00002238 for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
2239 *apColl = multiSelectCollSeq(pParse, p, i);
2240 if( 0==*apColl ){
2241 *apColl = pParse->db->pDfltColl;
danielk1977dc1bdc42004-06-11 10:51:27 +00002242 }
2243 }
2244
drh0342b1f2005-09-01 03:07:44 +00002245 for(pLoop=p; pLoop; pLoop=pLoop->pPrior){
2246 for(i=0; i<2; i++){
drhb9bb7c12006-06-11 23:41:55 +00002247 int addr = pLoop->addrOpenEphm[i];
drh0342b1f2005-09-01 03:07:44 +00002248 if( addr<0 ){
2249 /* If [0] is unused then [1] is also unused. So we can
2250 ** always safely abort as soon as the first unused slot is found */
drhb9bb7c12006-06-11 23:41:55 +00002251 assert( pLoop->addrOpenEphm[1]<0 );
drh0342b1f2005-09-01 03:07:44 +00002252 break;
2253 }
2254 sqlite3VdbeChangeP2(v, addr, nCol);
drh66a51672008-01-03 00:01:23 +00002255 sqlite3VdbeChangeP4(v, addr, (char*)pKeyInfo, P4_KEYINFO);
drh0ee5a1e2007-01-26 19:04:00 +00002256 pLoop->addrOpenEphm[i] = -1;
drh0342b1f2005-09-01 03:07:44 +00002257 }
danielk1977dc1bdc42004-06-11 10:51:27 +00002258 }
2259
drh0342b1f2005-09-01 03:07:44 +00002260 if( pOrderBy ){
2261 struct ExprList_item *pOTerm = pOrderBy->a;
drh4efc0832005-11-16 13:47:50 +00002262 int nOrderByExpr = pOrderBy->nExpr;
drh0342b1f2005-09-01 03:07:44 +00002263 int addr;
drh4db38a72005-09-01 12:16:28 +00002264 u8 *pSortOrder;
drh0342b1f2005-09-01 03:07:44 +00002265
drhf68d7d12007-05-03 13:02:26 +00002266 /* Reuse the same pKeyInfo for the ORDER BY as was used above for
2267 ** the compound select statements. Except we have to change out the
2268 ** pKeyInfo->aColl[] values. Some of the aColl[] values will be
2269 ** reused when constructing the pKeyInfo for the ORDER BY, so make
2270 ** a copy. Sufficient space to hold both the nCol entries for
2271 ** the compound select and the nOrderbyExpr entries for the ORDER BY
2272 ** was allocated above. But we need to move the compound select
2273 ** entries out of the way before constructing the ORDER BY entries.
2274 ** Move the compound select entries into aCopy[] where they can be
2275 ** accessed and reused when constructing the ORDER BY entries.
2276 ** Because nCol might be greater than or less than nOrderByExpr
2277 ** we have to use memmove() when doing the copy.
2278 */
drh1e31e0b2006-08-11 19:08:27 +00002279 aCopy = &pKeyInfo->aColl[nOrderByExpr];
drh4efc0832005-11-16 13:47:50 +00002280 pSortOrder = pKeyInfo->aSortOrder = (u8*)&aCopy[nCol];
drhf68d7d12007-05-03 13:02:26 +00002281 memmove(aCopy, pKeyInfo->aColl, nCol*sizeof(CollSeq*));
2282
drh0342b1f2005-09-01 03:07:44 +00002283 apColl = pKeyInfo->aColl;
drh4efc0832005-11-16 13:47:50 +00002284 for(i=0; i<nOrderByExpr; i++, pOTerm++, apColl++, pSortOrder++){
drh0342b1f2005-09-01 03:07:44 +00002285 Expr *pExpr = pOTerm->pExpr;
drh8b4c40d2007-02-01 23:02:45 +00002286 if( (pExpr->flags & EP_ExpCollate) ){
2287 assert( pExpr->pColl!=0 );
2288 *apColl = pExpr->pColl;
danielk1977dc1bdc42004-06-11 10:51:27 +00002289 }else{
drh0342b1f2005-09-01 03:07:44 +00002290 *apColl = aCopy[pExpr->iColumn];
danielk1977dc1bdc42004-06-11 10:51:27 +00002291 }
drh4db38a72005-09-01 12:16:28 +00002292 *pSortOrder = pOTerm->sortOrder;
danielk1977dc1bdc42004-06-11 10:51:27 +00002293 }
drh0342b1f2005-09-01 03:07:44 +00002294 assert( p->pRightmost==p );
drhb9bb7c12006-06-11 23:41:55 +00002295 assert( p->addrOpenEphm[2]>=0 );
2296 addr = p->addrOpenEphm[2];
danielk1977a670b222007-05-14 16:50:48 +00002297 sqlite3VdbeChangeP2(v, addr, p->pOrderBy->nExpr+2);
drh4efc0832005-11-16 13:47:50 +00002298 pKeyInfo->nField = nOrderByExpr;
drh66a51672008-01-03 00:01:23 +00002299 sqlite3VdbeChangeP4(v, addr, (char*)pKeyInfo, P4_KEYINFO_HANDOFF);
drh4db38a72005-09-01 12:16:28 +00002300 pKeyInfo = 0;
danielk19776c8c8ce2008-01-02 16:27:09 +00002301 generateSortTail(pParse, p, v, p->pEList->nExpr, &dest);
danielk1977dc1bdc42004-06-11 10:51:27 +00002302 }
2303
drh17435752007-08-16 04:30:38 +00002304 sqlite3_free(pKeyInfo);
danielk197784ac9d02004-05-18 09:58:06 +00002305 }
danielk1977dc1bdc42004-06-11 10:51:27 +00002306
2307multi_select_end:
drh1013c932008-01-06 00:25:21 +00002308 pDest->iMem = dest.iMem;
drhad27e762008-03-26 12:46:23 +00002309 pDest->nMem = dest.nMem;
danielk197784ac9d02004-05-18 09:58:06 +00002310 return rc;
drh22827922000-06-06 17:27:05 +00002311}
drhb7f91642004-10-31 02:22:47 +00002312#endif /* SQLITE_OMIT_COMPOUND_SELECT */
drh22827922000-06-06 17:27:05 +00002313
drhb21e7c72008-06-22 12:37:57 +00002314/*
2315** Code an output subroutine for a coroutine implementation of a
2316** SELECT statment.
drh0acb7e42008-06-25 00:12:41 +00002317**
2318** The data to be output is contained in pIn->iMem. There are
2319** pIn->nMem columns to be output. pDest is where the output should
2320** be sent.
2321**
2322** regReturn is the number of the register holding the subroutine
2323** return address.
2324**
2325** If regPrev>0 then it is a the first register in a vector that
2326** records the previous output. mem[regPrev] is a flag that is false
2327** if there has been no previous output. If regPrev>0 then code is
2328** generated to suppress duplicates. pKeyInfo is used for comparing
2329** keys.
2330**
2331** If the LIMIT found in p->iLimit is reached, jump immediately to
2332** iBreak.
drhb21e7c72008-06-22 12:37:57 +00002333*/
drh0acb7e42008-06-25 00:12:41 +00002334static int generateOutputSubroutine(
drh92b01d52008-06-24 00:32:35 +00002335 Parse *pParse, /* Parsing context */
2336 Select *p, /* The SELECT statement */
2337 SelectDest *pIn, /* Coroutine supplying data */
2338 SelectDest *pDest, /* Where to send the data */
2339 int regReturn, /* The return address register */
drh0acb7e42008-06-25 00:12:41 +00002340 int regPrev, /* Previous result register. No uniqueness if 0 */
2341 KeyInfo *pKeyInfo, /* For comparing with previous entry */
2342 int p4type, /* The p4 type for pKeyInfo */
drh92b01d52008-06-24 00:32:35 +00002343 int iBreak /* Jump here if we hit the LIMIT */
drhb21e7c72008-06-22 12:37:57 +00002344){
2345 Vdbe *v = pParse->pVdbe;
drh92b01d52008-06-24 00:32:35 +00002346 int iContinue;
2347 int addr;
2348 if( v==0 ) return 0;
drhb21e7c72008-06-22 12:37:57 +00002349
drh92b01d52008-06-24 00:32:35 +00002350 addr = sqlite3VdbeCurrentAddr(v);
2351 iContinue = sqlite3VdbeMakeLabel(v);
drh0acb7e42008-06-25 00:12:41 +00002352
2353 /* Suppress duplicates for UNION, EXCEPT, and INTERSECT
2354 */
2355 if( regPrev ){
2356 int j1, j2;
2357 j1 = sqlite3VdbeAddOp1(v, OP_IfNot, regPrev);
2358 j2 = sqlite3VdbeAddOp4(v, OP_Compare, pIn->iMem, regPrev+1, pIn->nMem,
2359 (char*)pKeyInfo, p4type);
2360 sqlite3VdbeAddOp3(v, OP_Jump, j2+2, iContinue, j2+2);
2361 sqlite3VdbeJumpHere(v, j1);
2362 sqlite3ExprCodeCopy(pParse, pIn->iMem, regPrev+1, pIn->nMem);
2363 sqlite3VdbeAddOp2(v, OP_Integer, 1, regPrev);
2364 }
2365
2366 /* Suppress the the first OFFSET entries if there is an OFFSET clause
2367 */
drh92b01d52008-06-24 00:32:35 +00002368 codeOffset(v, p, iContinue);
drhb21e7c72008-06-22 12:37:57 +00002369
2370 switch( pDest->eDest ){
2371 /* Store the result as data using a unique key.
2372 */
2373 case SRT_Table:
2374 case SRT_EphemTab: {
2375 int r1 = sqlite3GetTempReg(pParse);
2376 int r2 = sqlite3GetTempReg(pParse);
drh92b01d52008-06-24 00:32:35 +00002377 sqlite3VdbeAddOp3(v, OP_MakeRecord, pIn->iMem, pIn->nMem, r1);
2378 sqlite3VdbeAddOp2(v, OP_NewRowid, pDest->iParm, r2);
2379 sqlite3VdbeAddOp3(v, OP_Insert, pDest->iParm, r1, r2);
drhb21e7c72008-06-22 12:37:57 +00002380 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
2381 sqlite3ReleaseTempReg(pParse, r2);
2382 sqlite3ReleaseTempReg(pParse, r1);
2383 break;
2384 }
2385
2386#ifndef SQLITE_OMIT_SUBQUERY
2387 /* If we are creating a set for an "expr IN (SELECT ...)" construct,
2388 ** then there should be a single item on the stack. Write this
2389 ** item into the set table with bogus data.
2390 */
2391 case SRT_Set: {
2392 int addr2, r1;
drh92b01d52008-06-24 00:32:35 +00002393 assert( pIn->nMem==1 );
2394 addr2 = sqlite3VdbeAddOp1(v, OP_IsNull, pIn->iMem);
2395 p->affinity =
2396 sqlite3CompareAffinity(p->pEList->a[0].pExpr, pDest->affinity);
drhb21e7c72008-06-22 12:37:57 +00002397 r1 = sqlite3GetTempReg(pParse);
drh92b01d52008-06-24 00:32:35 +00002398 sqlite3VdbeAddOp4(v, OP_MakeRecord, pIn->iMem, 1, r1, &p->affinity, 1);
2399 sqlite3ExprCacheAffinityChange(pParse, pIn->iMem, 1);
2400 sqlite3VdbeAddOp2(v, OP_IdxInsert, pDest->iParm, r1);
drhb21e7c72008-06-22 12:37:57 +00002401 sqlite3ReleaseTempReg(pParse, r1);
2402 sqlite3VdbeJumpHere(v, addr2);
2403 break;
2404 }
2405
2406 /* If any row exist in the result set, record that fact and abort.
2407 */
2408 case SRT_Exists: {
drh92b01d52008-06-24 00:32:35 +00002409 sqlite3VdbeAddOp2(v, OP_Integer, 1, pDest->iParm);
drhb21e7c72008-06-22 12:37:57 +00002410 /* The LIMIT clause will terminate the loop for us */
2411 break;
2412 }
2413
2414 /* If this is a scalar select that is part of an expression, then
2415 ** store the results in the appropriate memory cell and break out
2416 ** of the scan loop.
2417 */
2418 case SRT_Mem: {
drh92b01d52008-06-24 00:32:35 +00002419 assert( pIn->nMem==1 );
2420 sqlite3ExprCodeMove(pParse, pIn->iMem, pDest->iParm, 1);
drhb21e7c72008-06-22 12:37:57 +00002421 /* The LIMIT clause will jump out of the loop for us */
2422 break;
2423 }
2424#endif /* #ifndef SQLITE_OMIT_SUBQUERY */
2425
2426 /* Send the data to the callback function or to a subroutine. In the
2427 ** case of a subroutine, the subroutine itself is responsible for
2428 ** popping the data from the stack.
2429 */
drh92b01d52008-06-24 00:32:35 +00002430 case SRT_Coroutine: {
2431 if( pDest->iMem==0 ){
2432 pDest->iMem = sqlite3GetTempRange(pParse, pIn->nMem);
2433 pDest->nMem = pIn->nMem;
drhb21e7c72008-06-22 12:37:57 +00002434 }
drh92b01d52008-06-24 00:32:35 +00002435 sqlite3ExprCodeMove(pParse, pIn->iMem, pDest->iMem, pDest->nMem);
2436 sqlite3VdbeAddOp1(v, OP_Yield, pDest->iParm);
2437 break;
2438 }
2439
2440 case SRT_Callback: {
2441 sqlite3VdbeAddOp2(v, OP_ResultRow, pIn->iMem, pIn->nMem);
2442 sqlite3ExprCacheAffinityChange(pParse, pIn->iMem, pIn->nMem);
drhb21e7c72008-06-22 12:37:57 +00002443 break;
2444 }
2445
2446#if !defined(SQLITE_OMIT_TRIGGER)
2447 /* Discard the results. This is used for SELECT statements inside
2448 ** the body of a TRIGGER. The purpose of such selects is to call
2449 ** user-defined functions that have side effects. We do not care
2450 ** about the actual results of the select.
2451 */
2452 default: {
2453 break;
2454 }
2455#endif
2456 }
drh92b01d52008-06-24 00:32:35 +00002457
2458 /* Jump to the end of the loop if the LIMIT is reached.
2459 */
2460 if( p->iLimit ){
2461 sqlite3VdbeAddOp2(v, OP_AddImm, p->iLimit, -1);
2462 sqlite3VdbeAddOp2(v, OP_IfZero, p->iLimit, iBreak);
2463 }
2464
drh92b01d52008-06-24 00:32:35 +00002465 /* Generate the subroutine return
2466 */
drh0acb7e42008-06-25 00:12:41 +00002467 sqlite3VdbeResolveLabel(v, iContinue);
drh92b01d52008-06-24 00:32:35 +00002468 sqlite3VdbeAddOp1(v, OP_Return, regReturn);
2469
2470 return addr;
drhb21e7c72008-06-22 12:37:57 +00002471}
2472
2473/*
2474** Alternative compound select code generator for cases when there
2475** is an ORDER BY clause.
2476**
2477** We assume a query of the following form:
2478**
2479** <selectA> <operator> <selectB> ORDER BY <orderbylist>
2480**
2481** <operator> is one of UNION ALL, UNION, EXCEPT, or INTERSECT. The idea
2482** is to code both <selectA> and <selectB> with the ORDER BY clause as
2483** co-routines. Then run the co-routines in parallel and merge the results
2484** into the output. In addition to the two coroutines (called selectA and
2485** selectB) there are 7 subroutines:
2486**
2487** outA: Move the output of the selectA coroutine into the output
2488** of the compound query.
2489**
2490** outB: Move the output of the selectB coroutine into the output
2491** of the compound query. (Only generated for UNION and
2492** UNION ALL. EXCEPT and INSERTSECT never output a row that
2493** appears only in B.)
2494**
2495** AltB: Called when there is data from both coroutines and A<B.
2496**
2497** AeqB: Called when there is data from both coroutines and A==B.
2498**
2499** AgtB: Called when there is data from both coroutines and A>B.
2500**
2501** EofA: Called when data is exhausted from selectA.
2502**
2503** EofB: Called when data is exhausted from selectB.
2504**
2505** The implementation of the latter five subroutines depend on which
2506** <operator> is used:
2507**
2508**
2509** UNION ALL UNION EXCEPT INTERSECT
2510** ------------- ----------------- -------------- -----------------
drh0acb7e42008-06-25 00:12:41 +00002511** AltB: outA, nextA outA, nextA outA, nextA nextA
drhb21e7c72008-06-22 12:37:57 +00002512**
drh0acb7e42008-06-25 00:12:41 +00002513** AeqB: outA, nextA nextA nextA outA, nextA
drhb21e7c72008-06-22 12:37:57 +00002514**
drh0acb7e42008-06-25 00:12:41 +00002515** AgtB: outB, nextB outB, nextB nextB nextB
drhb21e7c72008-06-22 12:37:57 +00002516**
drh0acb7e42008-06-25 00:12:41 +00002517** EofA: outB, nextB outB, nextB halt halt
drhb21e7c72008-06-22 12:37:57 +00002518**
drh0acb7e42008-06-25 00:12:41 +00002519** EofB: outA, nextA outA, nextA outA, nextA halt
2520**
2521** In the AltB, AeqB, and AgtB subroutines, an EOF on A following nextA
2522** causes an immediate jump to EofA and an EOF on B following nextB causes
2523** an immediate jump to EofB. Within EofA and EofB, and EOF on entry or
2524** following nextX causes a jump to the end of the select processing.
2525**
2526** Duplicate removal in the UNION, EXCEPT, and INTERSECT cases is handled
2527** within the output subroutine. The regPrev register set holds the previously
2528** output value. A comparison is made against this value and the output
2529** is skipped if the next results would be the same as the previous.
drhb21e7c72008-06-22 12:37:57 +00002530**
2531** The implementation plan is to implement the two coroutines and seven
2532** subroutines first, then put the control logic at the bottom. Like this:
2533**
2534** goto Init
2535** coA: coroutine for left query (A)
2536** coB: coroutine for right query (B)
2537** outA: output one row of A
2538** outB: output one row of B (UNION and UNION ALL only)
2539** EofA: ...
2540** EofB: ...
2541** AltB: ...
2542** AeqB: ...
2543** AgtB: ...
2544** Init: initialize coroutine registers
2545** yield coA
2546** if eof(A) goto EofA
2547** yield coB
2548** if eof(B) goto EofB
2549** Cmpr: Compare A, B
2550** Jump AltB, AeqB, AgtB
2551** End: ...
2552**
2553** We call AltB, AeqB, AgtB, EofA, and EofB "subroutines" but they are not
2554** actually called using Gosub and they do not Return. EofA and EofB loop
2555** until all data is exhausted then jump to the "end" labe. AltB, AeqB,
2556** and AgtB jump to either L2 or to one of EofA or EofB.
2557*/
2558static int multiSelectOrderBy(
2559 Parse *pParse, /* Parsing context */
2560 Select *p, /* The right-most of SELECTs to be coded */
2561 SelectDest *pDest, /* What to do with query results */
2562 char *aff /* If eDest is SRT_Union, the affinity string */
2563){
drh0acb7e42008-06-25 00:12:41 +00002564 int i, j; /* Loop counters */
drhb21e7c72008-06-22 12:37:57 +00002565 Select *pPrior; /* Another SELECT immediately to our left */
2566 Vdbe *v; /* Generate code to this VDBE */
drhb21e7c72008-06-22 12:37:57 +00002567 SelectDest destA; /* Destination for coroutine A */
2568 SelectDest destB; /* Destination for coroutine B */
drh92b01d52008-06-24 00:32:35 +00002569 int regAddrA; /* Address register for select-A coroutine */
2570 int regEofA; /* Flag to indicate when select-A is complete */
2571 int regAddrB; /* Address register for select-B coroutine */
2572 int regEofB; /* Flag to indicate when select-B is complete */
2573 int addrSelectA; /* Address of the select-A coroutine */
2574 int addrSelectB; /* Address of the select-B coroutine */
2575 int regOutA; /* Address register for the output-A subroutine */
2576 int regOutB; /* Address register for the output-B subroutine */
2577 int addrOutA; /* Address of the output-A subroutine */
2578 int addrOutB; /* Address of the output-B subroutine */
2579 int addrEofA; /* Address of the select-A-exhausted subroutine */
2580 int addrEofB; /* Address of the select-B-exhausted subroutine */
2581 int addrAltB; /* Address of the A<B subroutine */
2582 int addrAeqB; /* Address of the A==B subroutine */
2583 int addrAgtB; /* Address of the A>B subroutine */
2584 int regLimitA; /* Limit register for select-A */
2585 int regLimitB; /* Limit register for select-A */
drh0acb7e42008-06-25 00:12:41 +00002586 int regPrev; /* A range of registers to hold previous output */
drh92b01d52008-06-24 00:32:35 +00002587 int savedLimit; /* Saved value of p->iLimit */
2588 int savedOffset; /* Saved value of p->iOffset */
2589 int labelCmpr; /* Label for the start of the merge algorithm */
2590 int labelEnd; /* Label for the end of the overall SELECT stmt */
drh0acb7e42008-06-25 00:12:41 +00002591 int j1; /* Jump instructions that get retargetted */
drh92b01d52008-06-24 00:32:35 +00002592 int op; /* One of TK_ALL, TK_UNION, TK_EXCEPT, TK_INTERSECT */
drh0acb7e42008-06-25 00:12:41 +00002593 KeyInfo *pKeyDup; /* Comparison information for duplicate removal */
2594 KeyInfo *pKeyMerge; /* Comparison information for merging rows */
2595 sqlite3 *db; /* Database connection */
2596 ExprList *pOrderBy; /* The ORDER BY clause */
2597 int nOrderBy; /* Number of terms in the ORDER BY clause */
2598 int *aPermute; /* Mapping from ORDER BY terms to result set columns */
2599 u8 NotUsed; /* Dummy variables */
drhb21e7c72008-06-22 12:37:57 +00002600
drh92b01d52008-06-24 00:32:35 +00002601 assert( p->pOrderBy!=0 );
drh0acb7e42008-06-25 00:12:41 +00002602 db = pParse->db;
drh92b01d52008-06-24 00:32:35 +00002603 v = pParse->pVdbe;
2604 if( v==0 ) return SQLITE_NOMEM;
2605 labelEnd = sqlite3VdbeMakeLabel(v);
2606 labelCmpr = sqlite3VdbeMakeLabel(v);
drh0acb7e42008-06-25 00:12:41 +00002607
drh92b01d52008-06-24 00:32:35 +00002608
2609 /* Patch up the ORDER BY clause
2610 */
2611 op = p->op;
drhb21e7c72008-06-22 12:37:57 +00002612 pPrior = p->pPrior;
drh92b01d52008-06-24 00:32:35 +00002613 assert( pPrior->pOrderBy==0 );
drh0acb7e42008-06-25 00:12:41 +00002614 pOrderBy = p->pOrderBy;
2615 if( pOrderBy ){
2616 if( processCompoundOrderBy(pParse, p, 0) ){
2617 return SQLITE_ERROR;
2618 }
2619 nOrderBy = pOrderBy->nExpr;
2620 }else{
2621 nOrderBy = 0;
drh92b01d52008-06-24 00:32:35 +00002622 }
drh0acb7e42008-06-25 00:12:41 +00002623 /* For operators other than UNION ALL we have to make sure that
2624 ** the ORDER BY clause covers every term of the result set. Add
2625 ** terms to the ORDER BY clause as necessary.
2626 */
2627 if( op!=TK_ALL ){
2628 for(i=1; db->mallocFailed==0 && i<=p->pEList->nExpr; i++){
2629 for(j=0; j<nOrderBy; j++){
2630 Expr *pTerm = pOrderBy->a[j].pExpr;
2631 assert( pTerm->op==TK_INTEGER );
2632 assert( (pTerm->flags & EP_IntValue)!=0 );
2633 if( pTerm->iTable==i ) break;
2634 }
2635 if( j==nOrderBy ){
2636 Expr *pNew = sqlite3PExpr(pParse, TK_INTEGER, 0, 0, 0);
2637 if( pNew==0 ) return SQLITE_NOMEM;
2638 pNew->flags |= EP_IntValue;
2639 pNew->iTable = i;
2640 pOrderBy = sqlite3ExprListAppend(pParse, pOrderBy, pNew, 0);
2641 nOrderBy++;
2642 }
2643 }
2644 }
2645
2646 /* Compute the comparison permutation and keyinfo that is used with
2647 ** the permutation in order to comparisons to determine if the next
2648 ** row of results comes from selectA or selectB. Also add explicit
2649 ** collations to the ORDER BY clause terms so that when the subqueries
2650 ** to the right and the left are evaluated, they use the correct
2651 ** collation.
2652 */
2653 aPermute = sqlite3DbMallocRaw(db, sizeof(int)*nOrderBy);
2654 if( aPermute ){
2655 for(i=0; i<nOrderBy; i++){
2656 Expr *pTerm = pOrderBy->a[i].pExpr;
2657 assert( pTerm->op==TK_INTEGER );
2658 assert( (pTerm->flags & EP_IntValue)!=0 );
2659 aPermute[i] = pTerm->iTable-1;
2660 assert( aPermute[i]>=0 && aPermute[i]<p->pEList->nExpr );
2661 }
2662 pKeyMerge =
2663 sqlite3DbMallocRaw(db, sizeof(*pKeyMerge)+nOrderBy*(sizeof(CollSeq*)+1));
2664 if( pKeyMerge ){
2665 pKeyMerge->aSortOrder = (u8*)&pKeyMerge->aColl[nOrderBy];
2666 pKeyMerge->nField = nOrderBy;
2667 pKeyMerge->enc = ENC(db);
2668 for(i=0; i<nOrderBy; i++){
2669 CollSeq *pColl;
2670 Expr *pTerm = pOrderBy->a[i].pExpr;
2671 if( pTerm->flags & EP_ExpCollate ){
2672 pColl = pTerm->pColl;
2673 }else{
2674 pColl = multiSelectCollSeq(pParse, p, aPermute[i]);
2675 pTerm->flags |= EP_ExpCollate;
2676 pTerm->pColl = pColl;
2677 }
2678 pKeyMerge->aColl[i] = pColl;
2679 pKeyMerge->aSortOrder[i] = pOrderBy->a[i].sortOrder;
2680 }
2681 }
2682 }else{
2683 pKeyMerge = 0;
2684 }
2685
2686 /* Reattach the ORDER BY clause to the query.
2687 */
2688 p->pOrderBy = pOrderBy;
2689 pPrior->pOrderBy = sqlite3ExprListDup(pParse->db, pOrderBy);
2690
2691 /* Allocate a range of temporary registers and the KeyInfo needed
2692 ** for the logic that removes duplicate result rows when the
2693 ** operator is UNION, EXCEPT, or INTERSECT (but not UNION ALL).
2694 */
2695 if( op==TK_ALL ){
2696 regPrev = 0;
2697 }else{
2698 int nExpr = p->pEList->nExpr;
2699 assert( nOrderBy>=nExpr );
2700 regPrev = sqlite3GetTempRange(pParse, nExpr+1);
2701 sqlite3VdbeAddOp2(v, OP_Integer, 0, regPrev);
2702 pKeyDup = sqlite3DbMallocZero(db,
2703 sizeof(*pKeyDup) + nExpr*(sizeof(CollSeq*)+1) );
2704 if( pKeyDup ){
2705 pKeyDup->aSortOrder = (u8*)&pKeyDup->aColl[nExpr];
2706 pKeyDup->nField = nExpr;
2707 pKeyDup->enc = ENC(db);
2708 for(i=0; i<nExpr; i++){
2709 pKeyDup->aColl[i] = multiSelectCollSeq(pParse, p, i);
2710 pKeyDup->aSortOrder[i] = 0;
2711 }
2712 }
2713 }
drh92b01d52008-06-24 00:32:35 +00002714
2715 /* Separate the left and the right query from one another
2716 */
2717 p->pPrior = 0;
2718 pPrior->pRightmost = 0;
drh0acb7e42008-06-25 00:12:41 +00002719 processOrderGroupBy(pParse, p, p->pOrderBy, 1, &NotUsed);
2720 if( pPrior->pPrior==0 ){
2721 processOrderGroupBy(pParse, pPrior, pPrior->pOrderBy, 1, &NotUsed);
2722 }
2723
drh92b01d52008-06-24 00:32:35 +00002724 /* Compute the limit registers */
2725 computeLimitRegisters(pParse, p, labelEnd);
drh0acb7e42008-06-25 00:12:41 +00002726 if( p->iLimit && op==TK_ALL ){
drh92b01d52008-06-24 00:32:35 +00002727 regLimitA = ++pParse->nMem;
2728 regLimitB = ++pParse->nMem;
2729 sqlite3VdbeAddOp2(v, OP_Copy, p->iOffset ? p->iOffset+1 : p->iLimit,
2730 regLimitA);
2731 sqlite3VdbeAddOp2(v, OP_Copy, regLimitA, regLimitB);
2732 }else{
2733 regLimitA = regLimitB = 0;
2734 }
drh0acb7e42008-06-25 00:12:41 +00002735 sqlite3ExprDelete(p->pLimit);
2736 p->pLimit = 0;
2737 sqlite3ExprDelete(p->pOffset);
2738 p->pOffset = 0;
drh92b01d52008-06-24 00:32:35 +00002739
drhb21e7c72008-06-22 12:37:57 +00002740 regAddrA = ++pParse->nMem;
2741 regEofA = ++pParse->nMem;
2742 regAddrB = ++pParse->nMem;
2743 regEofB = ++pParse->nMem;
2744 regOutA = ++pParse->nMem;
2745 regOutB = ++pParse->nMem;
2746 sqlite3SelectDestInit(&destA, SRT_Coroutine, regAddrA);
2747 sqlite3SelectDestInit(&destB, SRT_Coroutine, regAddrB);
2748
drh92b01d52008-06-24 00:32:35 +00002749 /* Jump past the various subroutines and coroutines to the main
2750 ** merge loop
2751 */
drhb21e7c72008-06-22 12:37:57 +00002752 j1 = sqlite3VdbeAddOp0(v, OP_Goto);
2753 addrSelectA = sqlite3VdbeCurrentAddr(v);
drh92b01d52008-06-24 00:32:35 +00002754
drh0acb7e42008-06-25 00:12:41 +00002755
drh92b01d52008-06-24 00:32:35 +00002756 /* Generate a coroutine to evaluate the SELECT statement to the
drh0acb7e42008-06-25 00:12:41 +00002757 ** left of the compound operator - the "A" select.
2758 */
drhb21e7c72008-06-22 12:37:57 +00002759 VdbeNoopComment((v, "Begin coroutine for left SELECT"));
drh92b01d52008-06-24 00:32:35 +00002760 pPrior->iLimit = regLimitA;
2761 sqlite3Select(pParse, pPrior, &destA, 0, 0, 0, 0);
drhb21e7c72008-06-22 12:37:57 +00002762 sqlite3VdbeAddOp2(v, OP_Integer, 1, regEofA);
drh92b01d52008-06-24 00:32:35 +00002763 sqlite3VdbeAddOp1(v, OP_Yield, regAddrA);
drhb21e7c72008-06-22 12:37:57 +00002764 VdbeNoopComment((v, "End coroutine for left SELECT"));
2765
drh92b01d52008-06-24 00:32:35 +00002766 /* Generate a coroutine to evaluate the SELECT statement on
2767 ** the right - the "B" select
2768 */
drhb21e7c72008-06-22 12:37:57 +00002769 addrSelectB = sqlite3VdbeCurrentAddr(v);
2770 VdbeNoopComment((v, "Begin coroutine for right SELECT"));
drh92b01d52008-06-24 00:32:35 +00002771 savedLimit = p->iLimit;
2772 savedOffset = p->iOffset;
2773 p->iLimit = regLimitB;
2774 p->iOffset = 0;
2775 sqlite3Select(pParse, p, &destB, 0, 0, 0, 0);
2776 p->iLimit = savedLimit;
2777 p->iOffset = savedOffset;
drhb21e7c72008-06-22 12:37:57 +00002778 sqlite3VdbeAddOp2(v, OP_Integer, 1, regEofB);
drh92b01d52008-06-24 00:32:35 +00002779 sqlite3VdbeAddOp1(v, OP_Yield, regAddrB);
drhb21e7c72008-06-22 12:37:57 +00002780 VdbeNoopComment((v, "End coroutine for right SELECT"));
2781
drh92b01d52008-06-24 00:32:35 +00002782 /* Generate a subroutine that outputs the current row of the A
drh0acb7e42008-06-25 00:12:41 +00002783 ** select as the next output row of the compound select.
drh92b01d52008-06-24 00:32:35 +00002784 */
drhb21e7c72008-06-22 12:37:57 +00002785 VdbeNoopComment((v, "Output routine for A"));
drh0acb7e42008-06-25 00:12:41 +00002786 addrOutA = generateOutputSubroutine(pParse,
2787 p, &destA, pDest, regOutA,
2788 regPrev, pKeyDup, P4_KEYINFO_HANDOFF, labelEnd);
drhb21e7c72008-06-22 12:37:57 +00002789
drh92b01d52008-06-24 00:32:35 +00002790 /* Generate a subroutine that outputs the current row of the B
drh0acb7e42008-06-25 00:12:41 +00002791 ** select as the next output row of the compound select.
drh92b01d52008-06-24 00:32:35 +00002792 */
drh0acb7e42008-06-25 00:12:41 +00002793 if( op==TK_ALL || op==TK_UNION ){
2794 VdbeNoopComment((v, "Output routine for B"));
2795 addrOutB = generateOutputSubroutine(pParse,
2796 p, &destB, pDest, regOutB,
2797 regPrev, pKeyDup, P4_KEYINFO_STATIC, labelEnd);
2798 }
drhb21e7c72008-06-22 12:37:57 +00002799
drh92b01d52008-06-24 00:32:35 +00002800 /* Generate a subroutine to run when the results from select A
2801 ** are exhausted and only data in select B remains.
2802 */
2803 VdbeNoopComment((v, "eof-A subroutine"));
drhb21e7c72008-06-22 12:37:57 +00002804 if( op==TK_EXCEPT || op==TK_INTERSECT ){
drh0acb7e42008-06-25 00:12:41 +00002805 addrEofA = sqlite3VdbeAddOp2(v, OP_Goto, 0, labelEnd);
drhb21e7c72008-06-22 12:37:57 +00002806 }else{
drh0acb7e42008-06-25 00:12:41 +00002807 addrEofA = sqlite3VdbeAddOp2(v, OP_If, regEofB, labelEnd);
2808 sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB);
2809 sqlite3VdbeAddOp1(v, OP_Yield, regAddrB);
2810 sqlite3VdbeAddOp2(v, OP_Goto, 0, addrEofA);
drhb21e7c72008-06-22 12:37:57 +00002811 }
2812
drh92b01d52008-06-24 00:32:35 +00002813 /* Generate a subroutine to run when the results from select B
2814 ** are exhausted and only data in select A remains.
2815 */
drhb21e7c72008-06-22 12:37:57 +00002816 if( op==TK_INTERSECT ){
drh92b01d52008-06-24 00:32:35 +00002817 addrEofB = addrEofA;
drhb21e7c72008-06-22 12:37:57 +00002818 }else{
drh92b01d52008-06-24 00:32:35 +00002819 VdbeNoopComment((v, "eof-B subroutine"));
drh0acb7e42008-06-25 00:12:41 +00002820 addrEofB = sqlite3VdbeAddOp2(v, OP_If, regEofA, labelEnd);
2821 sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA);
2822 sqlite3VdbeAddOp1(v, OP_Yield, regAddrA);
2823 sqlite3VdbeAddOp2(v, OP_Goto, 0, addrEofB);
drhb21e7c72008-06-22 12:37:57 +00002824 }
2825
drh92b01d52008-06-24 00:32:35 +00002826 /* Generate code to handle the case of A<B
2827 */
drhb21e7c72008-06-22 12:37:57 +00002828 VdbeNoopComment((v, "A-lt-B subroutine"));
drh0acb7e42008-06-25 00:12:41 +00002829 addrAltB = sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA);
2830 sqlite3VdbeAddOp1(v, OP_Yield, regAddrA);
drhb21e7c72008-06-22 12:37:57 +00002831 sqlite3VdbeAddOp2(v, OP_If, regEofA, addrEofA);
drh92b01d52008-06-24 00:32:35 +00002832 sqlite3VdbeAddOp2(v, OP_Goto, 0, labelCmpr);
drhb21e7c72008-06-22 12:37:57 +00002833
drh92b01d52008-06-24 00:32:35 +00002834 /* Generate code to handle the case of A==B
2835 */
drhb21e7c72008-06-22 12:37:57 +00002836 if( op==TK_ALL ){
2837 addrAeqB = addrAltB;
drh0acb7e42008-06-25 00:12:41 +00002838 }else if( op==TK_INTERSECT ){
2839 addrAeqB = addrAltB;
2840 addrAltB++;
drh92b01d52008-06-24 00:32:35 +00002841 }else{
drhb21e7c72008-06-22 12:37:57 +00002842 VdbeNoopComment((v, "A-eq-B subroutine"));
drh0acb7e42008-06-25 00:12:41 +00002843 addrAeqB =
2844 sqlite3VdbeAddOp1(v, OP_Yield, regAddrA);
2845 sqlite3VdbeAddOp2(v, OP_If, regEofA, addrEofA);
2846 sqlite3VdbeAddOp2(v, OP_Goto, 0, labelCmpr);
drhb21e7c72008-06-22 12:37:57 +00002847 }
2848
drh92b01d52008-06-24 00:32:35 +00002849 /* Generate code to handle the case of A>B
2850 */
drhb21e7c72008-06-22 12:37:57 +00002851 VdbeNoopComment((v, "A-gt-B subroutine"));
2852 addrAgtB = sqlite3VdbeCurrentAddr(v);
2853 if( op==TK_ALL || op==TK_UNION ){
2854 sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB);
2855 }
drh0acb7e42008-06-25 00:12:41 +00002856 sqlite3VdbeAddOp1(v, OP_Yield, regAddrB);
drhb21e7c72008-06-22 12:37:57 +00002857 sqlite3VdbeAddOp2(v, OP_If, regEofB, addrEofB);
drh92b01d52008-06-24 00:32:35 +00002858 sqlite3VdbeAddOp2(v, OP_Goto, 0, labelCmpr);
drhb21e7c72008-06-22 12:37:57 +00002859
drh92b01d52008-06-24 00:32:35 +00002860 /* This code runs once to initialize everything.
2861 */
drhb21e7c72008-06-22 12:37:57 +00002862 sqlite3VdbeJumpHere(v, j1);
2863 sqlite3VdbeAddOp2(v, OP_Integer, 0, regEofA);
2864 sqlite3VdbeAddOp2(v, OP_Integer, 0, regEofB);
drh92b01d52008-06-24 00:32:35 +00002865 sqlite3VdbeAddOp2(v, OP_Gosub, regAddrA, addrSelectA);
drh0acb7e42008-06-25 00:12:41 +00002866 sqlite3VdbeAddOp2(v, OP_Gosub, regAddrB, addrSelectB);
drhb21e7c72008-06-22 12:37:57 +00002867 sqlite3VdbeAddOp2(v, OP_If, regEofA, addrEofA);
drhb21e7c72008-06-22 12:37:57 +00002868 sqlite3VdbeAddOp2(v, OP_If, regEofB, addrEofB);
drh92b01d52008-06-24 00:32:35 +00002869
2870 /* Implement the main merge loop
2871 */
2872 sqlite3VdbeResolveLabel(v, labelCmpr);
drh0acb7e42008-06-25 00:12:41 +00002873 sqlite3VdbeAddOp4(v, OP_Permutation, 0, 0, 0, (char*)aPermute, P4_INTARRAY);
2874 sqlite3VdbeAddOp4(v, OP_Compare, destA.iMem, destB.iMem, nOrderBy,
2875 (char*)pKeyMerge, P4_KEYINFO_HANDOFF);
drhb21e7c72008-06-22 12:37:57 +00002876 sqlite3VdbeAddOp3(v, OP_Jump, addrAltB, addrAeqB, addrAgtB);
drh92b01d52008-06-24 00:32:35 +00002877
drh0acb7e42008-06-25 00:12:41 +00002878 /* Release temporary registers
2879 */
2880 if( regPrev ){
2881 sqlite3ReleaseTempRange(pParse, regPrev, nOrderBy+1);
2882 }
2883
drh92b01d52008-06-24 00:32:35 +00002884 /* Jump to the this point in order to terminate the query.
2885 */
drhb21e7c72008-06-22 12:37:57 +00002886 sqlite3VdbeResolveLabel(v, labelEnd);
drh92b01d52008-06-24 00:32:35 +00002887
2888 /* Set the number of output columns
2889 */
2890 if( pDest->eDest==SRT_Callback ){
drh0acb7e42008-06-25 00:12:41 +00002891 Select *pFirst = pPrior;
drh92b01d52008-06-24 00:32:35 +00002892 while( pFirst->pPrior ) pFirst = pFirst->pPrior;
2893 generateColumnNames(pParse, 0, pFirst->pEList);
2894 }
2895
drh0acb7e42008-06-25 00:12:41 +00002896 /* Reassembly the compound query so that it will be freed correctly
2897 ** by the calling function */
2898 p->pPrior = pPrior;
drh92b01d52008-06-24 00:32:35 +00002899
drh92b01d52008-06-24 00:32:35 +00002900 /*** TBD: Insert subroutine calls to close cursors on incomplete
2901 **** subqueries ****/
2902 return SQLITE_OK;
drhb21e7c72008-06-22 12:37:57 +00002903}
drhb21e7c72008-06-22 12:37:57 +00002904
drhb7f91642004-10-31 02:22:47 +00002905#ifndef SQLITE_OMIT_VIEW
drh17435752007-08-16 04:30:38 +00002906/* Forward Declarations */
2907static void substExprList(sqlite3*, ExprList*, int, ExprList*);
2908static void substSelect(sqlite3*, Select *, int, ExprList *);
2909
drh22827922000-06-06 17:27:05 +00002910/*
drh832508b2002-03-02 17:04:07 +00002911** Scan through the expression pExpr. Replace every reference to
drh6a3ea0e2003-05-02 14:32:12 +00002912** a column in table number iTable with a copy of the iColumn-th
drh84e59202002-03-14 14:33:31 +00002913** entry in pEList. (But leave references to the ROWID column
drh6a3ea0e2003-05-02 14:32:12 +00002914** unchanged.)
drh832508b2002-03-02 17:04:07 +00002915**
2916** This routine is part of the flattening procedure. A subquery
2917** whose result set is defined by pEList appears as entry in the
2918** FROM clause of a SELECT such that the VDBE cursor assigned to that
2919** FORM clause entry is iTable. This routine make the necessary
2920** changes to pExpr so that it refers directly to the source table
2921** of the subquery rather the result set of the subquery.
2922*/
drh17435752007-08-16 04:30:38 +00002923static void substExpr(
2924 sqlite3 *db, /* Report malloc errors to this connection */
2925 Expr *pExpr, /* Expr in which substitution occurs */
2926 int iTable, /* Table to be substituted */
2927 ExprList *pEList /* Substitute expressions */
2928){
drh832508b2002-03-02 17:04:07 +00002929 if( pExpr==0 ) return;
drh50350a12004-02-13 16:22:22 +00002930 if( pExpr->op==TK_COLUMN && pExpr->iTable==iTable ){
2931 if( pExpr->iColumn<0 ){
2932 pExpr->op = TK_NULL;
2933 }else{
2934 Expr *pNew;
2935 assert( pEList!=0 && pExpr->iColumn<pEList->nExpr );
2936 assert( pExpr->pLeft==0 && pExpr->pRight==0 && pExpr->pList==0 );
2937 pNew = pEList->a[pExpr->iColumn].pExpr;
2938 assert( pNew!=0 );
2939 pExpr->op = pNew->op;
drh50350a12004-02-13 16:22:22 +00002940 assert( pExpr->pLeft==0 );
drh17435752007-08-16 04:30:38 +00002941 pExpr->pLeft = sqlite3ExprDup(db, pNew->pLeft);
drh50350a12004-02-13 16:22:22 +00002942 assert( pExpr->pRight==0 );
drh17435752007-08-16 04:30:38 +00002943 pExpr->pRight = sqlite3ExprDup(db, pNew->pRight);
drh50350a12004-02-13 16:22:22 +00002944 assert( pExpr->pList==0 );
drh17435752007-08-16 04:30:38 +00002945 pExpr->pList = sqlite3ExprListDup(db, pNew->pList);
drh50350a12004-02-13 16:22:22 +00002946 pExpr->iTable = pNew->iTable;
danielk1977fbbe0052006-06-21 07:02:33 +00002947 pExpr->pTab = pNew->pTab;
drh50350a12004-02-13 16:22:22 +00002948 pExpr->iColumn = pNew->iColumn;
2949 pExpr->iAgg = pNew->iAgg;
drh17435752007-08-16 04:30:38 +00002950 sqlite3TokenCopy(db, &pExpr->token, &pNew->token);
2951 sqlite3TokenCopy(db, &pExpr->span, &pNew->span);
2952 pExpr->pSelect = sqlite3SelectDup(db, pNew->pSelect);
danielk1977a1cb1832005-02-12 08:59:55 +00002953 pExpr->flags = pNew->flags;
drh50350a12004-02-13 16:22:22 +00002954 }
drh832508b2002-03-02 17:04:07 +00002955 }else{
drh17435752007-08-16 04:30:38 +00002956 substExpr(db, pExpr->pLeft, iTable, pEList);
2957 substExpr(db, pExpr->pRight, iTable, pEList);
2958 substSelect(db, pExpr->pSelect, iTable, pEList);
2959 substExprList(db, pExpr->pList, iTable, pEList);
drh832508b2002-03-02 17:04:07 +00002960 }
2961}
drh17435752007-08-16 04:30:38 +00002962static void substExprList(
2963 sqlite3 *db, /* Report malloc errors here */
2964 ExprList *pList, /* List to scan and in which to make substitutes */
2965 int iTable, /* Table to be substituted */
2966 ExprList *pEList /* Substitute values */
2967){
drh832508b2002-03-02 17:04:07 +00002968 int i;
2969 if( pList==0 ) return;
2970 for(i=0; i<pList->nExpr; i++){
drh17435752007-08-16 04:30:38 +00002971 substExpr(db, pList->a[i].pExpr, iTable, pEList);
drh832508b2002-03-02 17:04:07 +00002972 }
2973}
drh17435752007-08-16 04:30:38 +00002974static void substSelect(
2975 sqlite3 *db, /* Report malloc errors here */
2976 Select *p, /* SELECT statement in which to make substitutions */
2977 int iTable, /* Table to be replaced */
2978 ExprList *pEList /* Substitute values */
2979){
danielk1977b3bce662005-01-29 08:32:43 +00002980 if( !p ) return;
drh17435752007-08-16 04:30:38 +00002981 substExprList(db, p->pEList, iTable, pEList);
2982 substExprList(db, p->pGroupBy, iTable, pEList);
2983 substExprList(db, p->pOrderBy, iTable, pEList);
2984 substExpr(db, p->pHaving, iTable, pEList);
2985 substExpr(db, p->pWhere, iTable, pEList);
2986 substSelect(db, p->pPrior, iTable, pEList);
danielk1977b3bce662005-01-29 08:32:43 +00002987}
drhb7f91642004-10-31 02:22:47 +00002988#endif /* !defined(SQLITE_OMIT_VIEW) */
drh832508b2002-03-02 17:04:07 +00002989
drhb7f91642004-10-31 02:22:47 +00002990#ifndef SQLITE_OMIT_VIEW
drh832508b2002-03-02 17:04:07 +00002991/*
drh1350b032002-02-27 19:00:20 +00002992** This routine attempts to flatten subqueries in order to speed
2993** execution. It returns 1 if it makes changes and 0 if no flattening
2994** occurs.
2995**
2996** To understand the concept of flattening, consider the following
2997** query:
2998**
2999** SELECT a FROM (SELECT x+y AS a FROM t1 WHERE z<100) WHERE a>5
3000**
3001** The default way of implementing this query is to execute the
3002** subquery first and store the results in a temporary table, then
3003** run the outer query on that temporary table. This requires two
3004** passes over the data. Furthermore, because the temporary table
3005** has no indices, the WHERE clause on the outer query cannot be
drh832508b2002-03-02 17:04:07 +00003006** optimized.
drh1350b032002-02-27 19:00:20 +00003007**
drh832508b2002-03-02 17:04:07 +00003008** This routine attempts to rewrite queries such as the above into
drh1350b032002-02-27 19:00:20 +00003009** a single flat select, like this:
3010**
3011** SELECT x+y AS a FROM t1 WHERE z<100 AND a>5
3012**
3013** The code generated for this simpification gives the same result
drh832508b2002-03-02 17:04:07 +00003014** but only has to scan the data once. And because indices might
3015** exist on the table t1, a complete scan of the data might be
3016** avoided.
drh1350b032002-02-27 19:00:20 +00003017**
drh832508b2002-03-02 17:04:07 +00003018** Flattening is only attempted if all of the following are true:
drh1350b032002-02-27 19:00:20 +00003019**
drh832508b2002-03-02 17:04:07 +00003020** (1) The subquery and the outer query do not both use aggregates.
drh1350b032002-02-27 19:00:20 +00003021**
drh832508b2002-03-02 17:04:07 +00003022** (2) The subquery is not an aggregate or the outer query is not a join.
3023**
drh8af4d3a2003-05-06 20:35:16 +00003024** (3) The subquery is not the right operand of a left outer join, or
3025** the subquery is not itself a join. (Ticket #306)
drh832508b2002-03-02 17:04:07 +00003026**
3027** (4) The subquery is not DISTINCT or the outer query is not a join.
3028**
3029** (5) The subquery is not DISTINCT or the outer query does not use
3030** aggregates.
3031**
3032** (6) The subquery does not use aggregates or the outer query is not
3033** DISTINCT.
3034**
drh08192d52002-04-30 19:20:28 +00003035** (7) The subquery has a FROM clause.
3036**
drhdf199a22002-06-14 22:38:41 +00003037** (8) The subquery does not use LIMIT or the outer query is not a join.
3038**
3039** (9) The subquery does not use LIMIT or the outer query does not use
3040** aggregates.
3041**
3042** (10) The subquery does not use aggregates or the outer query does not
3043** use LIMIT.
3044**
drh174b6192002-12-03 02:22:52 +00003045** (11) The subquery and the outer query do not both have ORDER BY clauses.
3046**
drh3fc673e2003-06-16 00:40:34 +00003047** (12) The subquery is not the right term of a LEFT OUTER JOIN or the
3048** subquery has no WHERE clause. (added by ticket #350)
3049**
drhac839632006-01-21 22:19:54 +00003050** (13) The subquery and outer query do not both use LIMIT
3051**
3052** (14) The subquery does not use OFFSET
3053**
drhad91c6c2007-05-06 20:04:24 +00003054** (15) The outer query is not part of a compound select or the
3055** subquery does not have both an ORDER BY and a LIMIT clause.
3056** (See ticket #2339)
3057**
drhc52e3552008-02-15 14:33:03 +00003058** (16) The outer query is not an aggregate or the subquery does
3059** not contain ORDER BY. (Ticket #2942) This used to not matter
3060** until we introduced the group_concat() function.
3061**
drh832508b2002-03-02 17:04:07 +00003062** In this routine, the "p" parameter is a pointer to the outer query.
3063** The subquery is p->pSrc->a[iFrom]. isAgg is true if the outer query
3064** uses aggregates and subqueryIsAgg is true if the subquery uses aggregates.
3065**
drh665de472003-03-31 13:36:09 +00003066** If flattening is not attempted, this routine is a no-op and returns 0.
drh832508b2002-03-02 17:04:07 +00003067** If flattening is attempted this routine returns 1.
3068**
3069** All of the expression analysis must occur on both the outer query and
3070** the subquery before this routine runs.
drh1350b032002-02-27 19:00:20 +00003071*/
drh8c74a8c2002-08-25 19:20:40 +00003072static int flattenSubquery(
drh17435752007-08-16 04:30:38 +00003073 sqlite3 *db, /* Database connection */
drh8c74a8c2002-08-25 19:20:40 +00003074 Select *p, /* The parent or outer SELECT statement */
3075 int iFrom, /* Index in p->pSrc->a[] of the inner subquery */
3076 int isAgg, /* True if outer SELECT uses aggregate functions */
3077 int subqueryIsAgg /* True if the subquery uses aggregate functions */
3078){
drh0bb28102002-05-08 11:54:14 +00003079 Select *pSub; /* The inner query or "subquery" */
drhad3cab52002-05-24 02:04:32 +00003080 SrcList *pSrc; /* The FROM clause of the outer query */
3081 SrcList *pSubSrc; /* The FROM clause of the subquery */
drh0bb28102002-05-08 11:54:14 +00003082 ExprList *pList; /* The result set of the outer query */
drh6a3ea0e2003-05-02 14:32:12 +00003083 int iParent; /* VDBE cursor number of the pSub result set temp table */
drh91bb0ee2004-09-01 03:06:34 +00003084 int i; /* Loop counter */
3085 Expr *pWhere; /* The WHERE clause */
3086 struct SrcList_item *pSubitem; /* The subquery */
drh1350b032002-02-27 19:00:20 +00003087
drh832508b2002-03-02 17:04:07 +00003088 /* Check to see if flattening is permitted. Return 0 if not.
3089 */
3090 if( p==0 ) return 0;
3091 pSrc = p->pSrc;
drhad3cab52002-05-24 02:04:32 +00003092 assert( pSrc && iFrom>=0 && iFrom<pSrc->nSrc );
drh91bb0ee2004-09-01 03:06:34 +00003093 pSubitem = &pSrc->a[iFrom];
3094 pSub = pSubitem->pSelect;
drh832508b2002-03-02 17:04:07 +00003095 assert( pSub!=0 );
drhac839632006-01-21 22:19:54 +00003096 if( isAgg && subqueryIsAgg ) return 0; /* Restriction (1) */
3097 if( subqueryIsAgg && pSrc->nSrc>1 ) return 0; /* Restriction (2) */
drh832508b2002-03-02 17:04:07 +00003098 pSubSrc = pSub->pSrc;
3099 assert( pSubSrc );
drhac839632006-01-21 22:19:54 +00003100 /* Prior to version 3.1.2, when LIMIT and OFFSET had to be simple constants,
3101 ** not arbitrary expresssions, we allowed some combining of LIMIT and OFFSET
3102 ** because they could be computed at compile-time. But when LIMIT and OFFSET
3103 ** became arbitrary expressions, we were forced to add restrictions (13)
3104 ** and (14). */
3105 if( pSub->pLimit && p->pLimit ) return 0; /* Restriction (13) */
3106 if( pSub->pOffset ) return 0; /* Restriction (14) */
drhad91c6c2007-05-06 20:04:24 +00003107 if( p->pRightmost && pSub->pLimit && pSub->pOrderBy ){
3108 return 0; /* Restriction (15) */
3109 }
drhac839632006-01-21 22:19:54 +00003110 if( pSubSrc->nSrc==0 ) return 0; /* Restriction (7) */
3111 if( (pSub->isDistinct || pSub->pLimit)
3112 && (pSrc->nSrc>1 || isAgg) ){ /* Restrictions (4)(5)(8)(9) */
3113 return 0;
drhdf199a22002-06-14 22:38:41 +00003114 }
drhac839632006-01-21 22:19:54 +00003115 if( p->isDistinct && subqueryIsAgg ) return 0; /* Restriction (6) */
3116 if( (p->disallowOrderBy || p->pOrderBy) && pSub->pOrderBy ){
3117 return 0; /* Restriction (11) */
3118 }
drhc52e3552008-02-15 14:33:03 +00003119 if( isAgg && pSub->pOrderBy ) return 0; /* Restriction (16) */
drh832508b2002-03-02 17:04:07 +00003120
drh8af4d3a2003-05-06 20:35:16 +00003121 /* Restriction 3: If the subquery is a join, make sure the subquery is
3122 ** not used as the right operand of an outer join. Examples of why this
3123 ** is not allowed:
3124 **
3125 ** t1 LEFT OUTER JOIN (t2 JOIN t3)
3126 **
3127 ** If we flatten the above, we would get
3128 **
3129 ** (t1 LEFT OUTER JOIN t2) JOIN t3
3130 **
3131 ** which is not at all the same thing.
3132 */
drh61dfc312006-12-16 16:25:15 +00003133 if( pSubSrc->nSrc>1 && (pSubitem->jointype & JT_OUTER)!=0 ){
drh8af4d3a2003-05-06 20:35:16 +00003134 return 0;
3135 }
3136
drh3fc673e2003-06-16 00:40:34 +00003137 /* Restriction 12: If the subquery is the right operand of a left outer
3138 ** join, make sure the subquery has no WHERE clause.
3139 ** An examples of why this is not allowed:
3140 **
3141 ** t1 LEFT OUTER JOIN (SELECT * FROM t2 WHERE t2.x>0)
3142 **
3143 ** If we flatten the above, we would get
3144 **
3145 ** (t1 LEFT OUTER JOIN t2) WHERE t2.x>0
3146 **
3147 ** But the t2.x>0 test will always fail on a NULL row of t2, which
3148 ** effectively converts the OUTER JOIN into an INNER JOIN.
3149 */
drh61dfc312006-12-16 16:25:15 +00003150 if( (pSubitem->jointype & JT_OUTER)!=0 && pSub->pWhere!=0 ){
drh3fc673e2003-06-16 00:40:34 +00003151 return 0;
3152 }
3153
drh0bb28102002-05-08 11:54:14 +00003154 /* If we reach this point, it means flattening is permitted for the
drh63eb5f22003-04-29 16:20:44 +00003155 ** iFrom-th entry of the FROM clause in the outer query.
drh832508b2002-03-02 17:04:07 +00003156 */
drhc31c2eb2003-05-02 16:04:17 +00003157
3158 /* Move all of the FROM elements of the subquery into the
3159 ** the FROM clause of the outer query. Before doing this, remember
3160 ** the cursor number for the original outer query FROM element in
3161 ** iParent. The iParent cursor will never be used. Subsequent code
3162 ** will scan expressions looking for iParent references and replace
3163 ** those references with expressions that resolve to the subquery FROM
3164 ** elements we are now copying in.
3165 */
drh91bb0ee2004-09-01 03:06:34 +00003166 iParent = pSubitem->iCursor;
drhc31c2eb2003-05-02 16:04:17 +00003167 {
3168 int nSubSrc = pSubSrc->nSrc;
drh91bb0ee2004-09-01 03:06:34 +00003169 int jointype = pSubitem->jointype;
drhc31c2eb2003-05-02 16:04:17 +00003170
danielk1977a04a34f2007-04-16 15:06:25 +00003171 sqlite3DeleteTable(pSubitem->pTab);
drh17435752007-08-16 04:30:38 +00003172 sqlite3_free(pSubitem->zDatabase);
3173 sqlite3_free(pSubitem->zName);
3174 sqlite3_free(pSubitem->zAlias);
drhcfa063b2007-11-21 15:24:00 +00003175 pSubitem->pTab = 0;
3176 pSubitem->zDatabase = 0;
3177 pSubitem->zName = 0;
3178 pSubitem->zAlias = 0;
drhc31c2eb2003-05-02 16:04:17 +00003179 if( nSubSrc>1 ){
3180 int extra = nSubSrc - 1;
3181 for(i=1; i<nSubSrc; i++){
drh17435752007-08-16 04:30:38 +00003182 pSrc = sqlite3SrcListAppend(db, pSrc, 0, 0);
drhcfa063b2007-11-21 15:24:00 +00003183 if( pSrc==0 ){
3184 p->pSrc = 0;
3185 return 1;
3186 }
drhc31c2eb2003-05-02 16:04:17 +00003187 }
3188 p->pSrc = pSrc;
3189 for(i=pSrc->nSrc-1; i-extra>=iFrom; i--){
3190 pSrc->a[i] = pSrc->a[i-extra];
3191 }
3192 }
3193 for(i=0; i<nSubSrc; i++){
3194 pSrc->a[i+iFrom] = pSubSrc->a[i];
3195 memset(&pSubSrc->a[i], 0, sizeof(pSubSrc->a[i]));
3196 }
drh61dfc312006-12-16 16:25:15 +00003197 pSrc->a[iFrom].jointype = jointype;
drhc31c2eb2003-05-02 16:04:17 +00003198 }
3199
3200 /* Now begin substituting subquery result set expressions for
3201 ** references to the iParent in the outer query.
3202 **
3203 ** Example:
3204 **
3205 ** SELECT a+5, b*10 FROM (SELECT x*3 AS a, y+10 AS b FROM t1) WHERE a>b;
3206 ** \ \_____________ subquery __________/ /
3207 ** \_____________________ outer query ______________________________/
3208 **
3209 ** We look at every expression in the outer query and every place we see
3210 ** "a" we substitute "x*3" and every place we see "b" we substitute "y+10".
3211 */
drh832508b2002-03-02 17:04:07 +00003212 pList = p->pEList;
3213 for(i=0; i<pList->nExpr; i++){
drh6977fea2002-10-22 23:38:04 +00003214 Expr *pExpr;
3215 if( pList->a[i].zName==0 && (pExpr = pList->a[i].pExpr)->span.z!=0 ){
drh17435752007-08-16 04:30:38 +00003216 pList->a[i].zName =
3217 sqlite3DbStrNDup(db, (char*)pExpr->span.z, pExpr->span.n);
drh832508b2002-03-02 17:04:07 +00003218 }
3219 }
danielk19771e536952007-08-16 10:09:01 +00003220 substExprList(db, p->pEList, iParent, pSub->pEList);
drh1b2e0322002-03-03 02:49:51 +00003221 if( isAgg ){
danielk19771e536952007-08-16 10:09:01 +00003222 substExprList(db, p->pGroupBy, iParent, pSub->pEList);
3223 substExpr(db, p->pHaving, iParent, pSub->pEList);
drh1b2e0322002-03-03 02:49:51 +00003224 }
drh174b6192002-12-03 02:22:52 +00003225 if( pSub->pOrderBy ){
3226 assert( p->pOrderBy==0 );
3227 p->pOrderBy = pSub->pOrderBy;
3228 pSub->pOrderBy = 0;
drh174b6192002-12-03 02:22:52 +00003229 }else if( p->pOrderBy ){
danielk19771e536952007-08-16 10:09:01 +00003230 substExprList(db, p->pOrderBy, iParent, pSub->pEList);
drh174b6192002-12-03 02:22:52 +00003231 }
drh832508b2002-03-02 17:04:07 +00003232 if( pSub->pWhere ){
drh17435752007-08-16 04:30:38 +00003233 pWhere = sqlite3ExprDup(db, pSub->pWhere);
drh832508b2002-03-02 17:04:07 +00003234 }else{
3235 pWhere = 0;
3236 }
3237 if( subqueryIsAgg ){
3238 assert( p->pHaving==0 );
drh1b2e0322002-03-03 02:49:51 +00003239 p->pHaving = p->pWhere;
3240 p->pWhere = pWhere;
danielk19771e536952007-08-16 10:09:01 +00003241 substExpr(db, p->pHaving, iParent, pSub->pEList);
drh17435752007-08-16 04:30:38 +00003242 p->pHaving = sqlite3ExprAnd(db, p->pHaving,
3243 sqlite3ExprDup(db, pSub->pHaving));
drh1b2e0322002-03-03 02:49:51 +00003244 assert( p->pGroupBy==0 );
drh17435752007-08-16 04:30:38 +00003245 p->pGroupBy = sqlite3ExprListDup(db, pSub->pGroupBy);
drh832508b2002-03-02 17:04:07 +00003246 }else{
danielk19771e536952007-08-16 10:09:01 +00003247 substExpr(db, p->pWhere, iParent, pSub->pEList);
drh17435752007-08-16 04:30:38 +00003248 p->pWhere = sqlite3ExprAnd(db, p->pWhere, pWhere);
drh832508b2002-03-02 17:04:07 +00003249 }
drhc31c2eb2003-05-02 16:04:17 +00003250
3251 /* The flattened query is distinct if either the inner or the
3252 ** outer query is distinct.
3253 */
drh832508b2002-03-02 17:04:07 +00003254 p->isDistinct = p->isDistinct || pSub->isDistinct;
drh8c74a8c2002-08-25 19:20:40 +00003255
danielk1977a58fdfb2005-02-08 07:50:40 +00003256 /*
3257 ** SELECT ... FROM (SELECT ... LIMIT a OFFSET b) LIMIT x OFFSET y;
drhac839632006-01-21 22:19:54 +00003258 **
3259 ** One is tempted to try to add a and b to combine the limits. But this
3260 ** does not work if either limit is negative.
danielk1977a58fdfb2005-02-08 07:50:40 +00003261 */
danielk1977a2dc3b12005-02-05 12:48:48 +00003262 if( pSub->pLimit ){
3263 p->pLimit = pSub->pLimit;
3264 pSub->pLimit = 0;
drhdf199a22002-06-14 22:38:41 +00003265 }
drh8c74a8c2002-08-25 19:20:40 +00003266
drhc31c2eb2003-05-02 16:04:17 +00003267 /* Finially, delete what is left of the subquery and return
3268 ** success.
3269 */
danielk19774adee202004-05-08 08:23:19 +00003270 sqlite3SelectDelete(pSub);
drh832508b2002-03-02 17:04:07 +00003271 return 1;
3272}
drhb7f91642004-10-31 02:22:47 +00003273#endif /* SQLITE_OMIT_VIEW */
drh1350b032002-02-27 19:00:20 +00003274
3275/*
danielk1977a9d1ccb2008-01-05 17:39:29 +00003276** Analyze the SELECT statement passed as an argument to see if it
drh08c88eb2008-04-10 13:33:18 +00003277** is a min() or max() query. Return WHERE_ORDERBY_MIN or WHERE_ORDERBY_MAX if
danielk1977a9d1ccb2008-01-05 17:39:29 +00003278** it is, or 0 otherwise. At present, a query is considered to be
3279** a min()/max() query if:
3280**
danielk1977738bdcf2008-01-07 10:16:40 +00003281** 1. There is a single object in the FROM clause.
3282**
3283** 2. There is a single expression in the result set, and it is
3284** either min(x) or max(x), where x is a column reference.
danielk1977a9d1ccb2008-01-05 17:39:29 +00003285*/
3286static int minMaxQuery(Parse *pParse, Select *p){
3287 Expr *pExpr;
3288 ExprList *pEList = p->pEList;
3289
drh08c88eb2008-04-10 13:33:18 +00003290 if( pEList->nExpr!=1 ) return WHERE_ORDERBY_NORMAL;
danielk1977a9d1ccb2008-01-05 17:39:29 +00003291 pExpr = pEList->a[0].pExpr;
3292 pEList = pExpr->pList;
3293 if( pExpr->op!=TK_AGG_FUNCTION || pEList==0 || pEList->nExpr!=1 ) return 0;
drh08c88eb2008-04-10 13:33:18 +00003294 if( pEList->a[0].pExpr->op!=TK_AGG_COLUMN ) return WHERE_ORDERBY_NORMAL;
3295 if( pExpr->token.n!=3 ) return WHERE_ORDERBY_NORMAL;
danielk1977a9d1ccb2008-01-05 17:39:29 +00003296 if( sqlite3StrNICmp((char*)pExpr->token.z,"min",3)==0 ){
drh08c88eb2008-04-10 13:33:18 +00003297 return WHERE_ORDERBY_MIN;
danielk1977a9d1ccb2008-01-05 17:39:29 +00003298 }else if( sqlite3StrNICmp((char*)pExpr->token.z,"max",3)==0 ){
drh08c88eb2008-04-10 13:33:18 +00003299 return WHERE_ORDERBY_MAX;
danielk1977a9d1ccb2008-01-05 17:39:29 +00003300 }
drh08c88eb2008-04-10 13:33:18 +00003301 return WHERE_ORDERBY_NORMAL;
danielk1977a9d1ccb2008-01-05 17:39:29 +00003302}
3303
3304/*
danielk1977b3bce662005-01-29 08:32:43 +00003305** This routine resolves any names used in the result set of the
3306** supplied SELECT statement. If the SELECT statement being resolved
3307** is a sub-select, then pOuterNC is a pointer to the NameContext
3308** of the parent SELECT.
3309*/
3310int sqlite3SelectResolve(
3311 Parse *pParse, /* The parser context */
3312 Select *p, /* The SELECT statement being coded. */
3313 NameContext *pOuterNC /* The outer name context. May be NULL. */
3314){
3315 ExprList *pEList; /* Result set. */
3316 int i; /* For-loop variable used in multiple places */
3317 NameContext sNC; /* Local name-context */
drh13449892005-09-07 21:22:45 +00003318 ExprList *pGroupBy; /* The group by clause */
danielk1977b3bce662005-01-29 08:32:43 +00003319
3320 /* If this routine has run before, return immediately. */
3321 if( p->isResolved ){
3322 assert( !pOuterNC );
3323 return SQLITE_OK;
3324 }
3325 p->isResolved = 1;
3326
3327 /* If there have already been errors, do nothing. */
3328 if( pParse->nErr>0 ){
3329 return SQLITE_ERROR;
3330 }
3331
3332 /* Prepare the select statement. This call will allocate all cursors
3333 ** required to handle the tables and subqueries in the FROM clause.
3334 */
3335 if( prepSelectStmt(pParse, p) ){
3336 return SQLITE_ERROR;
3337 }
3338
danielk1977a2dc3b12005-02-05 12:48:48 +00003339 /* Resolve the expressions in the LIMIT and OFFSET clauses. These
3340 ** are not allowed to refer to any names, so pass an empty NameContext.
3341 */
drhffe07b22005-11-03 00:41:17 +00003342 memset(&sNC, 0, sizeof(sNC));
danielk1977b3bce662005-01-29 08:32:43 +00003343 sNC.pParse = pParse;
danielk1977a2dc3b12005-02-05 12:48:48 +00003344 if( sqlite3ExprResolveNames(&sNC, p->pLimit) ||
3345 sqlite3ExprResolveNames(&sNC, p->pOffset) ){
3346 return SQLITE_ERROR;
3347 }
3348
3349 /* Set up the local name-context to pass to ExprResolveNames() to
3350 ** resolve the expression-list.
3351 */
3352 sNC.allowAgg = 1;
3353 sNC.pSrcList = p->pSrc;
3354 sNC.pNext = pOuterNC;
danielk1977b3bce662005-01-29 08:32:43 +00003355
danielk1977b3bce662005-01-29 08:32:43 +00003356 /* Resolve names in the result set. */
3357 pEList = p->pEList;
3358 if( !pEList ) return SQLITE_ERROR;
3359 for(i=0; i<pEList->nExpr; i++){
3360 Expr *pX = pEList->a[i].pExpr;
3361 if( sqlite3ExprResolveNames(&sNC, pX) ){
3362 return SQLITE_ERROR;
3363 }
3364 }
3365
3366 /* If there are no aggregate functions in the result-set, and no GROUP BY
3367 ** expression, do not allow aggregates in any of the other expressions.
3368 */
3369 assert( !p->isAgg );
drh13449892005-09-07 21:22:45 +00003370 pGroupBy = p->pGroupBy;
3371 if( pGroupBy || sNC.hasAgg ){
danielk1977b3bce662005-01-29 08:32:43 +00003372 p->isAgg = 1;
3373 }else{
3374 sNC.allowAgg = 0;
3375 }
3376
3377 /* If a HAVING clause is present, then there must be a GROUP BY clause.
3378 */
drh13449892005-09-07 21:22:45 +00003379 if( p->pHaving && !pGroupBy ){
danielk1977b3bce662005-01-29 08:32:43 +00003380 sqlite3ErrorMsg(pParse, "a GROUP BY clause is required before HAVING");
3381 return SQLITE_ERROR;
3382 }
3383
3384 /* Add the expression list to the name-context before parsing the
3385 ** other expressions in the SELECT statement. This is so that
3386 ** expressions in the WHERE clause (etc.) can refer to expressions by
3387 ** aliases in the result set.
3388 **
3389 ** Minor point: If this is the case, then the expression will be
3390 ** re-evaluated for each reference to it.
3391 */
3392 sNC.pEList = p->pEList;
3393 if( sqlite3ExprResolveNames(&sNC, p->pWhere) ||
drh994c80a2007-04-12 21:25:01 +00003394 sqlite3ExprResolveNames(&sNC, p->pHaving) ){
danielk1977b3bce662005-01-29 08:32:43 +00003395 return SQLITE_ERROR;
3396 }
drh9a993342007-12-13 02:45:31 +00003397 if( p->pPrior==0 ){
danielk197701874bf2007-12-13 07:58:50 +00003398 if( processOrderGroupBy(pParse, p, p->pOrderBy, 1, &sNC.hasAgg) ){
drh9a993342007-12-13 02:45:31 +00003399 return SQLITE_ERROR;
3400 }
drh4c774312007-12-08 21:10:20 +00003401 }
drh9a993342007-12-13 02:45:31 +00003402 if( processOrderGroupBy(pParse, p, pGroupBy, 0, &sNC.hasAgg) ){
drh4c774312007-12-08 21:10:20 +00003403 return SQLITE_ERROR;
drh994c80a2007-04-12 21:25:01 +00003404 }
danielk1977b3bce662005-01-29 08:32:43 +00003405
danielk19771e536952007-08-16 10:09:01 +00003406 if( pParse->db->mallocFailed ){
danielk19779afe6892007-05-31 08:20:43 +00003407 return SQLITE_NOMEM;
3408 }
3409
drh13449892005-09-07 21:22:45 +00003410 /* Make sure the GROUP BY clause does not contain aggregate functions.
3411 */
3412 if( pGroupBy ){
3413 struct ExprList_item *pItem;
3414
3415 for(i=0, pItem=pGroupBy->a; i<pGroupBy->nExpr; i++, pItem++){
3416 if( ExprHasProperty(pItem->pExpr, EP_Agg) ){
3417 sqlite3ErrorMsg(pParse, "aggregate functions are not allowed in "
3418 "the GROUP BY clause");
3419 return SQLITE_ERROR;
3420 }
3421 }
3422 }
3423
drhf6bbe022006-10-13 15:34:16 +00003424 /* If this is one SELECT of a compound, be sure to resolve names
3425 ** in the other SELECTs.
3426 */
3427 if( p->pPrior ){
3428 return sqlite3SelectResolve(pParse, p->pPrior, pOuterNC);
3429 }else{
3430 return SQLITE_OK;
3431 }
danielk1977b3bce662005-01-29 08:32:43 +00003432}
3433
3434/*
drh13449892005-09-07 21:22:45 +00003435** Reset the aggregate accumulator.
3436**
3437** The aggregate accumulator is a set of memory cells that hold
3438** intermediate results while calculating an aggregate. This
3439** routine simply stores NULLs in all of those memory cells.
danielk1977b3bce662005-01-29 08:32:43 +00003440*/
drh13449892005-09-07 21:22:45 +00003441static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){
3442 Vdbe *v = pParse->pVdbe;
3443 int i;
drhc99130f2005-09-11 11:56:27 +00003444 struct AggInfo_func *pFunc;
drh13449892005-09-07 21:22:45 +00003445 if( pAggInfo->nFunc+pAggInfo->nColumn==0 ){
3446 return;
3447 }
drh13449892005-09-07 21:22:45 +00003448 for(i=0; i<pAggInfo->nColumn; i++){
drh4c583122008-01-04 22:01:03 +00003449 sqlite3VdbeAddOp2(v, OP_Null, 0, pAggInfo->aCol[i].iMem);
drh13449892005-09-07 21:22:45 +00003450 }
drhc99130f2005-09-11 11:56:27 +00003451 for(pFunc=pAggInfo->aFunc, i=0; i<pAggInfo->nFunc; i++, pFunc++){
drh4c583122008-01-04 22:01:03 +00003452 sqlite3VdbeAddOp2(v, OP_Null, 0, pFunc->iMem);
drhc99130f2005-09-11 11:56:27 +00003453 if( pFunc->iDistinct>=0 ){
3454 Expr *pE = pFunc->pExpr;
3455 if( pE->pList==0 || pE->pList->nExpr!=1 ){
3456 sqlite3ErrorMsg(pParse, "DISTINCT in aggregate must be followed "
3457 "by an expression");
3458 pFunc->iDistinct = -1;
3459 }else{
3460 KeyInfo *pKeyInfo = keyInfoFromExprList(pParse, pE->pList);
drh66a51672008-01-03 00:01:23 +00003461 sqlite3VdbeAddOp4(v, OP_OpenEphemeral, pFunc->iDistinct, 0, 0,
3462 (char*)pKeyInfo, P4_KEYINFO_HANDOFF);
drhc99130f2005-09-11 11:56:27 +00003463 }
3464 }
drh13449892005-09-07 21:22:45 +00003465 }
danielk1977b3bce662005-01-29 08:32:43 +00003466}
3467
3468/*
drh13449892005-09-07 21:22:45 +00003469** Invoke the OP_AggFinalize opcode for every aggregate function
3470** in the AggInfo structure.
danielk1977b3bce662005-01-29 08:32:43 +00003471*/
drh13449892005-09-07 21:22:45 +00003472static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){
3473 Vdbe *v = pParse->pVdbe;
3474 int i;
3475 struct AggInfo_func *pF;
3476 for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
drha10a34b2005-09-07 22:09:48 +00003477 ExprList *pList = pF->pExpr->pList;
drh66a51672008-01-03 00:01:23 +00003478 sqlite3VdbeAddOp4(v, OP_AggFinal, pF->iMem, pList ? pList->nExpr : 0, 0,
3479 (void*)pF->pFunc, P4_FUNCDEF);
drh13449892005-09-07 21:22:45 +00003480 }
danielk1977b3bce662005-01-29 08:32:43 +00003481}
drh13449892005-09-07 21:22:45 +00003482
3483/*
3484** Update the accumulator memory cells for an aggregate based on
3485** the current cursor position.
3486*/
3487static void updateAccumulator(Parse *pParse, AggInfo *pAggInfo){
3488 Vdbe *v = pParse->pVdbe;
3489 int i;
3490 struct AggInfo_func *pF;
3491 struct AggInfo_col *pC;
drh13449892005-09-07 21:22:45 +00003492
3493 pAggInfo->directMode = 1;
3494 for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
3495 int nArg;
drhc99130f2005-09-11 11:56:27 +00003496 int addrNext = 0;
drh98757152008-01-09 23:04:12 +00003497 int regAgg;
drh13449892005-09-07 21:22:45 +00003498 ExprList *pList = pF->pExpr->pList;
3499 if( pList ){
3500 nArg = pList->nExpr;
drh892d3172008-01-10 03:46:36 +00003501 regAgg = sqlite3GetTempRange(pParse, nArg);
drh191b54c2008-04-15 12:14:21 +00003502 sqlite3ExprCodeExprList(pParse, pList, regAgg, 0);
drh13449892005-09-07 21:22:45 +00003503 }else{
3504 nArg = 0;
drh98757152008-01-09 23:04:12 +00003505 regAgg = 0;
drh13449892005-09-07 21:22:45 +00003506 }
drhc99130f2005-09-11 11:56:27 +00003507 if( pF->iDistinct>=0 ){
3508 addrNext = sqlite3VdbeMakeLabel(v);
3509 assert( nArg==1 );
drh2dcef112008-01-12 19:03:48 +00003510 codeDistinct(pParse, pF->iDistinct, addrNext, 1, regAgg);
drhc99130f2005-09-11 11:56:27 +00003511 }
drh13449892005-09-07 21:22:45 +00003512 if( pF->pFunc->needCollSeq ){
3513 CollSeq *pColl = 0;
3514 struct ExprList_item *pItem;
3515 int j;
drh43617e92006-03-06 20:55:46 +00003516 assert( pList!=0 ); /* pList!=0 if pF->pFunc->needCollSeq is true */
3517 for(j=0, pItem=pList->a; !pColl && j<nArg; j++, pItem++){
drh13449892005-09-07 21:22:45 +00003518 pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
3519 }
3520 if( !pColl ){
3521 pColl = pParse->db->pDfltColl;
3522 }
drh66a51672008-01-03 00:01:23 +00003523 sqlite3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ);
drh13449892005-09-07 21:22:45 +00003524 }
drh98757152008-01-09 23:04:12 +00003525 sqlite3VdbeAddOp4(v, OP_AggStep, 0, regAgg, pF->iMem,
drh66a51672008-01-03 00:01:23 +00003526 (void*)pF->pFunc, P4_FUNCDEF);
drh98757152008-01-09 23:04:12 +00003527 sqlite3VdbeChangeP5(v, nArg);
drh892d3172008-01-10 03:46:36 +00003528 sqlite3ReleaseTempRange(pParse, regAgg, nArg);
drhda250ea2008-04-01 05:07:14 +00003529 sqlite3ExprCacheAffinityChange(pParse, regAgg, nArg);
drhc99130f2005-09-11 11:56:27 +00003530 if( addrNext ){
3531 sqlite3VdbeResolveLabel(v, addrNext);
3532 }
drh13449892005-09-07 21:22:45 +00003533 }
drh13449892005-09-07 21:22:45 +00003534 for(i=0, pC=pAggInfo->aCol; i<pAggInfo->nAccumulator; i++, pC++){
drh389a1ad2008-01-03 23:44:53 +00003535 sqlite3ExprCode(pParse, pC->pExpr, pC->iMem);
drh13449892005-09-07 21:22:45 +00003536 }
3537 pAggInfo->directMode = 0;
3538}
3539
drhe265b082008-05-01 17:03:49 +00003540#if 0
danielk19778f2c54e2008-01-01 19:02:09 +00003541/*
3542** This function is used when a SELECT statement is used to create a
3543** temporary table for iterating through when running an INSTEAD OF
3544** UPDATE or INSTEAD OF DELETE trigger.
3545**
3546** If possible, the SELECT statement is modified so that NULL values
3547** are stored in the temporary table for all columns for which the
3548** corresponding bit in argument mask is not set. If mask takes the
3549** special value 0xffffffff, then all columns are populated.
3550*/
drhd2b3e232008-01-23 14:51:49 +00003551void sqlite3SelectMask(Parse *pParse, Select *p, u32 mask){
danielk1977cdf30202008-01-24 14:27:44 +00003552 if( p && !p->pPrior && !p->isDistinct && mask!=0xffffffff ){
danielk19778f2c54e2008-01-01 19:02:09 +00003553 ExprList *pEList;
3554 int i;
drhd2b3e232008-01-23 14:51:49 +00003555 sqlite3SelectResolve(pParse, p, 0);
danielk19778f2c54e2008-01-01 19:02:09 +00003556 pEList = p->pEList;
danielk1977cdf30202008-01-24 14:27:44 +00003557 for(i=0; pEList && i<pEList->nExpr && i<32; i++){
danielk19778f2c54e2008-01-01 19:02:09 +00003558 if( !(mask&((u32)1<<i)) ){
3559 sqlite3ExprDelete(pEList->a[i].pExpr);
3560 pEList->a[i].pExpr = sqlite3Expr(pParse->db, TK_NULL, 0, 0, 0);
3561 }
3562 }
3563 }
danielk19778f2c54e2008-01-01 19:02:09 +00003564}
3565#endif
drh13449892005-09-07 21:22:45 +00003566
danielk1977b3bce662005-01-29 08:32:43 +00003567/*
drh9bb61fe2000-06-05 16:01:39 +00003568** Generate code for the given SELECT statement.
3569**
drhfef52082000-06-06 01:50:43 +00003570** The results are distributed in various ways depending on the
danielk19776c8c8ce2008-01-02 16:27:09 +00003571** contents of the SelectDest structure pointed to by argument pDest
3572** as follows:
drhfef52082000-06-06 01:50:43 +00003573**
danielk19776c8c8ce2008-01-02 16:27:09 +00003574** pDest->eDest Result
drhfef52082000-06-06 01:50:43 +00003575** ------------ -------------------------------------------
3576** SRT_Callback Invoke the callback for each row of the result.
3577**
danielk19776c8c8ce2008-01-02 16:27:09 +00003578** SRT_Mem Store first result in memory cell pDest->iParm
drhfef52082000-06-06 01:50:43 +00003579**
danielk19776c8c8ce2008-01-02 16:27:09 +00003580** SRT_Set Store non-null results as keys of table pDest->iParm.
3581** Apply the affinity pDest->affinity before storing them.
drhfef52082000-06-06 01:50:43 +00003582**
danielk19776c8c8ce2008-01-02 16:27:09 +00003583** SRT_Union Store results as a key in a temporary table pDest->iParm.
drh82c3d632000-06-06 21:56:07 +00003584**
danielk19776c8c8ce2008-01-02 16:27:09 +00003585** SRT_Except Remove results from the temporary table pDest->iParm.
drhc4a3c772001-04-04 11:48:57 +00003586**
danielk19776c8c8ce2008-01-02 16:27:09 +00003587** SRT_Table Store results in temporary table pDest->iParm
drh9bb61fe2000-06-05 16:01:39 +00003588**
danielk19776c8c8ce2008-01-02 16:27:09 +00003589** SRT_EphemTab Create an temporary table pDest->iParm and store
3590** the result there. The cursor is left open after
3591** returning.
3592**
drhe00ee6e2008-06-20 15:24:01 +00003593** SRT_Coroutine Invoke a co-routine to compute a single row of
3594** the result
danielk19776c8c8ce2008-01-02 16:27:09 +00003595**
3596** SRT_Exists Store a 1 in memory cell pDest->iParm if the result
3597** set is not empty.
3598**
3599** SRT_Discard Throw the results away.
3600**
3601** See the selectInnerLoop() function for a canonical listing of the
3602** allowed values of eDest and their meanings.
drhe78e8282003-01-19 03:59:45 +00003603**
drh9bb61fe2000-06-05 16:01:39 +00003604** This routine returns the number of errors. If any errors are
3605** encountered, then an appropriate error message is left in
3606** pParse->zErrMsg.
3607**
3608** This routine does NOT free the Select structure passed in. The
3609** calling function needs to do that.
drh1b2e0322002-03-03 02:49:51 +00003610**
3611** The pParent, parentTab, and *pParentAgg fields are filled in if this
3612** SELECT is a subquery. This routine may try to combine this SELECT
3613** with its parent to form a single flat query. In so doing, it might
3614** change the parent query from a non-aggregate to an aggregate query.
3615** For that reason, the pParentAgg flag is passed as a pointer, so it
3616** can be changed.
drhe78e8282003-01-19 03:59:45 +00003617**
3618** Example 1: The meaning of the pParent parameter.
3619**
3620** SELECT * FROM t1 JOIN (SELECT x, count(*) FROM t2) JOIN t3;
3621** \ \_______ subquery _______/ /
3622** \ /
3623** \____________________ outer query ___________________/
3624**
3625** This routine is called for the outer query first. For that call,
3626** pParent will be NULL. During the processing of the outer query, this
3627** routine is called recursively to handle the subquery. For the recursive
3628** call, pParent will point to the outer query. Because the subquery is
3629** the second element in a three-way join, the parentTab parameter will
3630** be 1 (the 2nd value of a 0-indexed array.)
drh9bb61fe2000-06-05 16:01:39 +00003631*/
danielk19774adee202004-05-08 08:23:19 +00003632int sqlite3Select(
drhcce7d172000-05-31 15:34:51 +00003633 Parse *pParse, /* The parser context */
drh9bb61fe2000-06-05 16:01:39 +00003634 Select *p, /* The SELECT statement being coded. */
danielk19776c8c8ce2008-01-02 16:27:09 +00003635 SelectDest *pDest, /* What to do with the query results */
drh832508b2002-03-02 17:04:07 +00003636 Select *pParent, /* Another SELECT for which this is a sub-query */
3637 int parentTab, /* Index in pParent->pSrc of this query */
danielk197784ac9d02004-05-18 09:58:06 +00003638 int *pParentAgg, /* True if pParent uses aggregate functions */
danielk1977b3bce662005-01-29 08:32:43 +00003639 char *aff /* If eDest is SRT_Union, the affinity string */
drhcce7d172000-05-31 15:34:51 +00003640){
drh13449892005-09-07 21:22:45 +00003641 int i, j; /* Loop counters */
3642 WhereInfo *pWInfo; /* Return from sqlite3WhereBegin() */
3643 Vdbe *v; /* The virtual machine under construction */
danielk1977b3bce662005-01-29 08:32:43 +00003644 int isAgg; /* True for select lists like "count(*)" */
drha2e00042002-01-22 03:13:42 +00003645 ExprList *pEList; /* List of columns to extract. */
drhad3cab52002-05-24 02:04:32 +00003646 SrcList *pTabList; /* List of tables to select from */
drh9bb61fe2000-06-05 16:01:39 +00003647 Expr *pWhere; /* The WHERE clause. May be NULL */
3648 ExprList *pOrderBy; /* The ORDER BY clause. May be NULL */
drh22827922000-06-06 17:27:05 +00003649 ExprList *pGroupBy; /* The GROUP BY clause. May be NULL */
3650 Expr *pHaving; /* The HAVING clause. May be NULL */
drh19a775c2000-06-05 18:54:46 +00003651 int isDistinct; /* True if the DISTINCT keyword is present */
3652 int distinct; /* Table to use for the distinct set */
drh1d83f052002-02-17 00:30:36 +00003653 int rc = 1; /* Value to return from this function */
drhb9bb7c12006-06-11 23:41:55 +00003654 int addrSortIndex; /* Address of an OP_OpenEphemeral instruction */
drh13449892005-09-07 21:22:45 +00003655 AggInfo sAggInfo; /* Information used by aggregate queries */
drhec7429a2005-10-06 16:53:14 +00003656 int iEnd; /* Address of the end of the query */
drh17435752007-08-16 04:30:38 +00003657 sqlite3 *db; /* The database connection */
drh9bb61fe2000-06-05 16:01:39 +00003658
drh17435752007-08-16 04:30:38 +00003659 db = pParse->db;
3660 if( p==0 || db->mallocFailed || pParse->nErr ){
drh6f7adc82006-01-11 21:41:20 +00003661 return 1;
3662 }
danielk19774adee202004-05-08 08:23:19 +00003663 if( sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1;
drh13449892005-09-07 21:22:45 +00003664 memset(&sAggInfo, 0, sizeof(sAggInfo));
drhdaffd0e2001-04-11 14:28:42 +00003665
drh9a993342007-12-13 02:45:31 +00003666 pOrderBy = p->pOrderBy;
danielk19776c8c8ce2008-01-02 16:27:09 +00003667 if( IgnorableOrderby(pDest) ){
drh9a993342007-12-13 02:45:31 +00003668 p->pOrderBy = 0;
danielk19779ed1dfa2008-01-02 17:11:14 +00003669
3670 /* In these cases the DISTINCT operator makes no difference to the
3671 ** results, so remove it if it were specified.
3672 */
3673 assert(pDest->eDest==SRT_Exists || pDest->eDest==SRT_Union ||
3674 pDest->eDest==SRT_Except || pDest->eDest==SRT_Discard);
3675 p->isDistinct = 0;
drh9a993342007-12-13 02:45:31 +00003676 }
3677 if( sqlite3SelectResolve(pParse, p, 0) ){
3678 goto select_end;
3679 }
3680 p->pOrderBy = pOrderBy;
3681
drhb7f91642004-10-31 02:22:47 +00003682#ifndef SQLITE_OMIT_COMPOUND_SELECT
drh82c3d632000-06-06 21:56:07 +00003683 /* If there is are a sequence of queries, do the earlier ones first.
3684 */
3685 if( p->pPrior ){
drh0342b1f2005-09-01 03:07:44 +00003686 if( p->pRightmost==0 ){
drh1e281292007-12-13 03:45:07 +00003687 Select *pLoop, *pRight = 0;
drh0325d872007-06-07 10:55:35 +00003688 int cnt = 0;
drhbb4957f2008-03-20 14:03:29 +00003689 int mxSelect;
drh0325d872007-06-07 10:55:35 +00003690 for(pLoop=p; pLoop; pLoop=pLoop->pPrior, cnt++){
drh0342b1f2005-09-01 03:07:44 +00003691 pLoop->pRightmost = p;
drh1e281292007-12-13 03:45:07 +00003692 pLoop->pNext = pRight;
3693 pRight = pLoop;
drh0342b1f2005-09-01 03:07:44 +00003694 }
drhbb4957f2008-03-20 14:03:29 +00003695 mxSelect = db->aLimit[SQLITE_LIMIT_COMPOUND_SELECT];
3696 if( mxSelect && cnt>mxSelect ){
drh0325d872007-06-07 10:55:35 +00003697 sqlite3ErrorMsg(pParse, "too many terms in compound SELECT");
3698 return 1;
3699 }
drh0342b1f2005-09-01 03:07:44 +00003700 }
danielk19776c8c8ce2008-01-02 16:27:09 +00003701 return multiSelect(pParse, p, pDest, aff);
drh82c3d632000-06-06 21:56:07 +00003702 }
drhb7f91642004-10-31 02:22:47 +00003703#endif
drh82c3d632000-06-06 21:56:07 +00003704
3705 /* Make local copies of the parameters for this query.
3706 */
drh9bb61fe2000-06-05 16:01:39 +00003707 pTabList = p->pSrc;
3708 pWhere = p->pWhere;
drh22827922000-06-06 17:27:05 +00003709 pGroupBy = p->pGroupBy;
3710 pHaving = p->pHaving;
danielk1977b3bce662005-01-29 08:32:43 +00003711 isAgg = p->isAgg;
drh19a775c2000-06-05 18:54:46 +00003712 isDistinct = p->isDistinct;
danielk1977b3bce662005-01-29 08:32:43 +00003713 pEList = p->pEList;
3714 if( pEList==0 ) goto select_end;
drh9bb61fe2000-06-05 16:01:39 +00003715
3716 /*
3717 ** Do not even attempt to generate any code if we have already seen
3718 ** errors before this routine starts.
3719 */
drh1d83f052002-02-17 00:30:36 +00003720 if( pParse->nErr>0 ) goto select_end;
drhcce7d172000-05-31 15:34:51 +00003721
drh22827922000-06-06 17:27:05 +00003722 /* If writing to memory or generating a set
3723 ** only a single column may be output.
drh19a775c2000-06-05 18:54:46 +00003724 */
danielk197793758c82005-01-21 08:13:14 +00003725#ifndef SQLITE_OMIT_SUBQUERY
danielk19776c8c8ce2008-01-02 16:27:09 +00003726 if( checkForMultiColumnSelectError(pParse, pDest, pEList->nExpr) ){
drh1d83f052002-02-17 00:30:36 +00003727 goto select_end;
drh19a775c2000-06-05 18:54:46 +00003728 }
danielk197793758c82005-01-21 08:13:14 +00003729#endif
drh19a775c2000-06-05 18:54:46 +00003730
drhc926afb2002-06-20 03:38:26 +00003731 /* ORDER BY is ignored for some destinations.
drh22827922000-06-06 17:27:05 +00003732 */
danielk19776c8c8ce2008-01-02 16:27:09 +00003733 if( IgnorableOrderby(pDest) ){
drh13449892005-09-07 21:22:45 +00003734 pOrderBy = 0;
drh22827922000-06-06 17:27:05 +00003735 }
3736
drhd820cb12002-02-18 03:21:45 +00003737 /* Begin generating code.
3738 */
danielk19774adee202004-05-08 08:23:19 +00003739 v = sqlite3GetVdbe(pParse);
drhd820cb12002-02-18 03:21:45 +00003740 if( v==0 ) goto select_end;
3741
3742 /* Generate code for all sub-queries in the FROM clause
3743 */
drh51522cd2005-01-20 13:36:19 +00003744#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
drhad3cab52002-05-24 02:04:32 +00003745 for(i=0; i<pTabList->nSrc; i++){
danielk1977742f9472004-06-16 12:02:43 +00003746 const char *zSavedAuthContext = 0;
drhc31c2eb2003-05-02 16:04:17 +00003747 int needRestoreContext;
drh13449892005-09-07 21:22:45 +00003748 struct SrcList_item *pItem = &pTabList->a[i];
drh1013c932008-01-06 00:25:21 +00003749 SelectDest dest;
drhc31c2eb2003-05-02 16:04:17 +00003750
danielk19771787cca2006-02-10 07:07:14 +00003751 if( pItem->pSelect==0 || pItem->isPopulated ) continue;
drh13449892005-09-07 21:22:45 +00003752 if( pItem->zName!=0 ){
drh5cf590c2003-04-24 01:45:04 +00003753 zSavedAuthContext = pParse->zAuthContext;
drh13449892005-09-07 21:22:45 +00003754 pParse->zAuthContext = pItem->zName;
drhc31c2eb2003-05-02 16:04:17 +00003755 needRestoreContext = 1;
3756 }else{
3757 needRestoreContext = 0;
drh5cf590c2003-04-24 01:45:04 +00003758 }
danielk1977fc976062007-05-10 10:46:56 +00003759 /* Increment Parse.nHeight by the height of the largest expression
3760 ** tree refered to by this, the parent select. The child select
3761 ** may contain expression trees of at most
3762 ** (SQLITE_MAX_EXPR_DEPTH-Parse.nHeight) height. This is a bit
3763 ** more conservative than necessary, but much easier than enforcing
3764 ** an exact limit.
3765 */
3766 pParse->nHeight += sqlite3SelectExprHeight(p);
drh1013c932008-01-06 00:25:21 +00003767 sqlite3SelectDestInit(&dest, SRT_EphemTab, pItem->iCursor);
danielk19776c8c8ce2008-01-02 16:27:09 +00003768 sqlite3Select(pParse, pItem->pSelect, &dest, p, i, &isAgg, 0);
drhcfa063b2007-11-21 15:24:00 +00003769 if( db->mallocFailed ){
3770 goto select_end;
3771 }
danielk1977fc976062007-05-10 10:46:56 +00003772 pParse->nHeight -= sqlite3SelectExprHeight(p);
drhc31c2eb2003-05-02 16:04:17 +00003773 if( needRestoreContext ){
drh5cf590c2003-04-24 01:45:04 +00003774 pParse->zAuthContext = zSavedAuthContext;
3775 }
drh1b2e0322002-03-03 02:49:51 +00003776 pTabList = p->pSrc;
3777 pWhere = p->pWhere;
danielk19776c8c8ce2008-01-02 16:27:09 +00003778 if( !IgnorableOrderby(pDest) ){
drhacd4c692002-03-07 02:02:51 +00003779 pOrderBy = p->pOrderBy;
3780 }
drh1b2e0322002-03-03 02:49:51 +00003781 pGroupBy = p->pGroupBy;
3782 pHaving = p->pHaving;
3783 isDistinct = p->isDistinct;
drhd820cb12002-02-18 03:21:45 +00003784 }
drh51522cd2005-01-20 13:36:19 +00003785#endif
drhd820cb12002-02-18 03:21:45 +00003786
drh832508b2002-03-02 17:04:07 +00003787 /* Check to see if this is a subquery that can be "flattened" into its parent.
3788 ** If flattening is a possiblity, do so and return immediately.
3789 */
drhb7f91642004-10-31 02:22:47 +00003790#ifndef SQLITE_OMIT_VIEW
drh1b2e0322002-03-03 02:49:51 +00003791 if( pParent && pParentAgg &&
drh17435752007-08-16 04:30:38 +00003792 flattenSubquery(db, pParent, parentTab, *pParentAgg, isAgg) ){
drh1b2e0322002-03-03 02:49:51 +00003793 if( isAgg ) *pParentAgg = 1;
danielk1977b3bce662005-01-29 08:32:43 +00003794 goto select_end;
drh832508b2002-03-02 17:04:07 +00003795 }
drhb7f91642004-10-31 02:22:47 +00003796#endif
drh832508b2002-03-02 17:04:07 +00003797
danielk19770318d442007-11-12 15:40:41 +00003798 /* If possible, rewrite the query to use GROUP BY instead of DISTINCT.
3799 ** GROUP BY may use an index, DISTINCT never does.
danielk19773c4809a2007-11-12 15:29:18 +00003800 */
3801 if( p->isDistinct && !p->isAgg && !p->pGroupBy ){
3802 p->pGroupBy = sqlite3ExprListDup(db, p->pEList);
3803 pGroupBy = p->pGroupBy;
3804 p->isDistinct = 0;
3805 isDistinct = 0;
3806 }
3807
drh8b4c40d2007-02-01 23:02:45 +00003808 /* If there is an ORDER BY clause, then this sorting
3809 ** index might end up being unused if the data can be
drh9d2985c2005-09-08 01:58:42 +00003810 ** extracted in pre-sorted order. If that is the case, then the
drhb9bb7c12006-06-11 23:41:55 +00003811 ** OP_OpenEphemeral instruction will be changed to an OP_Noop once
drh9d2985c2005-09-08 01:58:42 +00003812 ** we figure out that the sorting index is not needed. The addrSortIndex
3813 ** variable is used to facilitate that change.
danielk19777cedc8d2004-06-10 10:50:08 +00003814 */
3815 if( pOrderBy ){
drh0342b1f2005-09-01 03:07:44 +00003816 KeyInfo *pKeyInfo;
drh0342b1f2005-09-01 03:07:44 +00003817 pKeyInfo = keyInfoFromExprList(pParse, pOrderBy);
drh9d2985c2005-09-08 01:58:42 +00003818 pOrderBy->iECursor = pParse->nTab++;
drhb9bb7c12006-06-11 23:41:55 +00003819 p->addrOpenEphm[2] = addrSortIndex =
drh66a51672008-01-03 00:01:23 +00003820 sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
3821 pOrderBy->iECursor, pOrderBy->nExpr+2, 0,
3822 (char*)pKeyInfo, P4_KEYINFO_HANDOFF);
drh9d2985c2005-09-08 01:58:42 +00003823 }else{
3824 addrSortIndex = -1;
danielk19777cedc8d2004-06-10 10:50:08 +00003825 }
3826
drh2d0794e2002-03-03 03:03:52 +00003827 /* If the output is destined for a temporary table, open that table.
3828 */
danielk19776c8c8ce2008-01-02 16:27:09 +00003829 if( pDest->eDest==SRT_EphemTab ){
drh66a51672008-01-03 00:01:23 +00003830 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pDest->iParm, pEList->nExpr);
drh2d0794e2002-03-03 03:03:52 +00003831 }
3832
drhf42bacc2006-04-26 17:39:34 +00003833 /* Set the limiter.
3834 */
3835 iEnd = sqlite3VdbeMakeLabel(v);
3836 computeLimitRegisters(pParse, p, iEnd);
3837
drhdece1a82005-08-31 18:20:00 +00003838 /* Open a virtual index to use for the distinct set.
drhefb72512000-05-31 20:00:52 +00003839 */
drh19a775c2000-06-05 18:54:46 +00003840 if( isDistinct ){
drh0342b1f2005-09-01 03:07:44 +00003841 KeyInfo *pKeyInfo;
danielk19773c4809a2007-11-12 15:29:18 +00003842 assert( isAgg || pGroupBy );
drh832508b2002-03-02 17:04:07 +00003843 distinct = pParse->nTab++;
drh0342b1f2005-09-01 03:07:44 +00003844 pKeyInfo = keyInfoFromExprList(pParse, p->pEList);
drh66a51672008-01-03 00:01:23 +00003845 sqlite3VdbeAddOp4(v, OP_OpenEphemeral, distinct, 0, 0,
3846 (char*)pKeyInfo, P4_KEYINFO_HANDOFF);
drh832508b2002-03-02 17:04:07 +00003847 }else{
3848 distinct = -1;
drhefb72512000-05-31 20:00:52 +00003849 }
drh832508b2002-03-02 17:04:07 +00003850
drh13449892005-09-07 21:22:45 +00003851 /* Aggregate and non-aggregate queries are handled differently */
3852 if( !isAgg && pGroupBy==0 ){
3853 /* This case is for non-aggregate queries
3854 ** Begin the database scan
3855 */
danielk1977a9d1ccb2008-01-05 17:39:29 +00003856 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, &pOrderBy, 0);
drh13449892005-09-07 21:22:45 +00003857 if( pWInfo==0 ) goto select_end;
drhcce7d172000-05-31 15:34:51 +00003858
drhb9bb7c12006-06-11 23:41:55 +00003859 /* If sorting index that was created by a prior OP_OpenEphemeral
3860 ** instruction ended up not being needed, then change the OP_OpenEphemeral
drh9d2985c2005-09-08 01:58:42 +00003861 ** into an OP_Noop.
3862 */
3863 if( addrSortIndex>=0 && pOrderBy==0 ){
drhf8875402006-03-17 13:56:34 +00003864 sqlite3VdbeChangeToNoop(v, addrSortIndex, 1);
drhb9bb7c12006-06-11 23:41:55 +00003865 p->addrOpenEphm[2] = -1;
drh9d2985c2005-09-08 01:58:42 +00003866 }
3867
drh13449892005-09-07 21:22:45 +00003868 /* Use the standard inner loop
3869 */
danielk19773c4809a2007-11-12 15:29:18 +00003870 assert(!isDistinct);
drhd2b3e232008-01-23 14:51:49 +00003871 selectInnerLoop(pParse, p, pEList, 0, 0, pOrderBy, -1, pDest,
3872 pWInfo->iContinue, pWInfo->iBreak, aff);
drhefb72512000-05-31 20:00:52 +00003873
drh13449892005-09-07 21:22:45 +00003874 /* End the database scan loop.
3875 */
3876 sqlite3WhereEnd(pWInfo);
3877 }else{
3878 /* This is the processing for aggregate queries */
3879 NameContext sNC; /* Name context for processing aggregate information */
3880 int iAMem; /* First Mem address for storing current GROUP BY */
3881 int iBMem; /* First Mem address for previous GROUP BY */
3882 int iUseFlag; /* Mem address holding flag indicating that at least
3883 ** one row of the input to the aggregator has been
3884 ** processed */
3885 int iAbortFlag; /* Mem address which causes query abort if positive */
3886 int groupBySort; /* Rows come from source in GROUP BY order */
drhcce7d172000-05-31 15:34:51 +00003887
drhcce7d172000-05-31 15:34:51 +00003888
drh13449892005-09-07 21:22:45 +00003889 /* The following variables hold addresses or labels for parts of the
3890 ** virtual machine program we are putting together */
3891 int addrOutputRow; /* Start of subroutine that outputs a result row */
drh16ee60f2008-06-20 18:13:25 +00003892 int regOutputRow; /* Return address register for output subroutine */
drh13449892005-09-07 21:22:45 +00003893 int addrSetAbort; /* Set the abort flag and return */
3894 int addrInitializeLoop; /* Start of code that initializes the input loop */
3895 int addrTopOfLoop; /* Top of the input loop */
drh13449892005-09-07 21:22:45 +00003896 int addrEnd; /* End of all processing */
drhb9bb7c12006-06-11 23:41:55 +00003897 int addrSortingIdx; /* The OP_OpenEphemeral for the sorting index */
drhe3133822005-09-20 13:11:59 +00003898 int addrReset; /* Subroutine for resetting the accumulator */
drh2eb95372008-06-06 15:04:36 +00003899 int regReset; /* Return address register for reset subroutine */
drh13449892005-09-07 21:22:45 +00003900
3901 addrEnd = sqlite3VdbeMakeLabel(v);
3902
3903 /* Convert TK_COLUMN nodes into TK_AGG_COLUMN and make entries in
3904 ** sAggInfo for all TK_AGG_FUNCTION nodes in expressions of the
3905 ** SELECT statement.
3906 */
3907 memset(&sNC, 0, sizeof(sNC));
3908 sNC.pParse = pParse;
3909 sNC.pSrcList = pTabList;
3910 sNC.pAggInfo = &sAggInfo;
3911 sAggInfo.nSortingColumn = pGroupBy ? pGroupBy->nExpr+1 : 0;
drh9d2985c2005-09-08 01:58:42 +00003912 sAggInfo.pGroupBy = pGroupBy;
drhd2b3e232008-01-23 14:51:49 +00003913 sqlite3ExprAnalyzeAggList(&sNC, pEList);
3914 sqlite3ExprAnalyzeAggList(&sNC, pOrderBy);
3915 if( pHaving ){
3916 sqlite3ExprAnalyzeAggregates(&sNC, pHaving);
drh13449892005-09-07 21:22:45 +00003917 }
3918 sAggInfo.nAccumulator = sAggInfo.nColumn;
3919 for(i=0; i<sAggInfo.nFunc; i++){
drhd2b3e232008-01-23 14:51:49 +00003920 sqlite3ExprAnalyzeAggList(&sNC, sAggInfo.aFunc[i].pExpr->pList);
drh13449892005-09-07 21:22:45 +00003921 }
drh17435752007-08-16 04:30:38 +00003922 if( db->mallocFailed ) goto select_end;
drh13449892005-09-07 21:22:45 +00003923
3924 /* Processing for aggregates with GROUP BY is very different and
danielk19773c4809a2007-11-12 15:29:18 +00003925 ** much more complex than aggregates without a GROUP BY.
drh13449892005-09-07 21:22:45 +00003926 */
3927 if( pGroupBy ){
3928 KeyInfo *pKeyInfo; /* Keying information for the group by clause */
drh16ee60f2008-06-20 18:13:25 +00003929 int j1;
drh13449892005-09-07 21:22:45 +00003930
3931 /* Create labels that we will be needing
3932 */
drh13449892005-09-07 21:22:45 +00003933 addrInitializeLoop = sqlite3VdbeMakeLabel(v);
drh13449892005-09-07 21:22:45 +00003934
3935 /* If there is a GROUP BY clause we might need a sorting index to
3936 ** implement it. Allocate that sorting index now. If it turns out
drhb9bb7c12006-06-11 23:41:55 +00003937 ** that we do not need it after all, the OpenEphemeral instruction
drh13449892005-09-07 21:22:45 +00003938 ** will be converted into a Noop.
3939 */
3940 sAggInfo.sortingIdx = pParse->nTab++;
3941 pKeyInfo = keyInfoFromExprList(pParse, pGroupBy);
danielk1977cd3e8f72008-03-25 09:47:35 +00003942 addrSortingIdx = sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
3943 sAggInfo.sortingIdx, sAggInfo.nSortingColumn,
3944 0, (char*)pKeyInfo, P4_KEYINFO_HANDOFF);
drh13449892005-09-07 21:22:45 +00003945
3946 /* Initialize memory locations used by GROUP BY aggregate processing
3947 */
drh0a07c102008-01-03 18:03:08 +00003948 iUseFlag = ++pParse->nMem;
3949 iAbortFlag = ++pParse->nMem;
3950 iAMem = pParse->nMem + 1;
drh13449892005-09-07 21:22:45 +00003951 pParse->nMem += pGroupBy->nExpr;
drh0a07c102008-01-03 18:03:08 +00003952 iBMem = pParse->nMem + 1;
drh13449892005-09-07 21:22:45 +00003953 pParse->nMem += pGroupBy->nExpr;
drh4c583122008-01-04 22:01:03 +00003954 sqlite3VdbeAddOp2(v, OP_Integer, 0, iAbortFlag);
drhd4e70eb2008-01-02 00:34:36 +00003955 VdbeComment((v, "clear abort flag"));
drh4c583122008-01-04 22:01:03 +00003956 sqlite3VdbeAddOp2(v, OP_Integer, 0, iUseFlag);
drhd4e70eb2008-01-02 00:34:36 +00003957 VdbeComment((v, "indicate accumulator empty"));
drh66a51672008-01-03 00:01:23 +00003958 sqlite3VdbeAddOp2(v, OP_Goto, 0, addrInitializeLoop);
drh13449892005-09-07 21:22:45 +00003959
3960 /* Generate a subroutine that outputs a single row of the result
3961 ** set. This subroutine first looks at the iUseFlag. If iUseFlag
3962 ** is less than or equal to zero, the subroutine is a no-op. If
3963 ** the processing calls for the query to abort, this subroutine
3964 ** increments the iAbortFlag memory location before returning in
3965 ** order to signal the caller to abort.
3966 */
3967 addrSetAbort = sqlite3VdbeCurrentAddr(v);
drh4c583122008-01-04 22:01:03 +00003968 sqlite3VdbeAddOp2(v, OP_Integer, 1, iAbortFlag);
drhd4e70eb2008-01-02 00:34:36 +00003969 VdbeComment((v, "set abort flag"));
drh2eb95372008-06-06 15:04:36 +00003970 regOutputRow = ++pParse->nMem;
3971 sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);
drh13449892005-09-07 21:22:45 +00003972 addrOutputRow = sqlite3VdbeCurrentAddr(v);
drh3c84ddf2008-01-09 02:15:38 +00003973 sqlite3VdbeAddOp2(v, OP_IfPos, iUseFlag, addrOutputRow+2);
drhd4e70eb2008-01-02 00:34:36 +00003974 VdbeComment((v, "Groupby result generator entry point"));
drh2eb95372008-06-06 15:04:36 +00003975 sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);
drh13449892005-09-07 21:22:45 +00003976 finalizeAggFunctions(pParse, &sAggInfo);
3977 if( pHaving ){
drh35573352008-01-08 23:54:25 +00003978 sqlite3ExprIfFalse(pParse, pHaving, addrOutputRow+1, SQLITE_JUMPIFNULL);
drh13449892005-09-07 21:22:45 +00003979 }
drhd2b3e232008-01-23 14:51:49 +00003980 selectInnerLoop(pParse, p, p->pEList, 0, 0, pOrderBy,
3981 distinct, pDest,
3982 addrOutputRow+1, addrSetAbort, aff);
drh2eb95372008-06-06 15:04:36 +00003983 sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);
drhd4e70eb2008-01-02 00:34:36 +00003984 VdbeComment((v, "end groupby result generator"));
drh13449892005-09-07 21:22:45 +00003985
drhe3133822005-09-20 13:11:59 +00003986 /* Generate a subroutine that will reset the group-by accumulator
3987 */
3988 addrReset = sqlite3VdbeCurrentAddr(v);
drh2eb95372008-06-06 15:04:36 +00003989 regReset = ++pParse->nMem;
drhe3133822005-09-20 13:11:59 +00003990 resetAccumulator(pParse, &sAggInfo);
drh2eb95372008-06-06 15:04:36 +00003991 sqlite3VdbeAddOp1(v, OP_Return, regReset);
drhe3133822005-09-20 13:11:59 +00003992
drh13449892005-09-07 21:22:45 +00003993 /* Begin a loop that will extract all source rows in GROUP BY order.
3994 ** This might involve two separate loops with an OP_Sort in between, or
3995 ** it might be a single loop that uses an index to extract information
3996 ** in the right order to begin with.
3997 */
3998 sqlite3VdbeResolveLabel(v, addrInitializeLoop);
drh2eb95372008-06-06 15:04:36 +00003999 sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset);
danielk1977a9d1ccb2008-01-05 17:39:29 +00004000 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, &pGroupBy, 0);
drh5360ad32005-09-08 00:13:27 +00004001 if( pWInfo==0 ) goto select_end;
drh13449892005-09-07 21:22:45 +00004002 if( pGroupBy==0 ){
4003 /* The optimizer is able to deliver rows in group by order so
drhb9bb7c12006-06-11 23:41:55 +00004004 ** we do not have to sort. The OP_OpenEphemeral table will be
drh13449892005-09-07 21:22:45 +00004005 ** cancelled later because we still need to use the pKeyInfo
4006 */
4007 pGroupBy = p->pGroupBy;
4008 groupBySort = 0;
4009 }else{
4010 /* Rows are coming out in undetermined order. We have to push
4011 ** each row into a sorting index, terminate the first loop,
4012 ** then loop over the sorting index in order to get the output
4013 ** in sorted order
4014 */
drh892d3172008-01-10 03:46:36 +00004015 int regBase;
4016 int regRecord;
4017 int nCol;
4018 int nGroupBy;
4019
drh13449892005-09-07 21:22:45 +00004020 groupBySort = 1;
drh892d3172008-01-10 03:46:36 +00004021 nGroupBy = pGroupBy->nExpr;
4022 nCol = nGroupBy + 1;
4023 j = nGroupBy+1;
4024 for(i=0; i<sAggInfo.nColumn; i++){
4025 if( sAggInfo.aCol[i].iSorterColumn>=j ){
4026 nCol++;
4027 j++;
4028 }
4029 }
4030 regBase = sqlite3GetTempRange(pParse, nCol);
drh191b54c2008-04-15 12:14:21 +00004031 sqlite3ExprCodeExprList(pParse, pGroupBy, regBase, 0);
drh892d3172008-01-10 03:46:36 +00004032 sqlite3VdbeAddOp2(v, OP_Sequence, sAggInfo.sortingIdx,regBase+nGroupBy);
4033 j = nGroupBy+1;
drh13449892005-09-07 21:22:45 +00004034 for(i=0; i<sAggInfo.nColumn; i++){
4035 struct AggInfo_col *pCol = &sAggInfo.aCol[i];
drh892d3172008-01-10 03:46:36 +00004036 if( pCol->iSorterColumn>=j ){
drhe55cbd72008-03-31 23:48:03 +00004037 int r1 = j + regBase;
4038 int r2 = sqlite3ExprCodeGetColumn(pParse,
drhda250ea2008-04-01 05:07:14 +00004039 pCol->pTab, pCol->iColumn, pCol->iTable, r1, 0);
drhe55cbd72008-03-31 23:48:03 +00004040 if( r1!=r2 ){
4041 sqlite3VdbeAddOp2(v, OP_SCopy, r2, r1);
4042 }
drh892d3172008-01-10 03:46:36 +00004043 j++;
4044 }
drh13449892005-09-07 21:22:45 +00004045 }
drh892d3172008-01-10 03:46:36 +00004046 regRecord = sqlite3GetTempReg(pParse);
drh1db639c2008-01-17 02:36:28 +00004047 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord);
drh892d3172008-01-10 03:46:36 +00004048 sqlite3VdbeAddOp2(v, OP_IdxInsert, sAggInfo.sortingIdx, regRecord);
4049 sqlite3ReleaseTempReg(pParse, regRecord);
4050 sqlite3ReleaseTempRange(pParse, regBase, nCol);
drh13449892005-09-07 21:22:45 +00004051 sqlite3WhereEnd(pWInfo);
drh66a51672008-01-03 00:01:23 +00004052 sqlite3VdbeAddOp2(v, OP_Sort, sAggInfo.sortingIdx, addrEnd);
drhd4e70eb2008-01-02 00:34:36 +00004053 VdbeComment((v, "GROUP BY sort"));
drh13449892005-09-07 21:22:45 +00004054 sAggInfo.useSortingIdx = 1;
4055 }
4056
4057 /* Evaluate the current GROUP BY terms and store in b0, b1, b2...
4058 ** (b0 is memory location iBMem+0, b1 is iBMem+1, and so forth)
4059 ** Then compare the current GROUP BY terms against the GROUP BY terms
4060 ** from the previous row currently stored in a0, a1, a2...
4061 */
4062 addrTopOfLoop = sqlite3VdbeCurrentAddr(v);
4063 for(j=0; j<pGroupBy->nExpr; j++){
4064 if( groupBySort ){
drh2dcef112008-01-12 19:03:48 +00004065 sqlite3VdbeAddOp3(v, OP_Column, sAggInfo.sortingIdx, j, iBMem+j);
drh13449892005-09-07 21:22:45 +00004066 }else{
4067 sAggInfo.directMode = 1;
drh2dcef112008-01-12 19:03:48 +00004068 sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr, iBMem+j);
drh13449892005-09-07 21:22:45 +00004069 }
drh13449892005-09-07 21:22:45 +00004070 }
drh16ee60f2008-06-20 18:13:25 +00004071 sqlite3VdbeAddOp4(v, OP_Compare, iAMem, iBMem, pGroupBy->nExpr,
drhb21e7c72008-06-22 12:37:57 +00004072 (char*)pKeyInfo, P4_KEYINFO);
drh16ee60f2008-06-20 18:13:25 +00004073 j1 = sqlite3VdbeCurrentAddr(v);
4074 sqlite3VdbeAddOp3(v, OP_Jump, j1+1, 0, j1+1);
drh13449892005-09-07 21:22:45 +00004075
4076 /* Generate code that runs whenever the GROUP BY changes.
drhe00ee6e2008-06-20 15:24:01 +00004077 ** Changes in the GROUP BY are detected by the previous code
drh13449892005-09-07 21:22:45 +00004078 ** block. If there were no changes, this block is skipped.
4079 **
4080 ** This code copies current group by terms in b0,b1,b2,...
4081 ** over to a0,a1,a2. It then calls the output subroutine
4082 ** and resets the aggregate accumulator registers in preparation
4083 ** for the next GROUP BY batch.
4084 */
drhb21e7c72008-06-22 12:37:57 +00004085 sqlite3ExprCodeMove(pParse, iBMem, iAMem, pGroupBy->nExpr);
drh2eb95372008-06-06 15:04:36 +00004086 sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow);
drhd4e70eb2008-01-02 00:34:36 +00004087 VdbeComment((v, "output one row"));
drh3c84ddf2008-01-09 02:15:38 +00004088 sqlite3VdbeAddOp2(v, OP_IfPos, iAbortFlag, addrEnd);
drhd4e70eb2008-01-02 00:34:36 +00004089 VdbeComment((v, "check abort flag"));
drh2eb95372008-06-06 15:04:36 +00004090 sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset);
drhd4e70eb2008-01-02 00:34:36 +00004091 VdbeComment((v, "reset accumulator"));
drh13449892005-09-07 21:22:45 +00004092
4093 /* Update the aggregate accumulators based on the content of
4094 ** the current row
4095 */
drh16ee60f2008-06-20 18:13:25 +00004096 sqlite3VdbeJumpHere(v, j1);
drh13449892005-09-07 21:22:45 +00004097 updateAccumulator(pParse, &sAggInfo);
drh4c583122008-01-04 22:01:03 +00004098 sqlite3VdbeAddOp2(v, OP_Integer, 1, iUseFlag);
drhd4e70eb2008-01-02 00:34:36 +00004099 VdbeComment((v, "indicate data in accumulator"));
drh13449892005-09-07 21:22:45 +00004100
4101 /* End of the loop
4102 */
4103 if( groupBySort ){
drh66a51672008-01-03 00:01:23 +00004104 sqlite3VdbeAddOp2(v, OP_Next, sAggInfo.sortingIdx, addrTopOfLoop);
drh13449892005-09-07 21:22:45 +00004105 }else{
4106 sqlite3WhereEnd(pWInfo);
drhf8875402006-03-17 13:56:34 +00004107 sqlite3VdbeChangeToNoop(v, addrSortingIdx, 1);
drh13449892005-09-07 21:22:45 +00004108 }
4109
4110 /* Output the final row of result
4111 */
drh2eb95372008-06-06 15:04:36 +00004112 sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow);
drhd4e70eb2008-01-02 00:34:36 +00004113 VdbeComment((v, "output final row"));
drh13449892005-09-07 21:22:45 +00004114
4115 } /* endif pGroupBy */
4116 else {
danielk1977a9d1ccb2008-01-05 17:39:29 +00004117 ExprList *pMinMax = 0;
danielk1977dba01372008-01-05 18:44:29 +00004118 ExprList *pDel = 0;
danielk1977a9d1ccb2008-01-05 17:39:29 +00004119 u8 flag;
4120
danielk1977738bdcf2008-01-07 10:16:40 +00004121 /* Check if the query is of one of the following forms:
4122 **
4123 ** SELECT min(x) FROM ...
4124 ** SELECT max(x) FROM ...
4125 **
4126 ** If it is, then ask the code in where.c to attempt to sort results
4127 ** as if there was an "ORDER ON x" or "ORDER ON x DESC" clause.
4128 ** If where.c is able to produce results sorted in this order, then
4129 ** add vdbe code to break out of the processing loop after the
4130 ** first iteration (since the first iteration of the loop is
4131 ** guaranteed to operate on the row with the minimum or maximum
4132 ** value of x, the only row required).
4133 **
4134 ** A special flag must be passed to sqlite3WhereBegin() to slightly
4135 ** modify behaviour as follows:
4136 **
4137 ** + If the query is a "SELECT min(x)", then the loop coded by
4138 ** where.c should not iterate over any values with a NULL value
4139 ** for x.
4140 **
4141 ** + The optimizer code in where.c (the thing that decides which
4142 ** index or indices to use) should place a different priority on
4143 ** satisfying the 'ORDER BY' clause than it does in other cases.
4144 ** Refer to code and comments in where.c for details.
4145 */
danielk1977a9d1ccb2008-01-05 17:39:29 +00004146 flag = minMaxQuery(pParse, p);
4147 if( flag ){
drh8cc74322008-01-15 02:22:24 +00004148 pDel = pMinMax = sqlite3ExprListDup(db, p->pEList->a[0].pExpr->pList);
drh0e359b32008-01-13 19:02:11 +00004149 if( pMinMax && !db->mallocFailed ){
drh08c88eb2008-04-10 13:33:18 +00004150 pMinMax->a[0].sortOrder = ((flag==WHERE_ORDERBY_MIN)?0:1);
danielk1977a9d1ccb2008-01-05 17:39:29 +00004151 pMinMax->a[0].pExpr->op = TK_COLUMN;
4152 }
4153 }
4154
drh13449892005-09-07 21:22:45 +00004155 /* This case runs if the aggregate has no GROUP BY clause. The
4156 ** processing is much simpler since there is only a single row
4157 ** of output.
4158 */
4159 resetAccumulator(pParse, &sAggInfo);
danielk1977a9d1ccb2008-01-05 17:39:29 +00004160 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, &pMinMax, flag);
danielk1977dba01372008-01-05 18:44:29 +00004161 if( pWInfo==0 ){
drh1013c932008-01-06 00:25:21 +00004162 sqlite3ExprListDelete(pDel);
danielk1977dba01372008-01-05 18:44:29 +00004163 goto select_end;
4164 }
drh13449892005-09-07 21:22:45 +00004165 updateAccumulator(pParse, &sAggInfo);
danielk1977a9d1ccb2008-01-05 17:39:29 +00004166 if( !pMinMax && flag ){
4167 sqlite3VdbeAddOp2(v, OP_Goto, 0, pWInfo->iBreak);
drh16ee60f2008-06-20 18:13:25 +00004168 VdbeComment((v, "%s() by index",(flag==WHERE_ORDERBY_MIN?"min":"max")));
danielk1977a9d1ccb2008-01-05 17:39:29 +00004169 }
drh13449892005-09-07 21:22:45 +00004170 sqlite3WhereEnd(pWInfo);
4171 finalizeAggFunctions(pParse, &sAggInfo);
4172 pOrderBy = 0;
drh5774b802005-09-07 22:48:16 +00004173 if( pHaving ){
drh35573352008-01-08 23:54:25 +00004174 sqlite3ExprIfFalse(pParse, pHaving, addrEnd, SQLITE_JUMPIFNULL);
drh5774b802005-09-07 22:48:16 +00004175 }
drh13449892005-09-07 21:22:45 +00004176 selectInnerLoop(pParse, p, p->pEList, 0, 0, 0, -1,
danielk19776c8c8ce2008-01-02 16:27:09 +00004177 pDest, addrEnd, addrEnd, aff);
danielk1977a9d1ccb2008-01-05 17:39:29 +00004178
danielk1977dba01372008-01-05 18:44:29 +00004179 sqlite3ExprListDelete(pDel);
drh13449892005-09-07 21:22:45 +00004180 }
4181 sqlite3VdbeResolveLabel(v, addrEnd);
4182
4183 } /* endif aggregate query */
drh22827922000-06-06 17:27:05 +00004184
drhcce7d172000-05-31 15:34:51 +00004185 /* If there is an ORDER BY clause, then we need to sort the results
4186 ** and send them to the callback one by one.
4187 */
4188 if( pOrderBy ){
danielk19776c8c8ce2008-01-02 16:27:09 +00004189 generateSortTail(pParse, p, v, pEList->nExpr, pDest);
drhcce7d172000-05-31 15:34:51 +00004190 }
drh6a535342001-10-19 16:44:56 +00004191
danielk197793758c82005-01-21 08:13:14 +00004192#ifndef SQLITE_OMIT_SUBQUERY
drhf620b4e2004-02-09 14:37:50 +00004193 /* If this was a subquery, we have now converted the subquery into a
danielk19771787cca2006-02-10 07:07:14 +00004194 ** temporary table. So set the SrcList_item.isPopulated flag to prevent
4195 ** this subquery from being evaluated again and to force the use of
4196 ** the temporary table.
drhf620b4e2004-02-09 14:37:50 +00004197 */
4198 if( pParent ){
4199 assert( pParent->pSrc->nSrc>parentTab );
4200 assert( pParent->pSrc->a[parentTab].pSelect==p );
danielk19771787cca2006-02-10 07:07:14 +00004201 pParent->pSrc->a[parentTab].isPopulated = 1;
drhf620b4e2004-02-09 14:37:50 +00004202 }
danielk197793758c82005-01-21 08:13:14 +00004203#endif
drhf620b4e2004-02-09 14:37:50 +00004204
drhec7429a2005-10-06 16:53:14 +00004205 /* Jump here to skip this query
4206 */
4207 sqlite3VdbeResolveLabel(v, iEnd);
4208
drh1d83f052002-02-17 00:30:36 +00004209 /* The SELECT was successfully coded. Set the return code to 0
4210 ** to indicate no errors.
4211 */
4212 rc = 0;
4213
4214 /* Control jumps to here if an error is encountered above, or upon
4215 ** successful coding of the SELECT.
4216 */
4217select_end:
danielk1977955de522006-02-10 02:27:42 +00004218
4219 /* Identify column names if we will be using them in a callback. This
4220 ** step is skipped if the output is going to some other destination.
4221 */
danielk19776c8c8ce2008-01-02 16:27:09 +00004222 if( rc==SQLITE_OK && pDest->eDest==SRT_Callback ){
danielk1977955de522006-02-10 02:27:42 +00004223 generateColumnNames(pParse, pTabList, pEList);
4224 }
4225
drh17435752007-08-16 04:30:38 +00004226 sqlite3_free(sAggInfo.aCol);
4227 sqlite3_free(sAggInfo.aFunc);
drh1d83f052002-02-17 00:30:36 +00004228 return rc;
drhcce7d172000-05-31 15:34:51 +00004229}
drh485f0032007-01-26 19:23:33 +00004230
drh77a2a5e2007-04-06 01:04:39 +00004231#if defined(SQLITE_DEBUG)
drh485f0032007-01-26 19:23:33 +00004232/*
4233*******************************************************************************
4234** The following code is used for testing and debugging only. The code
4235** that follows does not appear in normal builds.
4236**
4237** These routines are used to print out the content of all or part of a
4238** parse structures such as Select or Expr. Such printouts are useful
4239** for helping to understand what is happening inside the code generator
4240** during the execution of complex SELECT statements.
4241**
4242** These routine are not called anywhere from within the normal
4243** code base. Then are intended to be called from within the debugger
4244** or from temporary "printf" statements inserted for debugging.
4245*/
drhdafc0ce2008-04-17 19:14:02 +00004246void sqlite3PrintExpr(Expr *p){
drh485f0032007-01-26 19:23:33 +00004247 if( p->token.z && p->token.n>0 ){
4248 sqlite3DebugPrintf("(%.*s", p->token.n, p->token.z);
4249 }else{
4250 sqlite3DebugPrintf("(%d", p->op);
4251 }
4252 if( p->pLeft ){
4253 sqlite3DebugPrintf(" ");
4254 sqlite3PrintExpr(p->pLeft);
4255 }
4256 if( p->pRight ){
4257 sqlite3DebugPrintf(" ");
4258 sqlite3PrintExpr(p->pRight);
4259 }
4260 sqlite3DebugPrintf(")");
4261}
drhdafc0ce2008-04-17 19:14:02 +00004262void sqlite3PrintExprList(ExprList *pList){
drh485f0032007-01-26 19:23:33 +00004263 int i;
4264 for(i=0; i<pList->nExpr; i++){
4265 sqlite3PrintExpr(pList->a[i].pExpr);
4266 if( i<pList->nExpr-1 ){
4267 sqlite3DebugPrintf(", ");
4268 }
4269 }
4270}
drhdafc0ce2008-04-17 19:14:02 +00004271void sqlite3PrintSelect(Select *p, int indent){
drh485f0032007-01-26 19:23:33 +00004272 sqlite3DebugPrintf("%*sSELECT(%p) ", indent, "", p);
4273 sqlite3PrintExprList(p->pEList);
4274 sqlite3DebugPrintf("\n");
4275 if( p->pSrc ){
4276 char *zPrefix;
4277 int i;
4278 zPrefix = "FROM";
4279 for(i=0; i<p->pSrc->nSrc; i++){
4280 struct SrcList_item *pItem = &p->pSrc->a[i];
4281 sqlite3DebugPrintf("%*s ", indent+6, zPrefix);
4282 zPrefix = "";
4283 if( pItem->pSelect ){
4284 sqlite3DebugPrintf("(\n");
4285 sqlite3PrintSelect(pItem->pSelect, indent+10);
4286 sqlite3DebugPrintf("%*s)", indent+8, "");
4287 }else if( pItem->zName ){
4288 sqlite3DebugPrintf("%s", pItem->zName);
4289 }
4290 if( pItem->pTab ){
4291 sqlite3DebugPrintf("(table: %s)", pItem->pTab->zName);
4292 }
4293 if( pItem->zAlias ){
4294 sqlite3DebugPrintf(" AS %s", pItem->zAlias);
4295 }
4296 if( i<p->pSrc->nSrc-1 ){
4297 sqlite3DebugPrintf(",");
4298 }
4299 sqlite3DebugPrintf("\n");
4300 }
4301 }
4302 if( p->pWhere ){
4303 sqlite3DebugPrintf("%*s WHERE ", indent, "");
4304 sqlite3PrintExpr(p->pWhere);
4305 sqlite3DebugPrintf("\n");
4306 }
4307 if( p->pGroupBy ){
4308 sqlite3DebugPrintf("%*s GROUP BY ", indent, "");
4309 sqlite3PrintExprList(p->pGroupBy);
4310 sqlite3DebugPrintf("\n");
4311 }
4312 if( p->pHaving ){
4313 sqlite3DebugPrintf("%*s HAVING ", indent, "");
4314 sqlite3PrintExpr(p->pHaving);
4315 sqlite3DebugPrintf("\n");
4316 }
4317 if( p->pOrderBy ){
4318 sqlite3DebugPrintf("%*s ORDER BY ", indent, "");
4319 sqlite3PrintExprList(p->pOrderBy);
4320 sqlite3DebugPrintf("\n");
4321 }
4322}
4323/* End of the structure debug printing code
4324*****************************************************************************/
4325#endif /* defined(SQLITE_TEST) || defined(SQLITE_DEBUG) */