blob: c5fb15cd86b55b5e81e83b76181bcb38d2fdd044 [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*/
15#include "sqliteInt.h"
16
drh315555c2002-10-20 15:53:03 +000017
drhcce7d172000-05-31 15:34:51 +000018/*
drheda639e2006-01-22 00:42:09 +000019** Delete all the content of a Select structure but do not deallocate
20** the select structure itself.
21*/
drh633e6d52008-07-28 19:34:53 +000022static void clearSelect(sqlite3 *db, Select *p){
23 sqlite3ExprListDelete(db, p->pEList);
24 sqlite3SrcListDelete(db, p->pSrc);
25 sqlite3ExprDelete(db, p->pWhere);
26 sqlite3ExprListDelete(db, p->pGroupBy);
27 sqlite3ExprDelete(db, p->pHaving);
28 sqlite3ExprListDelete(db, p->pOrderBy);
29 sqlite3SelectDelete(db, p->pPrior);
30 sqlite3ExprDelete(db, p->pLimit);
31 sqlite3ExprDelete(db, p->pOffset);
dan4e9119d2014-01-13 15:12:23 +000032 sqlite3WithDelete(db, p->pWith);
drheda639e2006-01-22 00:42:09 +000033}
34
drh1013c932008-01-06 00:25:21 +000035/*
36** Initialize a SelectDest structure.
37*/
38void sqlite3SelectDestInit(SelectDest *pDest, int eDest, int iParm){
drhea678832008-12-10 19:26:22 +000039 pDest->eDest = (u8)eDest;
drh2b596da2012-07-23 21:43:19 +000040 pDest->iSDParm = iParm;
41 pDest->affSdst = 0;
42 pDest->iSdst = 0;
43 pDest->nSdst = 0;
drh1013c932008-01-06 00:25:21 +000044}
45
drheda639e2006-01-22 00:42:09 +000046
47/*
drh9bb61fe2000-06-05 16:01:39 +000048** Allocate a new Select structure and return a pointer to that
49** structure.
drhcce7d172000-05-31 15:34:51 +000050*/
danielk19774adee202004-05-08 08:23:19 +000051Select *sqlite3SelectNew(
drh17435752007-08-16 04:30:38 +000052 Parse *pParse, /* Parsing context */
drhdaffd0e2001-04-11 14:28:42 +000053 ExprList *pEList, /* which columns to include in the result */
drhad3cab52002-05-24 02:04:32 +000054 SrcList *pSrc, /* the FROM clause -- which tables to scan */
drhdaffd0e2001-04-11 14:28:42 +000055 Expr *pWhere, /* the WHERE clause */
56 ExprList *pGroupBy, /* the GROUP BY clause */
57 Expr *pHaving, /* the HAVING clause */
58 ExprList *pOrderBy, /* the ORDER BY clause */
drh832ee3d2012-12-18 19:36:11 +000059 u16 selFlags, /* Flag parameters, such as SF_Distinct */
danielk1977a2dc3b12005-02-05 12:48:48 +000060 Expr *pLimit, /* LIMIT value. NULL means not used */
61 Expr *pOffset /* OFFSET value. NULL means no offset */
drh9bb61fe2000-06-05 16:01:39 +000062){
63 Select *pNew;
drheda639e2006-01-22 00:42:09 +000064 Select standin;
drh17435752007-08-16 04:30:38 +000065 sqlite3 *db = pParse->db;
66 pNew = sqlite3DbMallocZero(db, sizeof(*pNew) );
drhd72a2762008-11-12 12:27:31 +000067 assert( db->mallocFailed || !pOffset || pLimit ); /* OFFSET implies LIMIT */
drhdaffd0e2001-04-11 14:28:42 +000068 if( pNew==0 ){
drh338ec3e2011-10-11 20:14:41 +000069 assert( db->mallocFailed );
drheda639e2006-01-22 00:42:09 +000070 pNew = &standin;
71 memset(pNew, 0, sizeof(*pNew));
72 }
73 if( pEList==0 ){
drhb7916a72009-05-27 10:31:29 +000074 pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db,TK_ALL,0));
drheda639e2006-01-22 00:42:09 +000075 }
76 pNew->pEList = pEList;
drh7b113ba2012-01-28 15:22:22 +000077 if( pSrc==0 ) pSrc = sqlite3DbMallocZero(db, sizeof(*pSrc));
drheda639e2006-01-22 00:42:09 +000078 pNew->pSrc = pSrc;
79 pNew->pWhere = pWhere;
80 pNew->pGroupBy = pGroupBy;
81 pNew->pHaving = pHaving;
82 pNew->pOrderBy = pOrderBy;
drh832ee3d2012-12-18 19:36:11 +000083 pNew->selFlags = selFlags;
drheda639e2006-01-22 00:42:09 +000084 pNew->op = TK_SELECT;
85 pNew->pLimit = pLimit;
86 pNew->pOffset = pOffset;
drh373cc2d2009-05-17 02:06:14 +000087 assert( pOffset==0 || pLimit!=0 );
drhb9bb7c12006-06-11 23:41:55 +000088 pNew->addrOpenEphm[0] = -1;
89 pNew->addrOpenEphm[1] = -1;
90 pNew->addrOpenEphm[2] = -1;
drh0a846f92008-08-25 17:23:29 +000091 if( db->mallocFailed ) {
drh633e6d52008-07-28 19:34:53 +000092 clearSelect(db, pNew);
drh0a846f92008-08-25 17:23:29 +000093 if( pNew!=&standin ) sqlite3DbFree(db, pNew);
drheda639e2006-01-22 00:42:09 +000094 pNew = 0;
drha464c232011-09-16 19:04:03 +000095 }else{
96 assert( pNew->pSrc!=0 || pParse->nErr>0 );
drhdaffd0e2001-04-11 14:28:42 +000097 }
drh338ec3e2011-10-11 20:14:41 +000098 assert( pNew!=&standin );
drh9bb61fe2000-06-05 16:01:39 +000099 return pNew;
100}
101
102/*
drheda639e2006-01-22 00:42:09 +0000103** Delete the given Select structure and all of its substructures.
104*/
drh633e6d52008-07-28 19:34:53 +0000105void sqlite3SelectDelete(sqlite3 *db, Select *p){
drheda639e2006-01-22 00:42:09 +0000106 if( p ){
drh633e6d52008-07-28 19:34:53 +0000107 clearSelect(db, p);
108 sqlite3DbFree(db, p);
drheda639e2006-01-22 00:42:09 +0000109 }
110}
111
112/*
drhf7b54962013-05-28 12:11:54 +0000113** Given 1 to 3 identifiers preceding the JOIN keyword, determine the
drh01f3f252002-05-24 16:14:15 +0000114** type of join. Return an integer constant that expresses that type
115** in terms of the following bit values:
116**
117** JT_INNER
drh3dec2232005-09-10 15:28:09 +0000118** JT_CROSS
drh01f3f252002-05-24 16:14:15 +0000119** JT_OUTER
120** JT_NATURAL
121** JT_LEFT
122** JT_RIGHT
123**
124** A full outer join is the combination of JT_LEFT and JT_RIGHT.
125**
126** If an illegal or unsupported join type is seen, then still return
127** a join type, but put an error in the pParse structure.
128*/
danielk19774adee202004-05-08 08:23:19 +0000129int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){
drh01f3f252002-05-24 16:14:15 +0000130 int jointype = 0;
131 Token *apAll[3];
132 Token *p;
drh373cc2d2009-05-17 02:06:14 +0000133 /* 0123456789 123456789 123456789 123 */
134 static const char zKeyText[] = "naturaleftouterightfullinnercross";
drh57196282004-10-06 15:41:16 +0000135 static const struct {
drh373cc2d2009-05-17 02:06:14 +0000136 u8 i; /* Beginning of keyword text in zKeyText[] */
137 u8 nChar; /* Length of the keyword in characters */
138 u8 code; /* Join type mask */
139 } aKeyword[] = {
140 /* natural */ { 0, 7, JT_NATURAL },
141 /* left */ { 6, 4, JT_LEFT|JT_OUTER },
142 /* outer */ { 10, 5, JT_OUTER },
143 /* right */ { 14, 5, JT_RIGHT|JT_OUTER },
144 /* full */ { 19, 4, JT_LEFT|JT_RIGHT|JT_OUTER },
145 /* inner */ { 23, 5, JT_INNER },
146 /* cross */ { 28, 5, JT_INNER|JT_CROSS },
drh01f3f252002-05-24 16:14:15 +0000147 };
148 int i, j;
149 apAll[0] = pA;
150 apAll[1] = pB;
151 apAll[2] = pC;
drh195e6962002-05-25 00:18:20 +0000152 for(i=0; i<3 && apAll[i]; i++){
drh01f3f252002-05-24 16:14:15 +0000153 p = apAll[i];
drh373cc2d2009-05-17 02:06:14 +0000154 for(j=0; j<ArraySize(aKeyword); j++){
155 if( p->n==aKeyword[j].nChar
156 && sqlite3StrNICmp((char*)p->z, &zKeyText[aKeyword[j].i], p->n)==0 ){
157 jointype |= aKeyword[j].code;
drh01f3f252002-05-24 16:14:15 +0000158 break;
159 }
160 }
drh373cc2d2009-05-17 02:06:14 +0000161 testcase( j==0 || j==1 || j==2 || j==3 || j==4 || j==5 || j==6 );
162 if( j>=ArraySize(aKeyword) ){
drh01f3f252002-05-24 16:14:15 +0000163 jointype |= JT_ERROR;
164 break;
165 }
166 }
drhad2d8302002-05-24 20:31:36 +0000167 if(
168 (jointype & (JT_INNER|JT_OUTER))==(JT_INNER|JT_OUTER) ||
drh195e6962002-05-25 00:18:20 +0000169 (jointype & JT_ERROR)!=0
drhad2d8302002-05-24 20:31:36 +0000170 ){
drha9671a22008-07-08 23:40:20 +0000171 const char *zSp = " ";
172 assert( pB!=0 );
173 if( pC==0 ){ zSp++; }
drhae29ffb2004-09-25 14:39:18 +0000174 sqlite3ErrorMsg(pParse, "unknown or unsupported join type: "
drha9671a22008-07-08 23:40:20 +0000175 "%T %T%s%T", pA, pB, zSp, pC);
drh01f3f252002-05-24 16:14:15 +0000176 jointype = JT_INNER;
drh373cc2d2009-05-17 02:06:14 +0000177 }else if( (jointype & JT_OUTER)!=0
178 && (jointype & (JT_LEFT|JT_RIGHT))!=JT_LEFT ){
danielk19774adee202004-05-08 08:23:19 +0000179 sqlite3ErrorMsg(pParse,
drhda93d232003-03-31 02:12:46 +0000180 "RIGHT and FULL OUTER JOINs are not currently supported");
drh195e6962002-05-25 00:18:20 +0000181 jointype = JT_INNER;
drh01f3f252002-05-24 16:14:15 +0000182 }
183 return jointype;
184}
185
186/*
drhad2d8302002-05-24 20:31:36 +0000187** Return the index of a column in a table. Return -1 if the column
188** is not contained in the table.
189*/
190static int columnIndex(Table *pTab, const char *zCol){
191 int i;
192 for(i=0; i<pTab->nCol; i++){
danielk19774adee202004-05-08 08:23:19 +0000193 if( sqlite3StrICmp(pTab->aCol[i].zName, zCol)==0 ) return i;
drhad2d8302002-05-24 20:31:36 +0000194 }
195 return -1;
196}
197
198/*
drh2179b432009-12-09 17:36:39 +0000199** Search the first N tables in pSrc, from left to right, looking for a
200** table that has a column named zCol.
201**
202** When found, set *piTab and *piCol to the table index and column index
203** of the matching column and return TRUE.
204**
205** If not found, return FALSE.
206*/
207static int tableAndColumnIndex(
208 SrcList *pSrc, /* Array of tables to search */
209 int N, /* Number of tables in pSrc->a[] to search */
210 const char *zCol, /* Name of the column we are looking for */
211 int *piTab, /* Write index of pSrc->a[] here */
212 int *piCol /* Write index of pSrc->a[*piTab].pTab->aCol[] here */
213){
214 int i; /* For looping over tables in pSrc */
215 int iCol; /* Index of column matching zCol */
216
217 assert( (piTab==0)==(piCol==0) ); /* Both or neither are NULL */
218 for(i=0; i<N; i++){
219 iCol = columnIndex(pSrc->a[i].pTab, zCol);
220 if( iCol>=0 ){
221 if( piTab ){
222 *piTab = i;
223 *piCol = iCol;
224 }
225 return 1;
226 }
227 }
228 return 0;
229}
230
231/*
danf7b0b0a2009-10-19 15:52:32 +0000232** This function is used to add terms implied by JOIN syntax to the
233** WHERE clause expression of a SELECT statement. The new term, which
234** is ANDed with the existing WHERE clause, is of the form:
235**
236** (tab1.col1 = tab2.col2)
237**
238** where tab1 is the iSrc'th table in SrcList pSrc and tab2 is the
239** (iSrc+1)'th. Column col1 is column iColLeft of tab1, and col2 is
240** column iColRight of tab2.
drhad2d8302002-05-24 20:31:36 +0000241*/
242static void addWhereTerm(
danf7b0b0a2009-10-19 15:52:32 +0000243 Parse *pParse, /* Parsing context */
244 SrcList *pSrc, /* List of tables in FROM clause */
drh2179b432009-12-09 17:36:39 +0000245 int iLeft, /* Index of first table to join in pSrc */
danf7b0b0a2009-10-19 15:52:32 +0000246 int iColLeft, /* Index of column in first table */
drh2179b432009-12-09 17:36:39 +0000247 int iRight, /* Index of second table in pSrc */
danf7b0b0a2009-10-19 15:52:32 +0000248 int iColRight, /* Index of column in second table */
249 int isOuterJoin, /* True if this is an OUTER join */
250 Expr **ppWhere /* IN/OUT: The WHERE clause to add to */
drhad2d8302002-05-24 20:31:36 +0000251){
danf7b0b0a2009-10-19 15:52:32 +0000252 sqlite3 *db = pParse->db;
253 Expr *pE1;
254 Expr *pE2;
255 Expr *pEq;
drhad2d8302002-05-24 20:31:36 +0000256
drh2179b432009-12-09 17:36:39 +0000257 assert( iLeft<iRight );
258 assert( pSrc->nSrc>iRight );
259 assert( pSrc->a[iLeft].pTab );
260 assert( pSrc->a[iRight].pTab );
danf7b0b0a2009-10-19 15:52:32 +0000261
drh2179b432009-12-09 17:36:39 +0000262 pE1 = sqlite3CreateColumnExpr(db, pSrc, iLeft, iColLeft);
263 pE2 = sqlite3CreateColumnExpr(db, pSrc, iRight, iColRight);
danf7b0b0a2009-10-19 15:52:32 +0000264
265 pEq = sqlite3PExpr(pParse, TK_EQ, pE1, pE2, 0);
266 if( pEq && isOuterJoin ){
267 ExprSetProperty(pEq, EP_FromJoin);
drhc5cd1242013-09-12 16:50:49 +0000268 assert( !ExprHasProperty(pEq, EP_TokenOnly|EP_Reduced) );
drhebb6a652013-09-12 23:42:22 +0000269 ExprSetVVAProperty(pEq, EP_NoReduce);
danf7b0b0a2009-10-19 15:52:32 +0000270 pEq->iRightJoinTable = (i16)pE2->iTable;
drh030530d2005-01-18 17:40:04 +0000271 }
danf7b0b0a2009-10-19 15:52:32 +0000272 *ppWhere = sqlite3ExprAnd(db, *ppWhere, pEq);
drhad2d8302002-05-24 20:31:36 +0000273}
274
275/*
drh1f162302002-10-27 19:35:33 +0000276** Set the EP_FromJoin property on all terms of the given expression.
drh22d6a532005-09-19 21:05:48 +0000277** And set the Expr.iRightJoinTable to iTable for every term in the
278** expression.
drh1cc093c2002-06-24 22:01:57 +0000279**
drhe78e8282003-01-19 03:59:45 +0000280** The EP_FromJoin property is used on terms of an expression to tell
drh1cc093c2002-06-24 22:01:57 +0000281** the LEFT OUTER JOIN processing logic that this term is part of the
drh1f162302002-10-27 19:35:33 +0000282** join restriction specified in the ON or USING clause and not a part
283** of the more general WHERE clause. These terms are moved over to the
284** WHERE clause during join processing but we need to remember that they
285** originated in the ON or USING clause.
drh22d6a532005-09-19 21:05:48 +0000286**
287** The Expr.iRightJoinTable tells the WHERE clause processing that the
288** expression depends on table iRightJoinTable even if that table is not
289** explicitly mentioned in the expression. That information is needed
290** for cases like this:
291**
292** SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.b AND t1.x=5
293**
294** The where clause needs to defer the handling of the t1.x=5
295** term until after the t2 loop of the join. In that way, a
296** NULL t2 row will be inserted whenever t1.x!=5. If we do not
297** defer the handling of t1.x=5, it will be processed immediately
298** after the t1 loop and rows with t1.x!=5 will never appear in
299** the output, which is incorrect.
drh1cc093c2002-06-24 22:01:57 +0000300*/
drh22d6a532005-09-19 21:05:48 +0000301static void setJoinExpr(Expr *p, int iTable){
drh1cc093c2002-06-24 22:01:57 +0000302 while( p ){
drh1f162302002-10-27 19:35:33 +0000303 ExprSetProperty(p, EP_FromJoin);
drhc5cd1242013-09-12 16:50:49 +0000304 assert( !ExprHasProperty(p, EP_TokenOnly|EP_Reduced) );
drhebb6a652013-09-12 23:42:22 +0000305 ExprSetVVAProperty(p, EP_NoReduce);
shanecf697392009-06-01 16:53:09 +0000306 p->iRightJoinTable = (i16)iTable;
drh22d6a532005-09-19 21:05:48 +0000307 setJoinExpr(p->pLeft, iTable);
drh1cc093c2002-06-24 22:01:57 +0000308 p = p->pRight;
309 }
310}
311
312/*
drhad2d8302002-05-24 20:31:36 +0000313** This routine processes the join information for a SELECT statement.
314** ON and USING clauses are converted into extra terms of the WHERE clause.
315** NATURAL joins also create extra WHERE clause terms.
316**
drh91bb0ee2004-09-01 03:06:34 +0000317** The terms of a FROM clause are contained in the Select.pSrc structure.
318** The left most table is the first entry in Select.pSrc. The right-most
319** table is the last entry. The join operator is held in the entry to
320** the left. Thus entry 0 contains the join operator for the join between
321** entries 0 and 1. Any ON or USING clauses associated with the join are
322** also attached to the left entry.
323**
drhad2d8302002-05-24 20:31:36 +0000324** This routine returns the number of errors encountered.
325*/
326static int sqliteProcessJoin(Parse *pParse, Select *p){
drh91bb0ee2004-09-01 03:06:34 +0000327 SrcList *pSrc; /* All tables in the FROM clause */
328 int i, j; /* Loop counters */
329 struct SrcList_item *pLeft; /* Left table being joined */
330 struct SrcList_item *pRight; /* Right table being joined */
drhad2d8302002-05-24 20:31:36 +0000331
drh91bb0ee2004-09-01 03:06:34 +0000332 pSrc = p->pSrc;
333 pLeft = &pSrc->a[0];
334 pRight = &pLeft[1];
335 for(i=0; i<pSrc->nSrc-1; i++, pRight++, pLeft++){
336 Table *pLeftTab = pLeft->pTab;
337 Table *pRightTab = pRight->pTab;
drhad27e762008-03-26 12:46:23 +0000338 int isOuter;
drh91bb0ee2004-09-01 03:06:34 +0000339
drh1c767f02009-01-09 02:49:31 +0000340 if( NEVER(pLeftTab==0 || pRightTab==0) ) continue;
drhad27e762008-03-26 12:46:23 +0000341 isOuter = (pRight->jointype & JT_OUTER)!=0;
drhad2d8302002-05-24 20:31:36 +0000342
343 /* When the NATURAL keyword is present, add WHERE clause terms for
344 ** every column that the two tables have in common.
345 */
drh61dfc312006-12-16 16:25:15 +0000346 if( pRight->jointype & JT_NATURAL ){
347 if( pRight->pOn || pRight->pUsing ){
danielk19774adee202004-05-08 08:23:19 +0000348 sqlite3ErrorMsg(pParse, "a NATURAL join may not have "
drhad2d8302002-05-24 20:31:36 +0000349 "an ON or USING clause", 0);
drhad2d8302002-05-24 20:31:36 +0000350 return 1;
351 }
drh2179b432009-12-09 17:36:39 +0000352 for(j=0; j<pRightTab->nCol; j++){
353 char *zName; /* Name of column in the right table */
354 int iLeft; /* Matching left table */
355 int iLeftCol; /* Matching column in the left table */
356
357 zName = pRightTab->aCol[j].zName;
358 if( tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol) ){
359 addWhereTerm(pParse, pSrc, iLeft, iLeftCol, i+1, j,
360 isOuter, &p->pWhere);
drhad2d8302002-05-24 20:31:36 +0000361 }
362 }
363 }
364
365 /* Disallow both ON and USING clauses in the same join
366 */
drh61dfc312006-12-16 16:25:15 +0000367 if( pRight->pOn && pRight->pUsing ){
danielk19774adee202004-05-08 08:23:19 +0000368 sqlite3ErrorMsg(pParse, "cannot have both ON and USING "
drhda93d232003-03-31 02:12:46 +0000369 "clauses in the same join");
drhad2d8302002-05-24 20:31:36 +0000370 return 1;
371 }
372
373 /* Add the ON clause to the end of the WHERE clause, connected by
drh91bb0ee2004-09-01 03:06:34 +0000374 ** an AND operator.
drhad2d8302002-05-24 20:31:36 +0000375 */
drh61dfc312006-12-16 16:25:15 +0000376 if( pRight->pOn ){
drhad27e762008-03-26 12:46:23 +0000377 if( isOuter ) setJoinExpr(pRight->pOn, pRight->iCursor);
drh17435752007-08-16 04:30:38 +0000378 p->pWhere = sqlite3ExprAnd(pParse->db, p->pWhere, pRight->pOn);
drh61dfc312006-12-16 16:25:15 +0000379 pRight->pOn = 0;
drhad2d8302002-05-24 20:31:36 +0000380 }
381
382 /* Create extra terms on the WHERE clause for each column named
383 ** in the USING clause. Example: If the two tables to be joined are
384 ** A and B and the USING clause names X, Y, and Z, then add this
385 ** to the WHERE clause: A.X=B.X AND A.Y=B.Y AND A.Z=B.Z
386 ** Report an error if any column mentioned in the USING clause is
387 ** not contained in both tables to be joined.
388 */
drh61dfc312006-12-16 16:25:15 +0000389 if( pRight->pUsing ){
390 IdList *pList = pRight->pUsing;
drhad2d8302002-05-24 20:31:36 +0000391 for(j=0; j<pList->nId; j++){
drh2179b432009-12-09 17:36:39 +0000392 char *zName; /* Name of the term in the USING clause */
393 int iLeft; /* Table on the left with matching column name */
394 int iLeftCol; /* Column number of matching column on the left */
395 int iRightCol; /* Column number of matching column on the right */
396
397 zName = pList->a[j].zName;
398 iRightCol = columnIndex(pRightTab, zName);
399 if( iRightCol<0
400 || !tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol)
401 ){
danielk19774adee202004-05-08 08:23:19 +0000402 sqlite3ErrorMsg(pParse, "cannot join using column %s - column "
drh91bb0ee2004-09-01 03:06:34 +0000403 "not present in both tables", zName);
drhad2d8302002-05-24 20:31:36 +0000404 return 1;
405 }
drh2179b432009-12-09 17:36:39 +0000406 addWhereTerm(pParse, pSrc, iLeft, iLeftCol, i+1, iRightCol,
407 isOuter, &p->pWhere);
drhad2d8302002-05-24 20:31:36 +0000408 }
409 }
410 }
411 return 0;
412}
413
414/*
drhc926afb2002-06-20 03:38:26 +0000415** Insert code into "v" that will push the record on the top of the
416** stack into the sorter.
417*/
drhd59ba6c2006-01-08 05:02:54 +0000418static void pushOntoSorter(
419 Parse *pParse, /* Parser context */
420 ExprList *pOrderBy, /* The ORDER BY clause */
drhb7654112008-01-12 12:48:07 +0000421 Select *pSelect, /* The whole SELECT statement */
422 int regData /* Register holding data to be sorted */
drhd59ba6c2006-01-08 05:02:54 +0000423){
424 Vdbe *v = pParse->pVdbe;
drh892d3172008-01-10 03:46:36 +0000425 int nExpr = pOrderBy->nExpr;
426 int regBase = sqlite3GetTempRange(pParse, nExpr+2);
427 int regRecord = sqlite3GetTempReg(pParse);
drhc6aff302011-09-01 15:32:47 +0000428 int op;
drhceea3322009-04-23 13:22:42 +0000429 sqlite3ExprCacheClear(pParse);
drh191b54c2008-04-15 12:14:21 +0000430 sqlite3ExprCodeExprList(pParse, pOrderBy, regBase, 0);
drh892d3172008-01-10 03:46:36 +0000431 sqlite3VdbeAddOp2(v, OP_Sequence, pOrderBy->iECursor, regBase+nExpr);
drhb21e7c72008-06-22 12:37:57 +0000432 sqlite3ExprCodeMove(pParse, regData, regBase+nExpr+1, 1);
drh1db639c2008-01-17 02:36:28 +0000433 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nExpr + 2, regRecord);
drhc6aff302011-09-01 15:32:47 +0000434 if( pSelect->selFlags & SF_UseSorter ){
435 op = OP_SorterInsert;
436 }else{
437 op = OP_IdxInsert;
438 }
439 sqlite3VdbeAddOp2(v, op, pOrderBy->iECursor, regRecord);
drh892d3172008-01-10 03:46:36 +0000440 sqlite3ReleaseTempReg(pParse, regRecord);
441 sqlite3ReleaseTempRange(pParse, regBase, nExpr+2);
drh92b01d52008-06-24 00:32:35 +0000442 if( pSelect->iLimit ){
drh15007a92006-01-08 18:10:17 +0000443 int addr1, addr2;
drhb7654112008-01-12 12:48:07 +0000444 int iLimit;
drh0acb7e42008-06-25 00:12:41 +0000445 if( pSelect->iOffset ){
drhb7654112008-01-12 12:48:07 +0000446 iLimit = pSelect->iOffset+1;
447 }else{
448 iLimit = pSelect->iLimit;
449 }
450 addr1 = sqlite3VdbeAddOp1(v, OP_IfZero, iLimit);
451 sqlite3VdbeAddOp2(v, OP_AddImm, iLimit, -1);
drh3c84ddf2008-01-09 02:15:38 +0000452 addr2 = sqlite3VdbeAddOp0(v, OP_Goto);
drhd59ba6c2006-01-08 05:02:54 +0000453 sqlite3VdbeJumpHere(v, addr1);
drh3c84ddf2008-01-09 02:15:38 +0000454 sqlite3VdbeAddOp1(v, OP_Last, pOrderBy->iECursor);
455 sqlite3VdbeAddOp1(v, OP_Delete, pOrderBy->iECursor);
drh15007a92006-01-08 18:10:17 +0000456 sqlite3VdbeJumpHere(v, addr2);
drhd59ba6c2006-01-08 05:02:54 +0000457 }
drhc926afb2002-06-20 03:38:26 +0000458}
459
460/*
drhec7429a2005-10-06 16:53:14 +0000461** Add code to implement the OFFSET
drhea48eb22004-07-19 23:16:38 +0000462*/
drhec7429a2005-10-06 16:53:14 +0000463static void codeOffset(
drhbab39e12004-07-19 23:38:11 +0000464 Vdbe *v, /* Generate code into this VM */
drhea48eb22004-07-19 23:16:38 +0000465 Select *p, /* The SELECT statement being coded */
drhb7654112008-01-12 12:48:07 +0000466 int iContinue /* Jump here to skip the current record */
drhea48eb22004-07-19 23:16:38 +0000467){
drh92b01d52008-06-24 00:32:35 +0000468 if( p->iOffset && iContinue!=0 ){
drh15007a92006-01-08 18:10:17 +0000469 int addr;
drh8558cde2008-01-05 05:20:10 +0000470 sqlite3VdbeAddOp2(v, OP_AddImm, p->iOffset, -1);
drh3c84ddf2008-01-09 02:15:38 +0000471 addr = sqlite3VdbeAddOp1(v, OP_IfNeg, p->iOffset);
drh66a51672008-01-03 00:01:23 +0000472 sqlite3VdbeAddOp2(v, OP_Goto, 0, iContinue);
drhd4e70eb2008-01-02 00:34:36 +0000473 VdbeComment((v, "skip OFFSET records"));
drh15007a92006-01-08 18:10:17 +0000474 sqlite3VdbeJumpHere(v, addr);
drhea48eb22004-07-19 23:16:38 +0000475 }
drhea48eb22004-07-19 23:16:38 +0000476}
477
478/*
drh98757152008-01-09 23:04:12 +0000479** Add code that will check to make sure the N registers starting at iMem
480** form a distinct entry. iTab is a sorting index that holds previously
drha2a49dc2008-01-02 14:28:13 +0000481** seen combinations of the N values. A new entry is made in iTab
482** if the current N values are new.
483**
484** A jump to addrRepeat is made and the N+1 values are popped from the
485** stack if the top N elements are not distinct.
486*/
487static void codeDistinct(
drh2dcef112008-01-12 19:03:48 +0000488 Parse *pParse, /* Parsing and code generating context */
drha2a49dc2008-01-02 14:28:13 +0000489 int iTab, /* A sorting index used to test for distinctness */
490 int addrRepeat, /* Jump to here if not distinct */
drh477df4b2008-01-05 18:48:24 +0000491 int N, /* Number of elements */
drha2a49dc2008-01-02 14:28:13 +0000492 int iMem /* First element */
493){
drh2dcef112008-01-12 19:03:48 +0000494 Vdbe *v;
495 int r1;
496
497 v = pParse->pVdbe;
498 r1 = sqlite3GetTempReg(pParse);
drh91fc4a02009-11-12 20:39:03 +0000499 sqlite3VdbeAddOp4Int(v, OP_Found, iTab, addrRepeat, iMem, N);
drh1db639c2008-01-17 02:36:28 +0000500 sqlite3VdbeAddOp3(v, OP_MakeRecord, iMem, N, r1);
drh2dcef112008-01-12 19:03:48 +0000501 sqlite3VdbeAddOp2(v, OP_IdxInsert, iTab, r1);
502 sqlite3ReleaseTempReg(pParse, r1);
drha2a49dc2008-01-02 14:28:13 +0000503}
504
drhbb7dd682010-09-07 12:17:36 +0000505#ifndef SQLITE_OMIT_SUBQUERY
drha2a49dc2008-01-02 14:28:13 +0000506/*
drhe305f432007-05-09 22:56:39 +0000507** Generate an error message when a SELECT is used within a subexpression
508** (example: "a IN (SELECT * FROM table)") but it has more than 1 result
drhbb7dd682010-09-07 12:17:36 +0000509** column. We do this in a subroutine because the error used to occur
510** in multiple places. (The error only occurs in one place now, but we
511** retain the subroutine to minimize code disruption.)
drhe305f432007-05-09 22:56:39 +0000512*/
danielk19776c8c8ce2008-01-02 16:27:09 +0000513static int checkForMultiColumnSelectError(
514 Parse *pParse, /* Parse context. */
515 SelectDest *pDest, /* Destination of SELECT results */
516 int nExpr /* Number of result columns returned by SELECT */
517){
518 int eDest = pDest->eDest;
drhe305f432007-05-09 22:56:39 +0000519 if( nExpr>1 && (eDest==SRT_Mem || eDest==SRT_Set) ){
520 sqlite3ErrorMsg(pParse, "only a single result allowed for "
521 "a SELECT that is part of an expression");
522 return 1;
523 }else{
524 return 0;
525 }
526}
drhbb7dd682010-09-07 12:17:36 +0000527#endif
drhc99130f2005-09-11 11:56:27 +0000528
529/*
drhe8e4af72012-09-21 00:04:28 +0000530** An instance of the following object is used to record information about
531** how to process the DISTINCT keyword, to simplify passing that information
532** into the selectInnerLoop() routine.
533*/
534typedef struct DistinctCtx DistinctCtx;
535struct DistinctCtx {
536 u8 isTnct; /* True if the DISTINCT keyword is present */
537 u8 eTnctType; /* One of the WHERE_DISTINCT_* operators */
538 int tabTnct; /* Ephemeral table used for DISTINCT processing */
539 int addrTnct; /* Address of OP_OpenEphemeral opcode for tabTnct */
540};
541
542/*
drh22827922000-06-06 17:27:05 +0000543** This routine generates the code for the inside of the inner loop
544** of a SELECT.
drh82c3d632000-06-06 21:56:07 +0000545**
drh38640e12002-07-05 21:42:36 +0000546** If srcTab and nColumn are both zero, then the pEList expressions
547** are evaluated in order to get the data for this row. If nColumn>0
548** then data is pulled from srcTab and pEList is used only to get the
549** datatypes for each column.
drh22827922000-06-06 17:27:05 +0000550*/
drhd2b3e232008-01-23 14:51:49 +0000551static void selectInnerLoop(
drh22827922000-06-06 17:27:05 +0000552 Parse *pParse, /* The parser context */
drhdf199a22002-06-14 22:38:41 +0000553 Select *p, /* The complete select statement being coded */
drh22827922000-06-06 17:27:05 +0000554 ExprList *pEList, /* List of values being extracted */
drh82c3d632000-06-06 21:56:07 +0000555 int srcTab, /* Pull data from this table */
drh967e8b72000-06-21 13:59:10 +0000556 int nColumn, /* Number of columns in the source table */
drh22827922000-06-06 17:27:05 +0000557 ExprList *pOrderBy, /* If not NULL, sort results using this key */
drhe8e4af72012-09-21 00:04:28 +0000558 DistinctCtx *pDistinct, /* If not NULL, info on how to process DISTINCT */
danielk19776c8c8ce2008-01-02 16:27:09 +0000559 SelectDest *pDest, /* How to dispose of the results */
drh22827922000-06-06 17:27:05 +0000560 int iContinue, /* Jump here to continue with next row */
drha9671a22008-07-08 23:40:20 +0000561 int iBreak /* Jump here to break out of the inner loop */
drh22827922000-06-06 17:27:05 +0000562){
563 Vdbe *v = pParse->pVdbe;
drhd847eaa2008-01-17 17:15:56 +0000564 int i;
drhea48eb22004-07-19 23:16:38 +0000565 int hasDistinct; /* True if the DISTINCT keyword is present */
drhd847eaa2008-01-17 17:15:56 +0000566 int regResult; /* Start of memory holding result set */
567 int eDest = pDest->eDest; /* How to dispose of results */
drh2b596da2012-07-23 21:43:19 +0000568 int iParm = pDest->iSDParm; /* First argument to disposal method */
drhd847eaa2008-01-17 17:15:56 +0000569 int nResultCol; /* Number of result columns */
drh38640e12002-07-05 21:42:36 +0000570
drh1c767f02009-01-09 02:49:31 +0000571 assert( v );
572 if( NEVER(v==0) ) return;
drh38640e12002-07-05 21:42:36 +0000573 assert( pEList!=0 );
drhe8e4af72012-09-21 00:04:28 +0000574 hasDistinct = pDistinct ? pDistinct->eTnctType : WHERE_DISTINCT_NOOP;
drhea48eb22004-07-19 23:16:38 +0000575 if( pOrderBy==0 && !hasDistinct ){
drhb7654112008-01-12 12:48:07 +0000576 codeOffset(v, p, iContinue);
drhdf199a22002-06-14 22:38:41 +0000577 }
578
drh967e8b72000-06-21 13:59:10 +0000579 /* Pull the requested columns.
drh22827922000-06-06 17:27:05 +0000580 */
drh38640e12002-07-05 21:42:36 +0000581 if( nColumn>0 ){
drhd847eaa2008-01-17 17:15:56 +0000582 nResultCol = nColumn;
drha2a49dc2008-01-02 14:28:13 +0000583 }else{
drhd847eaa2008-01-17 17:15:56 +0000584 nResultCol = pEList->nExpr;
drha2a49dc2008-01-02 14:28:13 +0000585 }
drh2b596da2012-07-23 21:43:19 +0000586 if( pDest->iSdst==0 ){
587 pDest->iSdst = pParse->nMem+1;
588 pDest->nSdst = nResultCol;
drh0acb7e42008-06-25 00:12:41 +0000589 pParse->nMem += nResultCol;
drh1c767f02009-01-09 02:49:31 +0000590 }else{
drh2b596da2012-07-23 21:43:19 +0000591 assert( pDest->nSdst==nResultCol );
drh1013c932008-01-06 00:25:21 +0000592 }
drh2b596da2012-07-23 21:43:19 +0000593 regResult = pDest->iSdst;
drha2a49dc2008-01-02 14:28:13 +0000594 if( nColumn>0 ){
drh967e8b72000-06-21 13:59:10 +0000595 for(i=0; i<nColumn; i++){
drhd847eaa2008-01-17 17:15:56 +0000596 sqlite3VdbeAddOp3(v, OP_Column, srcTab, i, regResult+i);
drh82c3d632000-06-06 21:56:07 +0000597 }
danielk19779ed1dfa2008-01-02 17:11:14 +0000598 }else if( eDest!=SRT_Exists ){
599 /* If the destination is an EXISTS(...) expression, the actual
600 ** values returned by the SELECT are not required.
601 */
drhd1a01ed2013-11-21 16:08:52 +0000602 sqlite3ExprCodeExprList(pParse, pEList, regResult,
603 (eDest==SRT_Output)?SQLITE_ECEL_DUP:0);
drh22827922000-06-06 17:27:05 +0000604 }
drhd847eaa2008-01-17 17:15:56 +0000605 nColumn = nResultCol;
drh22827922000-06-06 17:27:05 +0000606
drhdaffd0e2001-04-11 14:28:42 +0000607 /* If the DISTINCT keyword was present on the SELECT statement
608 ** and this row has been seen before, then do not make this row
609 ** part of the result.
drh22827922000-06-06 17:27:05 +0000610 */
drhea48eb22004-07-19 23:16:38 +0000611 if( hasDistinct ){
drhf8875402006-03-17 13:56:34 +0000612 assert( pEList!=0 );
613 assert( pEList->nExpr==nColumn );
drhe8e4af72012-09-21 00:04:28 +0000614 switch( pDistinct->eTnctType ){
615 case WHERE_DISTINCT_ORDERED: {
616 VdbeOp *pOp; /* No longer required OpenEphemeral instr. */
617 int iJump; /* Jump destination */
618 int regPrev; /* Previous row content */
619
620 /* Allocate space for the previous row */
621 regPrev = pParse->nMem+1;
622 pParse->nMem += nColumn;
623
624 /* Change the OP_OpenEphemeral coded earlier to an OP_Null
625 ** sets the MEM_Cleared bit on the first register of the
626 ** previous value. This will cause the OP_Ne below to always
627 ** fail on the first iteration of the loop even if the first
628 ** row is all NULLs.
629 */
630 sqlite3VdbeChangeToNoop(v, pDistinct->addrTnct);
631 pOp = sqlite3VdbeGetOp(v, pDistinct->addrTnct);
632 pOp->opcode = OP_Null;
633 pOp->p1 = 1;
634 pOp->p2 = regPrev;
635
636 iJump = sqlite3VdbeCurrentAddr(v) + nColumn;
637 for(i=0; i<nColumn; i++){
638 CollSeq *pColl = sqlite3ExprCollSeq(pParse, pEList->a[i].pExpr);
639 if( i<nColumn-1 ){
640 sqlite3VdbeAddOp3(v, OP_Ne, regResult+i, iJump, regPrev+i);
641 }else{
642 sqlite3VdbeAddOp3(v, OP_Eq, regResult+i, iContinue, regPrev+i);
643 }
644 sqlite3VdbeChangeP4(v, -1, (const char *)pColl, P4_COLLSEQ);
645 sqlite3VdbeChangeP5(v, SQLITE_NULLEQ);
646 }
647 assert( sqlite3VdbeCurrentAddr(v)==iJump );
648 sqlite3VdbeAddOp3(v, OP_Copy, regResult, regPrev, nColumn-1);
649 break;
650 }
651
652 case WHERE_DISTINCT_UNIQUE: {
653 sqlite3VdbeChangeToNoop(v, pDistinct->addrTnct);
654 break;
655 }
656
657 default: {
658 assert( pDistinct->eTnctType==WHERE_DISTINCT_UNORDERED );
659 codeDistinct(pParse, pDistinct->tabTnct, iContinue, nColumn, regResult);
660 break;
661 }
662 }
drhea48eb22004-07-19 23:16:38 +0000663 if( pOrderBy==0 ){
drhb7654112008-01-12 12:48:07 +0000664 codeOffset(v, p, iContinue);
drhea48eb22004-07-19 23:16:38 +0000665 }
drh22827922000-06-06 17:27:05 +0000666 }
drh82c3d632000-06-06 21:56:07 +0000667
drhc926afb2002-06-20 03:38:26 +0000668 switch( eDest ){
669 /* In this mode, write each query result to the key of the temporary
670 ** table iParm.
671 */
drh13449892005-09-07 21:22:45 +0000672#ifndef SQLITE_OMIT_COMPOUND_SELECT
drhc926afb2002-06-20 03:38:26 +0000673 case SRT_Union: {
drh9cbf3422008-01-17 16:22:13 +0000674 int r1;
675 r1 = sqlite3GetTempReg(pParse);
drhd847eaa2008-01-17 17:15:56 +0000676 sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nColumn, r1);
drh9cbf3422008-01-17 16:22:13 +0000677 sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, r1);
678 sqlite3ReleaseTempReg(pParse, r1);
drhc926afb2002-06-20 03:38:26 +0000679 break;
drh22827922000-06-06 17:27:05 +0000680 }
drh22827922000-06-06 17:27:05 +0000681
drhc926afb2002-06-20 03:38:26 +0000682 /* Construct a record from the query result, but instead of
683 ** saving that record, use it as a key to delete elements from
684 ** the temporary table iParm.
685 */
686 case SRT_Except: {
drhe14006d2008-03-25 17:23:32 +0000687 sqlite3VdbeAddOp3(v, OP_IdxDelete, iParm, regResult, nColumn);
drhc926afb2002-06-20 03:38:26 +0000688 break;
689 }
danielk19775338a5f2005-01-20 13:03:10 +0000690#endif
691
692 /* Store the result as data using a unique key.
693 */
dan8ce71842014-01-14 20:14:09 +0000694 case SRT_DistTable:
danielk19775338a5f2005-01-20 13:03:10 +0000695 case SRT_Table:
drhb9bb7c12006-06-11 23:41:55 +0000696 case SRT_EphemTab: {
drhb7654112008-01-12 12:48:07 +0000697 int r1 = sqlite3GetTempReg(pParse);
drh373cc2d2009-05-17 02:06:14 +0000698 testcase( eDest==SRT_Table );
699 testcase( eDest==SRT_EphemTab );
drhd847eaa2008-01-17 17:15:56 +0000700 sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nColumn, r1);
dan8ce71842014-01-14 20:14:09 +0000701#ifndef SQLITE_OMIT_CTE
702 if( eDest==SRT_DistTable ){
703 /* If the destination is DistTable, then cursor (iParm+1) is open
704 ** on an ephemeral index. If the current row is already present
705 ** in the index, do not write it to the output. If not, add the
706 ** current row to the index and proceed with writing it to the
707 ** output table as well. */
708 int addr = sqlite3VdbeCurrentAddr(v) + 4;
709 sqlite3VdbeAddOp4Int(v, OP_Found, iParm+1, addr, r1, 0);
710 sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm+1, r1);
711 assert( pOrderBy==0 );
712 }
713#endif
danielk19775338a5f2005-01-20 13:03:10 +0000714 if( pOrderBy ){
drhb7654112008-01-12 12:48:07 +0000715 pushOntoSorter(pParse, pOrderBy, p, r1);
danielk19775338a5f2005-01-20 13:03:10 +0000716 }else{
drhb7654112008-01-12 12:48:07 +0000717 int r2 = sqlite3GetTempReg(pParse);
718 sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, r2);
719 sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, r2);
720 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
721 sqlite3ReleaseTempReg(pParse, r2);
danielk19775338a5f2005-01-20 13:03:10 +0000722 }
drhb7654112008-01-12 12:48:07 +0000723 sqlite3ReleaseTempReg(pParse, r1);
danielk19775338a5f2005-01-20 13:03:10 +0000724 break;
725 }
drh5974a302000-06-07 14:42:26 +0000726
danielk197793758c82005-01-21 08:13:14 +0000727#ifndef SQLITE_OMIT_SUBQUERY
drhc926afb2002-06-20 03:38:26 +0000728 /* If we are creating a set for an "expr IN (SELECT ...)" construct,
729 ** then there should be a single item on the stack. Write this
730 ** item into the set table with bogus data.
731 */
732 case SRT_Set: {
733 assert( nColumn==1 );
drh634d81d2012-09-20 15:41:31 +0000734 pDest->affSdst =
735 sqlite3CompareAffinity(pEList->a[0].pExpr, pDest->affSdst);
drhc926afb2002-06-20 03:38:26 +0000736 if( pOrderBy ){
drhde941c62005-08-28 01:34:21 +0000737 /* At first glance you would think we could optimize out the
738 ** ORDER BY in this case since the order of entries in the set
739 ** does not matter. But there might be a LIMIT clause, in which
740 ** case the order does matter */
drhd847eaa2008-01-17 17:15:56 +0000741 pushOntoSorter(pParse, pOrderBy, p, regResult);
drhc926afb2002-06-20 03:38:26 +0000742 }else{
drhb7654112008-01-12 12:48:07 +0000743 int r1 = sqlite3GetTempReg(pParse);
drh634d81d2012-09-20 15:41:31 +0000744 sqlite3VdbeAddOp4(v, OP_MakeRecord, regResult,1,r1, &pDest->affSdst, 1);
drhda250ea2008-04-01 05:07:14 +0000745 sqlite3ExprCacheAffinityChange(pParse, regResult, 1);
drhb7654112008-01-12 12:48:07 +0000746 sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, r1);
747 sqlite3ReleaseTempReg(pParse, r1);
drhc926afb2002-06-20 03:38:26 +0000748 }
749 break;
750 }
drh22827922000-06-06 17:27:05 +0000751
drh504b6982006-01-22 21:52:56 +0000752 /* If any row exist in the result set, record that fact and abort.
drhec7429a2005-10-06 16:53:14 +0000753 */
754 case SRT_Exists: {
drh4c583122008-01-04 22:01:03 +0000755 sqlite3VdbeAddOp2(v, OP_Integer, 1, iParm);
drhec7429a2005-10-06 16:53:14 +0000756 /* The LIMIT clause will terminate the loop for us */
757 break;
758 }
759
drhc926afb2002-06-20 03:38:26 +0000760 /* If this is a scalar select that is part of an expression, then
761 ** store the results in the appropriate memory cell and break out
762 ** of the scan loop.
763 */
764 case SRT_Mem: {
765 assert( nColumn==1 );
766 if( pOrderBy ){
drhd847eaa2008-01-17 17:15:56 +0000767 pushOntoSorter(pParse, pOrderBy, p, regResult);
drhc926afb2002-06-20 03:38:26 +0000768 }else{
drhb21e7c72008-06-22 12:37:57 +0000769 sqlite3ExprCodeMove(pParse, regResult, iParm, 1);
drhec7429a2005-10-06 16:53:14 +0000770 /* The LIMIT clause will jump out of the loop for us */
drhc926afb2002-06-20 03:38:26 +0000771 }
772 break;
773 }
danielk197793758c82005-01-21 08:13:14 +0000774#endif /* #ifndef SQLITE_OMIT_SUBQUERY */
drh22827922000-06-06 17:27:05 +0000775
drhc182d162005-08-14 20:47:16 +0000776 /* Send the data to the callback function or to a subroutine. In the
777 ** case of a subroutine, the subroutine itself is responsible for
778 ** popping the data from the stack.
drhf46f9052002-06-22 02:33:38 +0000779 */
drhe00ee6e2008-06-20 15:24:01 +0000780 case SRT_Coroutine:
drh7d10d5a2008-08-20 16:35:10 +0000781 case SRT_Output: {
drh373cc2d2009-05-17 02:06:14 +0000782 testcase( eDest==SRT_Coroutine );
783 testcase( eDest==SRT_Output );
drhf46f9052002-06-22 02:33:38 +0000784 if( pOrderBy ){
drhb7654112008-01-12 12:48:07 +0000785 int r1 = sqlite3GetTempReg(pParse);
drhd847eaa2008-01-17 17:15:56 +0000786 sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nColumn, r1);
drhb7654112008-01-12 12:48:07 +0000787 pushOntoSorter(pParse, pOrderBy, p, r1);
788 sqlite3ReleaseTempReg(pParse, r1);
drhe00ee6e2008-06-20 15:24:01 +0000789 }else if( eDest==SRT_Coroutine ){
drh2b596da2012-07-23 21:43:19 +0000790 sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm);
drhc182d162005-08-14 20:47:16 +0000791 }else{
drhd847eaa2008-01-17 17:15:56 +0000792 sqlite3VdbeAddOp2(v, OP_ResultRow, regResult, nColumn);
drhda250ea2008-04-01 05:07:14 +0000793 sqlite3ExprCacheAffinityChange(pParse, regResult, nColumn);
drhac82fcf2002-09-08 17:23:41 +0000794 }
drh142e30d2002-08-28 03:00:58 +0000795 break;
796 }
797
danielk19776a67fe82005-02-04 04:07:16 +0000798#if !defined(SQLITE_OMIT_TRIGGER)
drhc926afb2002-06-20 03:38:26 +0000799 /* Discard the results. This is used for SELECT statements inside
800 ** the body of a TRIGGER. The purpose of such selects is to call
801 ** user-defined functions that have side effects. We do not care
802 ** about the actual results of the select.
803 */
drhc926afb2002-06-20 03:38:26 +0000804 default: {
drhf46f9052002-06-22 02:33:38 +0000805 assert( eDest==SRT_Discard );
drhc926afb2002-06-20 03:38:26 +0000806 break;
807 }
danielk197793758c82005-01-21 08:13:14 +0000808#endif
drh82c3d632000-06-06 21:56:07 +0000809 }
drhec7429a2005-10-06 16:53:14 +0000810
drh5e87be82010-10-06 18:55:37 +0000811 /* Jump to the end of the loop if the LIMIT is reached. Except, if
812 ** there is a sorter, in which case the sorter has already limited
813 ** the output for us.
drhec7429a2005-10-06 16:53:14 +0000814 */
drh5e87be82010-10-06 18:55:37 +0000815 if( pOrderBy==0 && p->iLimit ){
drh9b918ed2009-11-12 03:13:26 +0000816 sqlite3VdbeAddOp3(v, OP_IfZero, p->iLimit, iBreak, -1);
drhec7429a2005-10-06 16:53:14 +0000817 }
drh82c3d632000-06-06 21:56:07 +0000818}
819
820/*
drhad124322013-10-23 13:30:58 +0000821** Allocate a KeyInfo object sufficient for an index of N key columns and
822** X extra columns.
drh323df792013-08-05 19:11:29 +0000823*/
drhad124322013-10-23 13:30:58 +0000824KeyInfo *sqlite3KeyInfoAlloc(sqlite3 *db, int N, int X){
drh2ec2fb22013-11-06 19:59:23 +0000825 KeyInfo *p = sqlite3DbMallocZero(0,
drhad124322013-10-23 13:30:58 +0000826 sizeof(KeyInfo) + (N+X)*(sizeof(CollSeq*)+1));
drh323df792013-08-05 19:11:29 +0000827 if( p ){
drhad124322013-10-23 13:30:58 +0000828 p->aSortOrder = (u8*)&p->aColl[N+X];
drh323df792013-08-05 19:11:29 +0000829 p->nField = (u16)N;
drhad124322013-10-23 13:30:58 +0000830 p->nXField = (u16)X;
drh323df792013-08-05 19:11:29 +0000831 p->enc = ENC(db);
832 p->db = db;
drh2ec2fb22013-11-06 19:59:23 +0000833 p->nRef = 1;
834 }else{
835 db->mallocFailed = 1;
drh323df792013-08-05 19:11:29 +0000836 }
837 return p;
838}
839
840/*
drh2ec2fb22013-11-06 19:59:23 +0000841** Deallocate a KeyInfo object
842*/
843void sqlite3KeyInfoUnref(KeyInfo *p){
844 if( p ){
845 assert( p->nRef>0 );
drh2ec2fb22013-11-06 19:59:23 +0000846 p->nRef--;
mistachkinc6efe122013-11-09 23:44:02 +0000847 if( p->nRef==0 ) sqlite3DbFree(0, p);
drh2ec2fb22013-11-06 19:59:23 +0000848 }
849}
850
851/*
852** Make a new pointer to a KeyInfo object
853*/
854KeyInfo *sqlite3KeyInfoRef(KeyInfo *p){
855 if( p ){
856 assert( p->nRef>0 );
857 p->nRef++;
858 }
859 return p;
860}
861
862#ifdef SQLITE_DEBUG
863/*
864** Return TRUE if a KeyInfo object can be change. The KeyInfo object
865** can only be changed if this is just a single reference to the object.
866**
867** This routine is used only inside of assert() statements.
868*/
869int sqlite3KeyInfoIsWriteable(KeyInfo *p){ return p->nRef==1; }
870#endif /* SQLITE_DEBUG */
871
872/*
drhdece1a82005-08-31 18:20:00 +0000873** Given an expression list, generate a KeyInfo structure that records
874** the collating sequence for each expression in that expression list.
875**
drh0342b1f2005-09-01 03:07:44 +0000876** If the ExprList is an ORDER BY or GROUP BY clause then the resulting
877** KeyInfo structure is appropriate for initializing a virtual index to
878** implement that clause. If the ExprList is the result set of a SELECT
879** then the KeyInfo structure is appropriate for initializing a virtual
880** index to implement a DISTINCT test.
881**
drhdece1a82005-08-31 18:20:00 +0000882** Space to hold the KeyInfo structure is obtain from malloc. The calling
883** function is responsible for seeing that this structure is eventually
drh2ec2fb22013-11-06 19:59:23 +0000884** freed.
drhdece1a82005-08-31 18:20:00 +0000885*/
886static KeyInfo *keyInfoFromExprList(Parse *pParse, ExprList *pList){
drhdece1a82005-08-31 18:20:00 +0000887 int nExpr;
888 KeyInfo *pInfo;
889 struct ExprList_item *pItem;
drh323df792013-08-05 19:11:29 +0000890 sqlite3 *db = pParse->db;
drhdece1a82005-08-31 18:20:00 +0000891 int i;
892
893 nExpr = pList->nExpr;
drhad124322013-10-23 13:30:58 +0000894 pInfo = sqlite3KeyInfoAlloc(db, nExpr, 1);
drhdece1a82005-08-31 18:20:00 +0000895 if( pInfo ){
drh2ec2fb22013-11-06 19:59:23 +0000896 assert( sqlite3KeyInfoIsWriteable(pInfo) );
drhdece1a82005-08-31 18:20:00 +0000897 for(i=0, pItem=pList->a; i<nExpr; i++, pItem++){
898 CollSeq *pColl;
899 pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
drh323df792013-08-05 19:11:29 +0000900 if( !pColl ) pColl = db->pDfltColl;
drhdece1a82005-08-31 18:20:00 +0000901 pInfo->aColl[i] = pColl;
902 pInfo->aSortOrder[i] = pItem->sortOrder;
903 }
904 }
905 return pInfo;
906}
907
dan7f61e922010-11-11 16:46:40 +0000908#ifndef SQLITE_OMIT_COMPOUND_SELECT
909/*
910** Name of the connection operator, used for error messages.
911*/
912static const char *selectOpName(int id){
913 char *z;
914 switch( id ){
915 case TK_ALL: z = "UNION ALL"; break;
916 case TK_INTERSECT: z = "INTERSECT"; break;
917 case TK_EXCEPT: z = "EXCEPT"; break;
918 default: z = "UNION"; break;
919 }
920 return z;
921}
922#endif /* SQLITE_OMIT_COMPOUND_SELECT */
923
dan2ce22452010-11-08 19:01:16 +0000924#ifndef SQLITE_OMIT_EXPLAIN
dan17c0bc02010-11-09 17:35:19 +0000925/*
926** Unless an "EXPLAIN QUERY PLAN" command is being processed, this function
927** is a no-op. Otherwise, it adds a single row of output to the EQP result,
928** where the caption is of the form:
929**
930** "USE TEMP B-TREE FOR xxx"
931**
932** where xxx is one of "DISTINCT", "ORDER BY" or "GROUP BY". Exactly which
933** is determined by the zUsage argument.
934*/
dan2ce22452010-11-08 19:01:16 +0000935static void explainTempTable(Parse *pParse, const char *zUsage){
936 if( pParse->explain==2 ){
937 Vdbe *v = pParse->pVdbe;
938 char *zMsg = sqlite3MPrintf(pParse->db, "USE TEMP B-TREE FOR %s", zUsage);
939 sqlite3VdbeAddOp4(v, OP_Explain, pParse->iSelectId, 0, 0, zMsg, P4_DYNAMIC);
940 }
941}
dan17c0bc02010-11-09 17:35:19 +0000942
943/*
danbb2b4412011-04-06 17:54:31 +0000944** Assign expression b to lvalue a. A second, no-op, version of this macro
945** is provided when SQLITE_OMIT_EXPLAIN is defined. This allows the code
946** in sqlite3Select() to assign values to structure member variables that
947** only exist if SQLITE_OMIT_EXPLAIN is not defined without polluting the
948** code with #ifndef directives.
949*/
950# define explainSetInteger(a, b) a = b
951
952#else
953/* No-op versions of the explainXXX() functions and macros. */
954# define explainTempTable(y,z)
955# define explainSetInteger(y,z)
956#endif
957
958#if !defined(SQLITE_OMIT_EXPLAIN) && !defined(SQLITE_OMIT_COMPOUND_SELECT)
959/*
dan7f61e922010-11-11 16:46:40 +0000960** Unless an "EXPLAIN QUERY PLAN" command is being processed, this function
961** is a no-op. Otherwise, it adds a single row of output to the EQP result,
962** where the caption is of one of the two forms:
963**
964** "COMPOSITE SUBQUERIES iSub1 and iSub2 (op)"
965** "COMPOSITE SUBQUERIES iSub1 and iSub2 USING TEMP B-TREE (op)"
966**
967** where iSub1 and iSub2 are the integers passed as the corresponding
968** function parameters, and op is the text representation of the parameter
969** of the same name. The parameter "op" must be one of TK_UNION, TK_EXCEPT,
970** TK_INTERSECT or TK_ALL. The first form is used if argument bUseTmp is
971** false, or the second form if it is true.
972*/
973static void explainComposite(
974 Parse *pParse, /* Parse context */
975 int op, /* One of TK_UNION, TK_EXCEPT etc. */
976 int iSub1, /* Subquery id 1 */
977 int iSub2, /* Subquery id 2 */
978 int bUseTmp /* True if a temp table was used */
979){
980 assert( op==TK_UNION || op==TK_EXCEPT || op==TK_INTERSECT || op==TK_ALL );
981 if( pParse->explain==2 ){
982 Vdbe *v = pParse->pVdbe;
983 char *zMsg = sqlite3MPrintf(
dan30969d32010-11-11 17:48:51 +0000984 pParse->db, "COMPOUND SUBQUERIES %d AND %d %s(%s)", iSub1, iSub2,
dan7f61e922010-11-11 16:46:40 +0000985 bUseTmp?"USING TEMP B-TREE ":"", selectOpName(op)
986 );
987 sqlite3VdbeAddOp4(v, OP_Explain, pParse->iSelectId, 0, 0, zMsg, P4_DYNAMIC);
988 }
989}
dan2ce22452010-11-08 19:01:16 +0000990#else
dan17c0bc02010-11-09 17:35:19 +0000991/* No-op versions of the explainXXX() functions and macros. */
dan7f61e922010-11-11 16:46:40 +0000992# define explainComposite(v,w,x,y,z)
dan2ce22452010-11-08 19:01:16 +0000993#endif
drhdece1a82005-08-31 18:20:00 +0000994
995/*
drhd8bc7082000-06-07 23:51:50 +0000996** If the inner loop was generated using a non-null pOrderBy argument,
997** then the results were placed in a sorter. After the loop is terminated
998** we need to run the sorter and output the results. The following
999** routine generates the code needed to do that.
1000*/
drhc926afb2002-06-20 03:38:26 +00001001static void generateSortTail(
danielk19776c8c8ce2008-01-02 16:27:09 +00001002 Parse *pParse, /* Parsing context */
1003 Select *p, /* The SELECT statement */
1004 Vdbe *v, /* Generate code into this VDBE */
1005 int nColumn, /* Number of columns of data */
1006 SelectDest *pDest /* Write the sorted results here */
drhc926afb2002-06-20 03:38:26 +00001007){
drhdc5ea5c2008-12-10 17:19:59 +00001008 int addrBreak = sqlite3VdbeMakeLabel(v); /* Jump here to exit loop */
1009 int addrContinue = sqlite3VdbeMakeLabel(v); /* Jump here for next cycle */
drhd8bc7082000-06-07 23:51:50 +00001010 int addr;
drh0342b1f2005-09-01 03:07:44 +00001011 int iTab;
drh61fc5952007-04-01 23:49:51 +00001012 int pseudoTab = 0;
drh0342b1f2005-09-01 03:07:44 +00001013 ExprList *pOrderBy = p->pOrderBy;
drhffbc3082004-05-21 01:29:06 +00001014
danielk19776c8c8ce2008-01-02 16:27:09 +00001015 int eDest = pDest->eDest;
drh2b596da2012-07-23 21:43:19 +00001016 int iParm = pDest->iSDParm;
danielk19776c8c8ce2008-01-02 16:27:09 +00001017
drh2d401ab2008-01-10 23:50:11 +00001018 int regRow;
1019 int regRowid;
1020
drh9d2985c2005-09-08 01:58:42 +00001021 iTab = pOrderBy->iECursor;
drh3e9ca092009-09-08 01:14:48 +00001022 regRow = sqlite3GetTempReg(pParse);
drh7d10d5a2008-08-20 16:35:10 +00001023 if( eDest==SRT_Output || eDest==SRT_Coroutine ){
drhcdd536f2006-03-17 00:04:03 +00001024 pseudoTab = pParse->nTab++;
drh3e9ca092009-09-08 01:14:48 +00001025 sqlite3VdbeAddOp3(v, OP_OpenPseudo, pseudoTab, regRow, nColumn);
1026 regRowid = 0;
1027 }else{
1028 regRowid = sqlite3GetTempReg(pParse);
drhcdd536f2006-03-17 00:04:03 +00001029 }
drhc6aff302011-09-01 15:32:47 +00001030 if( p->selFlags & SF_UseSorter ){
drhc2bb3282011-09-04 01:11:46 +00001031 int regSortOut = ++pParse->nMem;
drhc6aff302011-09-01 15:32:47 +00001032 int ptab2 = pParse->nTab++;
1033 sqlite3VdbeAddOp3(v, OP_OpenPseudo, ptab2, regSortOut, pOrderBy->nExpr+2);
1034 addr = 1 + sqlite3VdbeAddOp2(v, OP_SorterSort, iTab, addrBreak);
1035 codeOffset(v, p, addrContinue);
1036 sqlite3VdbeAddOp2(v, OP_SorterData, iTab, regSortOut);
1037 sqlite3VdbeAddOp3(v, OP_Column, ptab2, pOrderBy->nExpr+1, regRow);
1038 sqlite3VdbeChangeP5(v, OPFLAG_CLEARCACHE);
1039 }else{
1040 addr = 1 + sqlite3VdbeAddOp2(v, OP_Sort, iTab, addrBreak);
1041 codeOffset(v, p, addrContinue);
1042 sqlite3VdbeAddOp3(v, OP_Column, iTab, pOrderBy->nExpr+1, regRow);
1043 }
drhc926afb2002-06-20 03:38:26 +00001044 switch( eDest ){
drhc926afb2002-06-20 03:38:26 +00001045 case SRT_Table:
drhb9bb7c12006-06-11 23:41:55 +00001046 case SRT_EphemTab: {
drh1c767f02009-01-09 02:49:31 +00001047 testcase( eDest==SRT_Table );
1048 testcase( eDest==SRT_EphemTab );
drh2d401ab2008-01-10 23:50:11 +00001049 sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, regRowid);
1050 sqlite3VdbeAddOp3(v, OP_Insert, iParm, regRow, regRowid);
1051 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
drhc926afb2002-06-20 03:38:26 +00001052 break;
1053 }
danielk197793758c82005-01-21 08:13:14 +00001054#ifndef SQLITE_OMIT_SUBQUERY
drhc926afb2002-06-20 03:38:26 +00001055 case SRT_Set: {
1056 assert( nColumn==1 );
drh634d81d2012-09-20 15:41:31 +00001057 sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, 1, regRowid,
1058 &pDest->affSdst, 1);
drhda250ea2008-04-01 05:07:14 +00001059 sqlite3ExprCacheAffinityChange(pParse, regRow, 1);
danielk1977a7a8e142008-02-13 18:25:27 +00001060 sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, regRowid);
drhc926afb2002-06-20 03:38:26 +00001061 break;
1062 }
1063 case SRT_Mem: {
1064 assert( nColumn==1 );
drhb21e7c72008-06-22 12:37:57 +00001065 sqlite3ExprCodeMove(pParse, regRow, iParm, 1);
drhec7429a2005-10-06 16:53:14 +00001066 /* The LIMIT clause will terminate the loop for us */
drhc926afb2002-06-20 03:38:26 +00001067 break;
1068 }
danielk197793758c82005-01-21 08:13:14 +00001069#endif
drh373cc2d2009-05-17 02:06:14 +00001070 default: {
drhac82fcf2002-09-08 17:23:41 +00001071 int i;
drh373cc2d2009-05-17 02:06:14 +00001072 assert( eDest==SRT_Output || eDest==SRT_Coroutine );
drh1c767f02009-01-09 02:49:31 +00001073 testcase( eDest==SRT_Output );
1074 testcase( eDest==SRT_Coroutine );
drhac82fcf2002-09-08 17:23:41 +00001075 for(i=0; i<nColumn; i++){
drh2b596da2012-07-23 21:43:19 +00001076 assert( regRow!=pDest->iSdst+i );
1077 sqlite3VdbeAddOp3(v, OP_Column, pseudoTab, i, pDest->iSdst+i);
drh3e9ca092009-09-08 01:14:48 +00001078 if( i==0 ){
1079 sqlite3VdbeChangeP5(v, OPFLAG_CLEARCACHE);
1080 }
drhac82fcf2002-09-08 17:23:41 +00001081 }
drh7d10d5a2008-08-20 16:35:10 +00001082 if( eDest==SRT_Output ){
drh2b596da2012-07-23 21:43:19 +00001083 sqlite3VdbeAddOp2(v, OP_ResultRow, pDest->iSdst, nColumn);
1084 sqlite3ExprCacheAffinityChange(pParse, pDest->iSdst, nColumn);
drha9671a22008-07-08 23:40:20 +00001085 }else{
drh2b596da2012-07-23 21:43:19 +00001086 sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm);
drhce665cf2004-05-21 03:01:58 +00001087 }
drhac82fcf2002-09-08 17:23:41 +00001088 break;
1089 }
drhc926afb2002-06-20 03:38:26 +00001090 }
drh2d401ab2008-01-10 23:50:11 +00001091 sqlite3ReleaseTempReg(pParse, regRow);
1092 sqlite3ReleaseTempReg(pParse, regRowid);
drhec7429a2005-10-06 16:53:14 +00001093
drhec7429a2005-10-06 16:53:14 +00001094 /* The bottom of the loop
1095 */
drhdc5ea5c2008-12-10 17:19:59 +00001096 sqlite3VdbeResolveLabel(v, addrContinue);
drhc6aff302011-09-01 15:32:47 +00001097 if( p->selFlags & SF_UseSorter ){
1098 sqlite3VdbeAddOp2(v, OP_SorterNext, iTab, addr);
1099 }else{
1100 sqlite3VdbeAddOp2(v, OP_Next, iTab, addr);
1101 }
drhdc5ea5c2008-12-10 17:19:59 +00001102 sqlite3VdbeResolveLabel(v, addrBreak);
drh7d10d5a2008-08-20 16:35:10 +00001103 if( eDest==SRT_Output || eDest==SRT_Coroutine ){
drh66a51672008-01-03 00:01:23 +00001104 sqlite3VdbeAddOp2(v, OP_Close, pseudoTab, 0);
drhcdd536f2006-03-17 00:04:03 +00001105 }
drhd8bc7082000-06-07 23:51:50 +00001106}
1107
1108/*
danielk1977517eb642004-06-07 10:00:31 +00001109** Return a pointer to a string containing the 'declaration type' of the
1110** expression pExpr. The string may be treated as static by the caller.
drhe78e8282003-01-19 03:59:45 +00001111**
drh5f3e5e72013-10-08 20:01:35 +00001112** Also try to estimate the size of the returned value and return that
1113** result in *pEstWidth.
1114**
danielk1977955de522006-02-10 02:27:42 +00001115** The declaration type is the exact datatype definition extracted from the
1116** original CREATE TABLE statement if the expression is a column. The
1117** declaration type for a ROWID field is INTEGER. Exactly when an expression
1118** is considered a column can be complex in the presence of subqueries. The
1119** result-set expression in all of the following SELECT statements is
1120** considered a column by this function.
1121**
1122** SELECT col FROM tbl;
1123** SELECT (SELECT col FROM tbl;
1124** SELECT (SELECT col FROM tbl);
1125** SELECT abc FROM (SELECT col AS abc FROM tbl);
danielk1977517eb642004-06-07 10:00:31 +00001126**
danielk1977955de522006-02-10 02:27:42 +00001127** The declaration type for any expression other than a column is NULL.
drh5f3e5e72013-10-08 20:01:35 +00001128**
1129** This routine has either 3 or 6 parameters depending on whether or not
1130** the SQLITE_ENABLE_COLUMN_METADATA compile-time option is used.
danielk1977517eb642004-06-07 10:00:31 +00001131*/
drh5f3e5e72013-10-08 20:01:35 +00001132#ifdef SQLITE_ENABLE_COLUMN_METADATA
1133# define columnType(A,B,C,D,E,F) columnTypeImpl(A,B,C,D,E,F)
1134static const char *columnTypeImpl(
danielk1977955de522006-02-10 02:27:42 +00001135 NameContext *pNC,
1136 Expr *pExpr,
drh5f3e5e72013-10-08 20:01:35 +00001137 const char **pzOrigDb,
1138 const char **pzOrigTab,
1139 const char **pzOrigCol,
1140 u8 *pEstWidth
danielk1977955de522006-02-10 02:27:42 +00001141){
drh5f3e5e72013-10-08 20:01:35 +00001142 char const *zOrigDb = 0;
1143 char const *zOrigTab = 0;
1144 char const *zOrigCol = 0;
1145#else /* if !defined(SQLITE_ENABLE_COLUMN_METADATA) */
1146# define columnType(A,B,C,D,E,F) columnTypeImpl(A,B,F)
1147static const char *columnTypeImpl(
1148 NameContext *pNC,
1149 Expr *pExpr,
1150 u8 *pEstWidth
1151){
1152#endif /* !defined(SQLITE_ENABLE_COLUMN_METADATA) */
danielk1977955de522006-02-10 02:27:42 +00001153 char const *zType = 0;
danielk1977517eb642004-06-07 10:00:31 +00001154 int j;
drh5f3e5e72013-10-08 20:01:35 +00001155 u8 estWidth = 1;
danielk19775338a5f2005-01-20 13:03:10 +00001156
drh5f3e5e72013-10-08 20:01:35 +00001157 if( NEVER(pExpr==0) || pNC->pSrcList==0 ) return 0;
danielk197700e279d2004-06-21 07:36:32 +00001158 switch( pExpr->op ){
drh30bcf5d2006-04-07 13:50:37 +00001159 case TK_AGG_COLUMN:
danielk197700e279d2004-06-21 07:36:32 +00001160 case TK_COLUMN: {
danielk1977955de522006-02-10 02:27:42 +00001161 /* The expression is a column. Locate the table the column is being
1162 ** extracted from in NameContext.pSrcList. This table may be real
1163 ** database table or a subquery.
1164 */
1165 Table *pTab = 0; /* Table structure column is extracted from */
1166 Select *pS = 0; /* Select the column is extracted from */
1167 int iCol = pExpr->iColumn; /* Index of column in pTab */
drh373cc2d2009-05-17 02:06:14 +00001168 testcase( pExpr->op==TK_AGG_COLUMN );
1169 testcase( pExpr->op==TK_COLUMN );
dan43bc88b2009-09-10 10:15:59 +00001170 while( pNC && !pTab ){
danielk1977b3bce662005-01-29 08:32:43 +00001171 SrcList *pTabList = pNC->pSrcList;
1172 for(j=0;j<pTabList->nSrc && pTabList->a[j].iCursor!=pExpr->iTable;j++);
1173 if( j<pTabList->nSrc ){
1174 pTab = pTabList->a[j].pTab;
danielk1977955de522006-02-10 02:27:42 +00001175 pS = pTabList->a[j].pSelect;
danielk1977b3bce662005-01-29 08:32:43 +00001176 }else{
1177 pNC = pNC->pNext;
1178 }
1179 }
danielk1977955de522006-02-10 02:27:42 +00001180
dan43bc88b2009-09-10 10:15:59 +00001181 if( pTab==0 ){
drh417168a2009-09-07 18:14:02 +00001182 /* At one time, code such as "SELECT new.x" within a trigger would
1183 ** cause this condition to run. Since then, we have restructured how
1184 ** trigger code is generated and so this condition is no longer
dan43bc88b2009-09-10 10:15:59 +00001185 ** possible. However, it can still be true for statements like
1186 ** the following:
1187 **
1188 ** CREATE TABLE t1(col INTEGER);
1189 ** SELECT (SELECT t1.col) FROM FROM t1;
1190 **
1191 ** when columnType() is called on the expression "t1.col" in the
1192 ** sub-select. In this case, set the column type to NULL, even
1193 ** though it should really be "INTEGER".
1194 **
1195 ** This is not a problem, as the column type of "t1.col" is never
1196 ** used. When columnType() is called on the expression
1197 ** "(SELECT t1.col)", the correct type is returned (see the TK_SELECT
1198 ** branch below. */
drh7e627792005-04-29 02:10:00 +00001199 break;
1200 }
danielk1977955de522006-02-10 02:27:42 +00001201
dan43bc88b2009-09-10 10:15:59 +00001202 assert( pTab && pExpr->pTab==pTab );
danielk1977955de522006-02-10 02:27:42 +00001203 if( pS ){
1204 /* The "table" is actually a sub-select or a view in the FROM clause
1205 ** of the SELECT statement. Return the declaration type and origin
1206 ** data for the result-set column of the sub-select.
1207 */
drh7b688ed2009-12-22 00:29:53 +00001208 if( iCol>=0 && ALWAYS(iCol<pS->pEList->nExpr) ){
danielk1977955de522006-02-10 02:27:42 +00001209 /* If iCol is less than zero, then the expression requests the
1210 ** rowid of the sub-select or view. This expression is legal (see
1211 ** test case misc2.2.2) - it always evaluates to NULL.
1212 */
1213 NameContext sNC;
1214 Expr *p = pS->pEList->a[iCol].pExpr;
1215 sNC.pSrcList = pS->pSrc;
dan43bc88b2009-09-10 10:15:59 +00001216 sNC.pNext = pNC;
danielk1977955de522006-02-10 02:27:42 +00001217 sNC.pParse = pNC->pParse;
drh5f3e5e72013-10-08 20:01:35 +00001218 zType = columnType(&sNC, p,&zOrigDb,&zOrigTab,&zOrigCol, &estWidth);
danielk1977955de522006-02-10 02:27:42 +00001219 }
drh93c36bb2014-01-15 20:10:15 +00001220 }else if( pTab->pSchema ){
danielk1977955de522006-02-10 02:27:42 +00001221 /* A real table */
1222 assert( !pS );
1223 if( iCol<0 ) iCol = pTab->iPKey;
1224 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
drh5f3e5e72013-10-08 20:01:35 +00001225#ifdef SQLITE_ENABLE_COLUMN_METADATA
danielk1977955de522006-02-10 02:27:42 +00001226 if( iCol<0 ){
1227 zType = "INTEGER";
drh5f3e5e72013-10-08 20:01:35 +00001228 zOrigCol = "rowid";
danielk1977955de522006-02-10 02:27:42 +00001229 }else{
1230 zType = pTab->aCol[iCol].zType;
drh5f3e5e72013-10-08 20:01:35 +00001231 zOrigCol = pTab->aCol[iCol].zName;
1232 estWidth = pTab->aCol[iCol].szEst;
danielk1977955de522006-02-10 02:27:42 +00001233 }
drh5f3e5e72013-10-08 20:01:35 +00001234 zOrigTab = pTab->zName;
danielk1977955de522006-02-10 02:27:42 +00001235 if( pNC->pParse ){
1236 int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema);
drh5f3e5e72013-10-08 20:01:35 +00001237 zOrigDb = pNC->pParse->db->aDb[iDb].zName;
danielk1977955de522006-02-10 02:27:42 +00001238 }
drh5f3e5e72013-10-08 20:01:35 +00001239#else
1240 if( iCol<0 ){
1241 zType = "INTEGER";
1242 }else{
1243 zType = pTab->aCol[iCol].zType;
1244 estWidth = pTab->aCol[iCol].szEst;
1245 }
1246#endif
danielk197700e279d2004-06-21 07:36:32 +00001247 }
1248 break;
danielk1977517eb642004-06-07 10:00:31 +00001249 }
danielk197793758c82005-01-21 08:13:14 +00001250#ifndef SQLITE_OMIT_SUBQUERY
danielk197700e279d2004-06-21 07:36:32 +00001251 case TK_SELECT: {
danielk1977955de522006-02-10 02:27:42 +00001252 /* The expression is a sub-select. Return the declaration type and
1253 ** origin info for the single column in the result set of the SELECT
1254 ** statement.
1255 */
danielk1977b3bce662005-01-29 08:32:43 +00001256 NameContext sNC;
danielk19776ab3a2e2009-02-19 14:39:25 +00001257 Select *pS = pExpr->x.pSelect;
danielk1977955de522006-02-10 02:27:42 +00001258 Expr *p = pS->pEList->a[0].pExpr;
danielk19776ab3a2e2009-02-19 14:39:25 +00001259 assert( ExprHasProperty(pExpr, EP_xIsSelect) );
danielk1977955de522006-02-10 02:27:42 +00001260 sNC.pSrcList = pS->pSrc;
danielk1977b3bce662005-01-29 08:32:43 +00001261 sNC.pNext = pNC;
danielk1977955de522006-02-10 02:27:42 +00001262 sNC.pParse = pNC->pParse;
drh5f3e5e72013-10-08 20:01:35 +00001263 zType = columnType(&sNC, p, &zOrigDb, &zOrigTab, &zOrigCol, &estWidth);
danielk197700e279d2004-06-21 07:36:32 +00001264 break;
danielk1977517eb642004-06-07 10:00:31 +00001265 }
danielk197793758c82005-01-21 08:13:14 +00001266#endif
danielk1977517eb642004-06-07 10:00:31 +00001267 }
drh5f3e5e72013-10-08 20:01:35 +00001268
1269#ifdef SQLITE_ENABLE_COLUMN_METADATA
1270 if( pzOrigDb ){
1271 assert( pzOrigTab && pzOrigCol );
1272 *pzOrigDb = zOrigDb;
1273 *pzOrigTab = zOrigTab;
1274 *pzOrigCol = zOrigCol;
danielk1977955de522006-02-10 02:27:42 +00001275 }
drh5f3e5e72013-10-08 20:01:35 +00001276#endif
1277 if( pEstWidth ) *pEstWidth = estWidth;
danielk1977517eb642004-06-07 10:00:31 +00001278 return zType;
1279}
1280
1281/*
1282** Generate code that will tell the VDBE the declaration types of columns
1283** in the result set.
drhfcb78a42003-01-18 20:11:05 +00001284*/
1285static void generateColumnTypes(
1286 Parse *pParse, /* Parser context */
drhfcb78a42003-01-18 20:11:05 +00001287 SrcList *pTabList, /* List of tables */
1288 ExprList *pEList /* Expressions defining the result set */
1289){
drh3f913572008-03-22 01:07:17 +00001290#ifndef SQLITE_OMIT_DECLTYPE
drhfcb78a42003-01-18 20:11:05 +00001291 Vdbe *v = pParse->pVdbe;
danielk1977517eb642004-06-07 10:00:31 +00001292 int i;
danielk1977b3bce662005-01-29 08:32:43 +00001293 NameContext sNC;
1294 sNC.pSrcList = pTabList;
danielk1977955de522006-02-10 02:27:42 +00001295 sNC.pParse = pParse;
drhfcb78a42003-01-18 20:11:05 +00001296 for(i=0; i<pEList->nExpr; i++){
1297 Expr *p = pEList->a[i].pExpr;
drh3f913572008-03-22 01:07:17 +00001298 const char *zType;
1299#ifdef SQLITE_ENABLE_COLUMN_METADATA
danielk1977955de522006-02-10 02:27:42 +00001300 const char *zOrigDb = 0;
1301 const char *zOrigTab = 0;
1302 const char *zOrigCol = 0;
drh5f3e5e72013-10-08 20:01:35 +00001303 zType = columnType(&sNC, p, &zOrigDb, &zOrigTab, &zOrigCol, 0);
danielk1977955de522006-02-10 02:27:42 +00001304
drh85b623f2007-12-13 21:54:09 +00001305 /* The vdbe must make its own copy of the column-type and other
danielk19774b1ae992006-02-10 03:06:10 +00001306 ** column specific strings, in case the schema is reset before this
1307 ** virtual machine is deleted.
danielk1977fbcd5852004-06-15 02:44:18 +00001308 */
danielk197710fb7492008-10-31 10:53:22 +00001309 sqlite3VdbeSetColName(v, i, COLNAME_DATABASE, zOrigDb, SQLITE_TRANSIENT);
1310 sqlite3VdbeSetColName(v, i, COLNAME_TABLE, zOrigTab, SQLITE_TRANSIENT);
1311 sqlite3VdbeSetColName(v, i, COLNAME_COLUMN, zOrigCol, SQLITE_TRANSIENT);
drh3f913572008-03-22 01:07:17 +00001312#else
drh5f3e5e72013-10-08 20:01:35 +00001313 zType = columnType(&sNC, p, 0, 0, 0, 0);
drh3f913572008-03-22 01:07:17 +00001314#endif
danielk197710fb7492008-10-31 10:53:22 +00001315 sqlite3VdbeSetColName(v, i, COLNAME_DECLTYPE, zType, SQLITE_TRANSIENT);
drhfcb78a42003-01-18 20:11:05 +00001316 }
drh5f3e5e72013-10-08 20:01:35 +00001317#endif /* !defined(SQLITE_OMIT_DECLTYPE) */
drhfcb78a42003-01-18 20:11:05 +00001318}
1319
1320/*
1321** Generate code that will tell the VDBE the names of columns
1322** in the result set. This information is used to provide the
drhfcabd462004-02-20 14:50:58 +00001323** azCol[] values in the callback.
drh82c3d632000-06-06 21:56:07 +00001324*/
drh832508b2002-03-02 17:04:07 +00001325static void generateColumnNames(
1326 Parse *pParse, /* Parser context */
drhad3cab52002-05-24 02:04:32 +00001327 SrcList *pTabList, /* List of tables */
drh832508b2002-03-02 17:04:07 +00001328 ExprList *pEList /* Expressions defining the result set */
1329){
drhd8bc7082000-06-07 23:51:50 +00001330 Vdbe *v = pParse->pVdbe;
drh6a3ea0e2003-05-02 14:32:12 +00001331 int i, j;
drh9bb575f2004-09-06 17:24:11 +00001332 sqlite3 *db = pParse->db;
drhfcabd462004-02-20 14:50:58 +00001333 int fullNames, shortNames;
1334
drhfe2093d2005-01-20 22:48:47 +00001335#ifndef SQLITE_OMIT_EXPLAIN
danielk19773cf86062004-05-26 10:11:05 +00001336 /* If this is an EXPLAIN, skip this step */
1337 if( pParse->explain ){
danielk197761de0d12004-05-27 23:56:16 +00001338 return;
danielk19773cf86062004-05-26 10:11:05 +00001339 }
danielk19775338a5f2005-01-20 13:03:10 +00001340#endif
danielk19773cf86062004-05-26 10:11:05 +00001341
drhe2f02ba2009-01-09 01:12:27 +00001342 if( pParse->colNamesSet || NEVER(v==0) || db->mallocFailed ) return;
drhd8bc7082000-06-07 23:51:50 +00001343 pParse->colNamesSet = 1;
drhfcabd462004-02-20 14:50:58 +00001344 fullNames = (db->flags & SQLITE_FullColNames)!=0;
1345 shortNames = (db->flags & SQLITE_ShortColNames)!=0;
danielk197722322fd2004-05-25 23:35:17 +00001346 sqlite3VdbeSetNumCols(v, pEList->nExpr);
drh82c3d632000-06-06 21:56:07 +00001347 for(i=0; i<pEList->nExpr; i++){
1348 Expr *p;
drh5a387052003-01-11 14:19:51 +00001349 p = pEList->a[i].pExpr;
drh373cc2d2009-05-17 02:06:14 +00001350 if( NEVER(p==0) ) continue;
drh82c3d632000-06-06 21:56:07 +00001351 if( pEList->a[i].zName ){
1352 char *zName = pEList->a[i].zName;
danielk197710fb7492008-10-31 10:53:22 +00001353 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_TRANSIENT);
drhf018cc22008-09-13 01:20:14 +00001354 }else if( (p->op==TK_COLUMN || p->op==TK_AGG_COLUMN) && pTabList ){
drh6a3ea0e2003-05-02 14:32:12 +00001355 Table *pTab;
drh97665872002-02-13 23:22:53 +00001356 char *zCol;
drh8aff1012001-12-22 14:49:24 +00001357 int iCol = p->iColumn;
drhe2f02ba2009-01-09 01:12:27 +00001358 for(j=0; ALWAYS(j<pTabList->nSrc); j++){
1359 if( pTabList->a[j].iCursor==p->iTable ) break;
1360 }
drh6a3ea0e2003-05-02 14:32:12 +00001361 assert( j<pTabList->nSrc );
1362 pTab = pTabList->a[j].pTab;
drh8aff1012001-12-22 14:49:24 +00001363 if( iCol<0 ) iCol = pTab->iPKey;
drh97665872002-02-13 23:22:53 +00001364 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
drhb1363202002-06-26 02:45:03 +00001365 if( iCol<0 ){
drh47a6db22005-01-18 16:02:40 +00001366 zCol = "rowid";
drhb1363202002-06-26 02:45:03 +00001367 }else{
1368 zCol = pTab->aCol[iCol].zName;
drhb1363202002-06-26 02:45:03 +00001369 }
drhe49b1462008-07-09 01:39:44 +00001370 if( !shortNames && !fullNames ){
danielk197710fb7492008-10-31 10:53:22 +00001371 sqlite3VdbeSetColName(v, i, COLNAME_NAME,
drhb7916a72009-05-27 10:31:29 +00001372 sqlite3DbStrDup(db, pEList->a[i].zSpan), SQLITE_DYNAMIC);
drh1c767f02009-01-09 02:49:31 +00001373 }else if( fullNames ){
drh82c3d632000-06-06 21:56:07 +00001374 char *zName = 0;
drh1c767f02009-01-09 02:49:31 +00001375 zName = sqlite3MPrintf(db, "%s.%s", pTab->zName, zCol);
danielk197710fb7492008-10-31 10:53:22 +00001376 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_DYNAMIC);
drh82c3d632000-06-06 21:56:07 +00001377 }else{
danielk197710fb7492008-10-31 10:53:22 +00001378 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zCol, SQLITE_TRANSIENT);
drh82c3d632000-06-06 21:56:07 +00001379 }
drh1bee3d72001-10-15 00:44:35 +00001380 }else{
drh859bc542014-01-13 20:32:18 +00001381 const char *z = pEList->a[i].zSpan;
1382 z = z==0 ? sqlite3MPrintf(db, "column%d", i+1) : sqlite3DbStrDup(db, z);
1383 sqlite3VdbeSetColName(v, i, COLNAME_NAME, z, SQLITE_DYNAMIC);
drh82c3d632000-06-06 21:56:07 +00001384 }
1385 }
danielk197776d505b2004-05-28 13:13:02 +00001386 generateColumnTypes(pParse, pTabList, pEList);
drh82c3d632000-06-06 21:56:07 +00001387}
1388
drhd8bc7082000-06-07 23:51:50 +00001389/*
drh7d10d5a2008-08-20 16:35:10 +00001390** Given a an expression list (which is really the list of expressions
1391** that form the result set of a SELECT statement) compute appropriate
1392** column names for a table that would hold the expression list.
1393**
1394** All column names will be unique.
1395**
1396** Only the column names are computed. Column.zType, Column.zColl,
1397** and other fields of Column are zeroed.
1398**
1399** Return SQLITE_OK on success. If a memory allocation error occurs,
1400** store NULL in *paCol and 0 in *pnCol and return SQLITE_NOMEM.
drh315555c2002-10-20 15:53:03 +00001401*/
drh7d10d5a2008-08-20 16:35:10 +00001402static int selectColumnsFromExprList(
1403 Parse *pParse, /* Parsing context */
1404 ExprList *pEList, /* Expr list from which to derive column names */
drhd815f172012-09-13 14:42:43 +00001405 i16 *pnCol, /* Write the number of columns here */
drh7d10d5a2008-08-20 16:35:10 +00001406 Column **paCol /* Write the new column list here */
1407){
drhdc5ea5c2008-12-10 17:19:59 +00001408 sqlite3 *db = pParse->db; /* Database connection */
1409 int i, j; /* Loop counters */
1410 int cnt; /* Index added to make the name unique */
1411 Column *aCol, *pCol; /* For looping over result columns */
1412 int nCol; /* Number of columns in the result set */
1413 Expr *p; /* Expression for a single result column */
1414 char *zName; /* Column name */
1415 int nName; /* Size of name in zName[] */
drh22f70c32002-02-18 01:17:00 +00001416
dan8c2e0f02012-03-31 15:08:56 +00001417 if( pEList ){
1418 nCol = pEList->nExpr;
1419 aCol = sqlite3DbMallocZero(db, sizeof(aCol[0])*nCol);
1420 testcase( aCol==0 );
1421 }else{
1422 nCol = 0;
1423 aCol = 0;
1424 }
1425 *pnCol = nCol;
1426 *paCol = aCol;
1427
drh7d10d5a2008-08-20 16:35:10 +00001428 for(i=0, pCol=aCol; i<nCol; i++, pCol++){
drh79d5f632005-01-18 17:20:10 +00001429 /* Get an appropriate name for the column
1430 */
drh580c8c12012-12-08 03:34:04 +00001431 p = sqlite3ExprSkipCollate(pEList->a[i].pExpr);
drh91bb0ee2004-09-01 03:06:34 +00001432 if( (zName = pEList->a[i].zName)!=0 ){
drh79d5f632005-01-18 17:20:10 +00001433 /* If the column contains an "AS <name>" phrase, use <name> as the name */
drh17435752007-08-16 04:30:38 +00001434 zName = sqlite3DbStrDup(db, zName);
drh93a960a2008-07-10 00:32:42 +00001435 }else{
drhdc5ea5c2008-12-10 17:19:59 +00001436 Expr *pColExpr = p; /* The expression that is the result column name */
1437 Table *pTab; /* Table associated with this expression */
drhb07028f2011-10-14 21:49:18 +00001438 while( pColExpr->op==TK_DOT ){
1439 pColExpr = pColExpr->pRight;
1440 assert( pColExpr!=0 );
1441 }
drh373cc2d2009-05-17 02:06:14 +00001442 if( pColExpr->op==TK_COLUMN && ALWAYS(pColExpr->pTab!=0) ){
drh7d10d5a2008-08-20 16:35:10 +00001443 /* For columns use the column name name */
drhdc5ea5c2008-12-10 17:19:59 +00001444 int iCol = pColExpr->iColumn;
drh373cc2d2009-05-17 02:06:14 +00001445 pTab = pColExpr->pTab;
drhf0209f72008-08-21 14:54:28 +00001446 if( iCol<0 ) iCol = pTab->iPKey;
1447 zName = sqlite3MPrintf(db, "%s",
1448 iCol>=0 ? pTab->aCol[iCol].zName : "rowid");
drhb7916a72009-05-27 10:31:29 +00001449 }else if( pColExpr->op==TK_ID ){
drh33e619f2009-05-28 01:00:55 +00001450 assert( !ExprHasProperty(pColExpr, EP_IntValue) );
1451 zName = sqlite3MPrintf(db, "%s", pColExpr->u.zToken);
drh7d10d5a2008-08-20 16:35:10 +00001452 }else{
1453 /* Use the original text of the column expression as its name */
drhb7916a72009-05-27 10:31:29 +00001454 zName = sqlite3MPrintf(db, "%s", pEList->a[i].zSpan);
drh7d10d5a2008-08-20 16:35:10 +00001455 }
drh22f70c32002-02-18 01:17:00 +00001456 }
drh7ce72f62008-07-24 15:50:41 +00001457 if( db->mallocFailed ){
drh633e6d52008-07-28 19:34:53 +00001458 sqlite3DbFree(db, zName);
drh7ce72f62008-07-24 15:50:41 +00001459 break;
drhdd5b2fa2005-03-28 03:39:55 +00001460 }
drh79d5f632005-01-18 17:20:10 +00001461
1462 /* Make sure the column name is unique. If the name is not unique,
1463 ** append a integer to the name so that it becomes unique.
1464 */
drhea678832008-12-10 19:26:22 +00001465 nName = sqlite3Strlen30(zName);
drh79d5f632005-01-18 17:20:10 +00001466 for(j=cnt=0; j<i; j++){
1467 if( sqlite3StrICmp(aCol[j].zName, zName)==0 ){
drh633e6d52008-07-28 19:34:53 +00001468 char *zNewName;
drhfb777322013-01-02 14:57:32 +00001469 int k;
1470 for(k=nName-1; k>1 && sqlite3Isdigit(zName[k]); k--){}
1471 if( zName[k]==':' ) nName = k;
drh2564ef92006-09-29 14:01:04 +00001472 zName[nName] = 0;
drh633e6d52008-07-28 19:34:53 +00001473 zNewName = sqlite3MPrintf(db, "%s:%d", zName, ++cnt);
1474 sqlite3DbFree(db, zName);
1475 zName = zNewName;
drh79d5f632005-01-18 17:20:10 +00001476 j = -1;
drhdd5b2fa2005-03-28 03:39:55 +00001477 if( zName==0 ) break;
drh79d5f632005-01-18 17:20:10 +00001478 }
1479 }
drh91bb0ee2004-09-01 03:06:34 +00001480 pCol->zName = zName;
drh7d10d5a2008-08-20 16:35:10 +00001481 }
1482 if( db->mallocFailed ){
drh7d10d5a2008-08-20 16:35:10 +00001483 for(j=0; j<i; j++){
1484 sqlite3DbFree(db, aCol[j].zName);
1485 }
1486 sqlite3DbFree(db, aCol);
1487 *paCol = 0;
1488 *pnCol = 0;
1489 return SQLITE_NOMEM;
1490 }
1491 return SQLITE_OK;
1492}
danielk1977517eb642004-06-07 10:00:31 +00001493
drh7d10d5a2008-08-20 16:35:10 +00001494/*
1495** Add type and collation information to a column list based on
1496** a SELECT statement.
1497**
1498** The column list presumably came from selectColumnNamesFromExprList().
1499** The column list has only names, not types or collations. This
1500** routine goes through and adds the types and collations.
1501**
shaneb08a67a2009-03-31 03:41:56 +00001502** This routine requires that all identifiers in the SELECT
drh7d10d5a2008-08-20 16:35:10 +00001503** statement be resolved.
1504*/
1505static void selectAddColumnTypeAndCollation(
1506 Parse *pParse, /* Parsing contexts */
drh186ad8c2013-10-08 18:40:37 +00001507 Table *pTab, /* Add column type information to this table */
drh7d10d5a2008-08-20 16:35:10 +00001508 Select *pSelect /* SELECT used to determine types and collations */
1509){
1510 sqlite3 *db = pParse->db;
1511 NameContext sNC;
1512 Column *pCol;
1513 CollSeq *pColl;
1514 int i;
1515 Expr *p;
1516 struct ExprList_item *a;
drh186ad8c2013-10-08 18:40:37 +00001517 u64 szAll = 0;
drh7d10d5a2008-08-20 16:35:10 +00001518
1519 assert( pSelect!=0 );
1520 assert( (pSelect->selFlags & SF_Resolved)!=0 );
drh186ad8c2013-10-08 18:40:37 +00001521 assert( pTab->nCol==pSelect->pEList->nExpr || db->mallocFailed );
drh7d10d5a2008-08-20 16:35:10 +00001522 if( db->mallocFailed ) return;
1523 memset(&sNC, 0, sizeof(sNC));
1524 sNC.pSrcList = pSelect->pSrc;
1525 a = pSelect->pEList->a;
drh186ad8c2013-10-08 18:40:37 +00001526 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
drh7d10d5a2008-08-20 16:35:10 +00001527 p = a[i].pExpr;
drh5f3e5e72013-10-08 20:01:35 +00001528 pCol->zType = sqlite3DbStrDup(db, columnType(&sNC, p,0,0,0, &pCol->szEst));
drh186ad8c2013-10-08 18:40:37 +00001529 szAll += pCol->szEst;
danielk1977c60e9b82005-01-31 12:42:29 +00001530 pCol->affinity = sqlite3ExprAffinity(p);
drhc4a64fa2009-05-11 20:53:28 +00001531 if( pCol->affinity==0 ) pCol->affinity = SQLITE_AFF_NONE;
danielk1977b3bf5562006-01-10 17:58:23 +00001532 pColl = sqlite3ExprCollSeq(pParse, p);
1533 if( pColl ){
drh17435752007-08-16 04:30:38 +00001534 pCol->zColl = sqlite3DbStrDup(db, pColl->zName);
danielk19770202b292004-06-09 09:55:16 +00001535 }
drh22f70c32002-02-18 01:17:00 +00001536 }
drh186ad8c2013-10-08 18:40:37 +00001537 pTab->szTabRow = sqlite3LogEst(szAll*4);
drh7d10d5a2008-08-20 16:35:10 +00001538}
1539
1540/*
1541** Given a SELECT statement, generate a Table structure that describes
1542** the result set of that SELECT.
1543*/
1544Table *sqlite3ResultSetOfSelect(Parse *pParse, Select *pSelect){
1545 Table *pTab;
1546 sqlite3 *db = pParse->db;
1547 int savedFlags;
1548
1549 savedFlags = db->flags;
1550 db->flags &= ~SQLITE_FullColNames;
1551 db->flags |= SQLITE_ShortColNames;
1552 sqlite3SelectPrep(pParse, pSelect, 0);
1553 if( pParse->nErr ) return 0;
1554 while( pSelect->pPrior ) pSelect = pSelect->pPrior;
1555 db->flags = savedFlags;
1556 pTab = sqlite3DbMallocZero(db, sizeof(Table) );
1557 if( pTab==0 ){
1558 return 0;
1559 }
drh373cc2d2009-05-17 02:06:14 +00001560 /* The sqlite3ResultSetOfSelect() is only used n contexts where lookaside
drhb2468952010-07-23 17:06:32 +00001561 ** is disabled */
drh373cc2d2009-05-17 02:06:14 +00001562 assert( db->lookaside.bEnabled==0 );
drh7d10d5a2008-08-20 16:35:10 +00001563 pTab->nRef = 1;
1564 pTab->zName = 0;
drh186ad8c2013-10-08 18:40:37 +00001565 pTab->nRowEst = 1048576;
drh7d10d5a2008-08-20 16:35:10 +00001566 selectColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
drh186ad8c2013-10-08 18:40:37 +00001567 selectAddColumnTypeAndCollation(pParse, pTab, pSelect);
drh22f70c32002-02-18 01:17:00 +00001568 pTab->iPKey = -1;
drh7ce72f62008-07-24 15:50:41 +00001569 if( db->mallocFailed ){
dan1feeaed2010-07-23 15:41:47 +00001570 sqlite3DeleteTable(db, pTab);
drh7ce72f62008-07-24 15:50:41 +00001571 return 0;
1572 }
drh22f70c32002-02-18 01:17:00 +00001573 return pTab;
1574}
1575
1576/*
drhd8bc7082000-06-07 23:51:50 +00001577** Get a VDBE for the given parser context. Create a new one if necessary.
1578** If an error occurs, return NULL and leave a message in pParse.
1579*/
danielk19774adee202004-05-08 08:23:19 +00001580Vdbe *sqlite3GetVdbe(Parse *pParse){
drhd8bc7082000-06-07 23:51:50 +00001581 Vdbe *v = pParse->pVdbe;
1582 if( v==0 ){
drh9ac79622013-12-18 15:11:47 +00001583 v = pParse->pVdbe = sqlite3VdbeCreate(pParse);
drh949f9cd2008-01-12 21:35:57 +00001584#ifndef SQLITE_OMIT_TRACE
1585 if( v ){
1586 sqlite3VdbeAddOp0(v, OP_Trace);
1587 }
1588#endif
drhd8bc7082000-06-07 23:51:50 +00001589 }
drhd8bc7082000-06-07 23:51:50 +00001590 return v;
1591}
drhfcb78a42003-01-18 20:11:05 +00001592
drh15007a92006-01-08 18:10:17 +00001593
drhd8bc7082000-06-07 23:51:50 +00001594/*
drh7b58dae2003-07-20 01:16:46 +00001595** Compute the iLimit and iOffset fields of the SELECT based on the
drhec7429a2005-10-06 16:53:14 +00001596** pLimit and pOffset expressions. pLimit and pOffset hold the expressions
drh7b58dae2003-07-20 01:16:46 +00001597** that appear in the original SQL statement after the LIMIT and OFFSET
danielk1977a2dc3b12005-02-05 12:48:48 +00001598** keywords. Or NULL if those keywords are omitted. iLimit and iOffset
1599** are the integer memory register numbers for counters used to compute
1600** the limit and offset. If there is no limit and/or offset, then
1601** iLimit and iOffset are negative.
drh7b58dae2003-07-20 01:16:46 +00001602**
drhd59ba6c2006-01-08 05:02:54 +00001603** This routine changes the values of iLimit and iOffset only if
drhec7429a2005-10-06 16:53:14 +00001604** a limit or offset is defined by pLimit and pOffset. iLimit and
drh7b58dae2003-07-20 01:16:46 +00001605** iOffset should have been preset to appropriate default values
1606** (usually but not always -1) prior to calling this routine.
drhec7429a2005-10-06 16:53:14 +00001607** Only if pLimit!=0 or pOffset!=0 do the limit registers get
drh7b58dae2003-07-20 01:16:46 +00001608** redefined. The UNION ALL operator uses this property to force
1609** the reuse of the same limit and offset registers across multiple
1610** SELECT statements.
1611*/
drhec7429a2005-10-06 16:53:14 +00001612static void computeLimitRegisters(Parse *pParse, Select *p, int iBreak){
drh02afc862006-01-20 18:10:57 +00001613 Vdbe *v = 0;
1614 int iLimit = 0;
drh15007a92006-01-08 18:10:17 +00001615 int iOffset;
drh9b918ed2009-11-12 03:13:26 +00001616 int addr1, n;
drh0acb7e42008-06-25 00:12:41 +00001617 if( p->iLimit ) return;
drh15007a92006-01-08 18:10:17 +00001618
drh7b58dae2003-07-20 01:16:46 +00001619 /*
drh7b58dae2003-07-20 01:16:46 +00001620 ** "LIMIT -1" always shows all rows. There is some
drhf7b54962013-05-28 12:11:54 +00001621 ** controversy about what the correct behavior should be.
drh7b58dae2003-07-20 01:16:46 +00001622 ** The current implementation interprets "LIMIT 0" to mean
1623 ** no rows.
1624 */
drhceea3322009-04-23 13:22:42 +00001625 sqlite3ExprCacheClear(pParse);
drh373cc2d2009-05-17 02:06:14 +00001626 assert( p->pOffset==0 || p->pLimit!=0 );
danielk1977a2dc3b12005-02-05 12:48:48 +00001627 if( p->pLimit ){
drh0a07c102008-01-03 18:03:08 +00001628 p->iLimit = iLimit = ++pParse->nMem;
drh15007a92006-01-08 18:10:17 +00001629 v = sqlite3GetVdbe(pParse);
drh373cc2d2009-05-17 02:06:14 +00001630 if( NEVER(v==0) ) return; /* VDBE should have already been allocated */
drh9b918ed2009-11-12 03:13:26 +00001631 if( sqlite3ExprIsInteger(p->pLimit, &n) ){
drh456e4e42009-11-20 16:13:15 +00001632 sqlite3VdbeAddOp2(v, OP_Integer, n, iLimit);
1633 VdbeComment((v, "LIMIT counter"));
drh9b918ed2009-11-12 03:13:26 +00001634 if( n==0 ){
1635 sqlite3VdbeAddOp2(v, OP_Goto, 0, iBreak);
drh613ba1e2013-06-15 15:11:45 +00001636 }else if( n>=0 && p->nSelectRow>(u64)n ){
1637 p->nSelectRow = n;
drh9b918ed2009-11-12 03:13:26 +00001638 }
1639 }else{
1640 sqlite3ExprCode(pParse, p->pLimit, iLimit);
1641 sqlite3VdbeAddOp1(v, OP_MustBeInt, iLimit);
1642 VdbeComment((v, "LIMIT counter"));
1643 sqlite3VdbeAddOp2(v, OP_IfZero, iLimit, iBreak);
1644 }
drh373cc2d2009-05-17 02:06:14 +00001645 if( p->pOffset ){
1646 p->iOffset = iOffset = ++pParse->nMem;
drhb7654112008-01-12 12:48:07 +00001647 pParse->nMem++; /* Allocate an extra register for limit+offset */
drh373cc2d2009-05-17 02:06:14 +00001648 sqlite3ExprCode(pParse, p->pOffset, iOffset);
1649 sqlite3VdbeAddOp1(v, OP_MustBeInt, iOffset);
1650 VdbeComment((v, "OFFSET counter"));
1651 addr1 = sqlite3VdbeAddOp1(v, OP_IfPos, iOffset);
1652 sqlite3VdbeAddOp2(v, OP_Integer, 0, iOffset);
1653 sqlite3VdbeJumpHere(v, addr1);
drhb7654112008-01-12 12:48:07 +00001654 sqlite3VdbeAddOp3(v, OP_Add, iLimit, iOffset, iOffset+1);
1655 VdbeComment((v, "LIMIT+OFFSET"));
1656 addr1 = sqlite3VdbeAddOp1(v, OP_IfPos, iLimit);
1657 sqlite3VdbeAddOp2(v, OP_Integer, -1, iOffset+1);
1658 sqlite3VdbeJumpHere(v, addr1);
drhd59ba6c2006-01-08 05:02:54 +00001659 }
drh7b58dae2003-07-20 01:16:46 +00001660 }
1661}
1662
drhb7f91642004-10-31 02:22:47 +00001663#ifndef SQLITE_OMIT_COMPOUND_SELECT
drhfbc4ee72004-08-29 01:31:05 +00001664/*
drhfbc4ee72004-08-29 01:31:05 +00001665** Return the appropriate collating sequence for the iCol-th column of
1666** the result set for the compound-select statement "p". Return NULL if
1667** the column has no default collating sequence.
1668**
1669** The collating sequence for the compound select is taken from the
1670** left-most term of the select that has a collating sequence.
1671*/
danielk1977dc1bdc42004-06-11 10:51:27 +00001672static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){
drhfbc4ee72004-08-29 01:31:05 +00001673 CollSeq *pRet;
danielk1977dc1bdc42004-06-11 10:51:27 +00001674 if( p->pPrior ){
1675 pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
drhfbc4ee72004-08-29 01:31:05 +00001676 }else{
1677 pRet = 0;
danielk1977dc1bdc42004-06-11 10:51:27 +00001678 }
drh10c081a2009-04-16 00:24:23 +00001679 assert( iCol>=0 );
1680 if( pRet==0 && iCol<p->pEList->nExpr ){
danielk1977dc1bdc42004-06-11 10:51:27 +00001681 pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
1682 }
1683 return pRet;
drhd3d39e92004-05-20 22:16:29 +00001684}
drhb7f91642004-10-31 02:22:47 +00001685#endif /* SQLITE_OMIT_COMPOUND_SELECT */
drhd3d39e92004-05-20 22:16:29 +00001686
drhb21e7c72008-06-22 12:37:57 +00001687/* Forward reference */
1688static int multiSelectOrderBy(
1689 Parse *pParse, /* Parsing context */
1690 Select *p, /* The right-most of SELECTs to be coded */
drha9671a22008-07-08 23:40:20 +00001691 SelectDest *pDest /* What to do with query results */
drhb21e7c72008-06-22 12:37:57 +00001692);
1693
1694
drhb7f91642004-10-31 02:22:47 +00001695#ifndef SQLITE_OMIT_COMPOUND_SELECT
drhd3d39e92004-05-20 22:16:29 +00001696/*
drh16ee60f2008-06-20 18:13:25 +00001697** This routine is called to process a compound query form from
1698** two or more separate queries using UNION, UNION ALL, EXCEPT, or
1699** INTERSECT
drhc926afb2002-06-20 03:38:26 +00001700**
drhe78e8282003-01-19 03:59:45 +00001701** "p" points to the right-most of the two queries. the query on the
1702** left is p->pPrior. The left query could also be a compound query
1703** in which case this routine will be called recursively.
1704**
1705** The results of the total query are to be written into a destination
1706** of type eDest with parameter iParm.
1707**
1708** Example 1: Consider a three-way compound SQL statement.
1709**
1710** SELECT a FROM t1 UNION SELECT b FROM t2 UNION SELECT c FROM t3
1711**
1712** This statement is parsed up as follows:
1713**
1714** SELECT c FROM t3
1715** |
1716** `-----> SELECT b FROM t2
1717** |
jplyon4b11c6d2004-01-19 04:57:53 +00001718** `------> SELECT a FROM t1
drhe78e8282003-01-19 03:59:45 +00001719**
1720** The arrows in the diagram above represent the Select.pPrior pointer.
1721** So if this routine is called with p equal to the t3 query, then
1722** pPrior will be the t2 query. p->op will be TK_UNION in this case.
1723**
1724** Notice that because of the way SQLite parses compound SELECTs, the
1725** individual selects always group from left to right.
drh82c3d632000-06-06 21:56:07 +00001726*/
danielk197784ac9d02004-05-18 09:58:06 +00001727static int multiSelect(
drhfbc4ee72004-08-29 01:31:05 +00001728 Parse *pParse, /* Parsing context */
1729 Select *p, /* The right-most of SELECTs to be coded */
drha9671a22008-07-08 23:40:20 +00001730 SelectDest *pDest /* What to do with query results */
danielk197784ac9d02004-05-18 09:58:06 +00001731){
drhfbc4ee72004-08-29 01:31:05 +00001732 int rc = SQLITE_OK; /* Success code from a subroutine */
1733 Select *pPrior; /* Another SELECT immediately to our left */
1734 Vdbe *v; /* Generate code to this VDBE */
drh1013c932008-01-06 00:25:21 +00001735 SelectDest dest; /* Alternative data destination */
danielk1977eca7e012008-07-01 16:05:25 +00001736 Select *pDelete = 0; /* Chain of simple selects to delete */
drh633e6d52008-07-28 19:34:53 +00001737 sqlite3 *db; /* Database connection */
dan7f61e922010-11-11 16:46:40 +00001738#ifndef SQLITE_OMIT_EXPLAIN
1739 int iSub1; /* EQP id of left-hand query */
1740 int iSub2; /* EQP id of right-hand query */
1741#endif
drh82c3d632000-06-06 21:56:07 +00001742
drh7b58dae2003-07-20 01:16:46 +00001743 /* Make sure there is no ORDER BY or LIMIT clause on prior SELECTs. Only
drhfbc4ee72004-08-29 01:31:05 +00001744 ** the last (right-most) SELECT in the series may have an ORDER BY or LIMIT.
drh82c3d632000-06-06 21:56:07 +00001745 */
drh701bb3b2008-08-02 03:50:39 +00001746 assert( p && p->pPrior ); /* Calling function guarantees this much */
dan8ce71842014-01-14 20:14:09 +00001747 assert( p->pRecurse==0 || p->op==TK_ALL || p->op==TK_UNION );
drh633e6d52008-07-28 19:34:53 +00001748 db = pParse->db;
drhd8bc7082000-06-07 23:51:50 +00001749 pPrior = p->pPrior;
drh0342b1f2005-09-01 03:07:44 +00001750 assert( pPrior->pRightmost!=pPrior );
1751 assert( pPrior->pRightmost==p->pRightmost );
drhbc103772008-08-08 18:06:25 +00001752 dest = *pDest;
drhd8bc7082000-06-07 23:51:50 +00001753 if( pPrior->pOrderBy ){
danielk19774adee202004-05-08 08:23:19 +00001754 sqlite3ErrorMsg(pParse,"ORDER BY clause should come after %s not before",
drhda93d232003-03-31 02:12:46 +00001755 selectOpName(p->op));
danielk197784ac9d02004-05-18 09:58:06 +00001756 rc = 1;
1757 goto multi_select_end;
drh82c3d632000-06-06 21:56:07 +00001758 }
danielk1977a2dc3b12005-02-05 12:48:48 +00001759 if( pPrior->pLimit ){
danielk19774adee202004-05-08 08:23:19 +00001760 sqlite3ErrorMsg(pParse,"LIMIT clause should come after %s not before",
drh7b58dae2003-07-20 01:16:46 +00001761 selectOpName(p->op));
danielk197784ac9d02004-05-18 09:58:06 +00001762 rc = 1;
1763 goto multi_select_end;
drh7b58dae2003-07-20 01:16:46 +00001764 }
drh82c3d632000-06-06 21:56:07 +00001765
danielk19774adee202004-05-08 08:23:19 +00001766 v = sqlite3GetVdbe(pParse);
drh701bb3b2008-08-02 03:50:39 +00001767 assert( v!=0 ); /* The VDBE already created by calling function */
drhd8bc7082000-06-07 23:51:50 +00001768
drh1cc3d752002-03-23 00:31:29 +00001769 /* Create the destination temporary table if necessary
1770 */
danielk19776c8c8ce2008-01-02 16:27:09 +00001771 if( dest.eDest==SRT_EphemTab ){
danielk1977b4964b72004-05-18 01:23:38 +00001772 assert( p->pEList );
drh2b596da2012-07-23 21:43:19 +00001773 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, dest.iSDParm, p->pEList->nExpr);
drhd4187c72010-08-30 22:15:45 +00001774 sqlite3VdbeChangeP5(v, BTREE_UNORDERED);
danielk19776c8c8ce2008-01-02 16:27:09 +00001775 dest.eDest = SRT_Table;
drh1cc3d752002-03-23 00:31:29 +00001776 }
1777
drhf6e369a2008-06-24 12:46:30 +00001778 /* Make sure all SELECTs in the statement have the same number of elements
1779 ** in their result sets.
1780 */
1781 assert( p->pEList && pPrior->pEList );
1782 if( p->pEList->nExpr!=pPrior->pEList->nExpr ){
drh7b113ba2012-01-28 15:22:22 +00001783 if( p->selFlags & SF_Values ){
1784 sqlite3ErrorMsg(pParse, "all VALUES must have the same number of terms");
1785 }else{
1786 sqlite3ErrorMsg(pParse, "SELECTs to the left and right of %s"
1787 " do not have the same number of result columns", selectOpName(p->op));
1788 }
drhf6e369a2008-06-24 12:46:30 +00001789 rc = 1;
1790 goto multi_select_end;
1791 }
1792
daneede6a52014-01-15 19:42:23 +00001793#ifndef SQLITE_OMIT_CTE
dan8ce71842014-01-14 20:14:09 +00001794 /* If this is a recursive query, check that there is no ORDER BY or
1795 ** LIMIT clause. Neither of these are supported. */
1796 assert( p->pOffset==0 || p->pLimit );
1797 if( p->pRecurse && (p->pOrderBy || p->pLimit) ){
1798 sqlite3ErrorMsg(pParse, "%s in a recursive query is not allowed",
1799 p->pOrderBy ? "ORDER BY" : "LIMIT"
1800 );
1801 goto multi_select_end;
1802 }
1803
dan8ce71842014-01-14 20:14:09 +00001804 if( p->pRecurse ){
1805 int nCol = p->pEList->nExpr;
1806 int addrNext;
1807 int addrSwap;
1808 int iCont, iBreak;
1809 int tmp1, tmp2; /* Cursors used to access temporary tables */
1810 int tmp3 = 0; /* To ensure unique results if UNION */
1811 int eDest = SRT_Table;
1812 SelectDest tmp2dest;
1813
1814 iBreak = sqlite3VdbeMakeLabel(v);
1815 iCont = sqlite3VdbeMakeLabel(v);
1816
1817 tmp1 = pParse->nTab++;
1818 tmp2 = pParse->nTab++;
1819 if( p->op==TK_UNION ){
1820 eDest = SRT_DistTable;
1821 tmp3 = pParse->nTab++;
1822 }
1823 sqlite3SelectDestInit(&tmp2dest, eDest, tmp2);
1824
1825 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tmp1, nCol);
1826 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tmp2, nCol);
1827 if( tmp3 ){
1828 p->addrOpenEphm[0] = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tmp3, 0);
1829 p->selFlags |= SF_UsesEphemeral;
1830 }
1831
1832 /* Store the results of the initial SELECT in tmp2. */
1833 rc = sqlite3Select(pParse, pPrior, &tmp2dest);
1834 if( rc ) goto multi_select_end;
1835
daneede6a52014-01-15 19:42:23 +00001836 /* Clear tmp1. Then switch the contents of tmp1 and tmp2. Then return
dan8ce71842014-01-14 20:14:09 +00001837 ** the contents of tmp1 to the caller. Or, if tmp1 is empty at this
1838 ** point, the recursive query has finished - jump to address iBreak. */
1839 addrSwap = sqlite3VdbeAddOp2(v, OP_SwapCursors, tmp1, tmp2);
1840 sqlite3VdbeAddOp2(v, OP_Rewind, tmp1, iBreak);
1841 addrNext = sqlite3VdbeCurrentAddr(v);
1842 selectInnerLoop(pParse, p, p->pEList, tmp1, p->pEList->nExpr,
1843 0, 0, &dest, iCont, iBreak);
1844 sqlite3VdbeResolveLabel(v, iCont);
1845 sqlite3VdbeAddOp2(v, OP_Next, tmp1, addrNext);
1846
1847 /* Execute the recursive SELECT. Store the results in tmp2. While this
1848 ** SELECT is running, the contents of tmp1 are read by recursive
1849 ** references to the current CTE. */
1850 p->pPrior = 0;
1851 p->pRecurse->tnum = tmp1;
dan8290c2a2014-01-16 10:58:39 +00001852 assert( (p->pRecurse->tabFlags & TF_Recursive)==0 );
dan8ce71842014-01-14 20:14:09 +00001853 p->pRecurse->tabFlags |= TF_Recursive;
1854 rc = sqlite3Select(pParse, p, &tmp2dest);
1855 p->pRecurse->tabFlags &= ~TF_Recursive;
dan8290c2a2014-01-16 10:58:39 +00001856 assert( p->pPrior==0 );
dan8ce71842014-01-14 20:14:09 +00001857 p->pPrior = pPrior;
1858 if( rc ) goto multi_select_end;
1859
1860 sqlite3VdbeAddOp2(v, OP_Goto, 0, addrSwap);
1861 sqlite3VdbeResolveLabel(v, iBreak);
1862 }else
1863#endif
1864
daneede6a52014-01-15 19:42:23 +00001865 /* Compound SELECTs that have an ORDER BY clause are handled separately.
1866 */
1867 if( p->pOrderBy ){
1868 return multiSelectOrderBy(pParse, p, pDest);
1869 }else
1870
drhf46f9052002-06-22 02:33:38 +00001871 /* Generate code for the left and right SELECT statements.
drhd8bc7082000-06-07 23:51:50 +00001872 */
drh82c3d632000-06-06 21:56:07 +00001873 switch( p->op ){
drhf46f9052002-06-22 02:33:38 +00001874 case TK_ALL: {
drha9671a22008-07-08 23:40:20 +00001875 int addr = 0;
drh95aa47b2010-11-16 02:49:15 +00001876 int nLimit;
drha9671a22008-07-08 23:40:20 +00001877 assert( !pPrior->pLimit );
drh547180b2013-01-29 23:55:50 +00001878 pPrior->iLimit = p->iLimit;
1879 pPrior->iOffset = p->iOffset;
drha9671a22008-07-08 23:40:20 +00001880 pPrior->pLimit = p->pLimit;
1881 pPrior->pOffset = p->pOffset;
dan7f61e922010-11-11 16:46:40 +00001882 explainSetInteger(iSub1, pParse->iNextSelectId);
drh7d10d5a2008-08-20 16:35:10 +00001883 rc = sqlite3Select(pParse, pPrior, &dest);
drha9671a22008-07-08 23:40:20 +00001884 p->pLimit = 0;
1885 p->pOffset = 0;
1886 if( rc ){
1887 goto multi_select_end;
drhf46f9052002-06-22 02:33:38 +00001888 }
drha9671a22008-07-08 23:40:20 +00001889 p->pPrior = 0;
1890 p->iLimit = pPrior->iLimit;
1891 p->iOffset = pPrior->iOffset;
1892 if( p->iLimit ){
1893 addr = sqlite3VdbeAddOp1(v, OP_IfZero, p->iLimit);
1894 VdbeComment((v, "Jump ahead if LIMIT reached"));
1895 }
dan7f61e922010-11-11 16:46:40 +00001896 explainSetInteger(iSub2, pParse->iNextSelectId);
drh7d10d5a2008-08-20 16:35:10 +00001897 rc = sqlite3Select(pParse, p, &dest);
drh373cc2d2009-05-17 02:06:14 +00001898 testcase( rc!=SQLITE_OK );
drha9671a22008-07-08 23:40:20 +00001899 pDelete = p->pPrior;
1900 p->pPrior = pPrior;
drh95aa47b2010-11-16 02:49:15 +00001901 p->nSelectRow += pPrior->nSelectRow;
1902 if( pPrior->pLimit
1903 && sqlite3ExprIsInteger(pPrior->pLimit, &nLimit)
drh613ba1e2013-06-15 15:11:45 +00001904 && nLimit>0 && p->nSelectRow > (u64)nLimit
drh95aa47b2010-11-16 02:49:15 +00001905 ){
drhc63367e2013-06-10 20:46:50 +00001906 p->nSelectRow = nLimit;
drh95aa47b2010-11-16 02:49:15 +00001907 }
drha9671a22008-07-08 23:40:20 +00001908 if( addr ){
1909 sqlite3VdbeJumpHere(v, addr);
1910 }
1911 break;
drhf46f9052002-06-22 02:33:38 +00001912 }
drh82c3d632000-06-06 21:56:07 +00001913 case TK_EXCEPT:
1914 case TK_UNION: {
drhd8bc7082000-06-07 23:51:50 +00001915 int unionTab; /* Cursor number of the temporary table holding result */
drhea678832008-12-10 19:26:22 +00001916 u8 op = 0; /* One of the SRT_ operations to apply to self */
drhd8bc7082000-06-07 23:51:50 +00001917 int priorOp; /* The SRT_ operation to apply to prior selects */
danielk1977a2dc3b12005-02-05 12:48:48 +00001918 Expr *pLimit, *pOffset; /* Saved values of p->nLimit and p->nOffset */
danielk1977dc1bdc42004-06-11 10:51:27 +00001919 int addr;
danielk19776c8c8ce2008-01-02 16:27:09 +00001920 SelectDest uniondest;
drh82c3d632000-06-06 21:56:07 +00001921
drh373cc2d2009-05-17 02:06:14 +00001922 testcase( p->op==TK_EXCEPT );
1923 testcase( p->op==TK_UNION );
drh93a960a2008-07-10 00:32:42 +00001924 priorOp = SRT_Union;
drhe2f02ba2009-01-09 01:12:27 +00001925 if( dest.eDest==priorOp && ALWAYS(!p->pLimit &&!p->pOffset) ){
drhd8bc7082000-06-07 23:51:50 +00001926 /* We can reuse a temporary table generated by a SELECT to our
drhc926afb2002-06-20 03:38:26 +00001927 ** right.
drhd8bc7082000-06-07 23:51:50 +00001928 */
drhe2f02ba2009-01-09 01:12:27 +00001929 assert( p->pRightmost!=p ); /* Can only happen for leftward elements
1930 ** of a 3-way or more compound */
1931 assert( p->pLimit==0 ); /* Not allowed on leftward elements */
1932 assert( p->pOffset==0 ); /* Not allowed on leftward elements */
drh2b596da2012-07-23 21:43:19 +00001933 unionTab = dest.iSDParm;
drh82c3d632000-06-06 21:56:07 +00001934 }else{
drhd8bc7082000-06-07 23:51:50 +00001935 /* We will need to create our own temporary table to hold the
1936 ** intermediate results.
1937 */
1938 unionTab = pParse->nTab++;
drh93a960a2008-07-10 00:32:42 +00001939 assert( p->pOrderBy==0 );
drh66a51672008-01-03 00:01:23 +00001940 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, unionTab, 0);
drh93a960a2008-07-10 00:32:42 +00001941 assert( p->addrOpenEphm[0] == -1 );
1942 p->addrOpenEphm[0] = addr;
drh7d10d5a2008-08-20 16:35:10 +00001943 p->pRightmost->selFlags |= SF_UsesEphemeral;
danielk197784ac9d02004-05-18 09:58:06 +00001944 assert( p->pEList );
drh82c3d632000-06-06 21:56:07 +00001945 }
drhd8bc7082000-06-07 23:51:50 +00001946
1947 /* Code the SELECT statements to our left
1948 */
danielk1977b3bce662005-01-29 08:32:43 +00001949 assert( !pPrior->pOrderBy );
drh1013c932008-01-06 00:25:21 +00001950 sqlite3SelectDestInit(&uniondest, priorOp, unionTab);
dan7f61e922010-11-11 16:46:40 +00001951 explainSetInteger(iSub1, pParse->iNextSelectId);
drh7d10d5a2008-08-20 16:35:10 +00001952 rc = sqlite3Select(pParse, pPrior, &uniondest);
danielk197784ac9d02004-05-18 09:58:06 +00001953 if( rc ){
1954 goto multi_select_end;
1955 }
drhd8bc7082000-06-07 23:51:50 +00001956
1957 /* Code the current SELECT statement
1958 */
drh4cfb22f2008-08-01 18:47:01 +00001959 if( p->op==TK_EXCEPT ){
1960 op = SRT_Except;
1961 }else{
1962 assert( p->op==TK_UNION );
1963 op = SRT_Union;
drhd8bc7082000-06-07 23:51:50 +00001964 }
drh82c3d632000-06-06 21:56:07 +00001965 p->pPrior = 0;
danielk1977a2dc3b12005-02-05 12:48:48 +00001966 pLimit = p->pLimit;
1967 p->pLimit = 0;
1968 pOffset = p->pOffset;
1969 p->pOffset = 0;
danielk19776c8c8ce2008-01-02 16:27:09 +00001970 uniondest.eDest = op;
dan7f61e922010-11-11 16:46:40 +00001971 explainSetInteger(iSub2, pParse->iNextSelectId);
drh7d10d5a2008-08-20 16:35:10 +00001972 rc = sqlite3Select(pParse, p, &uniondest);
drh373cc2d2009-05-17 02:06:14 +00001973 testcase( rc!=SQLITE_OK );
drh5bd1bf22007-06-15 15:31:49 +00001974 /* Query flattening in sqlite3Select() might refill p->pOrderBy.
1975 ** Be sure to delete p->pOrderBy, therefore, to avoid a memory leak. */
drh633e6d52008-07-28 19:34:53 +00001976 sqlite3ExprListDelete(db, p->pOrderBy);
danielk1977eca7e012008-07-01 16:05:25 +00001977 pDelete = p->pPrior;
drh82c3d632000-06-06 21:56:07 +00001978 p->pPrior = pPrior;
drha9671a22008-07-08 23:40:20 +00001979 p->pOrderBy = 0;
drh95aa47b2010-11-16 02:49:15 +00001980 if( p->op==TK_UNION ) p->nSelectRow += pPrior->nSelectRow;
drh633e6d52008-07-28 19:34:53 +00001981 sqlite3ExprDelete(db, p->pLimit);
danielk1977a2dc3b12005-02-05 12:48:48 +00001982 p->pLimit = pLimit;
1983 p->pOffset = pOffset;
drh92b01d52008-06-24 00:32:35 +00001984 p->iLimit = 0;
1985 p->iOffset = 0;
drhd8bc7082000-06-07 23:51:50 +00001986
1987 /* Convert the data in the temporary table into whatever form
1988 ** it is that we currently need.
drh373cc2d2009-05-17 02:06:14 +00001989 */
drh2b596da2012-07-23 21:43:19 +00001990 assert( unionTab==dest.iSDParm || dest.eDest!=priorOp );
drh373cc2d2009-05-17 02:06:14 +00001991 if( dest.eDest!=priorOp ){
drh6b563442001-11-07 16:48:26 +00001992 int iCont, iBreak, iStart;
drh82c3d632000-06-06 21:56:07 +00001993 assert( p->pEList );
drh7d10d5a2008-08-20 16:35:10 +00001994 if( dest.eDest==SRT_Output ){
drh92378252006-03-26 01:21:22 +00001995 Select *pFirst = p;
1996 while( pFirst->pPrior ) pFirst = pFirst->pPrior;
1997 generateColumnNames(pParse, 0, pFirst->pEList);
drh41202cc2002-04-23 17:10:18 +00001998 }
danielk19774adee202004-05-08 08:23:19 +00001999 iBreak = sqlite3VdbeMakeLabel(v);
2000 iCont = sqlite3VdbeMakeLabel(v);
drhec7429a2005-10-06 16:53:14 +00002001 computeLimitRegisters(pParse, p, iBreak);
drh66a51672008-01-03 00:01:23 +00002002 sqlite3VdbeAddOp2(v, OP_Rewind, unionTab, iBreak);
danielk19774adee202004-05-08 08:23:19 +00002003 iStart = sqlite3VdbeCurrentAddr(v);
drhd2b3e232008-01-23 14:51:49 +00002004 selectInnerLoop(pParse, p, p->pEList, unionTab, p->pEList->nExpr,
drhe8e4af72012-09-21 00:04:28 +00002005 0, 0, &dest, iCont, iBreak);
danielk19774adee202004-05-08 08:23:19 +00002006 sqlite3VdbeResolveLabel(v, iCont);
drh66a51672008-01-03 00:01:23 +00002007 sqlite3VdbeAddOp2(v, OP_Next, unionTab, iStart);
danielk19774adee202004-05-08 08:23:19 +00002008 sqlite3VdbeResolveLabel(v, iBreak);
drh66a51672008-01-03 00:01:23 +00002009 sqlite3VdbeAddOp2(v, OP_Close, unionTab, 0);
drh82c3d632000-06-06 21:56:07 +00002010 }
2011 break;
2012 }
drh373cc2d2009-05-17 02:06:14 +00002013 default: assert( p->op==TK_INTERSECT ); {
drh82c3d632000-06-06 21:56:07 +00002014 int tab1, tab2;
drh6b563442001-11-07 16:48:26 +00002015 int iCont, iBreak, iStart;
danielk1977a2dc3b12005-02-05 12:48:48 +00002016 Expr *pLimit, *pOffset;
danielk1977dc1bdc42004-06-11 10:51:27 +00002017 int addr;
drh1013c932008-01-06 00:25:21 +00002018 SelectDest intersectdest;
drh9cbf3422008-01-17 16:22:13 +00002019 int r1;
drh82c3d632000-06-06 21:56:07 +00002020
drhd8bc7082000-06-07 23:51:50 +00002021 /* INTERSECT is different from the others since it requires
drh6206d502000-06-19 19:09:08 +00002022 ** two temporary tables. Hence it has its own case. Begin
drhd8bc7082000-06-07 23:51:50 +00002023 ** by allocating the tables we will need.
2024 */
drh82c3d632000-06-06 21:56:07 +00002025 tab1 = pParse->nTab++;
2026 tab2 = pParse->nTab++;
drh93a960a2008-07-10 00:32:42 +00002027 assert( p->pOrderBy==0 );
danielk1977dc1bdc42004-06-11 10:51:27 +00002028
drh66a51672008-01-03 00:01:23 +00002029 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab1, 0);
drhb9bb7c12006-06-11 23:41:55 +00002030 assert( p->addrOpenEphm[0] == -1 );
2031 p->addrOpenEphm[0] = addr;
drh7d10d5a2008-08-20 16:35:10 +00002032 p->pRightmost->selFlags |= SF_UsesEphemeral;
danielk197784ac9d02004-05-18 09:58:06 +00002033 assert( p->pEList );
drhd8bc7082000-06-07 23:51:50 +00002034
2035 /* Code the SELECTs to our left into temporary table "tab1".
2036 */
drh1013c932008-01-06 00:25:21 +00002037 sqlite3SelectDestInit(&intersectdest, SRT_Union, tab1);
dan7f61e922010-11-11 16:46:40 +00002038 explainSetInteger(iSub1, pParse->iNextSelectId);
drh7d10d5a2008-08-20 16:35:10 +00002039 rc = sqlite3Select(pParse, pPrior, &intersectdest);
danielk197784ac9d02004-05-18 09:58:06 +00002040 if( rc ){
2041 goto multi_select_end;
2042 }
drhd8bc7082000-06-07 23:51:50 +00002043
2044 /* Code the current SELECT into temporary table "tab2"
2045 */
drh66a51672008-01-03 00:01:23 +00002046 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab2, 0);
drhb9bb7c12006-06-11 23:41:55 +00002047 assert( p->addrOpenEphm[1] == -1 );
2048 p->addrOpenEphm[1] = addr;
drh82c3d632000-06-06 21:56:07 +00002049 p->pPrior = 0;
danielk1977a2dc3b12005-02-05 12:48:48 +00002050 pLimit = p->pLimit;
2051 p->pLimit = 0;
2052 pOffset = p->pOffset;
2053 p->pOffset = 0;
drh2b596da2012-07-23 21:43:19 +00002054 intersectdest.iSDParm = tab2;
dan7f61e922010-11-11 16:46:40 +00002055 explainSetInteger(iSub2, pParse->iNextSelectId);
drh7d10d5a2008-08-20 16:35:10 +00002056 rc = sqlite3Select(pParse, p, &intersectdest);
drh373cc2d2009-05-17 02:06:14 +00002057 testcase( rc!=SQLITE_OK );
danielk1977eca7e012008-07-01 16:05:25 +00002058 pDelete = p->pPrior;
drh82c3d632000-06-06 21:56:07 +00002059 p->pPrior = pPrior;
drh95aa47b2010-11-16 02:49:15 +00002060 if( p->nSelectRow>pPrior->nSelectRow ) p->nSelectRow = pPrior->nSelectRow;
drh633e6d52008-07-28 19:34:53 +00002061 sqlite3ExprDelete(db, p->pLimit);
danielk1977a2dc3b12005-02-05 12:48:48 +00002062 p->pLimit = pLimit;
2063 p->pOffset = pOffset;
drhd8bc7082000-06-07 23:51:50 +00002064
2065 /* Generate code to take the intersection of the two temporary
2066 ** tables.
2067 */
drh82c3d632000-06-06 21:56:07 +00002068 assert( p->pEList );
drh7d10d5a2008-08-20 16:35:10 +00002069 if( dest.eDest==SRT_Output ){
drh92378252006-03-26 01:21:22 +00002070 Select *pFirst = p;
2071 while( pFirst->pPrior ) pFirst = pFirst->pPrior;
2072 generateColumnNames(pParse, 0, pFirst->pEList);
drh41202cc2002-04-23 17:10:18 +00002073 }
danielk19774adee202004-05-08 08:23:19 +00002074 iBreak = sqlite3VdbeMakeLabel(v);
2075 iCont = sqlite3VdbeMakeLabel(v);
drhec7429a2005-10-06 16:53:14 +00002076 computeLimitRegisters(pParse, p, iBreak);
drh66a51672008-01-03 00:01:23 +00002077 sqlite3VdbeAddOp2(v, OP_Rewind, tab1, iBreak);
drh9cbf3422008-01-17 16:22:13 +00002078 r1 = sqlite3GetTempReg(pParse);
2079 iStart = sqlite3VdbeAddOp2(v, OP_RowKey, tab1, r1);
drh8cff69d2009-11-12 19:59:44 +00002080 sqlite3VdbeAddOp4Int(v, OP_NotFound, tab2, iCont, r1, 0);
drh9cbf3422008-01-17 16:22:13 +00002081 sqlite3ReleaseTempReg(pParse, r1);
drhd2b3e232008-01-23 14:51:49 +00002082 selectInnerLoop(pParse, p, p->pEList, tab1, p->pEList->nExpr,
drhe8e4af72012-09-21 00:04:28 +00002083 0, 0, &dest, iCont, iBreak);
danielk19774adee202004-05-08 08:23:19 +00002084 sqlite3VdbeResolveLabel(v, iCont);
drh66a51672008-01-03 00:01:23 +00002085 sqlite3VdbeAddOp2(v, OP_Next, tab1, iStart);
danielk19774adee202004-05-08 08:23:19 +00002086 sqlite3VdbeResolveLabel(v, iBreak);
drh66a51672008-01-03 00:01:23 +00002087 sqlite3VdbeAddOp2(v, OP_Close, tab2, 0);
2088 sqlite3VdbeAddOp2(v, OP_Close, tab1, 0);
drh82c3d632000-06-06 21:56:07 +00002089 break;
2090 }
2091 }
drh8cdbf832004-08-29 16:25:03 +00002092
dan7f61e922010-11-11 16:46:40 +00002093 explainComposite(pParse, p->op, iSub1, iSub2, p->op!=TK_ALL);
2094
drha9671a22008-07-08 23:40:20 +00002095 /* Compute collating sequences used by
2096 ** temporary tables needed to implement the compound select.
2097 ** Attach the KeyInfo structure to all temporary tables.
drh8cdbf832004-08-29 16:25:03 +00002098 **
2099 ** This section is run by the right-most SELECT statement only.
2100 ** SELECT statements to the left always skip this part. The right-most
2101 ** SELECT might also skip this part if it has no ORDER BY clause and
2102 ** no temp tables are required.
drhfbc4ee72004-08-29 01:31:05 +00002103 */
drh7d10d5a2008-08-20 16:35:10 +00002104 if( p->selFlags & SF_UsesEphemeral ){
drhfbc4ee72004-08-29 01:31:05 +00002105 int i; /* Loop counter */
2106 KeyInfo *pKeyInfo; /* Collating sequence for the result set */
drh0342b1f2005-09-01 03:07:44 +00002107 Select *pLoop; /* For looping through SELECT statements */
drhf68d7d12007-05-03 13:02:26 +00002108 CollSeq **apColl; /* For looping through pKeyInfo->aColl[] */
drh93a960a2008-07-10 00:32:42 +00002109 int nCol; /* Number of columns in result set */
drhfbc4ee72004-08-29 01:31:05 +00002110
drh0342b1f2005-09-01 03:07:44 +00002111 assert( p->pRightmost==p );
drh93a960a2008-07-10 00:32:42 +00002112 nCol = p->pEList->nExpr;
drhad124322013-10-23 13:30:58 +00002113 pKeyInfo = sqlite3KeyInfoAlloc(db, nCol, 1);
danielk1977dc1bdc42004-06-11 10:51:27 +00002114 if( !pKeyInfo ){
2115 rc = SQLITE_NOMEM;
2116 goto multi_select_end;
2117 }
drh0342b1f2005-09-01 03:07:44 +00002118 for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
2119 *apColl = multiSelectCollSeq(pParse, p, i);
2120 if( 0==*apColl ){
drh633e6d52008-07-28 19:34:53 +00002121 *apColl = db->pDfltColl;
danielk1977dc1bdc42004-06-11 10:51:27 +00002122 }
2123 }
2124
drh0342b1f2005-09-01 03:07:44 +00002125 for(pLoop=p; pLoop; pLoop=pLoop->pPrior){
2126 for(i=0; i<2; i++){
drhb9bb7c12006-06-11 23:41:55 +00002127 int addr = pLoop->addrOpenEphm[i];
drh0342b1f2005-09-01 03:07:44 +00002128 if( addr<0 ){
2129 /* If [0] is unused then [1] is also unused. So we can
2130 ** always safely abort as soon as the first unused slot is found */
drhb9bb7c12006-06-11 23:41:55 +00002131 assert( pLoop->addrOpenEphm[1]<0 );
drh0342b1f2005-09-01 03:07:44 +00002132 break;
2133 }
2134 sqlite3VdbeChangeP2(v, addr, nCol);
drh2ec2fb22013-11-06 19:59:23 +00002135 sqlite3VdbeChangeP4(v, addr, (char*)sqlite3KeyInfoRef(pKeyInfo),
2136 P4_KEYINFO);
drh0ee5a1e2007-01-26 19:04:00 +00002137 pLoop->addrOpenEphm[i] = -1;
drh0342b1f2005-09-01 03:07:44 +00002138 }
danielk1977dc1bdc42004-06-11 10:51:27 +00002139 }
drh2ec2fb22013-11-06 19:59:23 +00002140 sqlite3KeyInfoUnref(pKeyInfo);
danielk197784ac9d02004-05-18 09:58:06 +00002141 }
danielk1977dc1bdc42004-06-11 10:51:27 +00002142
2143multi_select_end:
drh2b596da2012-07-23 21:43:19 +00002144 pDest->iSdst = dest.iSdst;
2145 pDest->nSdst = dest.nSdst;
drh633e6d52008-07-28 19:34:53 +00002146 sqlite3SelectDelete(db, pDelete);
danielk197784ac9d02004-05-18 09:58:06 +00002147 return rc;
drh22827922000-06-06 17:27:05 +00002148}
drhb7f91642004-10-31 02:22:47 +00002149#endif /* SQLITE_OMIT_COMPOUND_SELECT */
drh22827922000-06-06 17:27:05 +00002150
drhb21e7c72008-06-22 12:37:57 +00002151/*
2152** Code an output subroutine for a coroutine implementation of a
2153** SELECT statment.
drh0acb7e42008-06-25 00:12:41 +00002154**
drh2b596da2012-07-23 21:43:19 +00002155** The data to be output is contained in pIn->iSdst. There are
2156** pIn->nSdst columns to be output. pDest is where the output should
drh0acb7e42008-06-25 00:12:41 +00002157** be sent.
2158**
2159** regReturn is the number of the register holding the subroutine
2160** return address.
2161**
drhf053d5b2010-08-09 14:26:32 +00002162** If regPrev>0 then it is the first register in a vector that
drh0acb7e42008-06-25 00:12:41 +00002163** records the previous output. mem[regPrev] is a flag that is false
2164** if there has been no previous output. If regPrev>0 then code is
2165** generated to suppress duplicates. pKeyInfo is used for comparing
2166** keys.
2167**
2168** If the LIMIT found in p->iLimit is reached, jump immediately to
2169** iBreak.
drhb21e7c72008-06-22 12:37:57 +00002170*/
drh0acb7e42008-06-25 00:12:41 +00002171static int generateOutputSubroutine(
drh92b01d52008-06-24 00:32:35 +00002172 Parse *pParse, /* Parsing context */
2173 Select *p, /* The SELECT statement */
2174 SelectDest *pIn, /* Coroutine supplying data */
2175 SelectDest *pDest, /* Where to send the data */
2176 int regReturn, /* The return address register */
drh0acb7e42008-06-25 00:12:41 +00002177 int regPrev, /* Previous result register. No uniqueness if 0 */
2178 KeyInfo *pKeyInfo, /* For comparing with previous entry */
drh92b01d52008-06-24 00:32:35 +00002179 int iBreak /* Jump here if we hit the LIMIT */
drhb21e7c72008-06-22 12:37:57 +00002180){
2181 Vdbe *v = pParse->pVdbe;
drh92b01d52008-06-24 00:32:35 +00002182 int iContinue;
2183 int addr;
drhb21e7c72008-06-22 12:37:57 +00002184
drh92b01d52008-06-24 00:32:35 +00002185 addr = sqlite3VdbeCurrentAddr(v);
2186 iContinue = sqlite3VdbeMakeLabel(v);
drh0acb7e42008-06-25 00:12:41 +00002187
2188 /* Suppress duplicates for UNION, EXCEPT, and INTERSECT
2189 */
2190 if( regPrev ){
2191 int j1, j2;
drhec86c722011-12-09 17:27:51 +00002192 j1 = sqlite3VdbeAddOp1(v, OP_IfNot, regPrev);
drh2b596da2012-07-23 21:43:19 +00002193 j2 = sqlite3VdbeAddOp4(v, OP_Compare, pIn->iSdst, regPrev+1, pIn->nSdst,
drh2ec2fb22013-11-06 19:59:23 +00002194 (char*)sqlite3KeyInfoRef(pKeyInfo), P4_KEYINFO);
drh0acb7e42008-06-25 00:12:41 +00002195 sqlite3VdbeAddOp3(v, OP_Jump, j2+2, iContinue, j2+2);
2196 sqlite3VdbeJumpHere(v, j1);
drhe8e4af72012-09-21 00:04:28 +00002197 sqlite3VdbeAddOp3(v, OP_Copy, pIn->iSdst, regPrev+1, pIn->nSdst-1);
drhec86c722011-12-09 17:27:51 +00002198 sqlite3VdbeAddOp2(v, OP_Integer, 1, regPrev);
drh0acb7e42008-06-25 00:12:41 +00002199 }
danielk19771f9caa42008-07-02 16:10:45 +00002200 if( pParse->db->mallocFailed ) return 0;
drh0acb7e42008-06-25 00:12:41 +00002201
mistachkind5578432012-08-25 10:01:29 +00002202 /* Suppress the first OFFSET entries if there is an OFFSET clause
drh0acb7e42008-06-25 00:12:41 +00002203 */
drh92b01d52008-06-24 00:32:35 +00002204 codeOffset(v, p, iContinue);
drhb21e7c72008-06-22 12:37:57 +00002205
2206 switch( pDest->eDest ){
2207 /* Store the result as data using a unique key.
2208 */
2209 case SRT_Table:
2210 case SRT_EphemTab: {
2211 int r1 = sqlite3GetTempReg(pParse);
2212 int r2 = sqlite3GetTempReg(pParse);
drh373cc2d2009-05-17 02:06:14 +00002213 testcase( pDest->eDest==SRT_Table );
2214 testcase( pDest->eDest==SRT_EphemTab );
drh2b596da2012-07-23 21:43:19 +00002215 sqlite3VdbeAddOp3(v, OP_MakeRecord, pIn->iSdst, pIn->nSdst, r1);
2216 sqlite3VdbeAddOp2(v, OP_NewRowid, pDest->iSDParm, r2);
2217 sqlite3VdbeAddOp3(v, OP_Insert, pDest->iSDParm, r1, r2);
drhb21e7c72008-06-22 12:37:57 +00002218 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
2219 sqlite3ReleaseTempReg(pParse, r2);
2220 sqlite3ReleaseTempReg(pParse, r1);
2221 break;
2222 }
2223
2224#ifndef SQLITE_OMIT_SUBQUERY
2225 /* If we are creating a set for an "expr IN (SELECT ...)" construct,
2226 ** then there should be a single item on the stack. Write this
2227 ** item into the set table with bogus data.
2228 */
2229 case SRT_Set: {
drh6fccc352008-06-27 00:52:45 +00002230 int r1;
drh2b596da2012-07-23 21:43:19 +00002231 assert( pIn->nSdst==1 );
drh634d81d2012-09-20 15:41:31 +00002232 pDest->affSdst =
drh2b596da2012-07-23 21:43:19 +00002233 sqlite3CompareAffinity(p->pEList->a[0].pExpr, pDest->affSdst);
drhb21e7c72008-06-22 12:37:57 +00002234 r1 = sqlite3GetTempReg(pParse);
drh634d81d2012-09-20 15:41:31 +00002235 sqlite3VdbeAddOp4(v, OP_MakeRecord, pIn->iSdst, 1, r1, &pDest->affSdst,1);
drh2b596da2012-07-23 21:43:19 +00002236 sqlite3ExprCacheAffinityChange(pParse, pIn->iSdst, 1);
2237 sqlite3VdbeAddOp2(v, OP_IdxInsert, pDest->iSDParm, r1);
drhb21e7c72008-06-22 12:37:57 +00002238 sqlite3ReleaseTempReg(pParse, r1);
drhb21e7c72008-06-22 12:37:57 +00002239 break;
2240 }
2241
drh85e9e222008-07-15 00:27:34 +00002242#if 0 /* Never occurs on an ORDER BY query */
drhb21e7c72008-06-22 12:37:57 +00002243 /* If any row exist in the result set, record that fact and abort.
2244 */
2245 case SRT_Exists: {
drh2b596da2012-07-23 21:43:19 +00002246 sqlite3VdbeAddOp2(v, OP_Integer, 1, pDest->iSDParm);
drhb21e7c72008-06-22 12:37:57 +00002247 /* The LIMIT clause will terminate the loop for us */
2248 break;
2249 }
drh85e9e222008-07-15 00:27:34 +00002250#endif
drhb21e7c72008-06-22 12:37:57 +00002251
2252 /* If this is a scalar select that is part of an expression, then
2253 ** store the results in the appropriate memory cell and break out
2254 ** of the scan loop.
2255 */
2256 case SRT_Mem: {
drh2b596da2012-07-23 21:43:19 +00002257 assert( pIn->nSdst==1 );
2258 sqlite3ExprCodeMove(pParse, pIn->iSdst, pDest->iSDParm, 1);
drhb21e7c72008-06-22 12:37:57 +00002259 /* The LIMIT clause will jump out of the loop for us */
2260 break;
2261 }
2262#endif /* #ifndef SQLITE_OMIT_SUBQUERY */
2263
drh7d10d5a2008-08-20 16:35:10 +00002264 /* The results are stored in a sequence of registers
drh2b596da2012-07-23 21:43:19 +00002265 ** starting at pDest->iSdst. Then the co-routine yields.
drhb21e7c72008-06-22 12:37:57 +00002266 */
drh92b01d52008-06-24 00:32:35 +00002267 case SRT_Coroutine: {
drh2b596da2012-07-23 21:43:19 +00002268 if( pDest->iSdst==0 ){
2269 pDest->iSdst = sqlite3GetTempRange(pParse, pIn->nSdst);
2270 pDest->nSdst = pIn->nSdst;
drhb21e7c72008-06-22 12:37:57 +00002271 }
drh2b596da2012-07-23 21:43:19 +00002272 sqlite3ExprCodeMove(pParse, pIn->iSdst, pDest->iSdst, pDest->nSdst);
2273 sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm);
drh92b01d52008-06-24 00:32:35 +00002274 break;
2275 }
2276
drhccfcbce2009-05-18 15:46:07 +00002277 /* If none of the above, then the result destination must be
2278 ** SRT_Output. This routine is never called with any other
2279 ** destination other than the ones handled above or SRT_Output.
2280 **
2281 ** For SRT_Output, results are stored in a sequence of registers.
2282 ** Then the OP_ResultRow opcode is used to cause sqlite3_step() to
2283 ** return the next row of result.
drh7d10d5a2008-08-20 16:35:10 +00002284 */
drhccfcbce2009-05-18 15:46:07 +00002285 default: {
2286 assert( pDest->eDest==SRT_Output );
drh2b596da2012-07-23 21:43:19 +00002287 sqlite3VdbeAddOp2(v, OP_ResultRow, pIn->iSdst, pIn->nSdst);
2288 sqlite3ExprCacheAffinityChange(pParse, pIn->iSdst, pIn->nSdst);
drhb21e7c72008-06-22 12:37:57 +00002289 break;
2290 }
drhb21e7c72008-06-22 12:37:57 +00002291 }
drh92b01d52008-06-24 00:32:35 +00002292
2293 /* Jump to the end of the loop if the LIMIT is reached.
2294 */
2295 if( p->iLimit ){
drh9b918ed2009-11-12 03:13:26 +00002296 sqlite3VdbeAddOp3(v, OP_IfZero, p->iLimit, iBreak, -1);
drh92b01d52008-06-24 00:32:35 +00002297 }
2298
drh92b01d52008-06-24 00:32:35 +00002299 /* Generate the subroutine return
2300 */
drh0acb7e42008-06-25 00:12:41 +00002301 sqlite3VdbeResolveLabel(v, iContinue);
drh92b01d52008-06-24 00:32:35 +00002302 sqlite3VdbeAddOp1(v, OP_Return, regReturn);
2303
2304 return addr;
drhb21e7c72008-06-22 12:37:57 +00002305}
2306
2307/*
2308** Alternative compound select code generator for cases when there
2309** is an ORDER BY clause.
2310**
2311** We assume a query of the following form:
2312**
2313** <selectA> <operator> <selectB> ORDER BY <orderbylist>
2314**
2315** <operator> is one of UNION ALL, UNION, EXCEPT, or INTERSECT. The idea
2316** is to code both <selectA> and <selectB> with the ORDER BY clause as
2317** co-routines. Then run the co-routines in parallel and merge the results
2318** into the output. In addition to the two coroutines (called selectA and
2319** selectB) there are 7 subroutines:
2320**
2321** outA: Move the output of the selectA coroutine into the output
2322** of the compound query.
2323**
2324** outB: Move the output of the selectB coroutine into the output
2325** of the compound query. (Only generated for UNION and
2326** UNION ALL. EXCEPT and INSERTSECT never output a row that
2327** appears only in B.)
2328**
2329** AltB: Called when there is data from both coroutines and A<B.
2330**
2331** AeqB: Called when there is data from both coroutines and A==B.
2332**
2333** AgtB: Called when there is data from both coroutines and A>B.
2334**
2335** EofA: Called when data is exhausted from selectA.
2336**
2337** EofB: Called when data is exhausted from selectB.
2338**
2339** The implementation of the latter five subroutines depend on which
2340** <operator> is used:
2341**
2342**
2343** UNION ALL UNION EXCEPT INTERSECT
2344** ------------- ----------------- -------------- -----------------
drh0acb7e42008-06-25 00:12:41 +00002345** AltB: outA, nextA outA, nextA outA, nextA nextA
drhb21e7c72008-06-22 12:37:57 +00002346**
drh0acb7e42008-06-25 00:12:41 +00002347** AeqB: outA, nextA nextA nextA outA, nextA
drhb21e7c72008-06-22 12:37:57 +00002348**
drh0acb7e42008-06-25 00:12:41 +00002349** AgtB: outB, nextB outB, nextB nextB nextB
drhb21e7c72008-06-22 12:37:57 +00002350**
drh0acb7e42008-06-25 00:12:41 +00002351** EofA: outB, nextB outB, nextB halt halt
drhb21e7c72008-06-22 12:37:57 +00002352**
drh0acb7e42008-06-25 00:12:41 +00002353** EofB: outA, nextA outA, nextA outA, nextA halt
2354**
2355** In the AltB, AeqB, and AgtB subroutines, an EOF on A following nextA
2356** causes an immediate jump to EofA and an EOF on B following nextB causes
2357** an immediate jump to EofB. Within EofA and EofB, and EOF on entry or
2358** following nextX causes a jump to the end of the select processing.
2359**
2360** Duplicate removal in the UNION, EXCEPT, and INTERSECT cases is handled
2361** within the output subroutine. The regPrev register set holds the previously
2362** output value. A comparison is made against this value and the output
2363** is skipped if the next results would be the same as the previous.
drhb21e7c72008-06-22 12:37:57 +00002364**
2365** The implementation plan is to implement the two coroutines and seven
2366** subroutines first, then put the control logic at the bottom. Like this:
2367**
2368** goto Init
2369** coA: coroutine for left query (A)
2370** coB: coroutine for right query (B)
2371** outA: output one row of A
2372** outB: output one row of B (UNION and UNION ALL only)
2373** EofA: ...
2374** EofB: ...
2375** AltB: ...
2376** AeqB: ...
2377** AgtB: ...
2378** Init: initialize coroutine registers
2379** yield coA
2380** if eof(A) goto EofA
2381** yield coB
2382** if eof(B) goto EofB
2383** Cmpr: Compare A, B
2384** Jump AltB, AeqB, AgtB
2385** End: ...
2386**
2387** We call AltB, AeqB, AgtB, EofA, and EofB "subroutines" but they are not
2388** actually called using Gosub and they do not Return. EofA and EofB loop
2389** until all data is exhausted then jump to the "end" labe. AltB, AeqB,
2390** and AgtB jump to either L2 or to one of EofA or EofB.
2391*/
danielk1977de3e41e2008-08-04 03:51:24 +00002392#ifndef SQLITE_OMIT_COMPOUND_SELECT
drhb21e7c72008-06-22 12:37:57 +00002393static int multiSelectOrderBy(
2394 Parse *pParse, /* Parsing context */
2395 Select *p, /* The right-most of SELECTs to be coded */
drha9671a22008-07-08 23:40:20 +00002396 SelectDest *pDest /* What to do with query results */
drhb21e7c72008-06-22 12:37:57 +00002397){
drh0acb7e42008-06-25 00:12:41 +00002398 int i, j; /* Loop counters */
drhb21e7c72008-06-22 12:37:57 +00002399 Select *pPrior; /* Another SELECT immediately to our left */
2400 Vdbe *v; /* Generate code to this VDBE */
drhb21e7c72008-06-22 12:37:57 +00002401 SelectDest destA; /* Destination for coroutine A */
2402 SelectDest destB; /* Destination for coroutine B */
drh92b01d52008-06-24 00:32:35 +00002403 int regAddrA; /* Address register for select-A coroutine */
2404 int regEofA; /* Flag to indicate when select-A is complete */
2405 int regAddrB; /* Address register for select-B coroutine */
2406 int regEofB; /* Flag to indicate when select-B is complete */
2407 int addrSelectA; /* Address of the select-A coroutine */
2408 int addrSelectB; /* Address of the select-B coroutine */
2409 int regOutA; /* Address register for the output-A subroutine */
2410 int regOutB; /* Address register for the output-B subroutine */
2411 int addrOutA; /* Address of the output-A subroutine */
drhb27b7f52008-12-10 18:03:45 +00002412 int addrOutB = 0; /* Address of the output-B subroutine */
drh92b01d52008-06-24 00:32:35 +00002413 int addrEofA; /* Address of the select-A-exhausted subroutine */
2414 int addrEofB; /* Address of the select-B-exhausted subroutine */
2415 int addrAltB; /* Address of the A<B subroutine */
2416 int addrAeqB; /* Address of the A==B subroutine */
2417 int addrAgtB; /* Address of the A>B subroutine */
2418 int regLimitA; /* Limit register for select-A */
2419 int regLimitB; /* Limit register for select-A */
drh0acb7e42008-06-25 00:12:41 +00002420 int regPrev; /* A range of registers to hold previous output */
drh92b01d52008-06-24 00:32:35 +00002421 int savedLimit; /* Saved value of p->iLimit */
2422 int savedOffset; /* Saved value of p->iOffset */
2423 int labelCmpr; /* Label for the start of the merge algorithm */
2424 int labelEnd; /* Label for the end of the overall SELECT stmt */
drh0acb7e42008-06-25 00:12:41 +00002425 int j1; /* Jump instructions that get retargetted */
drh92b01d52008-06-24 00:32:35 +00002426 int op; /* One of TK_ALL, TK_UNION, TK_EXCEPT, TK_INTERSECT */
drh96067812008-09-23 09:36:10 +00002427 KeyInfo *pKeyDup = 0; /* Comparison information for duplicate removal */
drh0acb7e42008-06-25 00:12:41 +00002428 KeyInfo *pKeyMerge; /* Comparison information for merging rows */
2429 sqlite3 *db; /* Database connection */
2430 ExprList *pOrderBy; /* The ORDER BY clause */
2431 int nOrderBy; /* Number of terms in the ORDER BY clause */
2432 int *aPermute; /* Mapping from ORDER BY terms to result set columns */
dan7f61e922010-11-11 16:46:40 +00002433#ifndef SQLITE_OMIT_EXPLAIN
2434 int iSub1; /* EQP id of left-hand query */
2435 int iSub2; /* EQP id of right-hand query */
2436#endif
drhb21e7c72008-06-22 12:37:57 +00002437
drh92b01d52008-06-24 00:32:35 +00002438 assert( p->pOrderBy!=0 );
drh96067812008-09-23 09:36:10 +00002439 assert( pKeyDup==0 ); /* "Managed" code needs this. Ticket #3382. */
drh0acb7e42008-06-25 00:12:41 +00002440 db = pParse->db;
drh92b01d52008-06-24 00:32:35 +00002441 v = pParse->pVdbe;
drhccfcbce2009-05-18 15:46:07 +00002442 assert( v!=0 ); /* Already thrown the error if VDBE alloc failed */
drh92b01d52008-06-24 00:32:35 +00002443 labelEnd = sqlite3VdbeMakeLabel(v);
2444 labelCmpr = sqlite3VdbeMakeLabel(v);
drh0acb7e42008-06-25 00:12:41 +00002445
drh92b01d52008-06-24 00:32:35 +00002446
2447 /* Patch up the ORDER BY clause
2448 */
2449 op = p->op;
drhb21e7c72008-06-22 12:37:57 +00002450 pPrior = p->pPrior;
drh92b01d52008-06-24 00:32:35 +00002451 assert( pPrior->pOrderBy==0 );
drh0acb7e42008-06-25 00:12:41 +00002452 pOrderBy = p->pOrderBy;
drh93a960a2008-07-10 00:32:42 +00002453 assert( pOrderBy );
drh93a960a2008-07-10 00:32:42 +00002454 nOrderBy = pOrderBy->nExpr;
2455
drh0acb7e42008-06-25 00:12:41 +00002456 /* For operators other than UNION ALL we have to make sure that
2457 ** the ORDER BY clause covers every term of the result set. Add
2458 ** terms to the ORDER BY clause as necessary.
2459 */
2460 if( op!=TK_ALL ){
2461 for(i=1; db->mallocFailed==0 && i<=p->pEList->nExpr; i++){
drh7d10d5a2008-08-20 16:35:10 +00002462 struct ExprList_item *pItem;
2463 for(j=0, pItem=pOrderBy->a; j<nOrderBy; j++, pItem++){
drhc2acc4e2013-11-15 18:15:19 +00002464 assert( pItem->u.x.iOrderByCol>0 );
2465 if( pItem->u.x.iOrderByCol==i ) break;
drh0acb7e42008-06-25 00:12:41 +00002466 }
2467 if( j==nOrderBy ){
drhb7916a72009-05-27 10:31:29 +00002468 Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0);
drh0acb7e42008-06-25 00:12:41 +00002469 if( pNew==0 ) return SQLITE_NOMEM;
2470 pNew->flags |= EP_IntValue;
drh33e619f2009-05-28 01:00:55 +00002471 pNew->u.iValue = i;
drhb7916a72009-05-27 10:31:29 +00002472 pOrderBy = sqlite3ExprListAppend(pParse, pOrderBy, pNew);
drhc2acc4e2013-11-15 18:15:19 +00002473 if( pOrderBy ) pOrderBy->a[nOrderBy++].u.x.iOrderByCol = (u16)i;
drh0acb7e42008-06-25 00:12:41 +00002474 }
2475 }
2476 }
2477
2478 /* Compute the comparison permutation and keyinfo that is used with
drh10c081a2009-04-16 00:24:23 +00002479 ** the permutation used to determine if the next
drh0acb7e42008-06-25 00:12:41 +00002480 ** row of results comes from selectA or selectB. Also add explicit
2481 ** collations to the ORDER BY clause terms so that when the subqueries
2482 ** to the right and the left are evaluated, they use the correct
2483 ** collation.
2484 */
2485 aPermute = sqlite3DbMallocRaw(db, sizeof(int)*nOrderBy);
2486 if( aPermute ){
drh7d10d5a2008-08-20 16:35:10 +00002487 struct ExprList_item *pItem;
2488 for(i=0, pItem=pOrderBy->a; i<nOrderBy; i++, pItem++){
drhc2acc4e2013-11-15 18:15:19 +00002489 assert( pItem->u.x.iOrderByCol>0
2490 && pItem->u.x.iOrderByCol<=p->pEList->nExpr );
2491 aPermute[i] = pItem->u.x.iOrderByCol - 1;
drh0acb7e42008-06-25 00:12:41 +00002492 }
drhad124322013-10-23 13:30:58 +00002493 pKeyMerge = sqlite3KeyInfoAlloc(db, nOrderBy, 1);
drh0acb7e42008-06-25 00:12:41 +00002494 if( pKeyMerge ){
drh0acb7e42008-06-25 00:12:41 +00002495 for(i=0; i<nOrderBy; i++){
2496 CollSeq *pColl;
2497 Expr *pTerm = pOrderBy->a[i].pExpr;
drhae80dde2012-12-06 21:16:43 +00002498 if( pTerm->flags & EP_Collate ){
2499 pColl = sqlite3ExprCollSeq(pParse, pTerm);
drh0acb7e42008-06-25 00:12:41 +00002500 }else{
2501 pColl = multiSelectCollSeq(pParse, p, aPermute[i]);
drh8e049632012-12-07 23:10:40 +00002502 if( pColl==0 ) pColl = db->pDfltColl;
2503 pOrderBy->a[i].pExpr =
2504 sqlite3ExprAddCollateString(pParse, pTerm, pColl->zName);
drh0acb7e42008-06-25 00:12:41 +00002505 }
drh2ec2fb22013-11-06 19:59:23 +00002506 assert( sqlite3KeyInfoIsWriteable(pKeyMerge) );
drh0acb7e42008-06-25 00:12:41 +00002507 pKeyMerge->aColl[i] = pColl;
2508 pKeyMerge->aSortOrder[i] = pOrderBy->a[i].sortOrder;
2509 }
2510 }
2511 }else{
2512 pKeyMerge = 0;
2513 }
2514
2515 /* Reattach the ORDER BY clause to the query.
2516 */
2517 p->pOrderBy = pOrderBy;
danielk19776ab3a2e2009-02-19 14:39:25 +00002518 pPrior->pOrderBy = sqlite3ExprListDup(pParse->db, pOrderBy, 0);
drh0acb7e42008-06-25 00:12:41 +00002519
2520 /* Allocate a range of temporary registers and the KeyInfo needed
2521 ** for the logic that removes duplicate result rows when the
2522 ** operator is UNION, EXCEPT, or INTERSECT (but not UNION ALL).
2523 */
2524 if( op==TK_ALL ){
2525 regPrev = 0;
2526 }else{
2527 int nExpr = p->pEList->nExpr;
drh1c0dc822008-10-30 22:13:23 +00002528 assert( nOrderBy>=nExpr || db->mallocFailed );
drhc8ac0d12013-02-16 02:41:01 +00002529 regPrev = pParse->nMem+1;
2530 pParse->nMem += nExpr+1;
drh0acb7e42008-06-25 00:12:41 +00002531 sqlite3VdbeAddOp2(v, OP_Integer, 0, regPrev);
drhad124322013-10-23 13:30:58 +00002532 pKeyDup = sqlite3KeyInfoAlloc(db, nExpr, 1);
drh0acb7e42008-06-25 00:12:41 +00002533 if( pKeyDup ){
drh2ec2fb22013-11-06 19:59:23 +00002534 assert( sqlite3KeyInfoIsWriteable(pKeyDup) );
drh0acb7e42008-06-25 00:12:41 +00002535 for(i=0; i<nExpr; i++){
2536 pKeyDup->aColl[i] = multiSelectCollSeq(pParse, p, i);
2537 pKeyDup->aSortOrder[i] = 0;
2538 }
2539 }
2540 }
drh92b01d52008-06-24 00:32:35 +00002541
2542 /* Separate the left and the right query from one another
2543 */
2544 p->pPrior = 0;
drh7d10d5a2008-08-20 16:35:10 +00002545 sqlite3ResolveOrderGroupBy(pParse, p, p->pOrderBy, "ORDER");
drh0acb7e42008-06-25 00:12:41 +00002546 if( pPrior->pPrior==0 ){
drh7d10d5a2008-08-20 16:35:10 +00002547 sqlite3ResolveOrderGroupBy(pParse, pPrior, pPrior->pOrderBy, "ORDER");
drh0acb7e42008-06-25 00:12:41 +00002548 }
2549
drh92b01d52008-06-24 00:32:35 +00002550 /* Compute the limit registers */
2551 computeLimitRegisters(pParse, p, labelEnd);
drh0acb7e42008-06-25 00:12:41 +00002552 if( p->iLimit && op==TK_ALL ){
drh92b01d52008-06-24 00:32:35 +00002553 regLimitA = ++pParse->nMem;
2554 regLimitB = ++pParse->nMem;
2555 sqlite3VdbeAddOp2(v, OP_Copy, p->iOffset ? p->iOffset+1 : p->iLimit,
2556 regLimitA);
2557 sqlite3VdbeAddOp2(v, OP_Copy, regLimitA, regLimitB);
2558 }else{
2559 regLimitA = regLimitB = 0;
2560 }
drh633e6d52008-07-28 19:34:53 +00002561 sqlite3ExprDelete(db, p->pLimit);
drh0acb7e42008-06-25 00:12:41 +00002562 p->pLimit = 0;
drh633e6d52008-07-28 19:34:53 +00002563 sqlite3ExprDelete(db, p->pOffset);
drh0acb7e42008-06-25 00:12:41 +00002564 p->pOffset = 0;
drh92b01d52008-06-24 00:32:35 +00002565
drhb21e7c72008-06-22 12:37:57 +00002566 regAddrA = ++pParse->nMem;
2567 regEofA = ++pParse->nMem;
2568 regAddrB = ++pParse->nMem;
2569 regEofB = ++pParse->nMem;
2570 regOutA = ++pParse->nMem;
2571 regOutB = ++pParse->nMem;
2572 sqlite3SelectDestInit(&destA, SRT_Coroutine, regAddrA);
2573 sqlite3SelectDestInit(&destB, SRT_Coroutine, regAddrB);
2574
drh92b01d52008-06-24 00:32:35 +00002575 /* Jump past the various subroutines and coroutines to the main
2576 ** merge loop
2577 */
drhb21e7c72008-06-22 12:37:57 +00002578 j1 = sqlite3VdbeAddOp0(v, OP_Goto);
2579 addrSelectA = sqlite3VdbeCurrentAddr(v);
drh92b01d52008-06-24 00:32:35 +00002580
drh0acb7e42008-06-25 00:12:41 +00002581
drh92b01d52008-06-24 00:32:35 +00002582 /* Generate a coroutine to evaluate the SELECT statement to the
drh0acb7e42008-06-25 00:12:41 +00002583 ** left of the compound operator - the "A" select.
2584 */
drhb21e7c72008-06-22 12:37:57 +00002585 VdbeNoopComment((v, "Begin coroutine for left SELECT"));
drh92b01d52008-06-24 00:32:35 +00002586 pPrior->iLimit = regLimitA;
dan7f61e922010-11-11 16:46:40 +00002587 explainSetInteger(iSub1, pParse->iNextSelectId);
drh7d10d5a2008-08-20 16:35:10 +00002588 sqlite3Select(pParse, pPrior, &destA);
drhb21e7c72008-06-22 12:37:57 +00002589 sqlite3VdbeAddOp2(v, OP_Integer, 1, regEofA);
drh92b01d52008-06-24 00:32:35 +00002590 sqlite3VdbeAddOp1(v, OP_Yield, regAddrA);
drhb21e7c72008-06-22 12:37:57 +00002591 VdbeNoopComment((v, "End coroutine for left SELECT"));
2592
drh92b01d52008-06-24 00:32:35 +00002593 /* Generate a coroutine to evaluate the SELECT statement on
2594 ** the right - the "B" select
2595 */
drhb21e7c72008-06-22 12:37:57 +00002596 addrSelectB = sqlite3VdbeCurrentAddr(v);
2597 VdbeNoopComment((v, "Begin coroutine for right SELECT"));
drh92b01d52008-06-24 00:32:35 +00002598 savedLimit = p->iLimit;
2599 savedOffset = p->iOffset;
2600 p->iLimit = regLimitB;
2601 p->iOffset = 0;
dan7f61e922010-11-11 16:46:40 +00002602 explainSetInteger(iSub2, pParse->iNextSelectId);
drh7d10d5a2008-08-20 16:35:10 +00002603 sqlite3Select(pParse, p, &destB);
drh92b01d52008-06-24 00:32:35 +00002604 p->iLimit = savedLimit;
2605 p->iOffset = savedOffset;
drhb21e7c72008-06-22 12:37:57 +00002606 sqlite3VdbeAddOp2(v, OP_Integer, 1, regEofB);
drh92b01d52008-06-24 00:32:35 +00002607 sqlite3VdbeAddOp1(v, OP_Yield, regAddrB);
drhb21e7c72008-06-22 12:37:57 +00002608 VdbeNoopComment((v, "End coroutine for right SELECT"));
2609
drh92b01d52008-06-24 00:32:35 +00002610 /* Generate a subroutine that outputs the current row of the A
drh0acb7e42008-06-25 00:12:41 +00002611 ** select as the next output row of the compound select.
drh92b01d52008-06-24 00:32:35 +00002612 */
drhb21e7c72008-06-22 12:37:57 +00002613 VdbeNoopComment((v, "Output routine for A"));
drh0acb7e42008-06-25 00:12:41 +00002614 addrOutA = generateOutputSubroutine(pParse,
2615 p, &destA, pDest, regOutA,
drh2ec2fb22013-11-06 19:59:23 +00002616 regPrev, pKeyDup, labelEnd);
drhb21e7c72008-06-22 12:37:57 +00002617
drh92b01d52008-06-24 00:32:35 +00002618 /* Generate a subroutine that outputs the current row of the B
drh0acb7e42008-06-25 00:12:41 +00002619 ** select as the next output row of the compound select.
drh92b01d52008-06-24 00:32:35 +00002620 */
drh0acb7e42008-06-25 00:12:41 +00002621 if( op==TK_ALL || op==TK_UNION ){
2622 VdbeNoopComment((v, "Output routine for B"));
2623 addrOutB = generateOutputSubroutine(pParse,
2624 p, &destB, pDest, regOutB,
drh2ec2fb22013-11-06 19:59:23 +00002625 regPrev, pKeyDup, labelEnd);
drh0acb7e42008-06-25 00:12:41 +00002626 }
drh2ec2fb22013-11-06 19:59:23 +00002627 sqlite3KeyInfoUnref(pKeyDup);
drhb21e7c72008-06-22 12:37:57 +00002628
drh92b01d52008-06-24 00:32:35 +00002629 /* Generate a subroutine to run when the results from select A
2630 ** are exhausted and only data in select B remains.
2631 */
2632 VdbeNoopComment((v, "eof-A subroutine"));
drhb21e7c72008-06-22 12:37:57 +00002633 if( op==TK_EXCEPT || op==TK_INTERSECT ){
drh0acb7e42008-06-25 00:12:41 +00002634 addrEofA = sqlite3VdbeAddOp2(v, OP_Goto, 0, labelEnd);
drhb21e7c72008-06-22 12:37:57 +00002635 }else{
drh0acb7e42008-06-25 00:12:41 +00002636 addrEofA = sqlite3VdbeAddOp2(v, OP_If, regEofB, labelEnd);
2637 sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB);
2638 sqlite3VdbeAddOp1(v, OP_Yield, regAddrB);
2639 sqlite3VdbeAddOp2(v, OP_Goto, 0, addrEofA);
drh95aa47b2010-11-16 02:49:15 +00002640 p->nSelectRow += pPrior->nSelectRow;
drhb21e7c72008-06-22 12:37:57 +00002641 }
2642
drh92b01d52008-06-24 00:32:35 +00002643 /* Generate a subroutine to run when the results from select B
2644 ** are exhausted and only data in select A remains.
2645 */
drhb21e7c72008-06-22 12:37:57 +00002646 if( op==TK_INTERSECT ){
drh92b01d52008-06-24 00:32:35 +00002647 addrEofB = addrEofA;
drh95aa47b2010-11-16 02:49:15 +00002648 if( p->nSelectRow > pPrior->nSelectRow ) p->nSelectRow = pPrior->nSelectRow;
drhb21e7c72008-06-22 12:37:57 +00002649 }else{
drh92b01d52008-06-24 00:32:35 +00002650 VdbeNoopComment((v, "eof-B subroutine"));
drh0acb7e42008-06-25 00:12:41 +00002651 addrEofB = sqlite3VdbeAddOp2(v, OP_If, regEofA, labelEnd);
2652 sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA);
2653 sqlite3VdbeAddOp1(v, OP_Yield, regAddrA);
2654 sqlite3VdbeAddOp2(v, OP_Goto, 0, addrEofB);
drhb21e7c72008-06-22 12:37:57 +00002655 }
2656
drh92b01d52008-06-24 00:32:35 +00002657 /* Generate code to handle the case of A<B
2658 */
drhb21e7c72008-06-22 12:37:57 +00002659 VdbeNoopComment((v, "A-lt-B subroutine"));
drh0acb7e42008-06-25 00:12:41 +00002660 addrAltB = sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA);
2661 sqlite3VdbeAddOp1(v, OP_Yield, regAddrA);
drhb21e7c72008-06-22 12:37:57 +00002662 sqlite3VdbeAddOp2(v, OP_If, regEofA, addrEofA);
drh92b01d52008-06-24 00:32:35 +00002663 sqlite3VdbeAddOp2(v, OP_Goto, 0, labelCmpr);
drhb21e7c72008-06-22 12:37:57 +00002664
drh92b01d52008-06-24 00:32:35 +00002665 /* Generate code to handle the case of A==B
2666 */
drhb21e7c72008-06-22 12:37:57 +00002667 if( op==TK_ALL ){
2668 addrAeqB = addrAltB;
drh0acb7e42008-06-25 00:12:41 +00002669 }else if( op==TK_INTERSECT ){
2670 addrAeqB = addrAltB;
2671 addrAltB++;
drh92b01d52008-06-24 00:32:35 +00002672 }else{
drhb21e7c72008-06-22 12:37:57 +00002673 VdbeNoopComment((v, "A-eq-B subroutine"));
drh0acb7e42008-06-25 00:12:41 +00002674 addrAeqB =
2675 sqlite3VdbeAddOp1(v, OP_Yield, regAddrA);
2676 sqlite3VdbeAddOp2(v, OP_If, regEofA, addrEofA);
2677 sqlite3VdbeAddOp2(v, OP_Goto, 0, labelCmpr);
drhb21e7c72008-06-22 12:37:57 +00002678 }
2679
drh92b01d52008-06-24 00:32:35 +00002680 /* Generate code to handle the case of A>B
2681 */
drhb21e7c72008-06-22 12:37:57 +00002682 VdbeNoopComment((v, "A-gt-B subroutine"));
2683 addrAgtB = sqlite3VdbeCurrentAddr(v);
2684 if( op==TK_ALL || op==TK_UNION ){
2685 sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB);
2686 }
drh0acb7e42008-06-25 00:12:41 +00002687 sqlite3VdbeAddOp1(v, OP_Yield, regAddrB);
drhb21e7c72008-06-22 12:37:57 +00002688 sqlite3VdbeAddOp2(v, OP_If, regEofB, addrEofB);
drh92b01d52008-06-24 00:32:35 +00002689 sqlite3VdbeAddOp2(v, OP_Goto, 0, labelCmpr);
drhb21e7c72008-06-22 12:37:57 +00002690
drh92b01d52008-06-24 00:32:35 +00002691 /* This code runs once to initialize everything.
2692 */
drhb21e7c72008-06-22 12:37:57 +00002693 sqlite3VdbeJumpHere(v, j1);
2694 sqlite3VdbeAddOp2(v, OP_Integer, 0, regEofA);
2695 sqlite3VdbeAddOp2(v, OP_Integer, 0, regEofB);
drh92b01d52008-06-24 00:32:35 +00002696 sqlite3VdbeAddOp2(v, OP_Gosub, regAddrA, addrSelectA);
drh0acb7e42008-06-25 00:12:41 +00002697 sqlite3VdbeAddOp2(v, OP_Gosub, regAddrB, addrSelectB);
drhb21e7c72008-06-22 12:37:57 +00002698 sqlite3VdbeAddOp2(v, OP_If, regEofA, addrEofA);
drhb21e7c72008-06-22 12:37:57 +00002699 sqlite3VdbeAddOp2(v, OP_If, regEofB, addrEofB);
drh92b01d52008-06-24 00:32:35 +00002700
2701 /* Implement the main merge loop
2702 */
2703 sqlite3VdbeResolveLabel(v, labelCmpr);
drh0acb7e42008-06-25 00:12:41 +00002704 sqlite3VdbeAddOp4(v, OP_Permutation, 0, 0, 0, (char*)aPermute, P4_INTARRAY);
drh2b596da2012-07-23 21:43:19 +00002705 sqlite3VdbeAddOp4(v, OP_Compare, destA.iSdst, destB.iSdst, nOrderBy,
drh2ec2fb22013-11-06 19:59:23 +00002706 (char*)pKeyMerge, P4_KEYINFO);
drh953f7612012-12-07 22:18:54 +00002707 sqlite3VdbeChangeP5(v, OPFLAG_PERMUTE);
drhb21e7c72008-06-22 12:37:57 +00002708 sqlite3VdbeAddOp3(v, OP_Jump, addrAltB, addrAeqB, addrAgtB);
drh92b01d52008-06-24 00:32:35 +00002709
2710 /* Jump to the this point in order to terminate the query.
2711 */
drhb21e7c72008-06-22 12:37:57 +00002712 sqlite3VdbeResolveLabel(v, labelEnd);
drh92b01d52008-06-24 00:32:35 +00002713
2714 /* Set the number of output columns
2715 */
drh7d10d5a2008-08-20 16:35:10 +00002716 if( pDest->eDest==SRT_Output ){
drh0acb7e42008-06-25 00:12:41 +00002717 Select *pFirst = pPrior;
drh92b01d52008-06-24 00:32:35 +00002718 while( pFirst->pPrior ) pFirst = pFirst->pPrior;
2719 generateColumnNames(pParse, 0, pFirst->pEList);
2720 }
2721
drh0acb7e42008-06-25 00:12:41 +00002722 /* Reassembly the compound query so that it will be freed correctly
2723 ** by the calling function */
danielk19775e7ad502008-07-01 17:39:27 +00002724 if( p->pPrior ){
drh633e6d52008-07-28 19:34:53 +00002725 sqlite3SelectDelete(db, p->pPrior);
danielk19775e7ad502008-07-01 17:39:27 +00002726 }
drh0acb7e42008-06-25 00:12:41 +00002727 p->pPrior = pPrior;
drh92b01d52008-06-24 00:32:35 +00002728
drh92b01d52008-06-24 00:32:35 +00002729 /*** TBD: Insert subroutine calls to close cursors on incomplete
2730 **** subqueries ****/
dan7f61e922010-11-11 16:46:40 +00002731 explainComposite(pParse, p->op, iSub1, iSub2, 0);
drh92b01d52008-06-24 00:32:35 +00002732 return SQLITE_OK;
drhb21e7c72008-06-22 12:37:57 +00002733}
danielk1977de3e41e2008-08-04 03:51:24 +00002734#endif
drhb21e7c72008-06-22 12:37:57 +00002735
shane3514b6f2008-07-22 05:00:55 +00002736#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
drh17435752007-08-16 04:30:38 +00002737/* Forward Declarations */
2738static void substExprList(sqlite3*, ExprList*, int, ExprList*);
2739static void substSelect(sqlite3*, Select *, int, ExprList *);
2740
drh22827922000-06-06 17:27:05 +00002741/*
drh832508b2002-03-02 17:04:07 +00002742** Scan through the expression pExpr. Replace every reference to
drh6a3ea0e2003-05-02 14:32:12 +00002743** a column in table number iTable with a copy of the iColumn-th
drh84e59202002-03-14 14:33:31 +00002744** entry in pEList. (But leave references to the ROWID column
drh6a3ea0e2003-05-02 14:32:12 +00002745** unchanged.)
drh832508b2002-03-02 17:04:07 +00002746**
2747** This routine is part of the flattening procedure. A subquery
2748** whose result set is defined by pEList appears as entry in the
2749** FROM clause of a SELECT such that the VDBE cursor assigned to that
2750** FORM clause entry is iTable. This routine make the necessary
2751** changes to pExpr so that it refers directly to the source table
2752** of the subquery rather the result set of the subquery.
2753*/
drhb7916a72009-05-27 10:31:29 +00002754static Expr *substExpr(
drh17435752007-08-16 04:30:38 +00002755 sqlite3 *db, /* Report malloc errors to this connection */
2756 Expr *pExpr, /* Expr in which substitution occurs */
2757 int iTable, /* Table to be substituted */
2758 ExprList *pEList /* Substitute expressions */
2759){
drhb7916a72009-05-27 10:31:29 +00002760 if( pExpr==0 ) return 0;
drh50350a12004-02-13 16:22:22 +00002761 if( pExpr->op==TK_COLUMN && pExpr->iTable==iTable ){
2762 if( pExpr->iColumn<0 ){
2763 pExpr->op = TK_NULL;
2764 }else{
2765 Expr *pNew;
2766 assert( pEList!=0 && pExpr->iColumn<pEList->nExpr );
danielk19776ab3a2e2009-02-19 14:39:25 +00002767 assert( pExpr->pLeft==0 && pExpr->pRight==0 );
drhb7916a72009-05-27 10:31:29 +00002768 pNew = sqlite3ExprDup(db, pEList->a[pExpr->iColumn].pExpr, 0);
2769 sqlite3ExprDelete(db, pExpr);
2770 pExpr = pNew;
drh50350a12004-02-13 16:22:22 +00002771 }
drh832508b2002-03-02 17:04:07 +00002772 }else{
drhb7916a72009-05-27 10:31:29 +00002773 pExpr->pLeft = substExpr(db, pExpr->pLeft, iTable, pEList);
2774 pExpr->pRight = substExpr(db, pExpr->pRight, iTable, pEList);
danielk19776ab3a2e2009-02-19 14:39:25 +00002775 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
2776 substSelect(db, pExpr->x.pSelect, iTable, pEList);
2777 }else{
2778 substExprList(db, pExpr->x.pList, iTable, pEList);
2779 }
drh832508b2002-03-02 17:04:07 +00002780 }
drhb7916a72009-05-27 10:31:29 +00002781 return pExpr;
drh832508b2002-03-02 17:04:07 +00002782}
drh17435752007-08-16 04:30:38 +00002783static void substExprList(
2784 sqlite3 *db, /* Report malloc errors here */
2785 ExprList *pList, /* List to scan and in which to make substitutes */
2786 int iTable, /* Table to be substituted */
2787 ExprList *pEList /* Substitute values */
2788){
drh832508b2002-03-02 17:04:07 +00002789 int i;
2790 if( pList==0 ) return;
2791 for(i=0; i<pList->nExpr; i++){
drhb7916a72009-05-27 10:31:29 +00002792 pList->a[i].pExpr = substExpr(db, pList->a[i].pExpr, iTable, pEList);
drh832508b2002-03-02 17:04:07 +00002793 }
2794}
drh17435752007-08-16 04:30:38 +00002795static void substSelect(
2796 sqlite3 *db, /* Report malloc errors here */
2797 Select *p, /* SELECT statement in which to make substitutions */
2798 int iTable, /* Table to be replaced */
2799 ExprList *pEList /* Substitute values */
2800){
drh588a9a12008-09-01 15:52:10 +00002801 SrcList *pSrc;
2802 struct SrcList_item *pItem;
2803 int i;
danielk1977b3bce662005-01-29 08:32:43 +00002804 if( !p ) return;
drh17435752007-08-16 04:30:38 +00002805 substExprList(db, p->pEList, iTable, pEList);
2806 substExprList(db, p->pGroupBy, iTable, pEList);
2807 substExprList(db, p->pOrderBy, iTable, pEList);
drhb7916a72009-05-27 10:31:29 +00002808 p->pHaving = substExpr(db, p->pHaving, iTable, pEList);
2809 p->pWhere = substExpr(db, p->pWhere, iTable, pEList);
drh17435752007-08-16 04:30:38 +00002810 substSelect(db, p->pPrior, iTable, pEList);
drh588a9a12008-09-01 15:52:10 +00002811 pSrc = p->pSrc;
drhe2f02ba2009-01-09 01:12:27 +00002812 assert( pSrc ); /* Even for (SELECT 1) we have: pSrc!=0 but pSrc->nSrc==0 */
2813 if( ALWAYS(pSrc) ){
drh588a9a12008-09-01 15:52:10 +00002814 for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){
2815 substSelect(db, pItem->pSelect, iTable, pEList);
2816 }
2817 }
danielk1977b3bce662005-01-29 08:32:43 +00002818}
shane3514b6f2008-07-22 05:00:55 +00002819#endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
drh832508b2002-03-02 17:04:07 +00002820
shane3514b6f2008-07-22 05:00:55 +00002821#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
drh832508b2002-03-02 17:04:07 +00002822/*
drh630d2962011-12-11 21:51:04 +00002823** This routine attempts to flatten subqueries as a performance optimization.
2824** This routine returns 1 if it makes changes and 0 if no flattening occurs.
drh1350b032002-02-27 19:00:20 +00002825**
2826** To understand the concept of flattening, consider the following
2827** query:
2828**
2829** SELECT a FROM (SELECT x+y AS a FROM t1 WHERE z<100) WHERE a>5
2830**
2831** The default way of implementing this query is to execute the
2832** subquery first and store the results in a temporary table, then
2833** run the outer query on that temporary table. This requires two
2834** passes over the data. Furthermore, because the temporary table
2835** has no indices, the WHERE clause on the outer query cannot be
drh832508b2002-03-02 17:04:07 +00002836** optimized.
drh1350b032002-02-27 19:00:20 +00002837**
drh832508b2002-03-02 17:04:07 +00002838** This routine attempts to rewrite queries such as the above into
drh1350b032002-02-27 19:00:20 +00002839** a single flat select, like this:
2840**
2841** SELECT x+y AS a FROM t1 WHERE z<100 AND a>5
2842**
2843** The code generated for this simpification gives the same result
drh832508b2002-03-02 17:04:07 +00002844** but only has to scan the data once. And because indices might
2845** exist on the table t1, a complete scan of the data might be
2846** avoided.
drh1350b032002-02-27 19:00:20 +00002847**
drh832508b2002-03-02 17:04:07 +00002848** Flattening is only attempted if all of the following are true:
drh1350b032002-02-27 19:00:20 +00002849**
drh832508b2002-03-02 17:04:07 +00002850** (1) The subquery and the outer query do not both use aggregates.
drh1350b032002-02-27 19:00:20 +00002851**
drh832508b2002-03-02 17:04:07 +00002852** (2) The subquery is not an aggregate or the outer query is not a join.
2853**
drh2b300d52008-08-14 00:19:48 +00002854** (3) The subquery is not the right operand of a left outer join
dan49ad3302010-08-13 16:38:48 +00002855** (Originally ticket #306. Strengthened by ticket #3300)
drh832508b2002-03-02 17:04:07 +00002856**
dan49ad3302010-08-13 16:38:48 +00002857** (4) The subquery is not DISTINCT.
drh832508b2002-03-02 17:04:07 +00002858**
dan49ad3302010-08-13 16:38:48 +00002859** (**) At one point restrictions (4) and (5) defined a subset of DISTINCT
2860** sub-queries that were excluded from this optimization. Restriction
2861** (4) has since been expanded to exclude all DISTINCT subqueries.
drh832508b2002-03-02 17:04:07 +00002862**
2863** (6) The subquery does not use aggregates or the outer query is not
2864** DISTINCT.
2865**
drh630d2962011-12-11 21:51:04 +00002866** (7) The subquery has a FROM clause. TODO: For subqueries without
2867** A FROM clause, consider adding a FROM close with the special
2868** table sqlite_once that consists of a single row containing a
2869** single NULL.
drh08192d52002-04-30 19:20:28 +00002870**
drhdf199a22002-06-14 22:38:41 +00002871** (8) The subquery does not use LIMIT or the outer query is not a join.
2872**
2873** (9) The subquery does not use LIMIT or the outer query does not use
2874** aggregates.
2875**
2876** (10) The subquery does not use aggregates or the outer query does not
2877** use LIMIT.
2878**
drh174b6192002-12-03 02:22:52 +00002879** (11) The subquery and the outer query do not both have ORDER BY clauses.
2880**
drh7b688ed2009-12-22 00:29:53 +00002881** (**) Not implemented. Subsumed into restriction (3). Was previously
drh2b300d52008-08-14 00:19:48 +00002882** a separate restriction deriving from ticket #350.
drh3fc673e2003-06-16 00:40:34 +00002883**
dan49ad3302010-08-13 16:38:48 +00002884** (13) The subquery and outer query do not both use LIMIT.
drhac839632006-01-21 22:19:54 +00002885**
dan49ad3302010-08-13 16:38:48 +00002886** (14) The subquery does not use OFFSET.
drhac839632006-01-21 22:19:54 +00002887**
drhad91c6c2007-05-06 20:04:24 +00002888** (15) The outer query is not part of a compound select or the
drhf3913272010-04-15 23:24:29 +00002889** subquery does not have a LIMIT clause.
2890** (See ticket #2339 and ticket [02a8e81d44]).
drhad91c6c2007-05-06 20:04:24 +00002891**
drhc52e3552008-02-15 14:33:03 +00002892** (16) The outer query is not an aggregate or the subquery does
2893** not contain ORDER BY. (Ticket #2942) This used to not matter
2894** until we introduced the group_concat() function.
2895**
danielk1977f23329a2008-07-01 14:09:13 +00002896** (17) The sub-query is not a compound select, or it is a UNION ALL
danielk19774914cf92008-07-01 18:26:49 +00002897** compound clause made up entirely of non-aggregate queries, and
danielk1977f23329a2008-07-01 14:09:13 +00002898** the parent query:
2899**
2900** * is not itself part of a compound select,
2901** * is not an aggregate or DISTINCT query, and
drh630d2962011-12-11 21:51:04 +00002902** * is not a join
danielk1977f23329a2008-07-01 14:09:13 +00002903**
danielk19774914cf92008-07-01 18:26:49 +00002904** The parent and sub-query may contain WHERE clauses. Subject to
2905** rules (11), (13) and (14), they may also contain ORDER BY,
drh630d2962011-12-11 21:51:04 +00002906** LIMIT and OFFSET clauses. The subquery cannot use any compound
2907** operator other than UNION ALL because all the other compound
2908** operators have an implied DISTINCT which is disallowed by
2909** restriction (4).
danielk1977f23329a2008-07-01 14:09:13 +00002910**
dan67c70142012-08-28 14:45:50 +00002911** Also, each component of the sub-query must return the same number
2912** of result columns. This is actually a requirement for any compound
2913** SELECT statement, but all the code here does is make sure that no
2914** such (illegal) sub-query is flattened. The caller will detect the
2915** syntax error and return a detailed message.
2916**
danielk197749fc1f62008-07-08 17:43:56 +00002917** (18) If the sub-query is a compound select, then all terms of the
2918** ORDER by clause of the parent must be simple references to
2919** columns of the sub-query.
2920**
drh229cf702008-08-26 12:56:14 +00002921** (19) The subquery does not use LIMIT or the outer query does not
2922** have a WHERE clause.
2923**
drhe8902a72009-04-02 16:59:47 +00002924** (20) If the sub-query is a compound select, then it must not use
2925** an ORDER BY clause. Ticket #3773. We could relax this constraint
2926** somewhat by saying that the terms of the ORDER BY clause must
drh630d2962011-12-11 21:51:04 +00002927** appear as unmodified result columns in the outer query. But we
drhe8902a72009-04-02 16:59:47 +00002928** have other optimizations in mind to deal with that case.
2929**
shaneha91491e2011-02-11 20:52:20 +00002930** (21) The subquery does not use LIMIT or the outer query is not
2931** DISTINCT. (See ticket [752e1646fc]).
2932**
dan8290c2a2014-01-16 10:58:39 +00002933** (22) The subquery is not a recursive CTE.
2934**
2935** (23) The parent is not a recursive CTE, or the sub-query is not a
2936** compound query. This restriction is because transforming the
2937** parent to a compound query confuses the code that handles
2938** recursive queries in multiSelect().
2939**
2940**
drh832508b2002-03-02 17:04:07 +00002941** In this routine, the "p" parameter is a pointer to the outer query.
2942** The subquery is p->pSrc->a[iFrom]. isAgg is true if the outer query
2943** uses aggregates and subqueryIsAgg is true if the subquery uses aggregates.
2944**
drh665de472003-03-31 13:36:09 +00002945** If flattening is not attempted, this routine is a no-op and returns 0.
drh832508b2002-03-02 17:04:07 +00002946** If flattening is attempted this routine returns 1.
2947**
2948** All of the expression analysis must occur on both the outer query and
2949** the subquery before this routine runs.
drh1350b032002-02-27 19:00:20 +00002950*/
drh8c74a8c2002-08-25 19:20:40 +00002951static int flattenSubquery(
danielk1977524cc212008-07-02 13:13:51 +00002952 Parse *pParse, /* Parsing context */
drh8c74a8c2002-08-25 19:20:40 +00002953 Select *p, /* The parent or outer SELECT statement */
2954 int iFrom, /* Index in p->pSrc->a[] of the inner subquery */
2955 int isAgg, /* True if outer SELECT uses aggregate functions */
2956 int subqueryIsAgg /* True if the subquery uses aggregate functions */
2957){
danielk1977524cc212008-07-02 13:13:51 +00002958 const char *zSavedAuthContext = pParse->zAuthContext;
danielk1977f23329a2008-07-01 14:09:13 +00002959 Select *pParent;
drh0bb28102002-05-08 11:54:14 +00002960 Select *pSub; /* The inner query or "subquery" */
danielk1977f23329a2008-07-01 14:09:13 +00002961 Select *pSub1; /* Pointer to the rightmost select in sub-query */
drhad3cab52002-05-24 02:04:32 +00002962 SrcList *pSrc; /* The FROM clause of the outer query */
2963 SrcList *pSubSrc; /* The FROM clause of the subquery */
drh0bb28102002-05-08 11:54:14 +00002964 ExprList *pList; /* The result set of the outer query */
drh6a3ea0e2003-05-02 14:32:12 +00002965 int iParent; /* VDBE cursor number of the pSub result set temp table */
drh91bb0ee2004-09-01 03:06:34 +00002966 int i; /* Loop counter */
2967 Expr *pWhere; /* The WHERE clause */
2968 struct SrcList_item *pSubitem; /* The subquery */
danielk1977524cc212008-07-02 13:13:51 +00002969 sqlite3 *db = pParse->db;
drh1350b032002-02-27 19:00:20 +00002970
drh832508b2002-03-02 17:04:07 +00002971 /* Check to see if flattening is permitted. Return 0 if not.
2972 */
drha78c22c2008-11-11 18:28:58 +00002973 assert( p!=0 );
drha78c22c2008-11-11 18:28:58 +00002974 assert( p->pPrior==0 ); /* Unable to flatten compound queries */
drh7e5418e2012-09-27 15:05:54 +00002975 if( OptimizationDisabled(db, SQLITE_QueryFlattener) ) return 0;
drh832508b2002-03-02 17:04:07 +00002976 pSrc = p->pSrc;
drhad3cab52002-05-24 02:04:32 +00002977 assert( pSrc && iFrom>=0 && iFrom<pSrc->nSrc );
drh91bb0ee2004-09-01 03:06:34 +00002978 pSubitem = &pSrc->a[iFrom];
danielk197749fc1f62008-07-08 17:43:56 +00002979 iParent = pSubitem->iCursor;
drh91bb0ee2004-09-01 03:06:34 +00002980 pSub = pSubitem->pSelect;
drh832508b2002-03-02 17:04:07 +00002981 assert( pSub!=0 );
drhac839632006-01-21 22:19:54 +00002982 if( isAgg && subqueryIsAgg ) return 0; /* Restriction (1) */
2983 if( subqueryIsAgg && pSrc->nSrc>1 ) return 0; /* Restriction (2) */
drh832508b2002-03-02 17:04:07 +00002984 pSubSrc = pSub->pSrc;
2985 assert( pSubSrc );
drhac839632006-01-21 22:19:54 +00002986 /* Prior to version 3.1.2, when LIMIT and OFFSET had to be simple constants,
2987 ** not arbitrary expresssions, we allowed some combining of LIMIT and OFFSET
2988 ** because they could be computed at compile-time. But when LIMIT and OFFSET
2989 ** became arbitrary expressions, we were forced to add restrictions (13)
2990 ** and (14). */
2991 if( pSub->pLimit && p->pLimit ) return 0; /* Restriction (13) */
2992 if( pSub->pOffset ) return 0; /* Restriction (14) */
drhf3913272010-04-15 23:24:29 +00002993 if( p->pRightmost && pSub->pLimit ){
drhad91c6c2007-05-06 20:04:24 +00002994 return 0; /* Restriction (15) */
2995 }
drhac839632006-01-21 22:19:54 +00002996 if( pSubSrc->nSrc==0 ) return 0; /* Restriction (7) */
dan49ad3302010-08-13 16:38:48 +00002997 if( pSub->selFlags & SF_Distinct ) return 0; /* Restriction (5) */
2998 if( pSub->pLimit && (pSrc->nSrc>1 || isAgg) ){
2999 return 0; /* Restrictions (8)(9) */
drhdf199a22002-06-14 22:38:41 +00003000 }
drh7d10d5a2008-08-20 16:35:10 +00003001 if( (p->selFlags & SF_Distinct)!=0 && subqueryIsAgg ){
3002 return 0; /* Restriction (6) */
3003 }
3004 if( p->pOrderBy && pSub->pOrderBy ){
drhac839632006-01-21 22:19:54 +00003005 return 0; /* Restriction (11) */
3006 }
drhc52e3552008-02-15 14:33:03 +00003007 if( isAgg && pSub->pOrderBy ) return 0; /* Restriction (16) */
drh229cf702008-08-26 12:56:14 +00003008 if( pSub->pLimit && p->pWhere ) return 0; /* Restriction (19) */
shaneha91491e2011-02-11 20:52:20 +00003009 if( pSub->pLimit && (p->selFlags & SF_Distinct)!=0 ){
3010 return 0; /* Restriction (21) */
3011 }
dan8290c2a2014-01-16 10:58:39 +00003012 if( pSub->pRecurse ) return 0; /* Restriction (22) */
3013 if( p->pRecurse && pSub->pPrior ) return 0; /* Restriction (23) */
drh832508b2002-03-02 17:04:07 +00003014
drh2b300d52008-08-14 00:19:48 +00003015 /* OBSOLETE COMMENT 1:
3016 ** Restriction 3: If the subquery is a join, make sure the subquery is
drh8af4d3a2003-05-06 20:35:16 +00003017 ** not used as the right operand of an outer join. Examples of why this
3018 ** is not allowed:
3019 **
3020 ** t1 LEFT OUTER JOIN (t2 JOIN t3)
3021 **
3022 ** If we flatten the above, we would get
3023 **
3024 ** (t1 LEFT OUTER JOIN t2) JOIN t3
3025 **
3026 ** which is not at all the same thing.
drh2b300d52008-08-14 00:19:48 +00003027 **
3028 ** OBSOLETE COMMENT 2:
3029 ** Restriction 12: If the subquery is the right operand of a left outer
drh3fc673e2003-06-16 00:40:34 +00003030 ** join, make sure the subquery has no WHERE clause.
3031 ** An examples of why this is not allowed:
3032 **
3033 ** t1 LEFT OUTER JOIN (SELECT * FROM t2 WHERE t2.x>0)
3034 **
3035 ** If we flatten the above, we would get
3036 **
3037 ** (t1 LEFT OUTER JOIN t2) WHERE t2.x>0
3038 **
3039 ** But the t2.x>0 test will always fail on a NULL row of t2, which
3040 ** effectively converts the OUTER JOIN into an INNER JOIN.
drh2b300d52008-08-14 00:19:48 +00003041 **
3042 ** THIS OVERRIDES OBSOLETE COMMENTS 1 AND 2 ABOVE:
3043 ** Ticket #3300 shows that flattening the right term of a LEFT JOIN
3044 ** is fraught with danger. Best to avoid the whole thing. If the
3045 ** subquery is the right term of a LEFT JOIN, then do not flatten.
drh3fc673e2003-06-16 00:40:34 +00003046 */
drh2b300d52008-08-14 00:19:48 +00003047 if( (pSubitem->jointype & JT_OUTER)!=0 ){
drh3fc673e2003-06-16 00:40:34 +00003048 return 0;
3049 }
3050
danielk1977f23329a2008-07-01 14:09:13 +00003051 /* Restriction 17: If the sub-query is a compound SELECT, then it must
3052 ** use only the UNION ALL operator. And none of the simple select queries
3053 ** that make up the compound SELECT are allowed to be aggregate or distinct
3054 ** queries.
3055 */
3056 if( pSub->pPrior ){
drhe8902a72009-04-02 16:59:47 +00003057 if( pSub->pOrderBy ){
3058 return 0; /* Restriction 20 */
3059 }
drhe2f02ba2009-01-09 01:12:27 +00003060 if( isAgg || (p->selFlags & SF_Distinct)!=0 || pSrc->nSrc!=1 ){
danielk1977f23329a2008-07-01 14:09:13 +00003061 return 0;
3062 }
3063 for(pSub1=pSub; pSub1; pSub1=pSub1->pPrior){
drhccfcbce2009-05-18 15:46:07 +00003064 testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct );
3065 testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate );
drh4b3ac732011-12-10 23:18:32 +00003066 assert( pSub->pSrc!=0 );
drh7d10d5a2008-08-20 16:35:10 +00003067 if( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))!=0
danielk197780b3c542008-07-10 17:59:12 +00003068 || (pSub1->pPrior && pSub1->op!=TK_ALL)
drh4b3ac732011-12-10 23:18:32 +00003069 || pSub1->pSrc->nSrc<1
dan67c70142012-08-28 14:45:50 +00003070 || pSub->pEList->nExpr!=pSub1->pEList->nExpr
danielk197780b3c542008-07-10 17:59:12 +00003071 ){
danielk1977f23329a2008-07-01 14:09:13 +00003072 return 0;
3073 }
drh4b3ac732011-12-10 23:18:32 +00003074 testcase( pSub1->pSrc->nSrc>1 );
danielk1977f23329a2008-07-01 14:09:13 +00003075 }
danielk197749fc1f62008-07-08 17:43:56 +00003076
3077 /* Restriction 18. */
3078 if( p->pOrderBy ){
3079 int ii;
3080 for(ii=0; ii<p->pOrderBy->nExpr; ii++){
drhc2acc4e2013-11-15 18:15:19 +00003081 if( p->pOrderBy->a[ii].u.x.iOrderByCol==0 ) return 0;
danielk197749fc1f62008-07-08 17:43:56 +00003082 }
3083 }
danielk1977f23329a2008-07-01 14:09:13 +00003084 }
3085
drh7d10d5a2008-08-20 16:35:10 +00003086 /***** If we reach this point, flattening is permitted. *****/
3087
3088 /* Authorize the subquery */
danielk1977524cc212008-07-02 13:13:51 +00003089 pParse->zAuthContext = pSubitem->zName;
drha2acb0d2012-04-11 23:22:37 +00003090 TESTONLY(i =) sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0);
3091 testcase( i==SQLITE_DENY );
danielk1977524cc212008-07-02 13:13:51 +00003092 pParse->zAuthContext = zSavedAuthContext;
3093
drh7d10d5a2008-08-20 16:35:10 +00003094 /* If the sub-query is a compound SELECT statement, then (by restrictions
3095 ** 17 and 18 above) it must be a UNION ALL and the parent query must
3096 ** be of the form:
danielk1977f23329a2008-07-01 14:09:13 +00003097 **
3098 ** SELECT <expr-list> FROM (<sub-query>) <where-clause>
3099 **
3100 ** followed by any ORDER BY, LIMIT and/or OFFSET clauses. This block
drha78c22c2008-11-11 18:28:58 +00003101 ** creates N-1 copies of the parent query without any ORDER BY, LIMIT or
danielk1977f23329a2008-07-01 14:09:13 +00003102 ** OFFSET clauses and joins them to the left-hand-side of the original
3103 ** using UNION ALL operators. In this case N is the number of simple
3104 ** select statements in the compound sub-query.
drha78c22c2008-11-11 18:28:58 +00003105 **
3106 ** Example:
3107 **
3108 ** SELECT a+1 FROM (
3109 ** SELECT x FROM tab
3110 ** UNION ALL
3111 ** SELECT y FROM tab
3112 ** UNION ALL
3113 ** SELECT abs(z*2) FROM tab2
3114 ** ) WHERE a!=5 ORDER BY 1
3115 **
3116 ** Transformed into:
3117 **
3118 ** SELECT x+1 FROM tab WHERE x+1!=5
3119 ** UNION ALL
3120 ** SELECT y+1 FROM tab WHERE y+1!=5
3121 ** UNION ALL
3122 ** SELECT abs(z*2)+1 FROM tab2 WHERE abs(z*2)+1!=5
3123 ** ORDER BY 1
3124 **
3125 ** We call this the "compound-subquery flattening".
danielk1977f23329a2008-07-01 14:09:13 +00003126 */
3127 for(pSub=pSub->pPrior; pSub; pSub=pSub->pPrior){
3128 Select *pNew;
3129 ExprList *pOrderBy = p->pOrderBy;
danielk19774b86ef12008-07-01 14:39:35 +00003130 Expr *pLimit = p->pLimit;
drh547180b2013-01-29 23:55:50 +00003131 Expr *pOffset = p->pOffset;
danielk1977f23329a2008-07-01 14:09:13 +00003132 Select *pPrior = p->pPrior;
3133 p->pOrderBy = 0;
3134 p->pSrc = 0;
3135 p->pPrior = 0;
danielk19774b86ef12008-07-01 14:39:35 +00003136 p->pLimit = 0;
drh547180b2013-01-29 23:55:50 +00003137 p->pOffset = 0;
danielk19776ab3a2e2009-02-19 14:39:25 +00003138 pNew = sqlite3SelectDup(db, p, 0);
drh547180b2013-01-29 23:55:50 +00003139 p->pOffset = pOffset;
danielk19774b86ef12008-07-01 14:39:35 +00003140 p->pLimit = pLimit;
drha78c22c2008-11-11 18:28:58 +00003141 p->pOrderBy = pOrderBy;
3142 p->pSrc = pSrc;
3143 p->op = TK_ALL;
danielk1977f23329a2008-07-01 14:09:13 +00003144 p->pRightmost = 0;
drha78c22c2008-11-11 18:28:58 +00003145 if( pNew==0 ){
3146 pNew = pPrior;
3147 }else{
3148 pNew->pPrior = pPrior;
3149 pNew->pRightmost = 0;
3150 }
3151 p->pPrior = pNew;
3152 if( db->mallocFailed ) return 1;
danielk1977f23329a2008-07-01 14:09:13 +00003153 }
3154
drh7d10d5a2008-08-20 16:35:10 +00003155 /* Begin flattening the iFrom-th entry of the FROM clause
3156 ** in the outer query.
drh832508b2002-03-02 17:04:07 +00003157 */
danielk1977f23329a2008-07-01 14:09:13 +00003158 pSub = pSub1 = pSubitem->pSelect;
drha78c22c2008-11-11 18:28:58 +00003159
3160 /* Delete the transient table structure associated with the
3161 ** subquery
3162 */
3163 sqlite3DbFree(db, pSubitem->zDatabase);
3164 sqlite3DbFree(db, pSubitem->zName);
3165 sqlite3DbFree(db, pSubitem->zAlias);
3166 pSubitem->zDatabase = 0;
3167 pSubitem->zName = 0;
3168 pSubitem->zAlias = 0;
3169 pSubitem->pSelect = 0;
3170
3171 /* Defer deleting the Table object associated with the
3172 ** subquery until code generation is
3173 ** complete, since there may still exist Expr.pTab entries that
3174 ** refer to the subquery even after flattening. Ticket #3346.
drhccfcbce2009-05-18 15:46:07 +00003175 **
3176 ** pSubitem->pTab is always non-NULL by test restrictions and tests above.
drha78c22c2008-11-11 18:28:58 +00003177 */
drhccfcbce2009-05-18 15:46:07 +00003178 if( ALWAYS(pSubitem->pTab!=0) ){
drha78c22c2008-11-11 18:28:58 +00003179 Table *pTabToDel = pSubitem->pTab;
3180 if( pTabToDel->nRef==1 ){
dan65a7cd12009-09-01 12:16:01 +00003181 Parse *pToplevel = sqlite3ParseToplevel(pParse);
3182 pTabToDel->pNextZombie = pToplevel->pZombieTab;
3183 pToplevel->pZombieTab = pTabToDel;
drha78c22c2008-11-11 18:28:58 +00003184 }else{
3185 pTabToDel->nRef--;
3186 }
3187 pSubitem->pTab = 0;
3188 }
3189
3190 /* The following loop runs once for each term in a compound-subquery
3191 ** flattening (as described above). If we are doing a different kind
3192 ** of flattening - a flattening other than a compound-subquery flattening -
3193 ** then this loop only runs once.
3194 **
3195 ** This loop moves all of the FROM elements of the subquery into the
3196 ** the FROM clause of the outer query. Before doing this, remember
3197 ** the cursor number for the original outer query FROM element in
3198 ** iParent. The iParent cursor will never be used. Subsequent code
3199 ** will scan expressions looking for iParent references and replace
3200 ** those references with expressions that resolve to the subquery FROM
3201 ** elements we are now copying in.
3202 */
danielk1977f23329a2008-07-01 14:09:13 +00003203 for(pParent=p; pParent; pParent=pParent->pPrior, pSub=pSub->pPrior){
drha78c22c2008-11-11 18:28:58 +00003204 int nSubSrc;
drhea678832008-12-10 19:26:22 +00003205 u8 jointype = 0;
drha78c22c2008-11-11 18:28:58 +00003206 pSubSrc = pSub->pSrc; /* FROM clause of subquery */
3207 nSubSrc = pSubSrc->nSrc; /* Number of terms in subquery FROM clause */
3208 pSrc = pParent->pSrc; /* FROM clause of the outer query */
drhc31c2eb2003-05-02 16:04:17 +00003209
danielk1977f23329a2008-07-01 14:09:13 +00003210 if( pSrc ){
drha78c22c2008-11-11 18:28:58 +00003211 assert( pParent==p ); /* First time through the loop */
danielk1977f23329a2008-07-01 14:09:13 +00003212 jointype = pSubitem->jointype;
drha78c22c2008-11-11 18:28:58 +00003213 }else{
3214 assert( pParent!=p ); /* 2nd and subsequent times through the loop */
3215 pSrc = pParent->pSrc = sqlite3SrcListAppend(db, 0, 0, 0);
3216 if( pSrc==0 ){
3217 assert( db->mallocFailed );
3218 break;
3219 }
3220 }
drh588a9a12008-09-01 15:52:10 +00003221
drha78c22c2008-11-11 18:28:58 +00003222 /* The subquery uses a single slot of the FROM clause of the outer
3223 ** query. If the subquery has more than one element in its FROM clause,
3224 ** then expand the outer query to make space for it to hold all elements
3225 ** of the subquery.
3226 **
3227 ** Example:
3228 **
3229 ** SELECT * FROM tabA, (SELECT * FROM sub1, sub2), tabB;
3230 **
3231 ** The outer query has 3 slots in its FROM clause. One slot of the
3232 ** outer query (the middle slot) is used by the subquery. The next
3233 ** block of code will expand the out query to 4 slots. The middle
3234 ** slot is expanded to two slots in order to make space for the
3235 ** two elements in the FROM clause of the subquery.
3236 */
3237 if( nSubSrc>1 ){
3238 pParent->pSrc = pSrc = sqlite3SrcListEnlarge(db, pSrc, nSubSrc-1,iFrom+1);
3239 if( db->mallocFailed ){
3240 break;
drhc31c2eb2003-05-02 16:04:17 +00003241 }
3242 }
drha78c22c2008-11-11 18:28:58 +00003243
3244 /* Transfer the FROM clause terms from the subquery into the
3245 ** outer query.
3246 */
drhc31c2eb2003-05-02 16:04:17 +00003247 for(i=0; i<nSubSrc; i++){
drhc3a84022009-06-12 03:27:26 +00003248 sqlite3IdListDelete(db, pSrc->a[i+iFrom].pUsing);
drhc31c2eb2003-05-02 16:04:17 +00003249 pSrc->a[i+iFrom] = pSubSrc->a[i];
3250 memset(&pSubSrc->a[i], 0, sizeof(pSubSrc->a[i]));
3251 }
drh61dfc312006-12-16 16:25:15 +00003252 pSrc->a[iFrom].jointype = jointype;
danielk1977f23329a2008-07-01 14:09:13 +00003253
3254 /* Now begin substituting subquery result set expressions for
3255 ** references to the iParent in the outer query.
3256 **
3257 ** Example:
3258 **
3259 ** SELECT a+5, b*10 FROM (SELECT x*3 AS a, y+10 AS b FROM t1) WHERE a>b;
3260 ** \ \_____________ subquery __________/ /
3261 ** \_____________________ outer query ______________________________/
3262 **
3263 ** We look at every expression in the outer query and every place we see
3264 ** "a" we substitute "x*3" and every place we see "b" we substitute "y+10".
3265 */
3266 pList = pParent->pEList;
3267 for(i=0; i<pList->nExpr; i++){
drhccfcbce2009-05-18 15:46:07 +00003268 if( pList->a[i].zName==0 ){
drh42fbf322012-10-15 16:24:07 +00003269 char *zName = sqlite3DbStrDup(db, pList->a[i].zSpan);
3270 sqlite3Dequote(zName);
3271 pList->a[i].zName = zName;
danielk1977f23329a2008-07-01 14:09:13 +00003272 }
drh832508b2002-03-02 17:04:07 +00003273 }
danielk1977f23329a2008-07-01 14:09:13 +00003274 substExprList(db, pParent->pEList, iParent, pSub->pEList);
3275 if( isAgg ){
3276 substExprList(db, pParent->pGroupBy, iParent, pSub->pEList);
drhb7916a72009-05-27 10:31:29 +00003277 pParent->pHaving = substExpr(db, pParent->pHaving, iParent, pSub->pEList);
danielk1977f23329a2008-07-01 14:09:13 +00003278 }
3279 if( pSub->pOrderBy ){
3280 assert( pParent->pOrderBy==0 );
3281 pParent->pOrderBy = pSub->pOrderBy;
3282 pSub->pOrderBy = 0;
3283 }else if( pParent->pOrderBy ){
3284 substExprList(db, pParent->pOrderBy, iParent, pSub->pEList);
3285 }
3286 if( pSub->pWhere ){
danielk19776ab3a2e2009-02-19 14:39:25 +00003287 pWhere = sqlite3ExprDup(db, pSub->pWhere, 0);
danielk1977f23329a2008-07-01 14:09:13 +00003288 }else{
3289 pWhere = 0;
3290 }
3291 if( subqueryIsAgg ){
3292 assert( pParent->pHaving==0 );
3293 pParent->pHaving = pParent->pWhere;
3294 pParent->pWhere = pWhere;
drhb7916a72009-05-27 10:31:29 +00003295 pParent->pHaving = substExpr(db, pParent->pHaving, iParent, pSub->pEList);
danielk1977f23329a2008-07-01 14:09:13 +00003296 pParent->pHaving = sqlite3ExprAnd(db, pParent->pHaving,
danielk19776ab3a2e2009-02-19 14:39:25 +00003297 sqlite3ExprDup(db, pSub->pHaving, 0));
danielk1977f23329a2008-07-01 14:09:13 +00003298 assert( pParent->pGroupBy==0 );
danielk19776ab3a2e2009-02-19 14:39:25 +00003299 pParent->pGroupBy = sqlite3ExprListDup(db, pSub->pGroupBy, 0);
danielk1977f23329a2008-07-01 14:09:13 +00003300 }else{
drhb7916a72009-05-27 10:31:29 +00003301 pParent->pWhere = substExpr(db, pParent->pWhere, iParent, pSub->pEList);
danielk1977f23329a2008-07-01 14:09:13 +00003302 pParent->pWhere = sqlite3ExprAnd(db, pParent->pWhere, pWhere);
3303 }
3304
3305 /* The flattened query is distinct if either the inner or the
3306 ** outer query is distinct.
3307 */
drh7d10d5a2008-08-20 16:35:10 +00003308 pParent->selFlags |= pSub->selFlags & SF_Distinct;
danielk1977f23329a2008-07-01 14:09:13 +00003309
3310 /*
3311 ** SELECT ... FROM (SELECT ... LIMIT a OFFSET b) LIMIT x OFFSET y;
3312 **
3313 ** One is tempted to try to add a and b to combine the limits. But this
3314 ** does not work if either limit is negative.
3315 */
3316 if( pSub->pLimit ){
3317 pParent->pLimit = pSub->pLimit;
3318 pSub->pLimit = 0;
3319 }
drhdf199a22002-06-14 22:38:41 +00003320 }
drh8c74a8c2002-08-25 19:20:40 +00003321
drhc31c2eb2003-05-02 16:04:17 +00003322 /* Finially, delete what is left of the subquery and return
3323 ** success.
3324 */
drh633e6d52008-07-28 19:34:53 +00003325 sqlite3SelectDelete(db, pSub1);
danielk1977f23329a2008-07-01 14:09:13 +00003326
drh832508b2002-03-02 17:04:07 +00003327 return 1;
3328}
shane3514b6f2008-07-22 05:00:55 +00003329#endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
drh1350b032002-02-27 19:00:20 +00003330
3331/*
dan4ac391f2012-12-13 16:37:10 +00003332** Based on the contents of the AggInfo structure indicated by the first
3333** argument, this function checks if the following are true:
danielk1977a9d1ccb2008-01-05 17:39:29 +00003334**
dan4ac391f2012-12-13 16:37:10 +00003335** * the query contains just a single aggregate function,
3336** * the aggregate function is either min() or max(), and
3337** * the argument to the aggregate function is a column value.
danielk1977738bdcf2008-01-07 10:16:40 +00003338**
dan4ac391f2012-12-13 16:37:10 +00003339** If all of the above are true, then WHERE_ORDERBY_MIN or WHERE_ORDERBY_MAX
3340** is returned as appropriate. Also, *ppMinMax is set to point to the
3341** list of arguments passed to the aggregate before returning.
3342**
3343** Or, if the conditions above are not met, *ppMinMax is set to 0 and
3344** WHERE_ORDERBY_NORMAL is returned.
danielk1977a9d1ccb2008-01-05 17:39:29 +00003345*/
dan4ac391f2012-12-13 16:37:10 +00003346static u8 minMaxQuery(AggInfo *pAggInfo, ExprList **ppMinMax){
3347 int eRet = WHERE_ORDERBY_NORMAL; /* Return value */
danielk1977a9d1ccb2008-01-05 17:39:29 +00003348
dan4ac391f2012-12-13 16:37:10 +00003349 *ppMinMax = 0;
3350 if( pAggInfo->nFunc==1 ){
3351 Expr *pExpr = pAggInfo->aFunc[0].pExpr; /* Aggregate function */
3352 ExprList *pEList = pExpr->x.pList; /* Arguments to agg function */
3353
3354 assert( pExpr->op==TK_AGG_FUNCTION );
3355 if( pEList && pEList->nExpr==1 && pEList->a[0].pExpr->op==TK_AGG_COLUMN ){
3356 const char *zFunc = pExpr->u.zToken;
3357 if( sqlite3StrICmp(zFunc, "min")==0 ){
3358 eRet = WHERE_ORDERBY_MIN;
3359 *ppMinMax = pEList;
3360 }else if( sqlite3StrICmp(zFunc, "max")==0 ){
3361 eRet = WHERE_ORDERBY_MAX;
3362 *ppMinMax = pEList;
3363 }
3364 }
danielk1977a9d1ccb2008-01-05 17:39:29 +00003365 }
dan4ac391f2012-12-13 16:37:10 +00003366
3367 assert( *ppMinMax==0 || (*ppMinMax)->nExpr==1 );
3368 return eRet;
danielk1977a9d1ccb2008-01-05 17:39:29 +00003369}
3370
3371/*
danielk1977a5533162009-02-24 10:01:51 +00003372** The select statement passed as the first argument is an aggregate query.
3373** The second argment is the associated aggregate-info object. This
3374** function tests if the SELECT is of the form:
3375**
3376** SELECT count(*) FROM <tbl>
3377**
3378** where table is a database table, not a sub-select or view. If the query
3379** does match this pattern, then a pointer to the Table object representing
3380** <tbl> is returned. Otherwise, 0 is returned.
3381*/
3382static Table *isSimpleCount(Select *p, AggInfo *pAggInfo){
3383 Table *pTab;
3384 Expr *pExpr;
3385
3386 assert( !p->pGroupBy );
3387
danielk19777a895a82009-02-24 18:33:15 +00003388 if( p->pWhere || p->pEList->nExpr!=1
danielk1977a5533162009-02-24 10:01:51 +00003389 || p->pSrc->nSrc!=1 || p->pSrc->a[0].pSelect
3390 ){
3391 return 0;
3392 }
danielk1977a5533162009-02-24 10:01:51 +00003393 pTab = p->pSrc->a[0].pTab;
3394 pExpr = p->pEList->a[0].pExpr;
danielk197702f33722009-02-25 08:56:47 +00003395 assert( pTab && !pTab->pSelect && pExpr );
3396
3397 if( IsVirtual(pTab) ) return 0;
danielk1977a5533162009-02-24 10:01:51 +00003398 if( pExpr->op!=TK_AGG_FUNCTION ) return 0;
drhfb0a6082012-08-24 01:07:52 +00003399 if( NEVER(pAggInfo->nFunc==0) ) return 0;
drhd36e1042013-09-06 13:10:12 +00003400 if( (pAggInfo->aFunc[0].pFunc->funcFlags&SQLITE_FUNC_COUNT)==0 ) return 0;
danielk1977a5533162009-02-24 10:01:51 +00003401 if( pExpr->flags&EP_Distinct ) return 0;
3402
3403 return pTab;
3404}
3405
3406/*
danielk1977b1c685b2008-10-06 16:18:39 +00003407** If the source-list item passed as an argument was augmented with an
3408** INDEXED BY clause, then try to locate the specified index. If there
3409** was such a clause and the named index cannot be found, return
3410** SQLITE_ERROR and leave an error in pParse. Otherwise, populate
3411** pFrom->pIndex and return SQLITE_OK.
3412*/
3413int sqlite3IndexedByLookup(Parse *pParse, struct SrcList_item *pFrom){
3414 if( pFrom->pTab && pFrom->zIndex ){
3415 Table *pTab = pFrom->pTab;
3416 char *zIndex = pFrom->zIndex;
3417 Index *pIdx;
3418 for(pIdx=pTab->pIndex;
3419 pIdx && sqlite3StrICmp(pIdx->zName, zIndex);
3420 pIdx=pIdx->pNext
3421 );
3422 if( !pIdx ){
3423 sqlite3ErrorMsg(pParse, "no such index: %s", zIndex, 0);
dan1db95102010-06-28 10:15:19 +00003424 pParse->checkSchema = 1;
danielk1977b1c685b2008-10-06 16:18:39 +00003425 return SQLITE_ERROR;
3426 }
3427 pFrom->pIndex = pIdx;
3428 }
3429 return SQLITE_OK;
3430}
drhc01b7302013-05-07 17:49:08 +00003431/*
3432** Detect compound SELECT statements that use an ORDER BY clause with
3433** an alternative collating sequence.
3434**
3435** SELECT ... FROM t1 EXCEPT SELECT ... FROM t2 ORDER BY .. COLLATE ...
3436**
3437** These are rewritten as a subquery:
3438**
3439** SELECT * FROM (SELECT ... FROM t1 EXCEPT SELECT ... FROM t2)
3440** ORDER BY ... COLLATE ...
3441**
3442** This transformation is necessary because the multiSelectOrderBy() routine
3443** above that generates the code for a compound SELECT with an ORDER BY clause
3444** uses a merge algorithm that requires the same collating sequence on the
3445** result columns as on the ORDER BY clause. See ticket
3446** http://www.sqlite.org/src/info/6709574d2a
3447**
3448** This transformation is only needed for EXCEPT, INTERSECT, and UNION.
3449** The UNION ALL operator works fine with multiSelectOrderBy() even when
3450** there are COLLATE terms in the ORDER BY.
3451*/
3452static int convertCompoundSelectToSubquery(Walker *pWalker, Select *p){
3453 int i;
3454 Select *pNew;
3455 Select *pX;
3456 sqlite3 *db;
3457 struct ExprList_item *a;
3458 SrcList *pNewSrc;
3459 Parse *pParse;
3460 Token dummy;
3461
3462 if( p->pPrior==0 ) return WRC_Continue;
3463 if( p->pOrderBy==0 ) return WRC_Continue;
3464 for(pX=p; pX && (pX->op==TK_ALL || pX->op==TK_SELECT); pX=pX->pPrior){}
3465 if( pX==0 ) return WRC_Continue;
3466 a = p->pOrderBy->a;
3467 for(i=p->pOrderBy->nExpr-1; i>=0; i--){
3468 if( a[i].pExpr->flags & EP_Collate ) break;
3469 }
3470 if( i<0 ) return WRC_Continue;
3471
3472 /* If we reach this point, that means the transformation is required. */
3473
3474 pParse = pWalker->pParse;
3475 db = pParse->db;
3476 pNew = sqlite3DbMallocZero(db, sizeof(*pNew) );
3477 if( pNew==0 ) return WRC_Abort;
3478 memset(&dummy, 0, sizeof(dummy));
3479 pNewSrc = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&dummy,pNew,0,0);
3480 if( pNewSrc==0 ) return WRC_Abort;
3481 *pNew = *p;
3482 p->pSrc = pNewSrc;
3483 p->pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ALL, 0));
3484 p->op = TK_SELECT;
3485 p->pWhere = 0;
3486 pNew->pGroupBy = 0;
3487 pNew->pHaving = 0;
3488 pNew->pOrderBy = 0;
3489 p->pPrior = 0;
3490 pNew->pLimit = 0;
3491 pNew->pOffset = 0;
3492 return WRC_Continue;
3493}
danielk1977b1c685b2008-10-06 16:18:39 +00003494
daneede6a52014-01-15 19:42:23 +00003495#ifndef SQLITE_OMIT_CTE
3496/*
3497** Argument pWith (which may be NULL) points to a linked list of nested
3498** WITH contexts, from inner to outermost. If the table identified by
3499** FROM clause element pItem is really a common-table-expression (CTE)
3500** then return a pointer to the CTE definition for that table. Otherwise
3501** return NULL.
drh60c1a2f2014-01-15 18:23:00 +00003502*/
daneede6a52014-01-15 19:42:23 +00003503static struct Cte *searchWith(With *pWith, struct SrcList_item *pItem){
drh7b19f252014-01-16 04:37:13 +00003504 const char *zName;
3505 if( pItem->zDatabase==0 && (zName = pItem->zName)!=0 ){
daneede6a52014-01-15 19:42:23 +00003506 With *p;
3507 for(p=pWith; p; p=p->pOuter){
dan4e9119d2014-01-13 15:12:23 +00003508 int i;
daneede6a52014-01-15 19:42:23 +00003509 for(i=0; i<p->nCte; i++){
3510 if( sqlite3StrICmp(zName, p->a[i].zName)==0 ){
3511 return &p->a[i];
dan4e9119d2014-01-13 15:12:23 +00003512 }
3513 }
3514 }
3515 }
3516 return 0;
3517}
3518
drhc49832c2014-01-15 18:35:52 +00003519/* The code generator maintains a stack of active WITH clauses
3520** with the inner-most WITH clause being at the top of the stack.
3521**
3522** These routines push and pull WITH clauses on the stack.
3523*/
dan4e9119d2014-01-13 15:12:23 +00003524void sqlite3WithPush(Parse *pParse, With *pWith){
3525 if( pWith ){
3526 pWith->pOuter = pParse->pWith;
3527 pParse->pWith = pWith;
3528 }
3529}
dan4e9119d2014-01-13 15:12:23 +00003530
daneede6a52014-01-15 19:42:23 +00003531/*
3532** If argument pCte is not NULL, check if it is already a part of the
3533** stack of CTEs stored by the parser. If so, this indicates an illegal
3534** recursive reference in a CTE, set of mutually recursive CTEs. Store
3535** an error in the parser and return SQLITE_ERROR if this is the case.
3536**
3537** Otherwise, if pCte is not already part of the stack of CTEs stored
3538** in the parser, push it onto the stop of that stack.
3539*/
dan4e9119d2014-01-13 15:12:23 +00003540static int ctePush(Parse *pParse, struct Cte *pCte){
3541 if( pCte ){
3542 struct Cte *p;
3543 for(p=pParse->pCte; p; p=p->pOuterCte){
3544 if( p==pCte ){
3545 sqlite3ErrorMsg(
3546 pParse, "illegal recursive defininition in cte: %s", pCte->zName
3547 );
3548 return SQLITE_ERROR;
3549 }
3550 }
3551
3552 pCte->pOuterCte = pParse->pCte;
3553 pParse->pCte = pCte;
3554 }
3555 return SQLITE_OK;
3556}
daneede6a52014-01-15 19:42:23 +00003557/*
3558** If argument pCte is not NULL, it must be a pointer to the CTE currently
3559** on top of the stack of CTEs stored in the parser. Remove it from that
3560** stack.
3561*/
dan4e9119d2014-01-13 15:12:23 +00003562static void ctePop(Parse *pParse, struct Cte *pCte){
3563 if( pCte ){
3564 assert( pParse->pCte==pCte );
3565 pParse->pCte = pCte->pOuterCte;
3566 }
3567}
3568
daneede6a52014-01-15 19:42:23 +00003569/*
3570** This function checks if argument pFrom refers to a CTE declared by
3571** a WITH clause on the stack currently maintained by the parser. And,
3572** if currently processing a CTE expression, if it is a recursive
3573** reference to the current CTE.
3574**
3575** If pFrom falls into either of the two categories above, pFrom->pTab
3576** and other fields are populated accordingly. The caller should check
3577** (pFrom->pTab!=0) to determine whether or not a successful match
3578** was found.
3579**
3580** Whether or not a match is found, SQLITE_OK is returned if no error
3581** occurs. If an error does occur, an error message is stored in the
3582** parser and some error code other than SQLITE_OK returned.
3583*/
dan8ce71842014-01-14 20:14:09 +00003584static int withExpand(
3585 Walker *pWalker,
daneede6a52014-01-15 19:42:23 +00003586 struct SrcList_item *pFrom
dan8ce71842014-01-14 20:14:09 +00003587){
3588 Table *pTab;
3589 Parse *pParse = pWalker->pParse;
3590 sqlite3 *db = pParse->db;
daneede6a52014-01-15 19:42:23 +00003591 struct Cte *pCte;
dan8ce71842014-01-14 20:14:09 +00003592
dan8ce71842014-01-14 20:14:09 +00003593 assert( pFrom->pTab==0 );
3594
daneede6a52014-01-15 19:42:23 +00003595 pCte = searchWith(pParse->pWith, pFrom);
3596 if( pCte==0 ){
3597 /* no-op */
3598 }else if( pCte==pParse->pCte && (pTab = pCte->pTab) ){
dan8ce71842014-01-14 20:14:09 +00003599 /* This is the recursive part of a recursive CTE */
daneede6a52014-01-15 19:42:23 +00003600 assert( pFrom->pTab==0 && pFrom->isRecursive==0 && pFrom->pSelect==0 );
dan8ce71842014-01-14 20:14:09 +00003601 pFrom->pTab = pTab;
danf43fe6e2014-01-15 18:12:00 +00003602 pFrom->isRecursive = 1;
dan8ce71842014-01-14 20:14:09 +00003603 pTab->nRef++;
3604 }else{
3605 ExprList *pEList;
3606 Select *pSel;
dan60e70682014-01-15 15:27:51 +00003607 Select *pLeft; /* Left-most SELECT statement */
dan8ce71842014-01-14 20:14:09 +00003608 int bRecursive;
3609
3610 pFrom->pTab = pTab = sqlite3DbMallocZero(db, sizeof(Table));
3611 if( pTab==0 ) return WRC_Abort;
3612 pTab->nRef = 1;
drhf9db5222014-01-15 02:40:11 +00003613 pTab->zName = sqlite3MPrintf(db, "%s", pCte->zName);
dan8ce71842014-01-14 20:14:09 +00003614 pTab->iPKey = -1;
3615 pTab->nRowEst = 1048576;
3616 pTab->tabFlags |= TF_Ephemeral;
3617 pFrom->pSelect = sqlite3SelectDup(db, pCte->pSelect, 0);
3618 if( db->mallocFailed ) return SQLITE_NOMEM;
3619 assert( pFrom->pSelect );
3620
3621 if( ctePush(pParse, pCte) ) return WRC_Abort;
3622 pSel = pFrom->pSelect;
3623 bRecursive = (pSel->op==TK_ALL || pSel->op==TK_UNION);
3624 if( bRecursive ){
3625 assert( pSel->pPrior );
3626 sqlite3WalkSelect(pWalker, pSel->pPrior);
3627 }else{
3628 sqlite3WalkSelect(pWalker, pSel);
3629 }
3630
dan60e70682014-01-15 15:27:51 +00003631 for(pLeft=pSel; pLeft->pPrior; pLeft=pLeft->pPrior);
3632 pEList = pLeft->pEList;
dan8ce71842014-01-14 20:14:09 +00003633 if( pCte->pCols ){
dan60e70682014-01-15 15:27:51 +00003634 if( pEList->nExpr!=pCte->pCols->nExpr ){
3635 sqlite3ErrorMsg(pParse, "cte \"%s\" returns %d values for %d columns",
3636 pCte->zName, pEList->nExpr, pCte->pCols->nExpr
3637 );
3638 return WRC_Abort;
3639 }
dan8ce71842014-01-14 20:14:09 +00003640 pEList = pCte->pCols;
dan8ce71842014-01-14 20:14:09 +00003641 }
dan60e70682014-01-15 15:27:51 +00003642
dan8ce71842014-01-14 20:14:09 +00003643 selectColumnsFromExprList(pParse, pEList, &pTab->nCol, &pTab->aCol);
3644
3645 if( bRecursive ){
3646 int nRef = pTab->nRef;
3647 pCte->pTab = pTab;
3648 sqlite3WalkSelect(pWalker, pSel);
3649 pCte->pTab = 0;
3650 if( pTab->nRef > nRef){
3651 pSel->pRecurse = pTab;
3652 assert( pTab->tnum==0 );
3653 }
3654 }
3655
3656 ctePop(pParse, pCte);
3657 }
3658
3659 return SQLITE_OK;
3660}
daneede6a52014-01-15 19:42:23 +00003661#endif
dan4e9119d2014-01-13 15:12:23 +00003662
danielk1977b1c685b2008-10-06 16:18:39 +00003663/*
drh7d10d5a2008-08-20 16:35:10 +00003664** This routine is a Walker callback for "expanding" a SELECT statement.
3665** "Expanding" means to do the following:
3666**
3667** (1) Make sure VDBE cursor numbers have been assigned to every
3668** element of the FROM clause.
3669**
3670** (2) Fill in the pTabList->a[].pTab fields in the SrcList that
3671** defines FROM clause. When views appear in the FROM clause,
3672** fill pTabList->a[].pSelect with a copy of the SELECT statement
3673** that implements the view. A copy is made of the view's SELECT
3674** statement so that we can freely modify or delete that statement
3675** without worrying about messing up the presistent representation
3676** of the view.
3677**
3678** (3) Add terms to the WHERE clause to accomodate the NATURAL keyword
3679** on joins and the ON and USING clause of joins.
3680**
3681** (4) Scan the list of columns in the result set (pEList) looking
3682** for instances of the "*" operator or the TABLE.* operator.
3683** If found, expand each "*" to be every column in every table
3684** and TABLE.* to be every column in TABLE.
3685**
danielk1977b3bce662005-01-29 08:32:43 +00003686*/
drh7d10d5a2008-08-20 16:35:10 +00003687static int selectExpander(Walker *pWalker, Select *p){
3688 Parse *pParse = pWalker->pParse;
3689 int i, j, k;
3690 SrcList *pTabList;
3691 ExprList *pEList;
3692 struct SrcList_item *pFrom;
3693 sqlite3 *db = pParse->db;
drh3e3f1a52013-01-03 00:45:56 +00003694 Expr *pE, *pRight, *pExpr;
drh785097d2013-02-12 22:09:48 +00003695 u16 selFlags = p->selFlags;
danielk1977b3bce662005-01-29 08:32:43 +00003696
drh785097d2013-02-12 22:09:48 +00003697 p->selFlags |= SF_Expanded;
drh7d10d5a2008-08-20 16:35:10 +00003698 if( db->mallocFailed ){
3699 return WRC_Abort;
danielk1977b3bce662005-01-29 08:32:43 +00003700 }
drh785097d2013-02-12 22:09:48 +00003701 if( NEVER(p->pSrc==0) || (selFlags & SF_Expanded)!=0 ){
drh7d10d5a2008-08-20 16:35:10 +00003702 return WRC_Prune;
danielk1977b3bce662005-01-29 08:32:43 +00003703 }
drh7d10d5a2008-08-20 16:35:10 +00003704 pTabList = p->pSrc;
danielk1977b3bce662005-01-29 08:32:43 +00003705 pEList = p->pEList;
drh7d10d5a2008-08-20 16:35:10 +00003706
3707 /* Make sure cursor numbers have been assigned to all entries in
3708 ** the FROM clause of the SELECT statement.
3709 */
3710 sqlite3SrcListAssignCursors(pParse, pTabList);
3711
3712 /* Look up every table named in the FROM clause of the select. If
3713 ** an entry of the FROM clause is a subquery instead of a table or view,
3714 ** then create a transient table structure to describe the subquery.
3715 */
3716 for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
3717 Table *pTab;
3718 if( pFrom->pTab!=0 ){
3719 /* This statement has already been prepared. There is no need
3720 ** to go further. */
3721 assert( i==0 );
3722 return WRC_Prune;
3723 }
dan4e9119d2014-01-13 15:12:23 +00003724#ifndef SQLITE_OMIT_CTE
daneede6a52014-01-15 19:42:23 +00003725 if( withExpand(pWalker, pFrom) ) return WRC_Abort;
3726 if( pFrom->pTab ) {} else
dan4e9119d2014-01-13 15:12:23 +00003727#endif
dan8ce71842014-01-14 20:14:09 +00003728 if( pFrom->zName==0 ){
drh7d10d5a2008-08-20 16:35:10 +00003729#ifndef SQLITE_OMIT_SUBQUERY
3730 Select *pSel = pFrom->pSelect;
3731 /* A sub-query in the FROM clause of a SELECT */
3732 assert( pSel!=0 );
3733 assert( pFrom->pTab==0 );
3734 sqlite3WalkSelect(pWalker, pSel);
3735 pFrom->pTab = pTab = sqlite3DbMallocZero(db, sizeof(Table));
3736 if( pTab==0 ) return WRC_Abort;
drh7d10d5a2008-08-20 16:35:10 +00003737 pTab->nRef = 1;
drh186ad8c2013-10-08 18:40:37 +00003738 pTab->zName = sqlite3MPrintf(db, "sqlite_sq_%p", (void*)pTab);
drh7d10d5a2008-08-20 16:35:10 +00003739 while( pSel->pPrior ){ pSel = pSel->pPrior; }
dan8ce71842014-01-14 20:14:09 +00003740 selectColumnsFromExprList(pParse, pSel->pEList, &pTab->nCol, &pTab->aCol);
drh7d10d5a2008-08-20 16:35:10 +00003741 pTab->iPKey = -1;
drh186ad8c2013-10-08 18:40:37 +00003742 pTab->nRowEst = 1048576;
drh7d10d5a2008-08-20 16:35:10 +00003743 pTab->tabFlags |= TF_Ephemeral;
3744#endif
3745 }else{
3746 /* An ordinary table or view name in the FROM clause */
3747 assert( pFrom->pTab==0 );
dan41fb5cd2012-10-04 19:33:00 +00003748 pFrom->pTab = pTab = sqlite3LocateTableItem(pParse, 0, pFrom);
drh7d10d5a2008-08-20 16:35:10 +00003749 if( pTab==0 ) return WRC_Abort;
drhd2a56232013-01-28 19:00:20 +00003750 if( pTab->nRef==0xffff ){
3751 sqlite3ErrorMsg(pParse, "too many references to \"%s\": max 65535",
3752 pTab->zName);
3753 pFrom->pTab = 0;
3754 return WRC_Abort;
3755 }
drh7d10d5a2008-08-20 16:35:10 +00003756 pTab->nRef++;
3757#if !defined(SQLITE_OMIT_VIEW) || !defined (SQLITE_OMIT_VIRTUALTABLE)
3758 if( pTab->pSelect || IsVirtual(pTab) ){
3759 /* We reach here if the named table is a really a view */
3760 if( sqlite3ViewGetColumnNames(pParse, pTab) ) return WRC_Abort;
drh43152cf2009-05-19 19:04:58 +00003761 assert( pFrom->pSelect==0 );
3762 pFrom->pSelect = sqlite3SelectDup(db, pTab->pSelect, 0);
3763 sqlite3WalkSelect(pWalker, pFrom->pSelect);
drh7d10d5a2008-08-20 16:35:10 +00003764 }
3765#endif
danielk1977b3bce662005-01-29 08:32:43 +00003766 }
danielk197785574e32008-10-06 05:32:18 +00003767
3768 /* Locate the index named by the INDEXED BY clause, if any. */
danielk1977b1c685b2008-10-06 16:18:39 +00003769 if( sqlite3IndexedByLookup(pParse, pFrom) ){
3770 return WRC_Abort;
danielk197785574e32008-10-06 05:32:18 +00003771 }
danielk1977b3bce662005-01-29 08:32:43 +00003772 }
3773
drh7d10d5a2008-08-20 16:35:10 +00003774 /* Process NATURAL keywords, and ON and USING clauses of joins.
danielk1977b3bce662005-01-29 08:32:43 +00003775 */
drh7d10d5a2008-08-20 16:35:10 +00003776 if( db->mallocFailed || sqliteProcessJoin(pParse, p) ){
3777 return WRC_Abort;
danielk1977b3bce662005-01-29 08:32:43 +00003778 }
3779
drh7d10d5a2008-08-20 16:35:10 +00003780 /* For every "*" that occurs in the column list, insert the names of
3781 ** all columns in all tables. And for every TABLE.* insert the names
3782 ** of all columns in TABLE. The parser inserted a special expression
3783 ** with the TK_ALL operator for each "*" that it found in the column list.
3784 ** The following code just has to locate the TK_ALL expressions and expand
3785 ** each one to the list of all columns in all tables.
danielk1977b3bce662005-01-29 08:32:43 +00003786 **
drh7d10d5a2008-08-20 16:35:10 +00003787 ** The first loop just checks to see if there are any "*" operators
3788 ** that need expanding.
danielk1977b3bce662005-01-29 08:32:43 +00003789 */
drh7d10d5a2008-08-20 16:35:10 +00003790 for(k=0; k<pEList->nExpr; k++){
drh3e3f1a52013-01-03 00:45:56 +00003791 pE = pEList->a[k].pExpr;
drh7d10d5a2008-08-20 16:35:10 +00003792 if( pE->op==TK_ALL ) break;
drh43152cf2009-05-19 19:04:58 +00003793 assert( pE->op!=TK_DOT || pE->pRight!=0 );
3794 assert( pE->op!=TK_DOT || (pE->pLeft!=0 && pE->pLeft->op==TK_ID) );
3795 if( pE->op==TK_DOT && pE->pRight->op==TK_ALL ) break;
danielk1977b3bce662005-01-29 08:32:43 +00003796 }
drh7d10d5a2008-08-20 16:35:10 +00003797 if( k<pEList->nExpr ){
3798 /*
3799 ** If we get here it means the result set contains one or more "*"
3800 ** operators that need to be expanded. Loop through each expression
3801 ** in the result set and expand them one by one.
3802 */
3803 struct ExprList_item *a = pEList->a;
3804 ExprList *pNew = 0;
3805 int flags = pParse->db->flags;
3806 int longNames = (flags & SQLITE_FullColNames)!=0
drh38b384a2013-01-03 17:34:28 +00003807 && (flags & SQLITE_ShortColNames)==0;
3808
3809 /* When processing FROM-clause subqueries, it is always the case
3810 ** that full_column_names=OFF and short_column_names=ON. The
3811 ** sqlite3ResultSetOfSelect() routine makes it so. */
3812 assert( (p->selFlags & SF_NestedFrom)==0
3813 || ((flags & SQLITE_FullColNames)==0 &&
3814 (flags & SQLITE_ShortColNames)!=0) );
drh7d10d5a2008-08-20 16:35:10 +00003815
3816 for(k=0; k<pEList->nExpr; k++){
drh3e3f1a52013-01-03 00:45:56 +00003817 pE = a[k].pExpr;
3818 pRight = pE->pRight;
3819 assert( pE->op!=TK_DOT || pRight!=0 );
3820 if( pE->op!=TK_ALL && (pE->op!=TK_DOT || pRight->op!=TK_ALL) ){
drh7d10d5a2008-08-20 16:35:10 +00003821 /* This particular expression does not need to be expanded.
3822 */
drhb7916a72009-05-27 10:31:29 +00003823 pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr);
drh7d10d5a2008-08-20 16:35:10 +00003824 if( pNew ){
3825 pNew->a[pNew->nExpr-1].zName = a[k].zName;
drhb7916a72009-05-27 10:31:29 +00003826 pNew->a[pNew->nExpr-1].zSpan = a[k].zSpan;
3827 a[k].zName = 0;
3828 a[k].zSpan = 0;
drh7d10d5a2008-08-20 16:35:10 +00003829 }
3830 a[k].pExpr = 0;
drh7d10d5a2008-08-20 16:35:10 +00003831 }else{
3832 /* This expression is a "*" or a "TABLE.*" and needs to be
3833 ** expanded. */
3834 int tableSeen = 0; /* Set to 1 when TABLE matches */
drh3e3f1a52013-01-03 00:45:56 +00003835 char *zTName = 0; /* text of name of TABLE */
drh43152cf2009-05-19 19:04:58 +00003836 if( pE->op==TK_DOT ){
3837 assert( pE->pLeft!=0 );
drh33e619f2009-05-28 01:00:55 +00003838 assert( !ExprHasProperty(pE->pLeft, EP_IntValue) );
3839 zTName = pE->pLeft->u.zToken;
drh7d10d5a2008-08-20 16:35:10 +00003840 }
3841 for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
3842 Table *pTab = pFrom->pTab;
drh3e3f1a52013-01-03 00:45:56 +00003843 Select *pSub = pFrom->pSelect;
drh7d10d5a2008-08-20 16:35:10 +00003844 char *zTabName = pFrom->zAlias;
drh3e3f1a52013-01-03 00:45:56 +00003845 const char *zSchemaName = 0;
drhc75e09c2013-01-03 16:54:20 +00003846 int iDb;
drh43152cf2009-05-19 19:04:58 +00003847 if( zTabName==0 ){
drh7d10d5a2008-08-20 16:35:10 +00003848 zTabName = pTab->zName;
3849 }
3850 if( db->mallocFailed ) break;
drh3e3f1a52013-01-03 00:45:56 +00003851 if( pSub==0 || (pSub->selFlags & SF_NestedFrom)==0 ){
drh3e3f1a52013-01-03 00:45:56 +00003852 pSub = 0;
3853 if( zTName && sqlite3StrICmp(zTName, zTabName)!=0 ){
3854 continue;
3855 }
3856 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
drhc75e09c2013-01-03 16:54:20 +00003857 zSchemaName = iDb>=0 ? db->aDb[iDb].zName : "*";
drh7d10d5a2008-08-20 16:35:10 +00003858 }
drh7d10d5a2008-08-20 16:35:10 +00003859 for(j=0; j<pTab->nCol; j++){
drh7d10d5a2008-08-20 16:35:10 +00003860 char *zName = pTab->aCol[j].zName;
drhb7916a72009-05-27 10:31:29 +00003861 char *zColname; /* The computed column name */
3862 char *zToFree; /* Malloced string that needs to be freed */
3863 Token sColname; /* Computed column name as a token */
drh7d10d5a2008-08-20 16:35:10 +00003864
drhc75e09c2013-01-03 16:54:20 +00003865 assert( zName );
drh3e3f1a52013-01-03 00:45:56 +00003866 if( zTName && pSub
3867 && sqlite3MatchSpanName(pSub->pEList->a[j].zSpan, 0, zTName, 0)==0
3868 ){
3869 continue;
3870 }
3871
drh7d10d5a2008-08-20 16:35:10 +00003872 /* If a column is marked as 'hidden' (currently only possible
3873 ** for virtual tables), do not include it in the expanded
3874 ** result-set list.
3875 */
3876 if( IsHiddenColumn(&pTab->aCol[j]) ){
3877 assert(IsVirtual(pTab));
3878 continue;
3879 }
drh3e3f1a52013-01-03 00:45:56 +00003880 tableSeen = 1;
drh7d10d5a2008-08-20 16:35:10 +00003881
drhda55c482008-12-05 00:00:07 +00003882 if( i>0 && zTName==0 ){
drh2179b432009-12-09 17:36:39 +00003883 if( (pFrom->jointype & JT_NATURAL)!=0
3884 && tableAndColumnIndex(pTabList, i, zName, 0, 0)
3885 ){
drh7d10d5a2008-08-20 16:35:10 +00003886 /* In a NATURAL join, omit the join columns from the
drh2179b432009-12-09 17:36:39 +00003887 ** table to the right of the join */
drh7d10d5a2008-08-20 16:35:10 +00003888 continue;
3889 }
drh2179b432009-12-09 17:36:39 +00003890 if( sqlite3IdListIndex(pFrom->pUsing, zName)>=0 ){
drh7d10d5a2008-08-20 16:35:10 +00003891 /* In a join with a USING clause, omit columns in the
3892 ** using clause from the table on the right. */
3893 continue;
3894 }
3895 }
drhb7916a72009-05-27 10:31:29 +00003896 pRight = sqlite3Expr(db, TK_ID, zName);
3897 zColname = zName;
3898 zToFree = 0;
drh7d10d5a2008-08-20 16:35:10 +00003899 if( longNames || pTabList->nSrc>1 ){
drhb7916a72009-05-27 10:31:29 +00003900 Expr *pLeft;
3901 pLeft = sqlite3Expr(db, TK_ID, zTabName);
drh7d10d5a2008-08-20 16:35:10 +00003902 pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight, 0);
drh38b384a2013-01-03 17:34:28 +00003903 if( zSchemaName ){
drhc75e09c2013-01-03 16:54:20 +00003904 pLeft = sqlite3Expr(db, TK_ID, zSchemaName);
3905 pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pExpr, 0);
3906 }
drhb7916a72009-05-27 10:31:29 +00003907 if( longNames ){
3908 zColname = sqlite3MPrintf(db, "%s.%s", zTabName, zName);
3909 zToFree = zColname;
3910 }
drh7d10d5a2008-08-20 16:35:10 +00003911 }else{
3912 pExpr = pRight;
drh7d10d5a2008-08-20 16:35:10 +00003913 }
drhb7916a72009-05-27 10:31:29 +00003914 pNew = sqlite3ExprListAppend(pParse, pNew, pExpr);
3915 sColname.z = zColname;
3916 sColname.n = sqlite3Strlen30(zColname);
3917 sqlite3ExprListSetName(pParse, pNew, &sColname, 0);
drh8f25d182012-12-19 02:36:45 +00003918 if( pNew && (p->selFlags & SF_NestedFrom)!=0 ){
drh3e3f1a52013-01-03 00:45:56 +00003919 struct ExprList_item *pX = &pNew->a[pNew->nExpr-1];
3920 if( pSub ){
3921 pX->zSpan = sqlite3DbStrDup(db, pSub->pEList->a[j].zSpan);
drhc75e09c2013-01-03 16:54:20 +00003922 testcase( pX->zSpan==0 );
drh3e3f1a52013-01-03 00:45:56 +00003923 }else{
3924 pX->zSpan = sqlite3MPrintf(db, "%s.%s.%s",
3925 zSchemaName, zTabName, zColname);
drhc75e09c2013-01-03 16:54:20 +00003926 testcase( pX->zSpan==0 );
drh3e3f1a52013-01-03 00:45:56 +00003927 }
3928 pX->bSpanIsTab = 1;
drh8f25d182012-12-19 02:36:45 +00003929 }
drhb7916a72009-05-27 10:31:29 +00003930 sqlite3DbFree(db, zToFree);
drh7d10d5a2008-08-20 16:35:10 +00003931 }
3932 }
3933 if( !tableSeen ){
3934 if( zTName ){
3935 sqlite3ErrorMsg(pParse, "no such table: %s", zTName);
3936 }else{
3937 sqlite3ErrorMsg(pParse, "no tables specified");
3938 }
3939 }
drh7d10d5a2008-08-20 16:35:10 +00003940 }
drh9a993342007-12-13 02:45:31 +00003941 }
drh7d10d5a2008-08-20 16:35:10 +00003942 sqlite3ExprListDelete(db, pEList);
3943 p->pEList = pNew;
drh4c774312007-12-08 21:10:20 +00003944 }
drh7d10d5a2008-08-20 16:35:10 +00003945#if SQLITE_MAX_COLUMN
3946 if( p->pEList && p->pEList->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
3947 sqlite3ErrorMsg(pParse, "too many columns in result set");
drh994c80a2007-04-12 21:25:01 +00003948 }
drh7d10d5a2008-08-20 16:35:10 +00003949#endif
3950 return WRC_Continue;
3951}
danielk1977b3bce662005-01-29 08:32:43 +00003952
daneede6a52014-01-15 19:42:23 +00003953/*
3954** Function (or macro) selectExpanderWith is used as the SELECT callback
3955** by sqlite3SelectExpand(). In builds that do not support CTEs, this
3956** is equivalent to the selectExpander() function. In CTE-enabled builds,
3957** any WITH clause associated with the SELECT statement needs to be
3958** pushed onto the stack before calling selectExpander(), and popped
3959** off again afterwards.
3960*/
3961#ifndef SQLITE_OMIT_CTE
dan4e9119d2014-01-13 15:12:23 +00003962static int selectExpanderWith(Walker *pWalker, Select *p){
daneede6a52014-01-15 19:42:23 +00003963 Parse *pParse = pWalker->pParse;
dan4e9119d2014-01-13 15:12:23 +00003964 int res;
daneede6a52014-01-15 19:42:23 +00003965 sqlite3WithPush(pParse, p->pWith);
dan4e9119d2014-01-13 15:12:23 +00003966 res = selectExpander(pWalker, p);
daneede6a52014-01-15 19:42:23 +00003967 if( p->pWith ){
3968 assert( pParse->pWith==p->pWith );
3969 pParse->pWith = p->pWith->pOuter;
3970 }
dan4e9119d2014-01-13 15:12:23 +00003971 return res;
3972}
daneede6a52014-01-15 19:42:23 +00003973#else
3974#define selectExpanderWith selectExpander
3975#endif
dan4e9119d2014-01-13 15:12:23 +00003976
drh7d10d5a2008-08-20 16:35:10 +00003977/*
3978** No-op routine for the parse-tree walker.
3979**
3980** When this routine is the Walker.xExprCallback then expression trees
3981** are walked without any actions being taken at each node. Presumably,
3982** when this routine is used for Walker.xExprCallback then
3983** Walker.xSelectCallback is set to do something useful for every
3984** subquery in the parser tree.
3985*/
danielk197762c14b32008-11-19 09:05:26 +00003986static int exprWalkNoop(Walker *NotUsed, Expr *NotUsed2){
3987 UNUSED_PARAMETER2(NotUsed, NotUsed2);
drh7d10d5a2008-08-20 16:35:10 +00003988 return WRC_Continue;
3989}
danielk19779afe6892007-05-31 08:20:43 +00003990
drh7d10d5a2008-08-20 16:35:10 +00003991/*
3992** This routine "expands" a SELECT statement and all of its subqueries.
3993** For additional information on what it means to "expand" a SELECT
3994** statement, see the comment on the selectExpand worker callback above.
3995**
3996** Expanding a SELECT statement is the first step in processing a
3997** SELECT statement. The SELECT statement must be expanded before
3998** name resolution is performed.
3999**
4000** If anything goes wrong, an error message is written into pParse.
4001** The calling function can detect the problem by looking at pParse->nErr
4002** and/or pParse->db->mallocFailed.
4003*/
4004static void sqlite3SelectExpand(Parse *pParse, Select *pSelect){
4005 Walker w;
drhaa87f9a2013-04-25 00:57:10 +00004006 memset(&w, 0, sizeof(w));
drh7d10d5a2008-08-20 16:35:10 +00004007 w.xExprCallback = exprWalkNoop;
4008 w.pParse = pParse;
drhd58d3272013-08-05 22:05:02 +00004009 if( pParse->hasCompound ){
4010 w.xSelectCallback = convertCompoundSelectToSubquery;
4011 sqlite3WalkSelect(&w, pSelect);
4012 }
dan4e9119d2014-01-13 15:12:23 +00004013 w.xSelectCallback = selectExpanderWith;
drhc01b7302013-05-07 17:49:08 +00004014 sqlite3WalkSelect(&w, pSelect);
drh7d10d5a2008-08-20 16:35:10 +00004015}
4016
4017
4018#ifndef SQLITE_OMIT_SUBQUERY
4019/*
4020** This is a Walker.xSelectCallback callback for the sqlite3SelectTypeInfo()
4021** interface.
4022**
4023** For each FROM-clause subquery, add Column.zType and Column.zColl
4024** information to the Table structure that represents the result set
4025** of that subquery.
4026**
4027** The Table structure that represents the result set was constructed
4028** by selectExpander() but the type and collation information was omitted
4029** at that point because identifiers had not yet been resolved. This
4030** routine is called after identifier resolution.
4031*/
4032static int selectAddSubqueryTypeInfo(Walker *pWalker, Select *p){
4033 Parse *pParse;
4034 int i;
4035 SrcList *pTabList;
4036 struct SrcList_item *pFrom;
4037
drh9d8b3072008-08-22 16:29:51 +00004038 assert( p->selFlags & SF_Resolved );
drh5a29d9c2010-02-24 15:10:14 +00004039 if( (p->selFlags & SF_HasTypeInfo)==0 ){
4040 p->selFlags |= SF_HasTypeInfo;
4041 pParse = pWalker->pParse;
4042 pTabList = p->pSrc;
4043 for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
4044 Table *pTab = pFrom->pTab;
4045 if( ALWAYS(pTab!=0) && (pTab->tabFlags & TF_Ephemeral)!=0 ){
4046 /* A sub-query in the FROM clause of a SELECT */
4047 Select *pSel = pFrom->pSelect;
dan8ce71842014-01-14 20:14:09 +00004048 if( pSel ){
4049 while( pSel->pPrior ) pSel = pSel->pPrior;
4050 selectAddColumnTypeAndCollation(pParse, pTab, pSel);
4051 }
drh5a29d9c2010-02-24 15:10:14 +00004052 }
drh13449892005-09-07 21:22:45 +00004053 }
4054 }
drh7d10d5a2008-08-20 16:35:10 +00004055 return WRC_Continue;
4056}
4057#endif
drh13449892005-09-07 21:22:45 +00004058
drh7d10d5a2008-08-20 16:35:10 +00004059
4060/*
4061** This routine adds datatype and collating sequence information to
4062** the Table structures of all FROM-clause subqueries in a
4063** SELECT statement.
4064**
4065** Use this routine after name resolution.
4066*/
4067static void sqlite3SelectAddTypeInfo(Parse *pParse, Select *pSelect){
4068#ifndef SQLITE_OMIT_SUBQUERY
4069 Walker w;
drhaa87f9a2013-04-25 00:57:10 +00004070 memset(&w, 0, sizeof(w));
drh7d10d5a2008-08-20 16:35:10 +00004071 w.xSelectCallback = selectAddSubqueryTypeInfo;
4072 w.xExprCallback = exprWalkNoop;
4073 w.pParse = pParse;
drhaa87f9a2013-04-25 00:57:10 +00004074 w.bSelectDepthFirst = 1;
drh7d10d5a2008-08-20 16:35:10 +00004075 sqlite3WalkSelect(&w, pSelect);
4076#endif
4077}
4078
4079
4080/*
drh030796d2012-08-23 16:18:10 +00004081** This routine sets up a SELECT statement for processing. The
drh7d10d5a2008-08-20 16:35:10 +00004082** following is accomplished:
4083**
4084** * VDBE Cursor numbers are assigned to all FROM-clause terms.
4085** * Ephemeral Table objects are created for all FROM-clause subqueries.
4086** * ON and USING clauses are shifted into WHERE statements
4087** * Wildcards "*" and "TABLE.*" in result sets are expanded.
4088** * Identifiers in expression are matched to tables.
4089**
4090** This routine acts recursively on all subqueries within the SELECT.
4091*/
4092void sqlite3SelectPrep(
4093 Parse *pParse, /* The parser context */
4094 Select *p, /* The SELECT statement being coded. */
4095 NameContext *pOuterNC /* Name context for container */
4096){
4097 sqlite3 *db;
drh43152cf2009-05-19 19:04:58 +00004098 if( NEVER(p==0) ) return;
drh7d10d5a2008-08-20 16:35:10 +00004099 db = pParse->db;
drh785097d2013-02-12 22:09:48 +00004100 if( db->mallocFailed ) return;
drh7d10d5a2008-08-20 16:35:10 +00004101 if( p->selFlags & SF_HasTypeInfo ) return;
drh7d10d5a2008-08-20 16:35:10 +00004102 sqlite3SelectExpand(pParse, p);
4103 if( pParse->nErr || db->mallocFailed ) return;
4104 sqlite3ResolveSelectNames(pParse, p, pOuterNC);
4105 if( pParse->nErr || db->mallocFailed ) return;
4106 sqlite3SelectAddTypeInfo(pParse, p);
danielk1977b3bce662005-01-29 08:32:43 +00004107}
4108
4109/*
drh13449892005-09-07 21:22:45 +00004110** Reset the aggregate accumulator.
4111**
4112** The aggregate accumulator is a set of memory cells that hold
4113** intermediate results while calculating an aggregate. This
drh030796d2012-08-23 16:18:10 +00004114** routine generates code that stores NULLs in all of those memory
4115** cells.
danielk1977b3bce662005-01-29 08:32:43 +00004116*/
drh13449892005-09-07 21:22:45 +00004117static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){
4118 Vdbe *v = pParse->pVdbe;
4119 int i;
drhc99130f2005-09-11 11:56:27 +00004120 struct AggInfo_func *pFunc;
drh7e61d182013-12-20 13:11:45 +00004121 int nReg = pAggInfo->nFunc + pAggInfo->nColumn;
4122 if( nReg==0 ) return;
4123#ifdef SQLITE_DEBUG
4124 /* Verify that all AggInfo registers are within the range specified by
4125 ** AggInfo.mnReg..AggInfo.mxReg */
4126 assert( nReg==pAggInfo->mxReg-pAggInfo->mnReg+1 );
drh13449892005-09-07 21:22:45 +00004127 for(i=0; i<pAggInfo->nColumn; i++){
drh7e61d182013-12-20 13:11:45 +00004128 assert( pAggInfo->aCol[i].iMem>=pAggInfo->mnReg
4129 && pAggInfo->aCol[i].iMem<=pAggInfo->mxReg );
drh13449892005-09-07 21:22:45 +00004130 }
drh7e61d182013-12-20 13:11:45 +00004131 for(i=0; i<pAggInfo->nFunc; i++){
4132 assert( pAggInfo->aFunc[i].iMem>=pAggInfo->mnReg
4133 && pAggInfo->aFunc[i].iMem<=pAggInfo->mxReg );
4134 }
4135#endif
4136 sqlite3VdbeAddOp3(v, OP_Null, 0, pAggInfo->mnReg, pAggInfo->mxReg);
drhc99130f2005-09-11 11:56:27 +00004137 for(pFunc=pAggInfo->aFunc, i=0; i<pAggInfo->nFunc; i++, pFunc++){
drhc99130f2005-09-11 11:56:27 +00004138 if( pFunc->iDistinct>=0 ){
4139 Expr *pE = pFunc->pExpr;
danielk19776ab3a2e2009-02-19 14:39:25 +00004140 assert( !ExprHasProperty(pE, EP_xIsSelect) );
4141 if( pE->x.pList==0 || pE->x.pList->nExpr!=1 ){
drh0daa0022009-02-09 13:19:28 +00004142 sqlite3ErrorMsg(pParse, "DISTINCT aggregates must have exactly one "
4143 "argument");
drhc99130f2005-09-11 11:56:27 +00004144 pFunc->iDistinct = -1;
4145 }else{
danielk19776ab3a2e2009-02-19 14:39:25 +00004146 KeyInfo *pKeyInfo = keyInfoFromExprList(pParse, pE->x.pList);
drh66a51672008-01-03 00:01:23 +00004147 sqlite3VdbeAddOp4(v, OP_OpenEphemeral, pFunc->iDistinct, 0, 0,
drh2ec2fb22013-11-06 19:59:23 +00004148 (char*)pKeyInfo, P4_KEYINFO);
drhc99130f2005-09-11 11:56:27 +00004149 }
4150 }
drh13449892005-09-07 21:22:45 +00004151 }
danielk1977b3bce662005-01-29 08:32:43 +00004152}
4153
4154/*
drh13449892005-09-07 21:22:45 +00004155** Invoke the OP_AggFinalize opcode for every aggregate function
4156** in the AggInfo structure.
danielk1977b3bce662005-01-29 08:32:43 +00004157*/
drh13449892005-09-07 21:22:45 +00004158static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){
4159 Vdbe *v = pParse->pVdbe;
4160 int i;
4161 struct AggInfo_func *pF;
4162 for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
danielk19776ab3a2e2009-02-19 14:39:25 +00004163 ExprList *pList = pF->pExpr->x.pList;
4164 assert( !ExprHasProperty(pF->pExpr, EP_xIsSelect) );
drh66a51672008-01-03 00:01:23 +00004165 sqlite3VdbeAddOp4(v, OP_AggFinal, pF->iMem, pList ? pList->nExpr : 0, 0,
4166 (void*)pF->pFunc, P4_FUNCDEF);
drh13449892005-09-07 21:22:45 +00004167 }
danielk1977b3bce662005-01-29 08:32:43 +00004168}
drh13449892005-09-07 21:22:45 +00004169
4170/*
4171** Update the accumulator memory cells for an aggregate based on
4172** the current cursor position.
4173*/
4174static void updateAccumulator(Parse *pParse, AggInfo *pAggInfo){
4175 Vdbe *v = pParse->pVdbe;
4176 int i;
drh7a957892012-02-02 17:35:43 +00004177 int regHit = 0;
4178 int addrHitTest = 0;
drh13449892005-09-07 21:22:45 +00004179 struct AggInfo_func *pF;
4180 struct AggInfo_col *pC;
drh13449892005-09-07 21:22:45 +00004181
4182 pAggInfo->directMode = 1;
4183 for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
4184 int nArg;
drhc99130f2005-09-11 11:56:27 +00004185 int addrNext = 0;
drh98757152008-01-09 23:04:12 +00004186 int regAgg;
danielk19776ab3a2e2009-02-19 14:39:25 +00004187 ExprList *pList = pF->pExpr->x.pList;
4188 assert( !ExprHasProperty(pF->pExpr, EP_xIsSelect) );
drh13449892005-09-07 21:22:45 +00004189 if( pList ){
4190 nArg = pList->nExpr;
drh892d3172008-01-10 03:46:36 +00004191 regAgg = sqlite3GetTempRange(pParse, nArg);
drhd1a01ed2013-11-21 16:08:52 +00004192 sqlite3ExprCodeExprList(pParse, pList, regAgg, SQLITE_ECEL_DUP);
drh13449892005-09-07 21:22:45 +00004193 }else{
4194 nArg = 0;
drh98757152008-01-09 23:04:12 +00004195 regAgg = 0;
drh13449892005-09-07 21:22:45 +00004196 }
drhc99130f2005-09-11 11:56:27 +00004197 if( pF->iDistinct>=0 ){
4198 addrNext = sqlite3VdbeMakeLabel(v);
4199 assert( nArg==1 );
drh2dcef112008-01-12 19:03:48 +00004200 codeDistinct(pParse, pF->iDistinct, addrNext, 1, regAgg);
drhc99130f2005-09-11 11:56:27 +00004201 }
drhd36e1042013-09-06 13:10:12 +00004202 if( pF->pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL ){
drh13449892005-09-07 21:22:45 +00004203 CollSeq *pColl = 0;
4204 struct ExprList_item *pItem;
4205 int j;
drhe82f5d02008-10-07 19:53:14 +00004206 assert( pList!=0 ); /* pList!=0 if pF->pFunc has NEEDCOLL */
drh43617e92006-03-06 20:55:46 +00004207 for(j=0, pItem=pList->a; !pColl && j<nArg; j++, pItem++){
drh13449892005-09-07 21:22:45 +00004208 pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
4209 }
4210 if( !pColl ){
4211 pColl = pParse->db->pDfltColl;
4212 }
drh7a957892012-02-02 17:35:43 +00004213 if( regHit==0 && pAggInfo->nAccumulator ) regHit = ++pParse->nMem;
4214 sqlite3VdbeAddOp4(v, OP_CollSeq, regHit, 0, 0, (char *)pColl, P4_COLLSEQ);
drh13449892005-09-07 21:22:45 +00004215 }
drh98757152008-01-09 23:04:12 +00004216 sqlite3VdbeAddOp4(v, OP_AggStep, 0, regAgg, pF->iMem,
drh66a51672008-01-03 00:01:23 +00004217 (void*)pF->pFunc, P4_FUNCDEF);
drhea678832008-12-10 19:26:22 +00004218 sqlite3VdbeChangeP5(v, (u8)nArg);
drhda250ea2008-04-01 05:07:14 +00004219 sqlite3ExprCacheAffinityChange(pParse, regAgg, nArg);
drhf49f3522009-12-30 14:12:38 +00004220 sqlite3ReleaseTempRange(pParse, regAgg, nArg);
drhc99130f2005-09-11 11:56:27 +00004221 if( addrNext ){
4222 sqlite3VdbeResolveLabel(v, addrNext);
drhceea3322009-04-23 13:22:42 +00004223 sqlite3ExprCacheClear(pParse);
drhc99130f2005-09-11 11:56:27 +00004224 }
drh13449892005-09-07 21:22:45 +00004225 }
dan67a6a402010-03-31 15:02:56 +00004226
4227 /* Before populating the accumulator registers, clear the column cache.
4228 ** Otherwise, if any of the required column values are already present
4229 ** in registers, sqlite3ExprCode() may use OP_SCopy to copy the value
4230 ** to pC->iMem. But by the time the value is used, the original register
4231 ** may have been used, invalidating the underlying buffer holding the
4232 ** text or blob value. See ticket [883034dcb5].
4233 **
4234 ** Another solution would be to change the OP_SCopy used to copy cached
4235 ** values to an OP_Copy.
4236 */
drh7a957892012-02-02 17:35:43 +00004237 if( regHit ){
4238 addrHitTest = sqlite3VdbeAddOp1(v, OP_If, regHit);
4239 }
dan67a6a402010-03-31 15:02:56 +00004240 sqlite3ExprCacheClear(pParse);
drh13449892005-09-07 21:22:45 +00004241 for(i=0, pC=pAggInfo->aCol; i<pAggInfo->nAccumulator; i++, pC++){
drh389a1ad2008-01-03 23:44:53 +00004242 sqlite3ExprCode(pParse, pC->pExpr, pC->iMem);
drh13449892005-09-07 21:22:45 +00004243 }
4244 pAggInfo->directMode = 0;
drhceea3322009-04-23 13:22:42 +00004245 sqlite3ExprCacheClear(pParse);
drh7a957892012-02-02 17:35:43 +00004246 if( addrHitTest ){
4247 sqlite3VdbeJumpHere(v, addrHitTest);
4248 }
drh13449892005-09-07 21:22:45 +00004249}
4250
danielk1977b3bce662005-01-29 08:32:43 +00004251/*
danef7075d2011-02-21 17:49:49 +00004252** Add a single OP_Explain instruction to the VDBE to explain a simple
4253** count(*) query ("SELECT count(*) FROM pTab").
4254*/
4255#ifndef SQLITE_OMIT_EXPLAIN
4256static void explainSimpleCount(
4257 Parse *pParse, /* Parse context */
4258 Table *pTab, /* Table being queried */
4259 Index *pIdx /* Index used to optimize scan, or NULL */
4260){
4261 if( pParse->explain==2 ){
drh8a4380d2013-06-11 02:32:50 +00004262 char *zEqp = sqlite3MPrintf(pParse->db, "SCAN TABLE %s%s%s",
danef7075d2011-02-21 17:49:49 +00004263 pTab->zName,
drh8a4380d2013-06-11 02:32:50 +00004264 pIdx ? " USING COVERING INDEX " : "",
4265 pIdx ? pIdx->zName : ""
danef7075d2011-02-21 17:49:49 +00004266 );
4267 sqlite3VdbeAddOp4(
4268 pParse->pVdbe, OP_Explain, pParse->iSelectId, 0, 0, zEqp, P4_DYNAMIC
4269 );
4270 }
4271}
4272#else
4273# define explainSimpleCount(a,b,c)
4274#endif
4275
4276/*
drh7d10d5a2008-08-20 16:35:10 +00004277** Generate code for the SELECT statement given in the p argument.
drh9bb61fe2000-06-05 16:01:39 +00004278**
drhfef52082000-06-06 01:50:43 +00004279** The results are distributed in various ways depending on the
danielk19776c8c8ce2008-01-02 16:27:09 +00004280** contents of the SelectDest structure pointed to by argument pDest
4281** as follows:
drhfef52082000-06-06 01:50:43 +00004282**
danielk19776c8c8ce2008-01-02 16:27:09 +00004283** pDest->eDest Result
drhfef52082000-06-06 01:50:43 +00004284** ------------ -------------------------------------------
drh7d10d5a2008-08-20 16:35:10 +00004285** SRT_Output Generate a row of output (using the OP_ResultRow
4286** opcode) for each row in the result set.
drhfef52082000-06-06 01:50:43 +00004287**
drh7d10d5a2008-08-20 16:35:10 +00004288** SRT_Mem Only valid if the result is a single column.
4289** Store the first column of the first result row
drh2b596da2012-07-23 21:43:19 +00004290** in register pDest->iSDParm then abandon the rest
drh7d10d5a2008-08-20 16:35:10 +00004291** of the query. This destination implies "LIMIT 1".
drhfef52082000-06-06 01:50:43 +00004292**
drh7d10d5a2008-08-20 16:35:10 +00004293** SRT_Set The result must be a single column. Store each
drh2b596da2012-07-23 21:43:19 +00004294** row of result as the key in table pDest->iSDParm.
drhc041c162012-07-24 19:46:38 +00004295** Apply the affinity pDest->affSdst before storing
drh7d10d5a2008-08-20 16:35:10 +00004296** results. Used to implement "IN (SELECT ...)".
drhfef52082000-06-06 01:50:43 +00004297**
drh2b596da2012-07-23 21:43:19 +00004298** SRT_Union Store results as a key in a temporary table
4299** identified by pDest->iSDParm.
drh82c3d632000-06-06 21:56:07 +00004300**
drh2b596da2012-07-23 21:43:19 +00004301** SRT_Except Remove results from the temporary table pDest->iSDParm.
drhc4a3c772001-04-04 11:48:57 +00004302**
drh2b596da2012-07-23 21:43:19 +00004303** SRT_Table Store results in temporary table pDest->iSDParm.
drh7d10d5a2008-08-20 16:35:10 +00004304** This is like SRT_EphemTab except that the table
4305** is assumed to already be open.
drh9bb61fe2000-06-05 16:01:39 +00004306**
drh2b596da2012-07-23 21:43:19 +00004307** SRT_EphemTab Create an temporary table pDest->iSDParm and store
danielk19776c8c8ce2008-01-02 16:27:09 +00004308** the result there. The cursor is left open after
drh7d10d5a2008-08-20 16:35:10 +00004309** returning. This is like SRT_Table except that
4310** this destination uses OP_OpenEphemeral to create
4311** the table first.
danielk19776c8c8ce2008-01-02 16:27:09 +00004312**
drh7d10d5a2008-08-20 16:35:10 +00004313** SRT_Coroutine Generate a co-routine that returns a new row of
4314** results each time it is invoked. The entry point
drh2b596da2012-07-23 21:43:19 +00004315** of the co-routine is stored in register pDest->iSDParm.
danielk19776c8c8ce2008-01-02 16:27:09 +00004316**
drh2b596da2012-07-23 21:43:19 +00004317** SRT_Exists Store a 1 in memory cell pDest->iSDParm if the result
danielk19776c8c8ce2008-01-02 16:27:09 +00004318** set is not empty.
4319**
drh7d10d5a2008-08-20 16:35:10 +00004320** SRT_Discard Throw the results away. This is used by SELECT
4321** statements within triggers whose only purpose is
4322** the side-effects of functions.
drhe78e8282003-01-19 03:59:45 +00004323**
drh9bb61fe2000-06-05 16:01:39 +00004324** This routine returns the number of errors. If any errors are
4325** encountered, then an appropriate error message is left in
4326** pParse->zErrMsg.
4327**
4328** This routine does NOT free the Select structure passed in. The
4329** calling function needs to do that.
4330*/
danielk19774adee202004-05-08 08:23:19 +00004331int sqlite3Select(
drhcce7d172000-05-31 15:34:51 +00004332 Parse *pParse, /* The parser context */
drh9bb61fe2000-06-05 16:01:39 +00004333 Select *p, /* The SELECT statement being coded. */
drh7d10d5a2008-08-20 16:35:10 +00004334 SelectDest *pDest /* What to do with the query results */
drhcce7d172000-05-31 15:34:51 +00004335){
drh13449892005-09-07 21:22:45 +00004336 int i, j; /* Loop counters */
4337 WhereInfo *pWInfo; /* Return from sqlite3WhereBegin() */
4338 Vdbe *v; /* The virtual machine under construction */
danielk1977b3bce662005-01-29 08:32:43 +00004339 int isAgg; /* True for select lists like "count(*)" */
drha2e00042002-01-22 03:13:42 +00004340 ExprList *pEList; /* List of columns to extract. */
drhad3cab52002-05-24 02:04:32 +00004341 SrcList *pTabList; /* List of tables to select from */
drh9bb61fe2000-06-05 16:01:39 +00004342 Expr *pWhere; /* The WHERE clause. May be NULL */
4343 ExprList *pOrderBy; /* The ORDER BY clause. May be NULL */
drh22827922000-06-06 17:27:05 +00004344 ExprList *pGroupBy; /* The GROUP BY clause. May be NULL */
4345 Expr *pHaving; /* The HAVING clause. May be NULL */
drh1d83f052002-02-17 00:30:36 +00004346 int rc = 1; /* Value to return from this function */
drhb9bb7c12006-06-11 23:41:55 +00004347 int addrSortIndex; /* Address of an OP_OpenEphemeral instruction */
drhe8e4af72012-09-21 00:04:28 +00004348 DistinctCtx sDistinct; /* Info on how to code the DISTINCT keyword */
drh13449892005-09-07 21:22:45 +00004349 AggInfo sAggInfo; /* Information used by aggregate queries */
drhec7429a2005-10-06 16:53:14 +00004350 int iEnd; /* Address of the end of the query */
drh17435752007-08-16 04:30:38 +00004351 sqlite3 *db; /* The database connection */
drh9bb61fe2000-06-05 16:01:39 +00004352
dan2ce22452010-11-08 19:01:16 +00004353#ifndef SQLITE_OMIT_EXPLAIN
4354 int iRestoreSelectId = pParse->iSelectId;
4355 pParse->iSelectId = pParse->iNextSelectId++;
4356#endif
4357
drh17435752007-08-16 04:30:38 +00004358 db = pParse->db;
4359 if( p==0 || db->mallocFailed || pParse->nErr ){
drh6f7adc82006-01-11 21:41:20 +00004360 return 1;
4361 }
danielk19774adee202004-05-08 08:23:19 +00004362 if( sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1;
drh13449892005-09-07 21:22:45 +00004363 memset(&sAggInfo, 0, sizeof(sAggInfo));
drhdaffd0e2001-04-11 14:28:42 +00004364
danielk19776c8c8ce2008-01-02 16:27:09 +00004365 if( IgnorableOrderby(pDest) ){
danielk19779ed1dfa2008-01-02 17:11:14 +00004366 assert(pDest->eDest==SRT_Exists || pDest->eDest==SRT_Union ||
4367 pDest->eDest==SRT_Except || pDest->eDest==SRT_Discard);
drhccfcbce2009-05-18 15:46:07 +00004368 /* If ORDER BY makes no difference in the output then neither does
4369 ** DISTINCT so it can be removed too. */
4370 sqlite3ExprListDelete(db, p->pOrderBy);
4371 p->pOrderBy = 0;
drh7d10d5a2008-08-20 16:35:10 +00004372 p->selFlags &= ~SF_Distinct;
drh9a993342007-12-13 02:45:31 +00004373 }
drh7d10d5a2008-08-20 16:35:10 +00004374 sqlite3SelectPrep(pParse, p, 0);
drhccfcbce2009-05-18 15:46:07 +00004375 pOrderBy = p->pOrderBy;
drhb27b7f52008-12-10 18:03:45 +00004376 pTabList = p->pSrc;
4377 pEList = p->pEList;
danielk1977956f4312008-11-21 09:43:20 +00004378 if( pParse->nErr || db->mallocFailed ){
drh9a993342007-12-13 02:45:31 +00004379 goto select_end;
4380 }
drh7d10d5a2008-08-20 16:35:10 +00004381 isAgg = (p->selFlags & SF_Aggregate)!=0;
drh43152cf2009-05-19 19:04:58 +00004382 assert( pEList!=0 );
drhcce7d172000-05-31 15:34:51 +00004383
drhd820cb12002-02-18 03:21:45 +00004384 /* Begin generating code.
4385 */
danielk19774adee202004-05-08 08:23:19 +00004386 v = sqlite3GetVdbe(pParse);
drhd820cb12002-02-18 03:21:45 +00004387 if( v==0 ) goto select_end;
4388
dan74b617b2010-09-02 19:01:16 +00004389 /* If writing to memory or generating a set
4390 ** only a single column may be output.
4391 */
4392#ifndef SQLITE_OMIT_SUBQUERY
4393 if( checkForMultiColumnSelectError(pParse, pDest, pEList->nExpr) ){
4394 goto select_end;
4395 }
4396#endif
4397
drhd820cb12002-02-18 03:21:45 +00004398 /* Generate code for all sub-queries in the FROM clause
4399 */
drh51522cd2005-01-20 13:36:19 +00004400#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
danielk1977f23329a2008-07-01 14:09:13 +00004401 for(i=0; !p->pPrior && i<pTabList->nSrc; i++){
drh13449892005-09-07 21:22:45 +00004402 struct SrcList_item *pItem = &pTabList->a[i];
drh1013c932008-01-06 00:25:21 +00004403 SelectDest dest;
danielk1977daf79ac2008-06-30 18:12:28 +00004404 Select *pSub = pItem->pSelect;
danielk1977f23329a2008-07-01 14:09:13 +00004405 int isAggSub;
drhc31c2eb2003-05-02 16:04:17 +00004406
drh5b6a9ed2011-09-15 23:58:14 +00004407 if( pSub==0 ) continue;
drh21172c42012-10-30 00:29:07 +00004408
4409 /* Sometimes the code for a subquery will be generated more than
4410 ** once, if the subquery is part of the WHERE clause in a LEFT JOIN,
4411 ** for example. In that case, do not regenerate the code to manifest
4412 ** a view or the co-routine to implement a view. The first instance
4413 ** is sufficient, though the subroutine to manifest the view does need
4414 ** to be invoked again. */
drh5b6a9ed2011-09-15 23:58:14 +00004415 if( pItem->addrFillSub ){
drh21172c42012-10-30 00:29:07 +00004416 if( pItem->viaCoroutine==0 ){
4417 sqlite3VdbeAddOp2(v, OP_Gosub, pItem->regReturn, pItem->addrFillSub);
4418 }
drh5b6a9ed2011-09-15 23:58:14 +00004419 continue;
4420 }
danielk1977daf79ac2008-06-30 18:12:28 +00004421
danielk1977fc976062007-05-10 10:46:56 +00004422 /* Increment Parse.nHeight by the height of the largest expression
drhf7b54962013-05-28 12:11:54 +00004423 ** tree referred to by this, the parent select. The child select
danielk1977fc976062007-05-10 10:46:56 +00004424 ** may contain expression trees of at most
4425 ** (SQLITE_MAX_EXPR_DEPTH-Parse.nHeight) height. This is a bit
4426 ** more conservative than necessary, but much easier than enforcing
4427 ** an exact limit.
4428 */
4429 pParse->nHeight += sqlite3SelectExprHeight(p);
danielk1977daf79ac2008-06-30 18:12:28 +00004430
drh7d10d5a2008-08-20 16:35:10 +00004431 isAggSub = (pSub->selFlags & SF_Aggregate)!=0;
danielk1977524cc212008-07-02 13:13:51 +00004432 if( flattenSubquery(pParse, p, i, isAgg, isAggSub) ){
drh5b6a9ed2011-09-15 23:58:14 +00004433 /* This subquery can be absorbed into its parent. */
danielk1977f23329a2008-07-01 14:09:13 +00004434 if( isAggSub ){
drh7d10d5a2008-08-20 16:35:10 +00004435 isAgg = 1;
4436 p->selFlags |= SF_Aggregate;
danielk1977daf79ac2008-06-30 18:12:28 +00004437 }
4438 i = -1;
drha5759672012-10-30 14:39:12 +00004439 }else if( pTabList->nSrc==1 && (p->selFlags & SF_Materialize)==0
4440 && OptimizationEnabled(db, SQLITE_SubqCoroutine)
4441 ){
drh21172c42012-10-30 00:29:07 +00004442 /* Implement a co-routine that will return a single row of the result
4443 ** set on each invocation.
4444 */
4445 int addrTop;
4446 int addrEof;
4447 pItem->regReturn = ++pParse->nMem;
4448 addrEof = ++pParse->nMem;
dan4b2f3582012-12-07 19:28:26 +00004449 /* Before coding the OP_Goto to jump to the start of the main routine,
4450 ** ensure that the jump to the verify-schema routine has already
4451 ** been coded. Otherwise, the verify-schema would likely be coded as
4452 ** part of the co-routine. If the main routine then accessed the
4453 ** database before invoking the co-routine for the first time (for
4454 ** example to initialize a LIMIT register from a sub-select), it would
4455 ** be doing so without having verified the schema version and obtained
4456 ** the required db locks. See ticket d6b36be38. */
4457 sqlite3CodeVerifySchema(pParse, -1);
drh21172c42012-10-30 00:29:07 +00004458 sqlite3VdbeAddOp0(v, OP_Goto);
4459 addrTop = sqlite3VdbeAddOp1(v, OP_OpenPseudo, pItem->iCursor);
4460 sqlite3VdbeChangeP5(v, 1);
4461 VdbeComment((v, "coroutine for %s", pItem->pTab->zName));
4462 pItem->addrFillSub = addrTop;
4463 sqlite3VdbeAddOp2(v, OP_Integer, 0, addrEof);
4464 sqlite3VdbeChangeP5(v, 1);
4465 sqlite3SelectDestInit(&dest, SRT_Coroutine, pItem->regReturn);
4466 explainSetInteger(pItem->iSelectId, (u8)pParse->iNextSelectId);
4467 sqlite3Select(pParse, pSub, &dest);
4468 pItem->pTab->nRowEst = (unsigned)pSub->nSelectRow;
4469 pItem->viaCoroutine = 1;
4470 sqlite3VdbeChangeP2(v, addrTop, dest.iSdst);
4471 sqlite3VdbeChangeP3(v, addrTop, dest.nSdst);
4472 sqlite3VdbeAddOp2(v, OP_Integer, 1, addrEof);
4473 sqlite3VdbeAddOp1(v, OP_Yield, pItem->regReturn);
4474 VdbeComment((v, "end %s", pItem->pTab->zName));
4475 sqlite3VdbeJumpHere(v, addrTop-1);
4476 sqlite3ClearTempRegCache(pParse);
danielk1977daf79ac2008-06-30 18:12:28 +00004477 }else{
drh5b6a9ed2011-09-15 23:58:14 +00004478 /* Generate a subroutine that will fill an ephemeral table with
4479 ** the content of this subquery. pItem->addrFillSub will point
4480 ** to the address of the generated subroutine. pItem->regReturn
4481 ** is a register allocated to hold the subroutine return address
4482 */
drh7157e8e2011-09-16 16:00:51 +00004483 int topAddr;
drh48f2d3b2011-09-16 01:34:43 +00004484 int onceAddr = 0;
drh7157e8e2011-09-16 16:00:51 +00004485 int retAddr;
drh5b6a9ed2011-09-15 23:58:14 +00004486 assert( pItem->addrFillSub==0 );
drh5b6a9ed2011-09-15 23:58:14 +00004487 pItem->regReturn = ++pParse->nMem;
drh7157e8e2011-09-16 16:00:51 +00004488 topAddr = sqlite3VdbeAddOp2(v, OP_Integer, 0, pItem->regReturn);
4489 pItem->addrFillSub = topAddr+1;
4490 VdbeNoopComment((v, "materialize %s", pItem->pTab->zName));
dan1d8cb212011-12-09 13:24:16 +00004491 if( pItem->isCorrelated==0 ){
drhed171672013-04-24 13:50:09 +00004492 /* If the subquery is not correlated and if we are not inside of
drh5b6a9ed2011-09-15 23:58:14 +00004493 ** a trigger, then we only need to compute the value of the subquery
4494 ** once. */
dan1d8cb212011-12-09 13:24:16 +00004495 onceAddr = sqlite3CodeOnce(pParse);
drh5b6a9ed2011-09-15 23:58:14 +00004496 }
danielk1977daf79ac2008-06-30 18:12:28 +00004497 sqlite3SelectDestInit(&dest, SRT_EphemTab, pItem->iCursor);
dance7e1892010-12-01 19:00:48 +00004498 explainSetInteger(pItem->iSelectId, (u8)pParse->iNextSelectId);
drh7d10d5a2008-08-20 16:35:10 +00004499 sqlite3Select(pParse, pSub, &dest);
drh95aa47b2010-11-16 02:49:15 +00004500 pItem->pTab->nRowEst = (unsigned)pSub->nSelectRow;
drh48f2d3b2011-09-16 01:34:43 +00004501 if( onceAddr ) sqlite3VdbeJumpHere(v, onceAddr);
drh7157e8e2011-09-16 16:00:51 +00004502 retAddr = sqlite3VdbeAddOp1(v, OP_Return, pItem->regReturn);
4503 VdbeComment((v, "end %s", pItem->pTab->zName));
4504 sqlite3VdbeChangeP1(v, topAddr, retAddr);
drhcdc69552011-12-06 13:24:59 +00004505 sqlite3ClearTempRegCache(pParse);
danielk1977daf79ac2008-06-30 18:12:28 +00004506 }
drh43152cf2009-05-19 19:04:58 +00004507 if( /*pParse->nErr ||*/ db->mallocFailed ){
drhcfa063b2007-11-21 15:24:00 +00004508 goto select_end;
4509 }
danielk1977fc976062007-05-10 10:46:56 +00004510 pParse->nHeight -= sqlite3SelectExprHeight(p);
drh1b2e0322002-03-03 02:49:51 +00004511 pTabList = p->pSrc;
danielk19776c8c8ce2008-01-02 16:27:09 +00004512 if( !IgnorableOrderby(pDest) ){
drhacd4c692002-03-07 02:02:51 +00004513 pOrderBy = p->pOrderBy;
4514 }
drhd820cb12002-02-18 03:21:45 +00004515 }
danielk1977daf79ac2008-06-30 18:12:28 +00004516 pEList = p->pEList;
drh51522cd2005-01-20 13:36:19 +00004517#endif
danielk1977daf79ac2008-06-30 18:12:28 +00004518 pWhere = p->pWhere;
4519 pGroupBy = p->pGroupBy;
4520 pHaving = p->pHaving;
drhe8e4af72012-09-21 00:04:28 +00004521 sDistinct.isTnct = (p->selFlags & SF_Distinct)!=0;
drh832508b2002-03-02 17:04:07 +00004522
danielk1977f23329a2008-07-01 14:09:13 +00004523#ifndef SQLITE_OMIT_COMPOUND_SELECT
4524 /* If there is are a sequence of queries, do the earlier ones first.
4525 */
4526 if( p->pPrior ){
4527 if( p->pRightmost==0 ){
4528 Select *pLoop, *pRight = 0;
4529 int cnt = 0;
4530 int mxSelect;
4531 for(pLoop=p; pLoop; pLoop=pLoop->pPrior, cnt++){
4532 pLoop->pRightmost = p;
4533 pLoop->pNext = pRight;
4534 pRight = pLoop;
4535 }
4536 mxSelect = db->aLimit[SQLITE_LIMIT_COMPOUND_SELECT];
4537 if( mxSelect && cnt>mxSelect ){
4538 sqlite3ErrorMsg(pParse, "too many terms in compound SELECT");
dan2ce22452010-11-08 19:01:16 +00004539 goto select_end;
danielk1977f23329a2008-07-01 14:09:13 +00004540 }
4541 }
dan7f61e922010-11-11 16:46:40 +00004542 rc = multiSelect(pParse, p, pDest);
dan17c0bc02010-11-09 17:35:19 +00004543 explainSetInteger(pParse->iSelectId, iRestoreSelectId);
dan7f61e922010-11-11 16:46:40 +00004544 return rc;
danielk1977f23329a2008-07-01 14:09:13 +00004545 }
4546#endif
4547
drh8c6f6662010-04-26 19:17:26 +00004548 /* If there is both a GROUP BY and an ORDER BY clause and they are
4549 ** identical, then disable the ORDER BY clause since the GROUP BY
4550 ** will cause elements to come out in the correct order. This is
4551 ** an optimization - the correct answer should result regardless.
4552 ** Use the SQLITE_GroupByOrder flag with SQLITE_TESTCTRL_OPTIMIZER
4553 ** to disable this optimization for testing purposes.
4554 */
drh619a1302013-08-01 13:04:46 +00004555 if( sqlite3ExprListCompare(p->pGroupBy, pOrderBy, -1)==0
drh7e5418e2012-09-27 15:05:54 +00004556 && OptimizationEnabled(db, SQLITE_GroupByOrder) ){
drh8c6f6662010-04-26 19:17:26 +00004557 pOrderBy = 0;
4558 }
4559
dan50118cd2011-07-01 14:21:38 +00004560 /* If the query is DISTINCT with an ORDER BY but is not an aggregate, and
4561 ** if the select-list is the same as the ORDER BY list, then this query
4562 ** can be rewritten as a GROUP BY. In other words, this:
4563 **
4564 ** SELECT DISTINCT xyz FROM ... ORDER BY xyz
4565 **
4566 ** is transformed to:
4567 **
4568 ** SELECT xyz FROM ... GROUP BY xyz
4569 **
4570 ** The second form is preferred as a single index (or temp-table) may be
4571 ** used for both the ORDER BY and DISTINCT processing. As originally
4572 ** written the query must use a temp-table for at least one of the ORDER
4573 ** BY and DISTINCT, and an index or separate temp-table for the other.
4574 */
4575 if( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct
drh619a1302013-08-01 13:04:46 +00004576 && sqlite3ExprListCompare(pOrderBy, p->pEList, -1)==0
dan50118cd2011-07-01 14:21:38 +00004577 ){
4578 p->selFlags &= ~SF_Distinct;
4579 p->pGroupBy = sqlite3ExprListDup(db, p->pEList, 0);
4580 pGroupBy = p->pGroupBy;
4581 pOrderBy = 0;
drhe8e4af72012-09-21 00:04:28 +00004582 /* Notice that even thought SF_Distinct has been cleared from p->selFlags,
4583 ** the sDistinct.isTnct is still set. Hence, isTnct represents the
4584 ** original setting of the SF_Distinct flag, not the current setting */
4585 assert( sDistinct.isTnct );
dan50118cd2011-07-01 14:21:38 +00004586 }
4587
drh8b4c40d2007-02-01 23:02:45 +00004588 /* If there is an ORDER BY clause, then this sorting
4589 ** index might end up being unused if the data can be
drh9d2985c2005-09-08 01:58:42 +00004590 ** extracted in pre-sorted order. If that is the case, then the
drhb9bb7c12006-06-11 23:41:55 +00004591 ** OP_OpenEphemeral instruction will be changed to an OP_Noop once
drh9d2985c2005-09-08 01:58:42 +00004592 ** we figure out that the sorting index is not needed. The addrSortIndex
4593 ** variable is used to facilitate that change.
danielk19777cedc8d2004-06-10 10:50:08 +00004594 */
4595 if( pOrderBy ){
drh0342b1f2005-09-01 03:07:44 +00004596 KeyInfo *pKeyInfo;
drh0342b1f2005-09-01 03:07:44 +00004597 pKeyInfo = keyInfoFromExprList(pParse, pOrderBy);
drh9d2985c2005-09-08 01:58:42 +00004598 pOrderBy->iECursor = pParse->nTab++;
drhb9bb7c12006-06-11 23:41:55 +00004599 p->addrOpenEphm[2] = addrSortIndex =
drh66a51672008-01-03 00:01:23 +00004600 sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
4601 pOrderBy->iECursor, pOrderBy->nExpr+2, 0,
drh2ec2fb22013-11-06 19:59:23 +00004602 (char*)pKeyInfo, P4_KEYINFO);
drh9d2985c2005-09-08 01:58:42 +00004603 }else{
4604 addrSortIndex = -1;
danielk19777cedc8d2004-06-10 10:50:08 +00004605 }
4606
drh2d0794e2002-03-03 03:03:52 +00004607 /* If the output is destined for a temporary table, open that table.
4608 */
danielk19776c8c8ce2008-01-02 16:27:09 +00004609 if( pDest->eDest==SRT_EphemTab ){
drh2b596da2012-07-23 21:43:19 +00004610 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pDest->iSDParm, pEList->nExpr);
drh2d0794e2002-03-03 03:03:52 +00004611 }
4612
drhf42bacc2006-04-26 17:39:34 +00004613 /* Set the limiter.
4614 */
4615 iEnd = sqlite3VdbeMakeLabel(v);
drhc63367e2013-06-10 20:46:50 +00004616 p->nSelectRow = LARGEST_INT64;
drhf42bacc2006-04-26 17:39:34 +00004617 computeLimitRegisters(pParse, p, iEnd);
drhc6aff302011-09-01 15:32:47 +00004618 if( p->iLimit==0 && addrSortIndex>=0 ){
4619 sqlite3VdbeGetOp(v, addrSortIndex)->opcode = OP_SorterOpen;
4620 p->selFlags |= SF_UseSorter;
4621 }
drhf42bacc2006-04-26 17:39:34 +00004622
drhdece1a82005-08-31 18:20:00 +00004623 /* Open a virtual index to use for the distinct set.
drhefb72512000-05-31 20:00:52 +00004624 */
dan2ce22452010-11-08 19:01:16 +00004625 if( p->selFlags & SF_Distinct ){
drhe8e4af72012-09-21 00:04:28 +00004626 sDistinct.tabTnct = pParse->nTab++;
4627 sDistinct.addrTnct = sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
4628 sDistinct.tabTnct, 0, 0,
4629 (char*)keyInfoFromExprList(pParse, p->pEList),
drh2ec2fb22013-11-06 19:59:23 +00004630 P4_KEYINFO);
drhd4187c72010-08-30 22:15:45 +00004631 sqlite3VdbeChangeP5(v, BTREE_UNORDERED);
drhe8e4af72012-09-21 00:04:28 +00004632 sDistinct.eTnctType = WHERE_DISTINCT_UNORDERED;
drh832508b2002-03-02 17:04:07 +00004633 }else{
drhe8e4af72012-09-21 00:04:28 +00004634 sDistinct.eTnctType = WHERE_DISTINCT_NOOP;
drhefb72512000-05-31 20:00:52 +00004635 }
drh832508b2002-03-02 17:04:07 +00004636
drh13449892005-09-07 21:22:45 +00004637 if( !isAgg && pGroupBy==0 ){
drhe8e4af72012-09-21 00:04:28 +00004638 /* No aggregate functions and no GROUP BY clause */
drh6457a352013-06-21 00:35:37 +00004639 u16 wctrlFlags = (sDistinct.isTnct ? WHERE_WANT_DISTINCT : 0);
dan38cc40c2011-06-30 20:17:15 +00004640
4641 /* Begin the database scan. */
drh6457a352013-06-21 00:35:37 +00004642 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pOrderBy, p->pEList,
4643 wctrlFlags, 0);
drh13449892005-09-07 21:22:45 +00004644 if( pWInfo==0 ) goto select_end;
drh6f328482013-06-05 23:39:34 +00004645 if( sqlite3WhereOutputRowCount(pWInfo) < p->nSelectRow ){
4646 p->nSelectRow = sqlite3WhereOutputRowCount(pWInfo);
4647 }
drh6457a352013-06-21 00:35:37 +00004648 if( sDistinct.isTnct && sqlite3WhereIsDistinct(pWInfo) ){
drh6f328482013-06-05 23:39:34 +00004649 sDistinct.eTnctType = sqlite3WhereIsDistinct(pWInfo);
4650 }
4651 if( pOrderBy && sqlite3WhereIsOrdered(pWInfo) ) pOrderBy = 0;
drhcce7d172000-05-31 15:34:51 +00004652
drhb9bb7c12006-06-11 23:41:55 +00004653 /* If sorting index that was created by a prior OP_OpenEphemeral
4654 ** instruction ended up not being needed, then change the OP_OpenEphemeral
drh9d2985c2005-09-08 01:58:42 +00004655 ** into an OP_Noop.
4656 */
4657 if( addrSortIndex>=0 && pOrderBy==0 ){
drh48f2d3b2011-09-16 01:34:43 +00004658 sqlite3VdbeChangeToNoop(v, addrSortIndex);
drhb9bb7c12006-06-11 23:41:55 +00004659 p->addrOpenEphm[2] = -1;
drh9d2985c2005-09-08 01:58:42 +00004660 }
4661
dan38cc40c2011-06-30 20:17:15 +00004662 /* Use the standard inner loop. */
drhe8e4af72012-09-21 00:04:28 +00004663 selectInnerLoop(pParse, p, pEList, 0, 0, pOrderBy, &sDistinct, pDest,
drh6f328482013-06-05 23:39:34 +00004664 sqlite3WhereContinueLabel(pWInfo),
4665 sqlite3WhereBreakLabel(pWInfo));
drhefb72512000-05-31 20:00:52 +00004666
drh13449892005-09-07 21:22:45 +00004667 /* End the database scan loop.
4668 */
4669 sqlite3WhereEnd(pWInfo);
4670 }else{
drhe8e4af72012-09-21 00:04:28 +00004671 /* This case when there exist aggregate functions or a GROUP BY clause
4672 ** or both */
drh13449892005-09-07 21:22:45 +00004673 NameContext sNC; /* Name context for processing aggregate information */
4674 int iAMem; /* First Mem address for storing current GROUP BY */
4675 int iBMem; /* First Mem address for previous GROUP BY */
4676 int iUseFlag; /* Mem address holding flag indicating that at least
4677 ** one row of the input to the aggregator has been
4678 ** processed */
4679 int iAbortFlag; /* Mem address which causes query abort if positive */
4680 int groupBySort; /* Rows come from source in GROUP BY order */
drhd1766112008-09-17 00:13:12 +00004681 int addrEnd; /* End of processing for this SELECT */
drh1c9d8352011-09-01 16:01:27 +00004682 int sortPTab = 0; /* Pseudotable used to decode sorting results */
4683 int sortOut = 0; /* Output register from the sorter */
drhcce7d172000-05-31 15:34:51 +00004684
drhd1766112008-09-17 00:13:12 +00004685 /* Remove any and all aliases between the result set and the
4686 ** GROUP BY clause.
4687 */
4688 if( pGroupBy ){
drhdc5ea5c2008-12-10 17:19:59 +00004689 int k; /* Loop counter */
drhd1766112008-09-17 00:13:12 +00004690 struct ExprList_item *pItem; /* For looping over expression in a list */
drhcce7d172000-05-31 15:34:51 +00004691
drhdc5ea5c2008-12-10 17:19:59 +00004692 for(k=p->pEList->nExpr, pItem=p->pEList->a; k>0; k--, pItem++){
drhc2acc4e2013-11-15 18:15:19 +00004693 pItem->u.x.iAlias = 0;
drhd1766112008-09-17 00:13:12 +00004694 }
drhdc5ea5c2008-12-10 17:19:59 +00004695 for(k=pGroupBy->nExpr, pItem=pGroupBy->a; k>0; k--, pItem++){
drhc2acc4e2013-11-15 18:15:19 +00004696 pItem->u.x.iAlias = 0;
drhd1766112008-09-17 00:13:12 +00004697 }
drhc63367e2013-06-10 20:46:50 +00004698 if( p->nSelectRow>100 ) p->nSelectRow = 100;
drh95aa47b2010-11-16 02:49:15 +00004699 }else{
drhc63367e2013-06-10 20:46:50 +00004700 p->nSelectRow = 1;
drhd1766112008-09-17 00:13:12 +00004701 }
drh13449892005-09-07 21:22:45 +00004702
drhd1766112008-09-17 00:13:12 +00004703
4704 /* Create a label to jump to when we want to abort the query */
drh13449892005-09-07 21:22:45 +00004705 addrEnd = sqlite3VdbeMakeLabel(v);
4706
4707 /* Convert TK_COLUMN nodes into TK_AGG_COLUMN and make entries in
4708 ** sAggInfo for all TK_AGG_FUNCTION nodes in expressions of the
4709 ** SELECT statement.
4710 */
4711 memset(&sNC, 0, sizeof(sNC));
4712 sNC.pParse = pParse;
4713 sNC.pSrcList = pTabList;
4714 sNC.pAggInfo = &sAggInfo;
drh7e61d182013-12-20 13:11:45 +00004715 sAggInfo.mnReg = pParse->nMem+1;
drh13449892005-09-07 21:22:45 +00004716 sAggInfo.nSortingColumn = pGroupBy ? pGroupBy->nExpr+1 : 0;
drh9d2985c2005-09-08 01:58:42 +00004717 sAggInfo.pGroupBy = pGroupBy;
drhd2b3e232008-01-23 14:51:49 +00004718 sqlite3ExprAnalyzeAggList(&sNC, pEList);
4719 sqlite3ExprAnalyzeAggList(&sNC, pOrderBy);
4720 if( pHaving ){
4721 sqlite3ExprAnalyzeAggregates(&sNC, pHaving);
drh13449892005-09-07 21:22:45 +00004722 }
4723 sAggInfo.nAccumulator = sAggInfo.nColumn;
4724 for(i=0; i<sAggInfo.nFunc; i++){
danielk19776ab3a2e2009-02-19 14:39:25 +00004725 assert( !ExprHasProperty(sAggInfo.aFunc[i].pExpr, EP_xIsSelect) );
drh3a8c4be2012-05-21 20:13:39 +00004726 sNC.ncFlags |= NC_InAggFunc;
danielk19776ab3a2e2009-02-19 14:39:25 +00004727 sqlite3ExprAnalyzeAggList(&sNC, sAggInfo.aFunc[i].pExpr->x.pList);
drh3a8c4be2012-05-21 20:13:39 +00004728 sNC.ncFlags &= ~NC_InAggFunc;
drh13449892005-09-07 21:22:45 +00004729 }
drh7e61d182013-12-20 13:11:45 +00004730 sAggInfo.mxReg = pParse->nMem;
drh17435752007-08-16 04:30:38 +00004731 if( db->mallocFailed ) goto select_end;
drh13449892005-09-07 21:22:45 +00004732
4733 /* Processing for aggregates with GROUP BY is very different and
danielk19773c4809a2007-11-12 15:29:18 +00004734 ** much more complex than aggregates without a GROUP BY.
drh13449892005-09-07 21:22:45 +00004735 */
4736 if( pGroupBy ){
4737 KeyInfo *pKeyInfo; /* Keying information for the group by clause */
drhd1766112008-09-17 00:13:12 +00004738 int j1; /* A-vs-B comparision jump */
4739 int addrOutputRow; /* Start of subroutine that outputs a result row */
4740 int regOutputRow; /* Return address register for output subroutine */
4741 int addrSetAbort; /* Set the abort flag and return */
4742 int addrTopOfLoop; /* Top of the input loop */
4743 int addrSortingIdx; /* The OP_OpenEphemeral for the sorting index */
4744 int addrReset; /* Subroutine for resetting the accumulator */
4745 int regReset; /* Return address register for reset subroutine */
drh13449892005-09-07 21:22:45 +00004746
4747 /* If there is a GROUP BY clause we might need a sorting index to
4748 ** implement it. Allocate that sorting index now. If it turns out
drh1c9d8352011-09-01 16:01:27 +00004749 ** that we do not need it after all, the OP_SorterOpen instruction
drh13449892005-09-07 21:22:45 +00004750 ** will be converted into a Noop.
4751 */
4752 sAggInfo.sortingIdx = pParse->nTab++;
4753 pKeyInfo = keyInfoFromExprList(pParse, pGroupBy);
drh1c9d8352011-09-01 16:01:27 +00004754 addrSortingIdx = sqlite3VdbeAddOp4(v, OP_SorterOpen,
danielk1977cd3e8f72008-03-25 09:47:35 +00004755 sAggInfo.sortingIdx, sAggInfo.nSortingColumn,
drh2ec2fb22013-11-06 19:59:23 +00004756 0, (char*)pKeyInfo, P4_KEYINFO);
drh13449892005-09-07 21:22:45 +00004757
4758 /* Initialize memory locations used by GROUP BY aggregate processing
4759 */
drh0a07c102008-01-03 18:03:08 +00004760 iUseFlag = ++pParse->nMem;
4761 iAbortFlag = ++pParse->nMem;
drhd1766112008-09-17 00:13:12 +00004762 regOutputRow = ++pParse->nMem;
4763 addrOutputRow = sqlite3VdbeMakeLabel(v);
4764 regReset = ++pParse->nMem;
4765 addrReset = sqlite3VdbeMakeLabel(v);
drh0a07c102008-01-03 18:03:08 +00004766 iAMem = pParse->nMem + 1;
drh13449892005-09-07 21:22:45 +00004767 pParse->nMem += pGroupBy->nExpr;
drh0a07c102008-01-03 18:03:08 +00004768 iBMem = pParse->nMem + 1;
drh13449892005-09-07 21:22:45 +00004769 pParse->nMem += pGroupBy->nExpr;
drh4c583122008-01-04 22:01:03 +00004770 sqlite3VdbeAddOp2(v, OP_Integer, 0, iAbortFlag);
drhd4e70eb2008-01-02 00:34:36 +00004771 VdbeComment((v, "clear abort flag"));
drh4c583122008-01-04 22:01:03 +00004772 sqlite3VdbeAddOp2(v, OP_Integer, 0, iUseFlag);
drhd4e70eb2008-01-02 00:34:36 +00004773 VdbeComment((v, "indicate accumulator empty"));
drhb8475df2011-12-09 16:21:19 +00004774 sqlite3VdbeAddOp3(v, OP_Null, 0, iAMem, iAMem+pGroupBy->nExpr-1);
drhe3133822005-09-20 13:11:59 +00004775
drh13449892005-09-07 21:22:45 +00004776 /* Begin a loop that will extract all source rows in GROUP BY order.
4777 ** This might involve two separate loops with an OP_Sort in between, or
4778 ** it might be a single loop that uses an index to extract information
4779 ** in the right order to begin with.
4780 */
drh2eb95372008-06-06 15:04:36 +00004781 sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset);
drh93ec45d2013-06-17 18:20:48 +00004782 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pGroupBy, 0,
4783 WHERE_GROUPBY, 0);
drh5360ad32005-09-08 00:13:27 +00004784 if( pWInfo==0 ) goto select_end;
drh6f328482013-06-05 23:39:34 +00004785 if( sqlite3WhereIsOrdered(pWInfo) ){
drh13449892005-09-07 21:22:45 +00004786 /* The optimizer is able to deliver rows in group by order so
drhb9bb7c12006-06-11 23:41:55 +00004787 ** we do not have to sort. The OP_OpenEphemeral table will be
drh13449892005-09-07 21:22:45 +00004788 ** cancelled later because we still need to use the pKeyInfo
4789 */
drh13449892005-09-07 21:22:45 +00004790 groupBySort = 0;
4791 }else{
4792 /* Rows are coming out in undetermined order. We have to push
4793 ** each row into a sorting index, terminate the first loop,
4794 ** then loop over the sorting index in order to get the output
4795 ** in sorted order
4796 */
drh892d3172008-01-10 03:46:36 +00004797 int regBase;
4798 int regRecord;
4799 int nCol;
4800 int nGroupBy;
4801
dan2ce22452010-11-08 19:01:16 +00004802 explainTempTable(pParse,
drhe8e4af72012-09-21 00:04:28 +00004803 (sDistinct.isTnct && (p->selFlags&SF_Distinct)==0) ?
4804 "DISTINCT" : "GROUP BY");
dan2ce22452010-11-08 19:01:16 +00004805
drh13449892005-09-07 21:22:45 +00004806 groupBySort = 1;
drh892d3172008-01-10 03:46:36 +00004807 nGroupBy = pGroupBy->nExpr;
4808 nCol = nGroupBy + 1;
4809 j = nGroupBy+1;
4810 for(i=0; i<sAggInfo.nColumn; i++){
4811 if( sAggInfo.aCol[i].iSorterColumn>=j ){
4812 nCol++;
4813 j++;
4814 }
4815 }
4816 regBase = sqlite3GetTempRange(pParse, nCol);
drhceea3322009-04-23 13:22:42 +00004817 sqlite3ExprCacheClear(pParse);
drh191b54c2008-04-15 12:14:21 +00004818 sqlite3ExprCodeExprList(pParse, pGroupBy, regBase, 0);
drh892d3172008-01-10 03:46:36 +00004819 sqlite3VdbeAddOp2(v, OP_Sequence, sAggInfo.sortingIdx,regBase+nGroupBy);
4820 j = nGroupBy+1;
drh13449892005-09-07 21:22:45 +00004821 for(i=0; i<sAggInfo.nColumn; i++){
4822 struct AggInfo_col *pCol = &sAggInfo.aCol[i];
drh892d3172008-01-10 03:46:36 +00004823 if( pCol->iSorterColumn>=j ){
drhe55cbd72008-03-31 23:48:03 +00004824 int r1 = j + regBase;
drh6a012f02008-08-21 14:15:59 +00004825 int r2;
drh701bb3b2008-08-02 03:50:39 +00004826
drh6a012f02008-08-21 14:15:59 +00004827 r2 = sqlite3ExprCodeGetColumn(pParse,
drha748fdc2012-03-28 01:34:47 +00004828 pCol->pTab, pCol->iColumn, pCol->iTable, r1, 0);
drh6a012f02008-08-21 14:15:59 +00004829 if( r1!=r2 ){
4830 sqlite3VdbeAddOp2(v, OP_SCopy, r2, r1);
4831 }
4832 j++;
drh892d3172008-01-10 03:46:36 +00004833 }
drh13449892005-09-07 21:22:45 +00004834 }
drh892d3172008-01-10 03:46:36 +00004835 regRecord = sqlite3GetTempReg(pParse);
drh1db639c2008-01-17 02:36:28 +00004836 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord);
drh1c9d8352011-09-01 16:01:27 +00004837 sqlite3VdbeAddOp2(v, OP_SorterInsert, sAggInfo.sortingIdx, regRecord);
drh892d3172008-01-10 03:46:36 +00004838 sqlite3ReleaseTempReg(pParse, regRecord);
4839 sqlite3ReleaseTempRange(pParse, regBase, nCol);
drh13449892005-09-07 21:22:45 +00004840 sqlite3WhereEnd(pWInfo);
dan5134d132011-09-02 10:31:11 +00004841 sAggInfo.sortingIdxPTab = sortPTab = pParse->nTab++;
drh1c9d8352011-09-01 16:01:27 +00004842 sortOut = sqlite3GetTempReg(pParse);
4843 sqlite3VdbeAddOp3(v, OP_OpenPseudo, sortPTab, sortOut, nCol);
4844 sqlite3VdbeAddOp2(v, OP_SorterSort, sAggInfo.sortingIdx, addrEnd);
drhd4e70eb2008-01-02 00:34:36 +00004845 VdbeComment((v, "GROUP BY sort"));
drh13449892005-09-07 21:22:45 +00004846 sAggInfo.useSortingIdx = 1;
drhceea3322009-04-23 13:22:42 +00004847 sqlite3ExprCacheClear(pParse);
drh13449892005-09-07 21:22:45 +00004848 }
4849
4850 /* Evaluate the current GROUP BY terms and store in b0, b1, b2...
4851 ** (b0 is memory location iBMem+0, b1 is iBMem+1, and so forth)
4852 ** Then compare the current GROUP BY terms against the GROUP BY terms
4853 ** from the previous row currently stored in a0, a1, a2...
4854 */
4855 addrTopOfLoop = sqlite3VdbeCurrentAddr(v);
drhceea3322009-04-23 13:22:42 +00004856 sqlite3ExprCacheClear(pParse);
drh1c9d8352011-09-01 16:01:27 +00004857 if( groupBySort ){
4858 sqlite3VdbeAddOp2(v, OP_SorterData, sAggInfo.sortingIdx, sortOut);
4859 }
drh13449892005-09-07 21:22:45 +00004860 for(j=0; j<pGroupBy->nExpr; j++){
4861 if( groupBySort ){
drh1c9d8352011-09-01 16:01:27 +00004862 sqlite3VdbeAddOp3(v, OP_Column, sortPTab, j, iBMem+j);
4863 if( j==0 ) sqlite3VdbeChangeP5(v, OPFLAG_CLEARCACHE);
drh13449892005-09-07 21:22:45 +00004864 }else{
4865 sAggInfo.directMode = 1;
drh2dcef112008-01-12 19:03:48 +00004866 sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr, iBMem+j);
drh13449892005-09-07 21:22:45 +00004867 }
drh13449892005-09-07 21:22:45 +00004868 }
drh16ee60f2008-06-20 18:13:25 +00004869 sqlite3VdbeAddOp4(v, OP_Compare, iAMem, iBMem, pGroupBy->nExpr,
drh2ec2fb22013-11-06 19:59:23 +00004870 (char*)sqlite3KeyInfoRef(pKeyInfo), P4_KEYINFO);
drh16ee60f2008-06-20 18:13:25 +00004871 j1 = sqlite3VdbeCurrentAddr(v);
4872 sqlite3VdbeAddOp3(v, OP_Jump, j1+1, 0, j1+1);
drh13449892005-09-07 21:22:45 +00004873
4874 /* Generate code that runs whenever the GROUP BY changes.
drhe00ee6e2008-06-20 15:24:01 +00004875 ** Changes in the GROUP BY are detected by the previous code
drh13449892005-09-07 21:22:45 +00004876 ** block. If there were no changes, this block is skipped.
4877 **
4878 ** This code copies current group by terms in b0,b1,b2,...
4879 ** over to a0,a1,a2. It then calls the output subroutine
4880 ** and resets the aggregate accumulator registers in preparation
4881 ** for the next GROUP BY batch.
4882 */
drhb21e7c72008-06-22 12:37:57 +00004883 sqlite3ExprCodeMove(pParse, iBMem, iAMem, pGroupBy->nExpr);
drh2eb95372008-06-06 15:04:36 +00004884 sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow);
drhd4e70eb2008-01-02 00:34:36 +00004885 VdbeComment((v, "output one row"));
drh3c84ddf2008-01-09 02:15:38 +00004886 sqlite3VdbeAddOp2(v, OP_IfPos, iAbortFlag, addrEnd);
drhd4e70eb2008-01-02 00:34:36 +00004887 VdbeComment((v, "check abort flag"));
drh2eb95372008-06-06 15:04:36 +00004888 sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset);
drhd4e70eb2008-01-02 00:34:36 +00004889 VdbeComment((v, "reset accumulator"));
drh13449892005-09-07 21:22:45 +00004890
4891 /* Update the aggregate accumulators based on the content of
4892 ** the current row
4893 */
drh16ee60f2008-06-20 18:13:25 +00004894 sqlite3VdbeJumpHere(v, j1);
drh13449892005-09-07 21:22:45 +00004895 updateAccumulator(pParse, &sAggInfo);
drh4c583122008-01-04 22:01:03 +00004896 sqlite3VdbeAddOp2(v, OP_Integer, 1, iUseFlag);
drhd4e70eb2008-01-02 00:34:36 +00004897 VdbeComment((v, "indicate data in accumulator"));
drh13449892005-09-07 21:22:45 +00004898
4899 /* End of the loop
4900 */
4901 if( groupBySort ){
drh1c9d8352011-09-01 16:01:27 +00004902 sqlite3VdbeAddOp2(v, OP_SorterNext, sAggInfo.sortingIdx, addrTopOfLoop);
drh13449892005-09-07 21:22:45 +00004903 }else{
4904 sqlite3WhereEnd(pWInfo);
drh48f2d3b2011-09-16 01:34:43 +00004905 sqlite3VdbeChangeToNoop(v, addrSortingIdx);
drh13449892005-09-07 21:22:45 +00004906 }
4907
4908 /* Output the final row of result
4909 */
drh2eb95372008-06-06 15:04:36 +00004910 sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow);
drhd4e70eb2008-01-02 00:34:36 +00004911 VdbeComment((v, "output final row"));
drhd1766112008-09-17 00:13:12 +00004912
4913 /* Jump over the subroutines
4914 */
4915 sqlite3VdbeAddOp2(v, OP_Goto, 0, addrEnd);
4916
4917 /* Generate a subroutine that outputs a single row of the result
4918 ** set. This subroutine first looks at the iUseFlag. If iUseFlag
4919 ** is less than or equal to zero, the subroutine is a no-op. If
4920 ** the processing calls for the query to abort, this subroutine
4921 ** increments the iAbortFlag memory location before returning in
4922 ** order to signal the caller to abort.
4923 */
4924 addrSetAbort = sqlite3VdbeCurrentAddr(v);
4925 sqlite3VdbeAddOp2(v, OP_Integer, 1, iAbortFlag);
4926 VdbeComment((v, "set abort flag"));
4927 sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);
4928 sqlite3VdbeResolveLabel(v, addrOutputRow);
4929 addrOutputRow = sqlite3VdbeCurrentAddr(v);
4930 sqlite3VdbeAddOp2(v, OP_IfPos, iUseFlag, addrOutputRow+2);
4931 VdbeComment((v, "Groupby result generator entry point"));
4932 sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);
4933 finalizeAggFunctions(pParse, &sAggInfo);
drh33cd4902009-05-30 20:49:20 +00004934 sqlite3ExprIfFalse(pParse, pHaving, addrOutputRow+1, SQLITE_JUMPIFNULL);
drhd1766112008-09-17 00:13:12 +00004935 selectInnerLoop(pParse, p, p->pEList, 0, 0, pOrderBy,
drhe8e4af72012-09-21 00:04:28 +00004936 &sDistinct, pDest,
drhd1766112008-09-17 00:13:12 +00004937 addrOutputRow+1, addrSetAbort);
4938 sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);
4939 VdbeComment((v, "end groupby result generator"));
4940
4941 /* Generate a subroutine that will reset the group-by accumulator
4942 */
4943 sqlite3VdbeResolveLabel(v, addrReset);
4944 resetAccumulator(pParse, &sAggInfo);
4945 sqlite3VdbeAddOp1(v, OP_Return, regReset);
4946
drh43152cf2009-05-19 19:04:58 +00004947 } /* endif pGroupBy. Begin aggregate queries without GROUP BY: */
drh13449892005-09-07 21:22:45 +00004948 else {
danielk1977dba01372008-01-05 18:44:29 +00004949 ExprList *pDel = 0;
danielk1977a5533162009-02-24 10:01:51 +00004950#ifndef SQLITE_OMIT_BTREECOUNT
4951 Table *pTab;
4952 if( (pTab = isSimpleCount(p, &sAggInfo))!=0 ){
4953 /* If isSimpleCount() returns a pointer to a Table structure, then
4954 ** the SQL statement is of the form:
4955 **
4956 ** SELECT count(*) FROM <tbl>
4957 **
4958 ** where the Table structure returned represents table <tbl>.
4959 **
4960 ** This statement is so common that it is optimized specially. The
4961 ** OP_Count instruction is executed either on the intkey table that
4962 ** contains the data for table <tbl> or on one of its indexes. It
4963 ** is better to execute the op on an index, as indexes are almost
4964 ** always spread across less pages than their corresponding tables.
4965 */
4966 const int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
4967 const int iCsr = pParse->nTab++; /* Cursor to scan b-tree */
4968 Index *pIdx; /* Iterator variable */
4969 KeyInfo *pKeyInfo = 0; /* Keyinfo for scanned index */
4970 Index *pBest = 0; /* Best index found so far */
4971 int iRoot = pTab->tnum; /* Root page of scanned b-tree */
danielk1977a9d1ccb2008-01-05 17:39:29 +00004972
danielk1977a5533162009-02-24 10:01:51 +00004973 sqlite3CodeVerifySchema(pParse, iDb);
4974 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
4975
drhd9e3cad2013-10-04 02:36:19 +00004976 /* Search for the index that has the lowest scan cost.
danielk1977a5533162009-02-24 10:01:51 +00004977 **
drh3e9548b2011-04-15 14:46:27 +00004978 ** (2011-04-15) Do not do a full scan of an unordered index.
4979 **
drhabcc1942013-11-12 14:55:40 +00004980 ** (2013-10-03) Do not count the entries in a partial index.
drh5f33f372013-10-04 00:00:12 +00004981 **
danielk1977a5533162009-02-24 10:01:51 +00004982 ** In practice the KeyInfo structure will not be used. It is only
4983 ** passed to keep OP_OpenRead happy.
4984 */
drh5c7917e2013-11-12 15:33:40 +00004985 if( !HasRowid(pTab) ) pBest = sqlite3PrimaryKeyIndex(pTab);
danielk1977a5533162009-02-24 10:01:51 +00004986 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
drhd9e3cad2013-10-04 02:36:19 +00004987 if( pIdx->bUnordered==0
drhe13e9f52013-10-05 19:18:00 +00004988 && pIdx->szIdxRow<pTab->szTabRow
drhd3037a42013-10-04 18:29:25 +00004989 && pIdx->pPartIdxWhere==0
drhe13e9f52013-10-05 19:18:00 +00004990 && (!pBest || pIdx->szIdxRow<pBest->szIdxRow)
drhd9e3cad2013-10-04 02:36:19 +00004991 ){
danielk1977a5533162009-02-24 10:01:51 +00004992 pBest = pIdx;
4993 }
4994 }
drhd9e3cad2013-10-04 02:36:19 +00004995 if( pBest ){
danielk1977a5533162009-02-24 10:01:51 +00004996 iRoot = pBest->tnum;
drh2ec2fb22013-11-06 19:59:23 +00004997 pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pBest);
danielk1977a5533162009-02-24 10:01:51 +00004998 }
4999
5000 /* Open a read-only cursor, execute the OP_Count, close the cursor. */
drh261c02d2013-10-25 14:46:15 +00005001 sqlite3VdbeAddOp4Int(v, OP_OpenRead, iCsr, iRoot, iDb, 1);
danielk1977a5533162009-02-24 10:01:51 +00005002 if( pKeyInfo ){
drh2ec2fb22013-11-06 19:59:23 +00005003 sqlite3VdbeChangeP4(v, -1, (char *)pKeyInfo, P4_KEYINFO);
danielk1977a5533162009-02-24 10:01:51 +00005004 }
5005 sqlite3VdbeAddOp2(v, OP_Count, iCsr, sAggInfo.aFunc[0].iMem);
5006 sqlite3VdbeAddOp1(v, OP_Close, iCsr);
danef7075d2011-02-21 17:49:49 +00005007 explainSimpleCount(pParse, pTab, pBest);
danielk1977a5533162009-02-24 10:01:51 +00005008 }else
5009#endif /* SQLITE_OMIT_BTREECOUNT */
5010 {
5011 /* Check if the query is of one of the following forms:
5012 **
5013 ** SELECT min(x) FROM ...
5014 ** SELECT max(x) FROM ...
5015 **
5016 ** If it is, then ask the code in where.c to attempt to sort results
5017 ** as if there was an "ORDER ON x" or "ORDER ON x DESC" clause.
5018 ** If where.c is able to produce results sorted in this order, then
5019 ** add vdbe code to break out of the processing loop after the
5020 ** first iteration (since the first iteration of the loop is
5021 ** guaranteed to operate on the row with the minimum or maximum
5022 ** value of x, the only row required).
5023 **
5024 ** A special flag must be passed to sqlite3WhereBegin() to slightly
mistachkin48864df2013-03-21 21:20:32 +00005025 ** modify behavior as follows:
danielk1977a5533162009-02-24 10:01:51 +00005026 **
5027 ** + If the query is a "SELECT min(x)", then the loop coded by
5028 ** where.c should not iterate over any values with a NULL value
5029 ** for x.
5030 **
5031 ** + The optimizer code in where.c (the thing that decides which
5032 ** index or indices to use) should place a different priority on
5033 ** satisfying the 'ORDER BY' clause than it does in other cases.
5034 ** Refer to code and comments in where.c for details.
5035 */
5036 ExprList *pMinMax = 0;
dan4ac391f2012-12-13 16:37:10 +00005037 u8 flag = WHERE_ORDERBY_NORMAL;
5038
5039 assert( p->pGroupBy==0 );
5040 assert( flag==0 );
5041 if( p->pHaving==0 ){
5042 flag = minMaxQuery(&sAggInfo, &pMinMax);
5043 }
5044 assert( flag==0 || (pMinMax!=0 && pMinMax->nExpr==1) );
5045
danielk1977a5533162009-02-24 10:01:51 +00005046 if( flag ){
dan4ac391f2012-12-13 16:37:10 +00005047 pMinMax = sqlite3ExprListDup(db, pMinMax, 0);
danielk1977a5533162009-02-24 10:01:51 +00005048 pDel = pMinMax;
5049 if( pMinMax && !db->mallocFailed ){
5050 pMinMax->a[0].sortOrder = flag!=WHERE_ORDERBY_MIN ?1:0;
5051 pMinMax->a[0].pExpr->op = TK_COLUMN;
5052 }
5053 }
5054
5055 /* This case runs if the aggregate has no GROUP BY clause. The
5056 ** processing is much simpler since there is only a single row
5057 ** of output.
5058 */
5059 resetAccumulator(pParse, &sAggInfo);
drh46ec5b62012-09-24 15:30:54 +00005060 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pMinMax,0,flag,0);
danielk1977a5533162009-02-24 10:01:51 +00005061 if( pWInfo==0 ){
5062 sqlite3ExprListDelete(db, pDel);
5063 goto select_end;
5064 }
5065 updateAccumulator(pParse, &sAggInfo);
drh46c35f92012-09-26 23:17:01 +00005066 assert( pMinMax==0 || pMinMax->nExpr==1 );
drh6f328482013-06-05 23:39:34 +00005067 if( sqlite3WhereIsOrdered(pWInfo) ){
5068 sqlite3VdbeAddOp2(v, OP_Goto, 0, sqlite3WhereBreakLabel(pWInfo));
danielk1977a5533162009-02-24 10:01:51 +00005069 VdbeComment((v, "%s() by index",
5070 (flag==WHERE_ORDERBY_MIN?"min":"max")));
5071 }
5072 sqlite3WhereEnd(pWInfo);
5073 finalizeAggFunctions(pParse, &sAggInfo);
danielk1977a9d1ccb2008-01-05 17:39:29 +00005074 }
5075
danielk19777a895a82009-02-24 18:33:15 +00005076 pOrderBy = 0;
drh33cd4902009-05-30 20:49:20 +00005077 sqlite3ExprIfFalse(pParse, pHaving, addrEnd, SQLITE_JUMPIFNULL);
drhe8e4af72012-09-21 00:04:28 +00005078 selectInnerLoop(pParse, p, p->pEList, 0, 0, 0, 0,
drha9671a22008-07-08 23:40:20 +00005079 pDest, addrEnd, addrEnd);
drh633e6d52008-07-28 19:34:53 +00005080 sqlite3ExprListDelete(db, pDel);
drh13449892005-09-07 21:22:45 +00005081 }
5082 sqlite3VdbeResolveLabel(v, addrEnd);
5083
5084 } /* endif aggregate query */
drh22827922000-06-06 17:27:05 +00005085
drhe8e4af72012-09-21 00:04:28 +00005086 if( sDistinct.eTnctType==WHERE_DISTINCT_UNORDERED ){
dan2ce22452010-11-08 19:01:16 +00005087 explainTempTable(pParse, "DISTINCT");
5088 }
5089
drhcce7d172000-05-31 15:34:51 +00005090 /* If there is an ORDER BY clause, then we need to sort the results
5091 ** and send them to the callback one by one.
5092 */
5093 if( pOrderBy ){
dan2ce22452010-11-08 19:01:16 +00005094 explainTempTable(pParse, "ORDER BY");
danielk19776c8c8ce2008-01-02 16:27:09 +00005095 generateSortTail(pParse, p, v, pEList->nExpr, pDest);
drhcce7d172000-05-31 15:34:51 +00005096 }
drh6a535342001-10-19 16:44:56 +00005097
drhec7429a2005-10-06 16:53:14 +00005098 /* Jump here to skip this query
5099 */
5100 sqlite3VdbeResolveLabel(v, iEnd);
5101
drh1d83f052002-02-17 00:30:36 +00005102 /* The SELECT was successfully coded. Set the return code to 0
5103 ** to indicate no errors.
5104 */
5105 rc = 0;
5106
5107 /* Control jumps to here if an error is encountered above, or upon
5108 ** successful coding of the SELECT.
5109 */
5110select_end:
dan17c0bc02010-11-09 17:35:19 +00005111 explainSetInteger(pParse->iSelectId, iRestoreSelectId);
danielk1977955de522006-02-10 02:27:42 +00005112
drh7d10d5a2008-08-20 16:35:10 +00005113 /* Identify column names if results of the SELECT are to be output.
danielk1977955de522006-02-10 02:27:42 +00005114 */
drh7d10d5a2008-08-20 16:35:10 +00005115 if( rc==SQLITE_OK && pDest->eDest==SRT_Output ){
danielk1977955de522006-02-10 02:27:42 +00005116 generateColumnNames(pParse, pTabList, pEList);
5117 }
5118
drh633e6d52008-07-28 19:34:53 +00005119 sqlite3DbFree(db, sAggInfo.aCol);
5120 sqlite3DbFree(db, sAggInfo.aFunc);
drh1d83f052002-02-17 00:30:36 +00005121 return rc;
drhcce7d172000-05-31 15:34:51 +00005122}
drh485f0032007-01-26 19:23:33 +00005123
drh678a9aa2011-12-10 15:55:01 +00005124#if defined(SQLITE_ENABLE_TREE_EXPLAIN)
drh485f0032007-01-26 19:23:33 +00005125/*
drh7e02e5e2011-12-06 19:44:51 +00005126** Generate a human-readable description of a the Select object.
drh485f0032007-01-26 19:23:33 +00005127*/
drha84203a2011-12-07 01:23:51 +00005128static void explainOneSelect(Vdbe *pVdbe, Select *p){
drh7e02e5e2011-12-06 19:44:51 +00005129 sqlite3ExplainPrintf(pVdbe, "SELECT ");
drh4e2a9c32011-12-07 22:49:42 +00005130 if( p->selFlags & (SF_Distinct|SF_Aggregate) ){
5131 if( p->selFlags & SF_Distinct ){
5132 sqlite3ExplainPrintf(pVdbe, "DISTINCT ");
drh485f0032007-01-26 19:23:33 +00005133 }
drh4e2a9c32011-12-07 22:49:42 +00005134 if( p->selFlags & SF_Aggregate ){
5135 sqlite3ExplainPrintf(pVdbe, "agg_flag ");
5136 }
5137 sqlite3ExplainNL(pVdbe);
5138 sqlite3ExplainPrintf(pVdbe, " ");
drh485f0032007-01-26 19:23:33 +00005139 }
drh7e02e5e2011-12-06 19:44:51 +00005140 sqlite3ExplainExprList(pVdbe, p->pEList);
5141 sqlite3ExplainNL(pVdbe);
drh7e02e5e2011-12-06 19:44:51 +00005142 if( p->pSrc && p->pSrc->nSrc ){
drh485f0032007-01-26 19:23:33 +00005143 int i;
drha84203a2011-12-07 01:23:51 +00005144 sqlite3ExplainPrintf(pVdbe, "FROM ");
drh7e02e5e2011-12-06 19:44:51 +00005145 sqlite3ExplainPush(pVdbe);
drh485f0032007-01-26 19:23:33 +00005146 for(i=0; i<p->pSrc->nSrc; i++){
5147 struct SrcList_item *pItem = &p->pSrc->a[i];
drh04b83422011-12-07 15:33:14 +00005148 sqlite3ExplainPrintf(pVdbe, "{%d,*} = ", pItem->iCursor);
drh485f0032007-01-26 19:23:33 +00005149 if( pItem->pSelect ){
drh7e02e5e2011-12-06 19:44:51 +00005150 sqlite3ExplainSelect(pVdbe, pItem->pSelect);
drh04b83422011-12-07 15:33:14 +00005151 if( pItem->pTab ){
5152 sqlite3ExplainPrintf(pVdbe, " (tabname=%s)", pItem->pTab->zName);
5153 }
drh485f0032007-01-26 19:23:33 +00005154 }else if( pItem->zName ){
drh7e02e5e2011-12-06 19:44:51 +00005155 sqlite3ExplainPrintf(pVdbe, "%s", pItem->zName);
drh485f0032007-01-26 19:23:33 +00005156 }
5157 if( pItem->zAlias ){
drh04b83422011-12-07 15:33:14 +00005158 sqlite3ExplainPrintf(pVdbe, " (AS %s)", pItem->zAlias);
drh485f0032007-01-26 19:23:33 +00005159 }
drha84203a2011-12-07 01:23:51 +00005160 if( pItem->jointype & JT_LEFT ){
5161 sqlite3ExplainPrintf(pVdbe, " LEFT-JOIN");
drh485f0032007-01-26 19:23:33 +00005162 }
drh7e02e5e2011-12-06 19:44:51 +00005163 sqlite3ExplainNL(pVdbe);
drh485f0032007-01-26 19:23:33 +00005164 }
drh7e02e5e2011-12-06 19:44:51 +00005165 sqlite3ExplainPop(pVdbe);
drh485f0032007-01-26 19:23:33 +00005166 }
5167 if( p->pWhere ){
drha84203a2011-12-07 01:23:51 +00005168 sqlite3ExplainPrintf(pVdbe, "WHERE ");
drh7e02e5e2011-12-06 19:44:51 +00005169 sqlite3ExplainExpr(pVdbe, p->pWhere);
5170 sqlite3ExplainNL(pVdbe);
drh485f0032007-01-26 19:23:33 +00005171 }
5172 if( p->pGroupBy ){
drha84203a2011-12-07 01:23:51 +00005173 sqlite3ExplainPrintf(pVdbe, "GROUPBY ");
drh7e02e5e2011-12-06 19:44:51 +00005174 sqlite3ExplainExprList(pVdbe, p->pGroupBy);
5175 sqlite3ExplainNL(pVdbe);
drh485f0032007-01-26 19:23:33 +00005176 }
5177 if( p->pHaving ){
drh7e02e5e2011-12-06 19:44:51 +00005178 sqlite3ExplainPrintf(pVdbe, "HAVING ");
5179 sqlite3ExplainExpr(pVdbe, p->pHaving);
5180 sqlite3ExplainNL(pVdbe);
drh485f0032007-01-26 19:23:33 +00005181 }
5182 if( p->pOrderBy ){
drha84203a2011-12-07 01:23:51 +00005183 sqlite3ExplainPrintf(pVdbe, "ORDERBY ");
drh7e02e5e2011-12-06 19:44:51 +00005184 sqlite3ExplainExprList(pVdbe, p->pOrderBy);
5185 sqlite3ExplainNL(pVdbe);
drh485f0032007-01-26 19:23:33 +00005186 }
drha84203a2011-12-07 01:23:51 +00005187 if( p->pLimit ){
5188 sqlite3ExplainPrintf(pVdbe, "LIMIT ");
5189 sqlite3ExplainExpr(pVdbe, p->pLimit);
5190 sqlite3ExplainNL(pVdbe);
5191 }
5192 if( p->pOffset ){
5193 sqlite3ExplainPrintf(pVdbe, "OFFSET ");
5194 sqlite3ExplainExpr(pVdbe, p->pOffset);
5195 sqlite3ExplainNL(pVdbe);
drh485f0032007-01-26 19:23:33 +00005196 }
5197}
drha84203a2011-12-07 01:23:51 +00005198void sqlite3ExplainSelect(Vdbe *pVdbe, Select *p){
5199 if( p==0 ){
5200 sqlite3ExplainPrintf(pVdbe, "(null-select)");
5201 return;
5202 }
drh47f22392013-01-28 22:52:34 +00005203 while( p->pPrior ){
5204 p->pPrior->pNext = p;
5205 p = p->pPrior;
5206 }
drha84203a2011-12-07 01:23:51 +00005207 sqlite3ExplainPush(pVdbe);
5208 while( p ){
5209 explainOneSelect(pVdbe, p);
5210 p = p->pNext;
5211 if( p==0 ) break;
5212 sqlite3ExplainNL(pVdbe);
5213 sqlite3ExplainPrintf(pVdbe, "%s\n", selectOpName(p->op));
5214 }
5215 sqlite3ExplainPrintf(pVdbe, "END");
5216 sqlite3ExplainPop(pVdbe);
drh485f0032007-01-26 19:23:33 +00005217}
drh7e02e5e2011-12-06 19:44:51 +00005218
drh485f0032007-01-26 19:23:33 +00005219/* End of the structure debug printing code
5220*****************************************************************************/
mistachkin14a55b72012-01-18 01:09:57 +00005221#endif /* defined(SQLITE_ENABLE_TREE_EXPLAIN) */