1 /*
2 ** 2001 September 15
3 **
4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
6 **
7 ** May you do good and not evil.
8 ** May you find forgiveness for yourself and forgive others.
9 ** May you share freely, never taking more than you give.
10 **
11 *************************************************************************
12 ** This file contains C code routines that are called by the parser
13 ** to handle SELECT statements in SQLite.
14 */
15 #include "sqliteInt.h"
16
17 /*
18 ** Trace output macros
19 */
20 #if SELECTTRACE_ENABLED
21 /***/ int sqlite3SelectTrace = 0;
22 # define SELECTTRACE(K,P,S,X) \
23 if(sqlite3SelectTrace&(K)) \
24 sqlite3DebugPrintf("%u/%d/%p: ",(S)->selId,(P)->addrExplain,(S)),\
25 sqlite3DebugPrintf X
26 #else
27 # define SELECTTRACE(K,P,S,X)
28 #endif
29
30
31 /*
32 ** An instance of the following object is used to record information about
33 ** how to process the DISTINCT keyword, to simplify passing that information
34 ** into the selectInnerLoop() routine.
35 */
36 typedef struct DistinctCtx DistinctCtx;
37 struct DistinctCtx {
38 u8 isTnct; /* True if the DISTINCT keyword is present */
39 u8 eTnctType; /* One of the WHERE_DISTINCT_* operators */
40 int tabTnct; /* Ephemeral table used for DISTINCT processing */
41 int addrTnct; /* Address of OP_OpenEphemeral opcode for tabTnct */
42 };
43
44 /*
45 ** An instance of the following object is used to record information about
46 ** the ORDER BY (or GROUP BY) clause of query is being coded.
47 **
48 ** The aDefer[] array is used by the sorter-references optimization. For
49 ** example, assuming there is no index that can be used for the ORDER BY,
50 ** for the query:
51 **
52 ** SELECT a, bigblob FROM t1 ORDER BY a LIMIT 10;
53 **
54 ** it may be more efficient to add just the "a" values to the sorter, and
55 ** retrieve the associated "bigblob" values directly from table t1 as the
56 ** 10 smallest "a" values are extracted from the sorter.
57 **
58 ** When the sorter-reference optimization is used, there is one entry in the
59 ** aDefer[] array for each database table that may be read as values are
60 ** extracted from the sorter.
61 */
62 typedef struct SortCtx SortCtx;
63 struct SortCtx {
64 ExprList *pOrderBy; /* The ORDER BY (or GROUP BY clause) */
65 int nOBSat; /* Number of ORDER BY terms satisfied by indices */
66 int iECursor; /* Cursor number for the sorter */
67 int regReturn; /* Register holding block-output return address */
68 int labelBkOut; /* Start label for the block-output subroutine */
69 int addrSortIndex; /* Address of the OP_SorterOpen or OP_OpenEphemeral */
70 int labelDone; /* Jump here when done, ex: LIMIT reached */
71 int labelOBLopt; /* Jump here when sorter is full */
72 u8 sortFlags; /* Zero or more SORTFLAG_* bits */
73 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
74 u8 nDefer; /* Number of valid entries in aDefer[] */
75 struct DeferredCsr {
76 Table *pTab; /* Table definition */
77 int iCsr; /* Cursor number for table */
78 int nKey; /* Number of PK columns for table pTab (>=1) */
79 } aDefer[4];
80 #endif
81 struct RowLoadInfo *pDeferredRowLoad; /* Deferred row loading info or NULL */
82 };
83 #define SORTFLAG_UseSorter 0x01 /* Use SorterOpen instead of OpenEphemeral */
84
85 /*
86 ** Delete all the content of a Select structure. Deallocate the structure
87 ** itself depending on the value of bFree
88 **
89 ** If bFree==1, call sqlite3DbFree() on the p object.
90 ** If bFree==0, Leave the first Select object unfreed
91 */
clearSelect(sqlite3 * db,Select * p,int bFree)92 static void clearSelect(sqlite3 *db, Select *p, int bFree){
93 while( p ){
94 Select *pPrior = p->pPrior;
95 sqlite3ExprListDelete(db, p->pEList);
96 sqlite3SrcListDelete(db, p->pSrc);
97 sqlite3ExprDelete(db, p->pWhere);
98 sqlite3ExprListDelete(db, p->pGroupBy);
99 sqlite3ExprDelete(db, p->pHaving);
100 sqlite3ExprListDelete(db, p->pOrderBy);
101 sqlite3ExprDelete(db, p->pLimit);
102 #ifndef SQLITE_OMIT_WINDOWFUNC
103 if( OK_IF_ALWAYS_TRUE(p->pWinDefn) ){
104 sqlite3WindowListDelete(db, p->pWinDefn);
105 }
106 assert( p->pWin==0 );
107 #endif
108 if( OK_IF_ALWAYS_TRUE(p->pWith) ) sqlite3WithDelete(db, p->pWith);
109 if( bFree ) sqlite3DbFreeNN(db, p);
110 p = pPrior;
111 bFree = 1;
112 }
113 }
114
115 /*
116 ** Initialize a SelectDest structure.
117 */
sqlite3SelectDestInit(SelectDest * pDest,int eDest,int iParm)118 void sqlite3SelectDestInit(SelectDest *pDest, int eDest, int iParm){
119 pDest->eDest = (u8)eDest;
120 pDest->iSDParm = iParm;
121 pDest->zAffSdst = 0;
122 pDest->iSdst = 0;
123 pDest->nSdst = 0;
124 }
125
126
127 /*
128 ** Allocate a new Select structure and return a pointer to that
129 ** structure.
130 */
sqlite3SelectNew(Parse * pParse,ExprList * pEList,SrcList * pSrc,Expr * pWhere,ExprList * pGroupBy,Expr * pHaving,ExprList * pOrderBy,u32 selFlags,Expr * pLimit)131 Select *sqlite3SelectNew(
132 Parse *pParse, /* Parsing context */
133 ExprList *pEList, /* which columns to include in the result */
134 SrcList *pSrc, /* the FROM clause -- which tables to scan */
135 Expr *pWhere, /* the WHERE clause */
136 ExprList *pGroupBy, /* the GROUP BY clause */
137 Expr *pHaving, /* the HAVING clause */
138 ExprList *pOrderBy, /* the ORDER BY clause */
139 u32 selFlags, /* Flag parameters, such as SF_Distinct */
140 Expr *pLimit /* LIMIT value. NULL means not used */
141 ){
142 Select *pNew;
143 Select standin;
144 pNew = sqlite3DbMallocRawNN(pParse->db, sizeof(*pNew) );
145 if( pNew==0 ){
146 assert( pParse->db->mallocFailed );
147 pNew = &standin;
148 }
149 if( pEList==0 ){
150 pEList = sqlite3ExprListAppend(pParse, 0,
151 sqlite3Expr(pParse->db,TK_ASTERISK,0));
152 }
153 pNew->pEList = pEList;
154 pNew->op = TK_SELECT;
155 pNew->selFlags = selFlags;
156 pNew->iLimit = 0;
157 pNew->iOffset = 0;
158 pNew->selId = ++pParse->nSelect;
159 pNew->addrOpenEphm[0] = -1;
160 pNew->addrOpenEphm[1] = -1;
161 pNew->nSelectRow = 0;
162 if( pSrc==0 ) pSrc = sqlite3DbMallocZero(pParse->db, sizeof(*pSrc));
163 pNew->pSrc = pSrc;
164 pNew->pWhere = pWhere;
165 pNew->pGroupBy = pGroupBy;
166 pNew->pHaving = pHaving;
167 pNew->pOrderBy = pOrderBy;
168 pNew->pPrior = 0;
169 pNew->pNext = 0;
170 pNew->pLimit = pLimit;
171 pNew->pWith = 0;
172 #ifndef SQLITE_OMIT_WINDOWFUNC
173 pNew->pWin = 0;
174 pNew->pWinDefn = 0;
175 #endif
176 if( pParse->db->mallocFailed ) {
177 clearSelect(pParse->db, pNew, pNew!=&standin);
178 pNew = 0;
179 }else{
180 assert( pNew->pSrc!=0 || pParse->nErr>0 );
181 }
182 assert( pNew!=&standin );
183 return pNew;
184 }
185
186
187 /*
188 ** Delete the given Select structure and all of its substructures.
189 */
sqlite3SelectDelete(sqlite3 * db,Select * p)190 void sqlite3SelectDelete(sqlite3 *db, Select *p){
191 if( OK_IF_ALWAYS_TRUE(p) ) clearSelect(db, p, 1);
192 }
193
194 /*
195 ** Delete all the substructure for p, but keep p allocated. Redefine
196 ** p to be a single SELECT where every column of the result set has a
197 ** value of NULL.
198 */
sqlite3SelectReset(Parse * pParse,Select * p)199 void sqlite3SelectReset(Parse *pParse, Select *p){
200 if( ALWAYS(p) ){
201 clearSelect(pParse->db, p, 0);
202 memset(&p->iLimit, 0, sizeof(Select) - offsetof(Select,iLimit));
203 p->pEList = sqlite3ExprListAppend(pParse, 0,
204 sqlite3ExprAlloc(pParse->db,TK_NULL,0,0));
205 p->pSrc = sqlite3DbMallocZero(pParse->db, sizeof(SrcList));
206 }
207 }
208
209 /*
210 ** Return a pointer to the right-most SELECT statement in a compound.
211 */
findRightmost(Select * p)212 static Select *findRightmost(Select *p){
213 while( p->pNext ) p = p->pNext;
214 return p;
215 }
216
217 /*
218 ** Given 1 to 3 identifiers preceding the JOIN keyword, determine the
219 ** type of join. Return an integer constant that expresses that type
220 ** in terms of the following bit values:
221 **
222 ** JT_INNER
223 ** JT_CROSS
224 ** JT_OUTER
225 ** JT_NATURAL
226 ** JT_LEFT
227 ** JT_RIGHT
228 **
229 ** A full outer join is the combination of JT_LEFT and JT_RIGHT.
230 **
231 ** If an illegal or unsupported join type is seen, then still return
232 ** a join type, but put an error in the pParse structure.
233 */
sqlite3JoinType(Parse * pParse,Token * pA,Token * pB,Token * pC)234 int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){
235 int jointype = 0;
236 Token *apAll[3];
237 Token *p;
238 /* 0123456789 123456789 123456789 123 */
239 static const char zKeyText[] = "naturaleftouterightfullinnercross";
240 static const struct {
241 u8 i; /* Beginning of keyword text in zKeyText[] */
242 u8 nChar; /* Length of the keyword in characters */
243 u8 code; /* Join type mask */
244 } aKeyword[] = {
245 /* natural */ { 0, 7, JT_NATURAL },
246 /* left */ { 6, 4, JT_LEFT|JT_OUTER },
247 /* outer */ { 10, 5, JT_OUTER },
248 /* right */ { 14, 5, JT_RIGHT|JT_OUTER },
249 /* full */ { 19, 4, JT_LEFT|JT_RIGHT|JT_OUTER },
250 /* inner */ { 23, 5, JT_INNER },
251 /* cross */ { 28, 5, JT_INNER|JT_CROSS },
252 };
253 int i, j;
254 apAll[0] = pA;
255 apAll[1] = pB;
256 apAll[2] = pC;
257 for(i=0; i<3 && apAll[i]; i++){
258 p = apAll[i];
259 for(j=0; j<ArraySize(aKeyword); j++){
260 if( p->n==aKeyword[j].nChar
261 && sqlite3StrNICmp((char*)p->z, &zKeyText[aKeyword[j].i], p->n)==0 ){
262 jointype |= aKeyword[j].code;
263 break;
264 }
265 }
266 testcase( j==0 || j==1 || j==2 || j==3 || j==4 || j==5 || j==6 );
267 if( j>=ArraySize(aKeyword) ){
268 jointype |= JT_ERROR;
269 break;
270 }
271 }
272 if(
273 (jointype & (JT_INNER|JT_OUTER))==(JT_INNER|JT_OUTER) ||
274 (jointype & JT_ERROR)!=0
275 ){
276 const char *zSp = " ";
277 assert( pB!=0 );
278 if( pC==0 ){ zSp++; }
279 sqlite3ErrorMsg(pParse, "unknown or unsupported join type: "
280 "%T %T%s%T", pA, pB, zSp, pC);
281 jointype = JT_INNER;
282 }else if( (jointype & JT_OUTER)!=0
283 && (jointype & (JT_LEFT|JT_RIGHT))!=JT_LEFT ){
284 sqlite3ErrorMsg(pParse,
285 "RIGHT and FULL OUTER JOINs are not currently supported");
286 jointype = JT_INNER;
287 }
288 return jointype;
289 }
290
291 /*
292 ** Return the index of a column in a table. Return -1 if the column
293 ** is not contained in the table.
294 */
columnIndex(Table * pTab,const char * zCol)295 static int columnIndex(Table *pTab, const char *zCol){
296 int i;
297 for(i=0; i<pTab->nCol; i++){
298 if( sqlite3StrICmp(pTab->aCol[i].zName, zCol)==0 ) return i;
299 }
300 return -1;
301 }
302
303 /*
304 ** Search the first N tables in pSrc, from left to right, looking for a
305 ** table that has a column named zCol.
306 **
307 ** When found, set *piTab and *piCol to the table index and column index
308 ** of the matching column and return TRUE.
309 **
310 ** If not found, return FALSE.
311 */
tableAndColumnIndex(SrcList * pSrc,int N,const char * zCol,int * piTab,int * piCol,int bIgnoreHidden)312 static int tableAndColumnIndex(
313 SrcList *pSrc, /* Array of tables to search */
314 int N, /* Number of tables in pSrc->a[] to search */
315 const char *zCol, /* Name of the column we are looking for */
316 int *piTab, /* Write index of pSrc->a[] here */
317 int *piCol, /* Write index of pSrc->a[*piTab].pTab->aCol[] here */
318 int bIgnoreHidden /* True to ignore hidden columns */
319 ){
320 int i; /* For looping over tables in pSrc */
321 int iCol; /* Index of column matching zCol */
322
323 assert( (piTab==0)==(piCol==0) ); /* Both or neither are NULL */
324 for(i=0; i<N; i++){
325 iCol = columnIndex(pSrc->a[i].pTab, zCol);
326 if( iCol>=0
327 && (bIgnoreHidden==0 || IsHiddenColumn(&pSrc->a[i].pTab->aCol[iCol])==0)
328 ){
329 if( piTab ){
330 *piTab = i;
331 *piCol = iCol;
332 }
333 return 1;
334 }
335 }
336 return 0;
337 }
338
339 /*
340 ** This function is used to add terms implied by JOIN syntax to the
341 ** WHERE clause expression of a SELECT statement. The new term, which
342 ** is ANDed with the existing WHERE clause, is of the form:
343 **
344 ** (tab1.col1 = tab2.col2)
345 **
346 ** where tab1 is the iSrc'th table in SrcList pSrc and tab2 is the
347 ** (iSrc+1)'th. Column col1 is column iColLeft of tab1, and col2 is
348 ** column iColRight of tab2.
349 */
addWhereTerm(Parse * pParse,SrcList * pSrc,int iLeft,int iColLeft,int iRight,int iColRight,int isOuterJoin,Expr ** ppWhere)350 static void addWhereTerm(
351 Parse *pParse, /* Parsing context */
352 SrcList *pSrc, /* List of tables in FROM clause */
353 int iLeft, /* Index of first table to join in pSrc */
354 int iColLeft, /* Index of column in first table */
355 int iRight, /* Index of second table in pSrc */
356 int iColRight, /* Index of column in second table */
357 int isOuterJoin, /* True if this is an OUTER join */
358 Expr **ppWhere /* IN/OUT: The WHERE clause to add to */
359 ){
360 sqlite3 *db = pParse->db;
361 Expr *pE1;
362 Expr *pE2;
363 Expr *pEq;
364
365 assert( iLeft<iRight );
366 assert( pSrc->nSrc>iRight );
367 assert( pSrc->a[iLeft].pTab );
368 assert( pSrc->a[iRight].pTab );
369
370 pE1 = sqlite3CreateColumnExpr(db, pSrc, iLeft, iColLeft);
371 pE2 = sqlite3CreateColumnExpr(db, pSrc, iRight, iColRight);
372
373 pEq = sqlite3PExpr(pParse, TK_EQ, pE1, pE2);
374 if( pEq && isOuterJoin ){
375 ExprSetProperty(pEq, EP_FromJoin);
376 assert( !ExprHasProperty(pEq, EP_TokenOnly|EP_Reduced) );
377 ExprSetVVAProperty(pEq, EP_NoReduce);
378 pEq->iRightJoinTable = (i16)pE2->iTable;
379 }
380 *ppWhere = sqlite3ExprAnd(pParse, *ppWhere, pEq);
381 }
382
383 /*
384 ** Set the EP_FromJoin property on all terms of the given expression.
385 ** And set the Expr.iRightJoinTable to iTable for every term in the
386 ** expression.
387 **
388 ** The EP_FromJoin property is used on terms of an expression to tell
389 ** the LEFT OUTER JOIN processing logic that this term is part of the
390 ** join restriction specified in the ON or USING clause and not a part
391 ** of the more general WHERE clause. These terms are moved over to the
392 ** WHERE clause during join processing but we need to remember that they
393 ** originated in the ON or USING clause.
394 **
395 ** The Expr.iRightJoinTable tells the WHERE clause processing that the
396 ** expression depends on table iRightJoinTable even if that table is not
397 ** explicitly mentioned in the expression. That information is needed
398 ** for cases like this:
399 **
400 ** SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.b AND t1.x=5
401 **
402 ** The where clause needs to defer the handling of the t1.x=5
403 ** term until after the t2 loop of the join. In that way, a
404 ** NULL t2 row will be inserted whenever t1.x!=5. If we do not
405 ** defer the handling of t1.x=5, it will be processed immediately
406 ** after the t1 loop and rows with t1.x!=5 will never appear in
407 ** the output, which is incorrect.
408 */
sqlite3SetJoinExpr(Expr * p,int iTable)409 void sqlite3SetJoinExpr(Expr *p, int iTable){
410 while( p ){
411 ExprSetProperty(p, EP_FromJoin);
412 assert( !ExprHasProperty(p, EP_TokenOnly|EP_Reduced) );
413 ExprSetVVAProperty(p, EP_NoReduce);
414 p->iRightJoinTable = (i16)iTable;
415 if( p->op==TK_FUNCTION && p->x.pList ){
416 int i;
417 for(i=0; i<p->x.pList->nExpr; i++){
418 sqlite3SetJoinExpr(p->x.pList->a[i].pExpr, iTable);
419 }
420 }
421 sqlite3SetJoinExpr(p->pLeft, iTable);
422 p = p->pRight;
423 }
424 }
425
426 /* Undo the work of sqlite3SetJoinExpr(). In the expression p, convert every
427 ** term that is marked with EP_FromJoin and iRightJoinTable==iTable into
428 ** an ordinary term that omits the EP_FromJoin mark.
429 **
430 ** This happens when a LEFT JOIN is simplified into an ordinary JOIN.
431 */
unsetJoinExpr(Expr * p,int iTable)432 static void unsetJoinExpr(Expr *p, int iTable){
433 while( p ){
434 if( ExprHasProperty(p, EP_FromJoin)
435 && (iTable<0 || p->iRightJoinTable==iTable) ){
436 ExprClearProperty(p, EP_FromJoin);
437 }
438 if( p->op==TK_FUNCTION && p->x.pList ){
439 int i;
440 for(i=0; i<p->x.pList->nExpr; i++){
441 unsetJoinExpr(p->x.pList->a[i].pExpr, iTable);
442 }
443 }
444 unsetJoinExpr(p->pLeft, iTable);
445 p = p->pRight;
446 }
447 }
448
449 /*
450 ** This routine processes the join information for a SELECT statement.
451 ** ON and USING clauses are converted into extra terms of the WHERE clause.
452 ** NATURAL joins also create extra WHERE clause terms.
453 **
454 ** The terms of a FROM clause are contained in the Select.pSrc structure.
455 ** The left most table is the first entry in Select.pSrc. The right-most
456 ** table is the last entry. The join operator is held in the entry to
457 ** the left. Thus entry 0 contains the join operator for the join between
458 ** entries 0 and 1. Any ON or USING clauses associated with the join are
459 ** also attached to the left entry.
460 **
461 ** This routine returns the number of errors encountered.
462 */
sqliteProcessJoin(Parse * pParse,Select * p)463 static int sqliteProcessJoin(Parse *pParse, Select *p){
464 SrcList *pSrc; /* All tables in the FROM clause */
465 int i, j; /* Loop counters */
466 struct SrcList_item *pLeft; /* Left table being joined */
467 struct SrcList_item *pRight; /* Right table being joined */
468
469 pSrc = p->pSrc;
470 pLeft = &pSrc->a[0];
471 pRight = &pLeft[1];
472 for(i=0; i<pSrc->nSrc-1; i++, pRight++, pLeft++){
473 Table *pRightTab = pRight->pTab;
474 int isOuter;
475
476 if( NEVER(pLeft->pTab==0 || pRightTab==0) ) continue;
477 isOuter = (pRight->fg.jointype & JT_OUTER)!=0;
478
479 /* When the NATURAL keyword is present, add WHERE clause terms for
480 ** every column that the two tables have in common.
481 */
482 if( pRight->fg.jointype & JT_NATURAL ){
483 if( pRight->pOn || pRight->pUsing ){
484 sqlite3ErrorMsg(pParse, "a NATURAL join may not have "
485 "an ON or USING clause", 0);
486 return 1;
487 }
488 for(j=0; j<pRightTab->nCol; j++){
489 char *zName; /* Name of column in the right table */
490 int iLeft; /* Matching left table */
491 int iLeftCol; /* Matching column in the left table */
492
493 if( IsHiddenColumn(&pRightTab->aCol[j]) ) continue;
494 zName = pRightTab->aCol[j].zName;
495 if( tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol, 1) ){
496 addWhereTerm(pParse, pSrc, iLeft, iLeftCol, i+1, j,
497 isOuter, &p->pWhere);
498 }
499 }
500 }
501
502 /* Disallow both ON and USING clauses in the same join
503 */
504 if( pRight->pOn && pRight->pUsing ){
505 sqlite3ErrorMsg(pParse, "cannot have both ON and USING "
506 "clauses in the same join");
507 return 1;
508 }
509
510 /* Add the ON clause to the end of the WHERE clause, connected by
511 ** an AND operator.
512 */
513 if( pRight->pOn ){
514 if( isOuter ) sqlite3SetJoinExpr(pRight->pOn, pRight->iCursor);
515 p->pWhere = sqlite3ExprAnd(pParse, p->pWhere, pRight->pOn);
516 pRight->pOn = 0;
517 }
518
519 /* Create extra terms on the WHERE clause for each column named
520 ** in the USING clause. Example: If the two tables to be joined are
521 ** A and B and the USING clause names X, Y, and Z, then add this
522 ** to the WHERE clause: A.X=B.X AND A.Y=B.Y AND A.Z=B.Z
523 ** Report an error if any column mentioned in the USING clause is
524 ** not contained in both tables to be joined.
525 */
526 if( pRight->pUsing ){
527 IdList *pList = pRight->pUsing;
528 for(j=0; j<pList->nId; j++){
529 char *zName; /* Name of the term in the USING clause */
530 int iLeft; /* Table on the left with matching column name */
531 int iLeftCol; /* Column number of matching column on the left */
532 int iRightCol; /* Column number of matching column on the right */
533
534 zName = pList->a[j].zName;
535 iRightCol = columnIndex(pRightTab, zName);
536 if( iRightCol<0
537 || !tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol, 0)
538 ){
539 sqlite3ErrorMsg(pParse, "cannot join using column %s - column "
540 "not present in both tables", zName);
541 return 1;
542 }
543 addWhereTerm(pParse, pSrc, iLeft, iLeftCol, i+1, iRightCol,
544 isOuter, &p->pWhere);
545 }
546 }
547 }
548 return 0;
549 }
550
551 /*
552 ** An instance of this object holds information (beyond pParse and pSelect)
553 ** needed to load the next result row that is to be added to the sorter.
554 */
555 typedef struct RowLoadInfo RowLoadInfo;
556 struct RowLoadInfo {
557 int regResult; /* Store results in array of registers here */
558 u8 ecelFlags; /* Flag argument to ExprCodeExprList() */
559 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
560 ExprList *pExtra; /* Extra columns needed by sorter refs */
561 int regExtraResult; /* Where to load the extra columns */
562 #endif
563 };
564
565 /*
566 ** This routine does the work of loading query data into an array of
567 ** registers so that it can be added to the sorter.
568 */
innerLoopLoadRow(Parse * pParse,Select * pSelect,RowLoadInfo * pInfo)569 static void innerLoopLoadRow(
570 Parse *pParse, /* Statement under construction */
571 Select *pSelect, /* The query being coded */
572 RowLoadInfo *pInfo /* Info needed to complete the row load */
573 ){
574 sqlite3ExprCodeExprList(pParse, pSelect->pEList, pInfo->regResult,
575 0, pInfo->ecelFlags);
576 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
577 if( pInfo->pExtra ){
578 sqlite3ExprCodeExprList(pParse, pInfo->pExtra, pInfo->regExtraResult, 0, 0);
579 sqlite3ExprListDelete(pParse->db, pInfo->pExtra);
580 }
581 #endif
582 }
583
584 /*
585 ** Code the OP_MakeRecord instruction that generates the entry to be
586 ** added into the sorter.
587 **
588 ** Return the register in which the result is stored.
589 */
makeSorterRecord(Parse * pParse,SortCtx * pSort,Select * pSelect,int regBase,int nBase)590 static int makeSorterRecord(
591 Parse *pParse,
592 SortCtx *pSort,
593 Select *pSelect,
594 int regBase,
595 int nBase
596 ){
597 int nOBSat = pSort->nOBSat;
598 Vdbe *v = pParse->pVdbe;
599 int regOut = ++pParse->nMem;
600 if( pSort->pDeferredRowLoad ){
601 innerLoopLoadRow(pParse, pSelect, pSort->pDeferredRowLoad);
602 }
603 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase+nOBSat, nBase-nOBSat, regOut);
604 return regOut;
605 }
606
607 /*
608 ** Generate code that will push the record in registers regData
609 ** through regData+nData-1 onto the sorter.
610 */
pushOntoSorter(Parse * pParse,SortCtx * pSort,Select * pSelect,int regData,int regOrigData,int nData,int nPrefixReg)611 static void pushOntoSorter(
612 Parse *pParse, /* Parser context */
613 SortCtx *pSort, /* Information about the ORDER BY clause */
614 Select *pSelect, /* The whole SELECT statement */
615 int regData, /* First register holding data to be sorted */
616 int regOrigData, /* First register holding data before packing */
617 int nData, /* Number of elements in the regData data array */
618 int nPrefixReg /* No. of reg prior to regData available for use */
619 ){
620 Vdbe *v = pParse->pVdbe; /* Stmt under construction */
621 int bSeq = ((pSort->sortFlags & SORTFLAG_UseSorter)==0);
622 int nExpr = pSort->pOrderBy->nExpr; /* No. of ORDER BY terms */
623 int nBase = nExpr + bSeq + nData; /* Fields in sorter record */
624 int regBase; /* Regs for sorter record */
625 int regRecord = 0; /* Assembled sorter record */
626 int nOBSat = pSort->nOBSat; /* ORDER BY terms to skip */
627 int op; /* Opcode to add sorter record to sorter */
628 int iLimit; /* LIMIT counter */
629 int iSkip = 0; /* End of the sorter insert loop */
630
631 assert( bSeq==0 || bSeq==1 );
632
633 /* Three cases:
634 ** (1) The data to be sorted has already been packed into a Record
635 ** by a prior OP_MakeRecord. In this case nData==1 and regData
636 ** will be completely unrelated to regOrigData.
637 ** (2) All output columns are included in the sort record. In that
638 ** case regData==regOrigData.
639 ** (3) Some output columns are omitted from the sort record due to
640 ** the SQLITE_ENABLE_SORTER_REFERENCE optimization, or due to the
641 ** SQLITE_ECEL_OMITREF optimization, or due to the
642 ** SortCtx.pDeferredRowLoad optimiation. In any of these cases
643 ** regOrigData is 0 to prevent this routine from trying to copy
644 ** values that might not yet exist.
645 */
646 assert( nData==1 || regData==regOrigData || regOrigData==0 );
647
648 if( nPrefixReg ){
649 assert( nPrefixReg==nExpr+bSeq );
650 regBase = regData - nPrefixReg;
651 }else{
652 regBase = pParse->nMem + 1;
653 pParse->nMem += nBase;
654 }
655 assert( pSelect->iOffset==0 || pSelect->iLimit!=0 );
656 iLimit = pSelect->iOffset ? pSelect->iOffset+1 : pSelect->iLimit;
657 pSort->labelDone = sqlite3VdbeMakeLabel(pParse);
658 sqlite3ExprCodeExprList(pParse, pSort->pOrderBy, regBase, regOrigData,
659 SQLITE_ECEL_DUP | (regOrigData? SQLITE_ECEL_REF : 0));
660 if( bSeq ){
661 sqlite3VdbeAddOp2(v, OP_Sequence, pSort->iECursor, regBase+nExpr);
662 }
663 if( nPrefixReg==0 && nData>0 ){
664 sqlite3ExprCodeMove(pParse, regData, regBase+nExpr+bSeq, nData);
665 }
666 if( nOBSat>0 ){
667 int regPrevKey; /* The first nOBSat columns of the previous row */
668 int addrFirst; /* Address of the OP_IfNot opcode */
669 int addrJmp; /* Address of the OP_Jump opcode */
670 VdbeOp *pOp; /* Opcode that opens the sorter */
671 int nKey; /* Number of sorting key columns, including OP_Sequence */
672 KeyInfo *pKI; /* Original KeyInfo on the sorter table */
673
674 regRecord = makeSorterRecord(pParse, pSort, pSelect, regBase, nBase);
675 regPrevKey = pParse->nMem+1;
676 pParse->nMem += pSort->nOBSat;
677 nKey = nExpr - pSort->nOBSat + bSeq;
678 if( bSeq ){
679 addrFirst = sqlite3VdbeAddOp1(v, OP_IfNot, regBase+nExpr);
680 }else{
681 addrFirst = sqlite3VdbeAddOp1(v, OP_SequenceTest, pSort->iECursor);
682 }
683 VdbeCoverage(v);
684 sqlite3VdbeAddOp3(v, OP_Compare, regPrevKey, regBase, pSort->nOBSat);
685 pOp = sqlite3VdbeGetOp(v, pSort->addrSortIndex);
686 if( pParse->db->mallocFailed ) return;
687 pOp->p2 = nKey + nData;
688 pKI = pOp->p4.pKeyInfo;
689 memset(pKI->aSortFlags, 0, pKI->nKeyField); /* Makes OP_Jump testable */
690 sqlite3VdbeChangeP4(v, -1, (char*)pKI, P4_KEYINFO);
691 testcase( pKI->nAllField > pKI->nKeyField+2 );
692 pOp->p4.pKeyInfo = sqlite3KeyInfoFromExprList(pParse,pSort->pOrderBy,nOBSat,
693 pKI->nAllField-pKI->nKeyField-1);
694 pOp = 0; /* Ensure pOp not used after sqltie3VdbeAddOp3() */
695 addrJmp = sqlite3VdbeCurrentAddr(v);
696 sqlite3VdbeAddOp3(v, OP_Jump, addrJmp+1, 0, addrJmp+1); VdbeCoverage(v);
697 pSort->labelBkOut = sqlite3VdbeMakeLabel(pParse);
698 pSort->regReturn = ++pParse->nMem;
699 sqlite3VdbeAddOp2(v, OP_Gosub, pSort->regReturn, pSort->labelBkOut);
700 sqlite3VdbeAddOp1(v, OP_ResetSorter, pSort->iECursor);
701 if( iLimit ){
702 sqlite3VdbeAddOp2(v, OP_IfNot, iLimit, pSort->labelDone);
703 VdbeCoverage(v);
704 }
705 sqlite3VdbeJumpHere(v, addrFirst);
706 sqlite3ExprCodeMove(pParse, regBase, regPrevKey, pSort->nOBSat);
707 sqlite3VdbeJumpHere(v, addrJmp);
708 }
709 if( iLimit ){
710 /* At this point the values for the new sorter entry are stored
711 ** in an array of registers. They need to be composed into a record
712 ** and inserted into the sorter if either (a) there are currently
713 ** less than LIMIT+OFFSET items or (b) the new record is smaller than
714 ** the largest record currently in the sorter. If (b) is true and there
715 ** are already LIMIT+OFFSET items in the sorter, delete the largest
716 ** entry before inserting the new one. This way there are never more
717 ** than LIMIT+OFFSET items in the sorter.
718 **
719 ** If the new record does not need to be inserted into the sorter,
720 ** jump to the next iteration of the loop. If the pSort->labelOBLopt
721 ** value is not zero, then it is a label of where to jump. Otherwise,
722 ** just bypass the row insert logic. See the header comment on the
723 ** sqlite3WhereOrderByLimitOptLabel() function for additional info.
724 */
725 int iCsr = pSort->iECursor;
726 sqlite3VdbeAddOp2(v, OP_IfNotZero, iLimit, sqlite3VdbeCurrentAddr(v)+4);
727 VdbeCoverage(v);
728 sqlite3VdbeAddOp2(v, OP_Last, iCsr, 0);
729 iSkip = sqlite3VdbeAddOp4Int(v, OP_IdxLE,
730 iCsr, 0, regBase+nOBSat, nExpr-nOBSat);
731 VdbeCoverage(v);
732 sqlite3VdbeAddOp1(v, OP_Delete, iCsr);
733 }
734 if( regRecord==0 ){
735 regRecord = makeSorterRecord(pParse, pSort, pSelect, regBase, nBase);
736 }
737 if( pSort->sortFlags & SORTFLAG_UseSorter ){
738 op = OP_SorterInsert;
739 }else{
740 op = OP_IdxInsert;
741 }
742 sqlite3VdbeAddOp4Int(v, op, pSort->iECursor, regRecord,
743 regBase+nOBSat, nBase-nOBSat);
744 if( iSkip ){
745 sqlite3VdbeChangeP2(v, iSkip,
746 pSort->labelOBLopt ? pSort->labelOBLopt : sqlite3VdbeCurrentAddr(v));
747 }
748 }
749
750 /*
751 ** Add code to implement the OFFSET
752 */
codeOffset(Vdbe * v,int iOffset,int iContinue)753 static void codeOffset(
754 Vdbe *v, /* Generate code into this VM */
755 int iOffset, /* Register holding the offset counter */
756 int iContinue /* Jump here to skip the current record */
757 ){
758 if( iOffset>0 ){
759 sqlite3VdbeAddOp3(v, OP_IfPos, iOffset, iContinue, 1); VdbeCoverage(v);
760 VdbeComment((v, "OFFSET"));
761 }
762 }
763
764 /*
765 ** Add code that will check to make sure the N registers starting at iMem
766 ** form a distinct entry. iTab is a sorting index that holds previously
767 ** seen combinations of the N values. A new entry is made in iTab
768 ** if the current N values are new.
769 **
770 ** A jump to addrRepeat is made and the N+1 values are popped from the
771 ** stack if the top N elements are not distinct.
772 */
codeDistinct(Parse * pParse,int iTab,int addrRepeat,int N,int iMem)773 static void codeDistinct(
774 Parse *pParse, /* Parsing and code generating context */
775 int iTab, /* A sorting index used to test for distinctness */
776 int addrRepeat, /* Jump to here if not distinct */
777 int N, /* Number of elements */
778 int iMem /* First element */
779 ){
780 Vdbe *v;
781 int r1;
782
783 v = pParse->pVdbe;
784 r1 = sqlite3GetTempReg(pParse);
785 sqlite3VdbeAddOp4Int(v, OP_Found, iTab, addrRepeat, iMem, N); VdbeCoverage(v);
786 sqlite3VdbeAddOp3(v, OP_MakeRecord, iMem, N, r1);
787 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iTab, r1, iMem, N);
788 sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
789 sqlite3ReleaseTempReg(pParse, r1);
790 }
791
792 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
793 /*
794 ** This function is called as part of inner-loop generation for a SELECT
795 ** statement with an ORDER BY that is not optimized by an index. It
796 ** determines the expressions, if any, that the sorter-reference
797 ** optimization should be used for. The sorter-reference optimization
798 ** is used for SELECT queries like:
799 **
800 ** SELECT a, bigblob FROM t1 ORDER BY a LIMIT 10
801 **
802 ** If the optimization is used for expression "bigblob", then instead of
803 ** storing values read from that column in the sorter records, the PK of
804 ** the row from table t1 is stored instead. Then, as records are extracted from
805 ** the sorter to return to the user, the required value of bigblob is
806 ** retrieved directly from table t1. If the values are very large, this
807 ** can be more efficient than storing them directly in the sorter records.
808 **
809 ** The ExprList_item.bSorterRef flag is set for each expression in pEList
810 ** for which the sorter-reference optimization should be enabled.
811 ** Additionally, the pSort->aDefer[] array is populated with entries
812 ** for all cursors required to evaluate all selected expressions. Finally.
813 ** output variable (*ppExtra) is set to an expression list containing
814 ** expressions for all extra PK values that should be stored in the
815 ** sorter records.
816 */
selectExprDefer(Parse * pParse,SortCtx * pSort,ExprList * pEList,ExprList ** ppExtra)817 static void selectExprDefer(
818 Parse *pParse, /* Leave any error here */
819 SortCtx *pSort, /* Sorter context */
820 ExprList *pEList, /* Expressions destined for sorter */
821 ExprList **ppExtra /* Expressions to append to sorter record */
822 ){
823 int i;
824 int nDefer = 0;
825 ExprList *pExtra = 0;
826 for(i=0; i<pEList->nExpr; i++){
827 struct ExprList_item *pItem = &pEList->a[i];
828 if( pItem->u.x.iOrderByCol==0 ){
829 Expr *pExpr = pItem->pExpr;
830 Table *pTab = pExpr->y.pTab;
831 if( pExpr->op==TK_COLUMN && pExpr->iColumn>=0 && pTab && !IsVirtual(pTab)
832 && (pTab->aCol[pExpr->iColumn].colFlags & COLFLAG_SORTERREF)
833 ){
834 int j;
835 for(j=0; j<nDefer; j++){
836 if( pSort->aDefer[j].iCsr==pExpr->iTable ) break;
837 }
838 if( j==nDefer ){
839 if( nDefer==ArraySize(pSort->aDefer) ){
840 continue;
841 }else{
842 int nKey = 1;
843 int k;
844 Index *pPk = 0;
845 if( !HasRowid(pTab) ){
846 pPk = sqlite3PrimaryKeyIndex(pTab);
847 nKey = pPk->nKeyCol;
848 }
849 for(k=0; k<nKey; k++){
850 Expr *pNew = sqlite3PExpr(pParse, TK_COLUMN, 0, 0);
851 if( pNew ){
852 pNew->iTable = pExpr->iTable;
853 pNew->y.pTab = pExpr->y.pTab;
854 pNew->iColumn = pPk ? pPk->aiColumn[k] : -1;
855 pExtra = sqlite3ExprListAppend(pParse, pExtra, pNew);
856 }
857 }
858 pSort->aDefer[nDefer].pTab = pExpr->y.pTab;
859 pSort->aDefer[nDefer].iCsr = pExpr->iTable;
860 pSort->aDefer[nDefer].nKey = nKey;
861 nDefer++;
862 }
863 }
864 pItem->bSorterRef = 1;
865 }
866 }
867 }
868 pSort->nDefer = (u8)nDefer;
869 *ppExtra = pExtra;
870 }
871 #endif
872
873 /*
874 ** This routine generates the code for the inside of the inner loop
875 ** of a SELECT.
876 **
877 ** If srcTab is negative, then the p->pEList expressions
878 ** are evaluated in order to get the data for this row. If srcTab is
879 ** zero or more, then data is pulled from srcTab and p->pEList is used only
880 ** to get the number of columns and the collation sequence for each column.
881 */
selectInnerLoop(Parse * pParse,Select * p,int srcTab,SortCtx * pSort,DistinctCtx * pDistinct,SelectDest * pDest,int iContinue,int iBreak)882 static void selectInnerLoop(
883 Parse *pParse, /* The parser context */
884 Select *p, /* The complete select statement being coded */
885 int srcTab, /* Pull data from this table if non-negative */
886 SortCtx *pSort, /* If not NULL, info on how to process ORDER BY */
887 DistinctCtx *pDistinct, /* If not NULL, info on how to process DISTINCT */
888 SelectDest *pDest, /* How to dispose of the results */
889 int iContinue, /* Jump here to continue with next row */
890 int iBreak /* Jump here to break out of the inner loop */
891 ){
892 Vdbe *v = pParse->pVdbe;
893 int i;
894 int hasDistinct; /* True if the DISTINCT keyword is present */
895 int eDest = pDest->eDest; /* How to dispose of results */
896 int iParm = pDest->iSDParm; /* First argument to disposal method */
897 int nResultCol; /* Number of result columns */
898 int nPrefixReg = 0; /* Number of extra registers before regResult */
899 RowLoadInfo sRowLoadInfo; /* Info for deferred row loading */
900
901 /* Usually, regResult is the first cell in an array of memory cells
902 ** containing the current result row. In this case regOrig is set to the
903 ** same value. However, if the results are being sent to the sorter, the
904 ** values for any expressions that are also part of the sort-key are omitted
905 ** from this array. In this case regOrig is set to zero. */
906 int regResult; /* Start of memory holding current results */
907 int regOrig; /* Start of memory holding full result (or 0) */
908
909 assert( v );
910 assert( p->pEList!=0 );
911 hasDistinct = pDistinct ? pDistinct->eTnctType : WHERE_DISTINCT_NOOP;
912 if( pSort && pSort->pOrderBy==0 ) pSort = 0;
913 if( pSort==0 && !hasDistinct ){
914 assert( iContinue!=0 );
915 codeOffset(v, p->iOffset, iContinue);
916 }
917
918 /* Pull the requested columns.
919 */
920 nResultCol = p->pEList->nExpr;
921
922 if( pDest->iSdst==0 ){
923 if( pSort ){
924 nPrefixReg = pSort->pOrderBy->nExpr;
925 if( !(pSort->sortFlags & SORTFLAG_UseSorter) ) nPrefixReg++;
926 pParse->nMem += nPrefixReg;
927 }
928 pDest->iSdst = pParse->nMem+1;
929 pParse->nMem += nResultCol;
930 }else if( pDest->iSdst+nResultCol > pParse->nMem ){
931 /* This is an error condition that can result, for example, when a SELECT
932 ** on the right-hand side of an INSERT contains more result columns than
933 ** there are columns in the table on the left. The error will be caught
934 ** and reported later. But we need to make sure enough memory is allocated
935 ** to avoid other spurious errors in the meantime. */
936 pParse->nMem += nResultCol;
937 }
938 pDest->nSdst = nResultCol;
939 regOrig = regResult = pDest->iSdst;
940 if( srcTab>=0 ){
941 for(i=0; i<nResultCol; i++){
942 sqlite3VdbeAddOp3(v, OP_Column, srcTab, i, regResult+i);
943 VdbeComment((v, "%s", p->pEList->a[i].zEName));
944 }
945 }else if( eDest!=SRT_Exists ){
946 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
947 ExprList *pExtra = 0;
948 #endif
949 /* If the destination is an EXISTS(...) expression, the actual
950 ** values returned by the SELECT are not required.
951 */
952 u8 ecelFlags; /* "ecel" is an abbreviation of "ExprCodeExprList" */
953 ExprList *pEList;
954 if( eDest==SRT_Mem || eDest==SRT_Output || eDest==SRT_Coroutine ){
955 ecelFlags = SQLITE_ECEL_DUP;
956 }else{
957 ecelFlags = 0;
958 }
959 if( pSort && hasDistinct==0 && eDest!=SRT_EphemTab && eDest!=SRT_Table ){
960 /* For each expression in p->pEList that is a copy of an expression in
961 ** the ORDER BY clause (pSort->pOrderBy), set the associated
962 ** iOrderByCol value to one more than the index of the ORDER BY
963 ** expression within the sort-key that pushOntoSorter() will generate.
964 ** This allows the p->pEList field to be omitted from the sorted record,
965 ** saving space and CPU cycles. */
966 ecelFlags |= (SQLITE_ECEL_OMITREF|SQLITE_ECEL_REF);
967
968 for(i=pSort->nOBSat; i<pSort->pOrderBy->nExpr; i++){
969 int j;
970 if( (j = pSort->pOrderBy->a[i].u.x.iOrderByCol)>0 ){
971 p->pEList->a[j-1].u.x.iOrderByCol = i+1-pSort->nOBSat;
972 }
973 }
974 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
975 selectExprDefer(pParse, pSort, p->pEList, &pExtra);
976 if( pExtra && pParse->db->mallocFailed==0 ){
977 /* If there are any extra PK columns to add to the sorter records,
978 ** allocate extra memory cells and adjust the OpenEphemeral
979 ** instruction to account for the larger records. This is only
980 ** required if there are one or more WITHOUT ROWID tables with
981 ** composite primary keys in the SortCtx.aDefer[] array. */
982 VdbeOp *pOp = sqlite3VdbeGetOp(v, pSort->addrSortIndex);
983 pOp->p2 += (pExtra->nExpr - pSort->nDefer);
984 pOp->p4.pKeyInfo->nAllField += (pExtra->nExpr - pSort->nDefer);
985 pParse->nMem += pExtra->nExpr;
986 }
987 #endif
988
989 /* Adjust nResultCol to account for columns that are omitted
990 ** from the sorter by the optimizations in this branch */
991 pEList = p->pEList;
992 for(i=0; i<pEList->nExpr; i++){
993 if( pEList->a[i].u.x.iOrderByCol>0
994 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
995 || pEList->a[i].bSorterRef
996 #endif
997 ){
998 nResultCol--;
999 regOrig = 0;
1000 }
1001 }
1002
1003 testcase( regOrig );
1004 testcase( eDest==SRT_Set );
1005 testcase( eDest==SRT_Mem );
1006 testcase( eDest==SRT_Coroutine );
1007 testcase( eDest==SRT_Output );
1008 assert( eDest==SRT_Set || eDest==SRT_Mem
1009 || eDest==SRT_Coroutine || eDest==SRT_Output );
1010 }
1011 sRowLoadInfo.regResult = regResult;
1012 sRowLoadInfo.ecelFlags = ecelFlags;
1013 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
1014 sRowLoadInfo.pExtra = pExtra;
1015 sRowLoadInfo.regExtraResult = regResult + nResultCol;
1016 if( pExtra ) nResultCol += pExtra->nExpr;
1017 #endif
1018 if( p->iLimit
1019 && (ecelFlags & SQLITE_ECEL_OMITREF)!=0
1020 && nPrefixReg>0
1021 ){
1022 assert( pSort!=0 );
1023 assert( hasDistinct==0 );
1024 pSort->pDeferredRowLoad = &sRowLoadInfo;
1025 regOrig = 0;
1026 }else{
1027 innerLoopLoadRow(pParse, p, &sRowLoadInfo);
1028 }
1029 }
1030
1031 /* If the DISTINCT keyword was present on the SELECT statement
1032 ** and this row has been seen before, then do not make this row
1033 ** part of the result.
1034 */
1035 if( hasDistinct ){
1036 switch( pDistinct->eTnctType ){
1037 case WHERE_DISTINCT_ORDERED: {
1038 VdbeOp *pOp; /* No longer required OpenEphemeral instr. */
1039 int iJump; /* Jump destination */
1040 int regPrev; /* Previous row content */
1041
1042 /* Allocate space for the previous row */
1043 regPrev = pParse->nMem+1;
1044 pParse->nMem += nResultCol;
1045
1046 /* Change the OP_OpenEphemeral coded earlier to an OP_Null
1047 ** sets the MEM_Cleared bit on the first register of the
1048 ** previous value. This will cause the OP_Ne below to always
1049 ** fail on the first iteration of the loop even if the first
1050 ** row is all NULLs.
1051 */
1052 sqlite3VdbeChangeToNoop(v, pDistinct->addrTnct);
1053 pOp = sqlite3VdbeGetOp(v, pDistinct->addrTnct);
1054 pOp->opcode = OP_Null;
1055 pOp->p1 = 1;
1056 pOp->p2 = regPrev;
1057 pOp = 0; /* Ensure pOp is not used after sqlite3VdbeAddOp() */
1058
1059 iJump = sqlite3VdbeCurrentAddr(v) + nResultCol;
1060 for(i=0; i<nResultCol; i++){
1061 CollSeq *pColl = sqlite3ExprCollSeq(pParse, p->pEList->a[i].pExpr);
1062 if( i<nResultCol-1 ){
1063 sqlite3VdbeAddOp3(v, OP_Ne, regResult+i, iJump, regPrev+i);
1064 VdbeCoverage(v);
1065 }else{
1066 sqlite3VdbeAddOp3(v, OP_Eq, regResult+i, iContinue, regPrev+i);
1067 VdbeCoverage(v);
1068 }
1069 sqlite3VdbeChangeP4(v, -1, (const char *)pColl, P4_COLLSEQ);
1070 sqlite3VdbeChangeP5(v, SQLITE_NULLEQ);
1071 }
1072 assert( sqlite3VdbeCurrentAddr(v)==iJump || pParse->db->mallocFailed );
1073 sqlite3VdbeAddOp3(v, OP_Copy, regResult, regPrev, nResultCol-1);
1074 break;
1075 }
1076
1077 case WHERE_DISTINCT_UNIQUE: {
1078 sqlite3VdbeChangeToNoop(v, pDistinct->addrTnct);
1079 break;
1080 }
1081
1082 default: {
1083 assert( pDistinct->eTnctType==WHERE_DISTINCT_UNORDERED );
1084 codeDistinct(pParse, pDistinct->tabTnct, iContinue, nResultCol,
1085 regResult);
1086 break;
1087 }
1088 }
1089 if( pSort==0 ){
1090 codeOffset(v, p->iOffset, iContinue);
1091 }
1092 }
1093
1094 switch( eDest ){
1095 /* In this mode, write each query result to the key of the temporary
1096 ** table iParm.
1097 */
1098 #ifndef SQLITE_OMIT_COMPOUND_SELECT
1099 case SRT_Union: {
1100 int r1;
1101 r1 = sqlite3GetTempReg(pParse);
1102 sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r1);
1103 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regResult, nResultCol);
1104 sqlite3ReleaseTempReg(pParse, r1);
1105 break;
1106 }
1107
1108 /* Construct a record from the query result, but instead of
1109 ** saving that record, use it as a key to delete elements from
1110 ** the temporary table iParm.
1111 */
1112 case SRT_Except: {
1113 sqlite3VdbeAddOp3(v, OP_IdxDelete, iParm, regResult, nResultCol);
1114 break;
1115 }
1116 #endif /* SQLITE_OMIT_COMPOUND_SELECT */
1117
1118 /* Store the result as data using a unique key.
1119 */
1120 case SRT_Fifo:
1121 case SRT_DistFifo:
1122 case SRT_Table:
1123 case SRT_EphemTab: {
1124 int r1 = sqlite3GetTempRange(pParse, nPrefixReg+1);
1125 testcase( eDest==SRT_Table );
1126 testcase( eDest==SRT_EphemTab );
1127 testcase( eDest==SRT_Fifo );
1128 testcase( eDest==SRT_DistFifo );
1129 sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r1+nPrefixReg);
1130 #ifndef SQLITE_OMIT_CTE
1131 if( eDest==SRT_DistFifo ){
1132 /* If the destination is DistFifo, then cursor (iParm+1) is open
1133 ** on an ephemeral index. If the current row is already present
1134 ** in the index, do not write it to the output. If not, add the
1135 ** current row to the index and proceed with writing it to the
1136 ** output table as well. */
1137 int addr = sqlite3VdbeCurrentAddr(v) + 4;
1138 sqlite3VdbeAddOp4Int(v, OP_Found, iParm+1, addr, r1, 0);
1139 VdbeCoverage(v);
1140 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm+1, r1,regResult,nResultCol);
1141 assert( pSort==0 );
1142 }
1143 #endif
1144 if( pSort ){
1145 assert( regResult==regOrig );
1146 pushOntoSorter(pParse, pSort, p, r1+nPrefixReg, regOrig, 1, nPrefixReg);
1147 }else{
1148 int r2 = sqlite3GetTempReg(pParse);
1149 sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, r2);
1150 sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, r2);
1151 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
1152 sqlite3ReleaseTempReg(pParse, r2);
1153 }
1154 sqlite3ReleaseTempRange(pParse, r1, nPrefixReg+1);
1155 break;
1156 }
1157
1158 #ifndef SQLITE_OMIT_SUBQUERY
1159 /* If we are creating a set for an "expr IN (SELECT ...)" construct,
1160 ** then there should be a single item on the stack. Write this
1161 ** item into the set table with bogus data.
1162 */
1163 case SRT_Set: {
1164 if( pSort ){
1165 /* At first glance you would think we could optimize out the
1166 ** ORDER BY in this case since the order of entries in the set
1167 ** does not matter. But there might be a LIMIT clause, in which
1168 ** case the order does matter */
1169 pushOntoSorter(
1170 pParse, pSort, p, regResult, regOrig, nResultCol, nPrefixReg);
1171 }else{
1172 int r1 = sqlite3GetTempReg(pParse);
1173 assert( sqlite3Strlen30(pDest->zAffSdst)==nResultCol );
1174 sqlite3VdbeAddOp4(v, OP_MakeRecord, regResult, nResultCol,
1175 r1, pDest->zAffSdst, nResultCol);
1176 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regResult, nResultCol);
1177 sqlite3ReleaseTempReg(pParse, r1);
1178 }
1179 break;
1180 }
1181
1182 /* If any row exist in the result set, record that fact and abort.
1183 */
1184 case SRT_Exists: {
1185 sqlite3VdbeAddOp2(v, OP_Integer, 1, iParm);
1186 /* The LIMIT clause will terminate the loop for us */
1187 break;
1188 }
1189
1190 /* If this is a scalar select that is part of an expression, then
1191 ** store the results in the appropriate memory cell or array of
1192 ** memory cells and break out of the scan loop.
1193 */
1194 case SRT_Mem: {
1195 if( pSort ){
1196 assert( nResultCol<=pDest->nSdst );
1197 pushOntoSorter(
1198 pParse, pSort, p, regResult, regOrig, nResultCol, nPrefixReg);
1199 }else{
1200 assert( nResultCol==pDest->nSdst );
1201 assert( regResult==iParm );
1202 /* The LIMIT clause will jump out of the loop for us */
1203 }
1204 break;
1205 }
1206 #endif /* #ifndef SQLITE_OMIT_SUBQUERY */
1207
1208 case SRT_Coroutine: /* Send data to a co-routine */
1209 case SRT_Output: { /* Return the results */
1210 testcase( eDest==SRT_Coroutine );
1211 testcase( eDest==SRT_Output );
1212 if( pSort ){
1213 pushOntoSorter(pParse, pSort, p, regResult, regOrig, nResultCol,
1214 nPrefixReg);
1215 }else if( eDest==SRT_Coroutine ){
1216 sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm);
1217 }else{
1218 sqlite3VdbeAddOp2(v, OP_ResultRow, regResult, nResultCol);
1219 }
1220 break;
1221 }
1222
1223 #ifndef SQLITE_OMIT_CTE
1224 /* Write the results into a priority queue that is order according to
1225 ** pDest->pOrderBy (in pSO). pDest->iSDParm (in iParm) is the cursor for an
1226 ** index with pSO->nExpr+2 columns. Build a key using pSO for the first
1227 ** pSO->nExpr columns, then make sure all keys are unique by adding a
1228 ** final OP_Sequence column. The last column is the record as a blob.
1229 */
1230 case SRT_DistQueue:
1231 case SRT_Queue: {
1232 int nKey;
1233 int r1, r2, r3;
1234 int addrTest = 0;
1235 ExprList *pSO;
1236 pSO = pDest->pOrderBy;
1237 assert( pSO );
1238 nKey = pSO->nExpr;
1239 r1 = sqlite3GetTempReg(pParse);
1240 r2 = sqlite3GetTempRange(pParse, nKey+2);
1241 r3 = r2+nKey+1;
1242 if( eDest==SRT_DistQueue ){
1243 /* If the destination is DistQueue, then cursor (iParm+1) is open
1244 ** on a second ephemeral index that holds all values every previously
1245 ** added to the queue. */
1246 addrTest = sqlite3VdbeAddOp4Int(v, OP_Found, iParm+1, 0,
1247 regResult, nResultCol);
1248 VdbeCoverage(v);
1249 }
1250 sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r3);
1251 if( eDest==SRT_DistQueue ){
1252 sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm+1, r3);
1253 sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
1254 }
1255 for(i=0; i<nKey; i++){
1256 sqlite3VdbeAddOp2(v, OP_SCopy,
1257 regResult + pSO->a[i].u.x.iOrderByCol - 1,
1258 r2+i);
1259 }
1260 sqlite3VdbeAddOp2(v, OP_Sequence, iParm, r2+nKey);
1261 sqlite3VdbeAddOp3(v, OP_MakeRecord, r2, nKey+2, r1);
1262 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, r2, nKey+2);
1263 if( addrTest ) sqlite3VdbeJumpHere(v, addrTest);
1264 sqlite3ReleaseTempReg(pParse, r1);
1265 sqlite3ReleaseTempRange(pParse, r2, nKey+2);
1266 break;
1267 }
1268 #endif /* SQLITE_OMIT_CTE */
1269
1270
1271
1272 #if !defined(SQLITE_OMIT_TRIGGER)
1273 /* Discard the results. This is used for SELECT statements inside
1274 ** the body of a TRIGGER. The purpose of such selects is to call
1275 ** user-defined functions that have side effects. We do not care
1276 ** about the actual results of the select.
1277 */
1278 default: {
1279 assert( eDest==SRT_Discard );
1280 break;
1281 }
1282 #endif
1283 }
1284
1285 /* Jump to the end of the loop if the LIMIT is reached. Except, if
1286 ** there is a sorter, in which case the sorter has already limited
1287 ** the output for us.
1288 */
1289 if( pSort==0 && p->iLimit ){
1290 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak); VdbeCoverage(v);
1291 }
1292 }
1293
1294 /*
1295 ** Allocate a KeyInfo object sufficient for an index of N key columns and
1296 ** X extra columns.
1297 */
sqlite3KeyInfoAlloc(sqlite3 * db,int N,int X)1298 KeyInfo *sqlite3KeyInfoAlloc(sqlite3 *db, int N, int X){
1299 int nExtra = (N+X)*(sizeof(CollSeq*)+1) - sizeof(CollSeq*);
1300 KeyInfo *p = sqlite3DbMallocRawNN(db, sizeof(KeyInfo) + nExtra);
1301 if( p ){
1302 p->aSortFlags = (u8*)&p->aColl[N+X];
1303 p->nKeyField = (u16)N;
1304 p->nAllField = (u16)(N+X);
1305 p->enc = ENC(db);
1306 p->db = db;
1307 p->nRef = 1;
1308 memset(&p[1], 0, nExtra);
1309 }else{
1310 sqlite3OomFault(db);
1311 }
1312 return p;
1313 }
1314
1315 /*
1316 ** Deallocate a KeyInfo object
1317 */
sqlite3KeyInfoUnref(KeyInfo * p)1318 void sqlite3KeyInfoUnref(KeyInfo *p){
1319 if( p ){
1320 assert( p->nRef>0 );
1321 p->nRef--;
1322 if( p->nRef==0 ) sqlite3DbFreeNN(p->db, p);
1323 }
1324 }
1325
1326 /*
1327 ** Make a new pointer to a KeyInfo object
1328 */
sqlite3KeyInfoRef(KeyInfo * p)1329 KeyInfo *sqlite3KeyInfoRef(KeyInfo *p){
1330 if( p ){
1331 assert( p->nRef>0 );
1332 p->nRef++;
1333 }
1334 return p;
1335 }
1336
1337 #ifdef SQLITE_DEBUG
1338 /*
1339 ** Return TRUE if a KeyInfo object can be change. The KeyInfo object
1340 ** can only be changed if this is just a single reference to the object.
1341 **
1342 ** This routine is used only inside of assert() statements.
1343 */
sqlite3KeyInfoIsWriteable(KeyInfo * p)1344 int sqlite3KeyInfoIsWriteable(KeyInfo *p){ return p->nRef==1; }
1345 #endif /* SQLITE_DEBUG */
1346
1347 /*
1348 ** Given an expression list, generate a KeyInfo structure that records
1349 ** the collating sequence for each expression in that expression list.
1350 **
1351 ** If the ExprList is an ORDER BY or GROUP BY clause then the resulting
1352 ** KeyInfo structure is appropriate for initializing a virtual index to
1353 ** implement that clause. If the ExprList is the result set of a SELECT
1354 ** then the KeyInfo structure is appropriate for initializing a virtual
1355 ** index to implement a DISTINCT test.
1356 **
1357 ** Space to hold the KeyInfo structure is obtained from malloc. The calling
1358 ** function is responsible for seeing that this structure is eventually
1359 ** freed.
1360 */
sqlite3KeyInfoFromExprList(Parse * pParse,ExprList * pList,int iStart,int nExtra)1361 KeyInfo *sqlite3KeyInfoFromExprList(
1362 Parse *pParse, /* Parsing context */
1363 ExprList *pList, /* Form the KeyInfo object from this ExprList */
1364 int iStart, /* Begin with this column of pList */
1365 int nExtra /* Add this many extra columns to the end */
1366 ){
1367 int nExpr;
1368 KeyInfo *pInfo;
1369 struct ExprList_item *pItem;
1370 sqlite3 *db = pParse->db;
1371 int i;
1372
1373 nExpr = pList->nExpr;
1374 pInfo = sqlite3KeyInfoAlloc(db, nExpr-iStart, nExtra+1);
1375 if( pInfo ){
1376 assert( sqlite3KeyInfoIsWriteable(pInfo) );
1377 for(i=iStart, pItem=pList->a+iStart; i<nExpr; i++, pItem++){
1378 pInfo->aColl[i-iStart] = sqlite3ExprNNCollSeq(pParse, pItem->pExpr);
1379 pInfo->aSortFlags[i-iStart] = pItem->sortFlags;
1380 }
1381 }
1382 return pInfo;
1383 }
1384
1385 /*
1386 ** Name of the connection operator, used for error messages.
1387 */
selectOpName(int id)1388 static const char *selectOpName(int id){
1389 char *z;
1390 switch( id ){
1391 case TK_ALL: z = "UNION ALL"; break;
1392 case TK_INTERSECT: z = "INTERSECT"; break;
1393 case TK_EXCEPT: z = "EXCEPT"; break;
1394 default: z = "UNION"; break;
1395 }
1396 return z;
1397 }
1398
1399 #ifndef SQLITE_OMIT_EXPLAIN
1400 /*
1401 ** Unless an "EXPLAIN QUERY PLAN" command is being processed, this function
1402 ** is a no-op. Otherwise, it adds a single row of output to the EQP result,
1403 ** where the caption is of the form:
1404 **
1405 ** "USE TEMP B-TREE FOR xxx"
1406 **
1407 ** where xxx is one of "DISTINCT", "ORDER BY" or "GROUP BY". Exactly which
1408 ** is determined by the zUsage argument.
1409 */
explainTempTable(Parse * pParse,const char * zUsage)1410 static void explainTempTable(Parse *pParse, const char *zUsage){
1411 ExplainQueryPlan((pParse, 0, "USE TEMP B-TREE FOR %s", zUsage));
1412 }
1413
1414 /*
1415 ** Assign expression b to lvalue a. A second, no-op, version of this macro
1416 ** is provided when SQLITE_OMIT_EXPLAIN is defined. This allows the code
1417 ** in sqlite3Select() to assign values to structure member variables that
1418 ** only exist if SQLITE_OMIT_EXPLAIN is not defined without polluting the
1419 ** code with #ifndef directives.
1420 */
1421 # define explainSetInteger(a, b) a = b
1422
1423 #else
1424 /* No-op versions of the explainXXX() functions and macros. */
1425 # define explainTempTable(y,z)
1426 # define explainSetInteger(y,z)
1427 #endif
1428
1429
1430 /*
1431 ** If the inner loop was generated using a non-null pOrderBy argument,
1432 ** then the results were placed in a sorter. After the loop is terminated
1433 ** we need to run the sorter and output the results. The following
1434 ** routine generates the code needed to do that.
1435 */
generateSortTail(Parse * pParse,Select * p,SortCtx * pSort,int nColumn,SelectDest * pDest)1436 static void generateSortTail(
1437 Parse *pParse, /* Parsing context */
1438 Select *p, /* The SELECT statement */
1439 SortCtx *pSort, /* Information on the ORDER BY clause */
1440 int nColumn, /* Number of columns of data */
1441 SelectDest *pDest /* Write the sorted results here */
1442 ){
1443 Vdbe *v = pParse->pVdbe; /* The prepared statement */
1444 int addrBreak = pSort->labelDone; /* Jump here to exit loop */
1445 int addrContinue = sqlite3VdbeMakeLabel(pParse);/* Jump here for next cycle */
1446 int addr; /* Top of output loop. Jump for Next. */
1447 int addrOnce = 0;
1448 int iTab;
1449 ExprList *pOrderBy = pSort->pOrderBy;
1450 int eDest = pDest->eDest;
1451 int iParm = pDest->iSDParm;
1452 int regRow;
1453 int regRowid;
1454 int iCol;
1455 int nKey; /* Number of key columns in sorter record */
1456 int iSortTab; /* Sorter cursor to read from */
1457 int i;
1458 int bSeq; /* True if sorter record includes seq. no. */
1459 int nRefKey = 0;
1460 struct ExprList_item *aOutEx = p->pEList->a;
1461
1462 assert( addrBreak<0 );
1463 if( pSort->labelBkOut ){
1464 sqlite3VdbeAddOp2(v, OP_Gosub, pSort->regReturn, pSort->labelBkOut);
1465 sqlite3VdbeGoto(v, addrBreak);
1466 sqlite3VdbeResolveLabel(v, pSort->labelBkOut);
1467 }
1468
1469 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
1470 /* Open any cursors needed for sorter-reference expressions */
1471 for(i=0; i<pSort->nDefer; i++){
1472 Table *pTab = pSort->aDefer[i].pTab;
1473 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
1474 sqlite3OpenTable(pParse, pSort->aDefer[i].iCsr, iDb, pTab, OP_OpenRead);
1475 nRefKey = MAX(nRefKey, pSort->aDefer[i].nKey);
1476 }
1477 #endif
1478
1479 iTab = pSort->iECursor;
1480 if( eDest==SRT_Output || eDest==SRT_Coroutine || eDest==SRT_Mem ){
1481 regRowid = 0;
1482 regRow = pDest->iSdst;
1483 }else{
1484 regRowid = sqlite3GetTempReg(pParse);
1485 if( eDest==SRT_EphemTab || eDest==SRT_Table ){
1486 regRow = sqlite3GetTempReg(pParse);
1487 nColumn = 0;
1488 }else{
1489 regRow = sqlite3GetTempRange(pParse, nColumn);
1490 }
1491 }
1492 nKey = pOrderBy->nExpr - pSort->nOBSat;
1493 if( pSort->sortFlags & SORTFLAG_UseSorter ){
1494 int regSortOut = ++pParse->nMem;
1495 iSortTab = pParse->nTab++;
1496 if( pSort->labelBkOut ){
1497 addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
1498 }
1499 sqlite3VdbeAddOp3(v, OP_OpenPseudo, iSortTab, regSortOut,
1500 nKey+1+nColumn+nRefKey);
1501 if( addrOnce ) sqlite3VdbeJumpHere(v, addrOnce);
1502 addr = 1 + sqlite3VdbeAddOp2(v, OP_SorterSort, iTab, addrBreak);
1503 VdbeCoverage(v);
1504 codeOffset(v, p->iOffset, addrContinue);
1505 sqlite3VdbeAddOp3(v, OP_SorterData, iTab, regSortOut, iSortTab);
1506 bSeq = 0;
1507 }else{
1508 addr = 1 + sqlite3VdbeAddOp2(v, OP_Sort, iTab, addrBreak); VdbeCoverage(v);
1509 codeOffset(v, p->iOffset, addrContinue);
1510 iSortTab = iTab;
1511 bSeq = 1;
1512 }
1513 for(i=0, iCol=nKey+bSeq-1; i<nColumn; i++){
1514 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
1515 if( aOutEx[i].bSorterRef ) continue;
1516 #endif
1517 if( aOutEx[i].u.x.iOrderByCol==0 ) iCol++;
1518 }
1519 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
1520 if( pSort->nDefer ){
1521 int iKey = iCol+1;
1522 int regKey = sqlite3GetTempRange(pParse, nRefKey);
1523
1524 for(i=0; i<pSort->nDefer; i++){
1525 int iCsr = pSort->aDefer[i].iCsr;
1526 Table *pTab = pSort->aDefer[i].pTab;
1527 int nKey = pSort->aDefer[i].nKey;
1528
1529 sqlite3VdbeAddOp1(v, OP_NullRow, iCsr);
1530 if( HasRowid(pTab) ){
1531 sqlite3VdbeAddOp3(v, OP_Column, iSortTab, iKey++, regKey);
1532 sqlite3VdbeAddOp3(v, OP_SeekRowid, iCsr,
1533 sqlite3VdbeCurrentAddr(v)+1, regKey);
1534 }else{
1535 int k;
1536 int iJmp;
1537 assert( sqlite3PrimaryKeyIndex(pTab)->nKeyCol==nKey );
1538 for(k=0; k<nKey; k++){
1539 sqlite3VdbeAddOp3(v, OP_Column, iSortTab, iKey++, regKey+k);
1540 }
1541 iJmp = sqlite3VdbeCurrentAddr(v);
1542 sqlite3VdbeAddOp4Int(v, OP_SeekGE, iCsr, iJmp+2, regKey, nKey);
1543 sqlite3VdbeAddOp4Int(v, OP_IdxLE, iCsr, iJmp+3, regKey, nKey);
1544 sqlite3VdbeAddOp1(v, OP_NullRow, iCsr);
1545 }
1546 }
1547 sqlite3ReleaseTempRange(pParse, regKey, nRefKey);
1548 }
1549 #endif
1550 for(i=nColumn-1; i>=0; i--){
1551 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
1552 if( aOutEx[i].bSorterRef ){
1553 sqlite3ExprCode(pParse, aOutEx[i].pExpr, regRow+i);
1554 }else
1555 #endif
1556 {
1557 int iRead;
1558 if( aOutEx[i].u.x.iOrderByCol ){
1559 iRead = aOutEx[i].u.x.iOrderByCol-1;
1560 }else{
1561 iRead = iCol--;
1562 }
1563 sqlite3VdbeAddOp3(v, OP_Column, iSortTab, iRead, regRow+i);
1564 VdbeComment((v, "%s", aOutEx[i].zEName));
1565 }
1566 }
1567 switch( eDest ){
1568 case SRT_Table:
1569 case SRT_EphemTab: {
1570 sqlite3VdbeAddOp3(v, OP_Column, iSortTab, nKey+bSeq, regRow);
1571 sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, regRowid);
1572 sqlite3VdbeAddOp3(v, OP_Insert, iParm, regRow, regRowid);
1573 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
1574 break;
1575 }
1576 #ifndef SQLITE_OMIT_SUBQUERY
1577 case SRT_Set: {
1578 assert( nColumn==sqlite3Strlen30(pDest->zAffSdst) );
1579 sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, nColumn, regRowid,
1580 pDest->zAffSdst, nColumn);
1581 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, regRowid, regRow, nColumn);
1582 break;
1583 }
1584 case SRT_Mem: {
1585 /* The LIMIT clause will terminate the loop for us */
1586 break;
1587 }
1588 #endif
1589 default: {
1590 assert( eDest==SRT_Output || eDest==SRT_Coroutine );
1591 testcase( eDest==SRT_Output );
1592 testcase( eDest==SRT_Coroutine );
1593 if( eDest==SRT_Output ){
1594 sqlite3VdbeAddOp2(v, OP_ResultRow, pDest->iSdst, nColumn);
1595 }else{
1596 sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm);
1597 }
1598 break;
1599 }
1600 }
1601 if( regRowid ){
1602 if( eDest==SRT_Set ){
1603 sqlite3ReleaseTempRange(pParse, regRow, nColumn);
1604 }else{
1605 sqlite3ReleaseTempReg(pParse, regRow);
1606 }
1607 sqlite3ReleaseTempReg(pParse, regRowid);
1608 }
1609 /* The bottom of the loop
1610 */
1611 sqlite3VdbeResolveLabel(v, addrContinue);
1612 if( pSort->sortFlags & SORTFLAG_UseSorter ){
1613 sqlite3VdbeAddOp2(v, OP_SorterNext, iTab, addr); VdbeCoverage(v);
1614 }else{
1615 sqlite3VdbeAddOp2(v, OP_Next, iTab, addr); VdbeCoverage(v);
1616 }
1617 if( pSort->regReturn ) sqlite3VdbeAddOp1(v, OP_Return, pSort->regReturn);
1618 sqlite3VdbeResolveLabel(v, addrBreak);
1619 }
1620
1621 /*
1622 ** Return a pointer to a string containing the 'declaration type' of the
1623 ** expression pExpr. The string may be treated as static by the caller.
1624 **
1625 ** Also try to estimate the size of the returned value and return that
1626 ** result in *pEstWidth.
1627 **
1628 ** The declaration type is the exact datatype definition extracted from the
1629 ** original CREATE TABLE statement if the expression is a column. The
1630 ** declaration type for a ROWID field is INTEGER. Exactly when an expression
1631 ** is considered a column can be complex in the presence of subqueries. The
1632 ** result-set expression in all of the following SELECT statements is
1633 ** considered a column by this function.
1634 **
1635 ** SELECT col FROM tbl;
1636 ** SELECT (SELECT col FROM tbl;
1637 ** SELECT (SELECT col FROM tbl);
1638 ** SELECT abc FROM (SELECT col AS abc FROM tbl);
1639 **
1640 ** The declaration type for any expression other than a column is NULL.
1641 **
1642 ** This routine has either 3 or 6 parameters depending on whether or not
1643 ** the SQLITE_ENABLE_COLUMN_METADATA compile-time option is used.
1644 */
1645 #ifdef SQLITE_ENABLE_COLUMN_METADATA
1646 # define columnType(A,B,C,D,E) columnTypeImpl(A,B,C,D,E)
1647 #else /* if !defined(SQLITE_ENABLE_COLUMN_METADATA) */
1648 # define columnType(A,B,C,D,E) columnTypeImpl(A,B)
1649 #endif
columnTypeImpl(NameContext * pNC,Expr * pExpr)1650 static const char *columnTypeImpl(
1651 NameContext *pNC,
1652 #ifndef SQLITE_ENABLE_COLUMN_METADATA
1653 Expr *pExpr
1654 #else
1655 Expr *pExpr,
1656 const char **pzOrigDb,
1657 const char **pzOrigTab,
1658 const char **pzOrigCol
1659 #endif
1660 ){
1661 char const *zType = 0;
1662 int j;
1663 #ifdef SQLITE_ENABLE_COLUMN_METADATA
1664 char const *zOrigDb = 0;
1665 char const *zOrigTab = 0;
1666 char const *zOrigCol = 0;
1667 #endif
1668
1669 assert( pExpr!=0 );
1670 assert( pNC->pSrcList!=0 );
1671 switch( pExpr->op ){
1672 case TK_COLUMN: {
1673 /* The expression is a column. Locate the table the column is being
1674 ** extracted from in NameContext.pSrcList. This table may be real
1675 ** database table or a subquery.
1676 */
1677 Table *pTab = 0; /* Table structure column is extracted from */
1678 Select *pS = 0; /* Select the column is extracted from */
1679 int iCol = pExpr->iColumn; /* Index of column in pTab */
1680 while( pNC && !pTab ){
1681 SrcList *pTabList = pNC->pSrcList;
1682 for(j=0;j<pTabList->nSrc && pTabList->a[j].iCursor!=pExpr->iTable;j++);
1683 if( j<pTabList->nSrc ){
1684 pTab = pTabList->a[j].pTab;
1685 pS = pTabList->a[j].pSelect;
1686 }else{
1687 pNC = pNC->pNext;
1688 }
1689 }
1690
1691 if( pTab==0 ){
1692 /* At one time, code such as "SELECT new.x" within a trigger would
1693 ** cause this condition to run. Since then, we have restructured how
1694 ** trigger code is generated and so this condition is no longer
1695 ** possible. However, it can still be true for statements like
1696 ** the following:
1697 **
1698 ** CREATE TABLE t1(col INTEGER);
1699 ** SELECT (SELECT t1.col) FROM FROM t1;
1700 **
1701 ** when columnType() is called on the expression "t1.col" in the
1702 ** sub-select. In this case, set the column type to NULL, even
1703 ** though it should really be "INTEGER".
1704 **
1705 ** This is not a problem, as the column type of "t1.col" is never
1706 ** used. When columnType() is called on the expression
1707 ** "(SELECT t1.col)", the correct type is returned (see the TK_SELECT
1708 ** branch below. */
1709 break;
1710 }
1711
1712 assert( pTab && pExpr->y.pTab==pTab );
1713 if( pS ){
1714 /* The "table" is actually a sub-select or a view in the FROM clause
1715 ** of the SELECT statement. Return the declaration type and origin
1716 ** data for the result-set column of the sub-select.
1717 */
1718 if( iCol>=0 && iCol<pS->pEList->nExpr ){
1719 /* If iCol is less than zero, then the expression requests the
1720 ** rowid of the sub-select or view. This expression is legal (see
1721 ** test case misc2.2.2) - it always evaluates to NULL.
1722 */
1723 NameContext sNC;
1724 Expr *p = pS->pEList->a[iCol].pExpr;
1725 sNC.pSrcList = pS->pSrc;
1726 sNC.pNext = pNC;
1727 sNC.pParse = pNC->pParse;
1728 zType = columnType(&sNC, p,&zOrigDb,&zOrigTab,&zOrigCol);
1729 }
1730 }else{
1731 /* A real table or a CTE table */
1732 assert( !pS );
1733 #ifdef SQLITE_ENABLE_COLUMN_METADATA
1734 if( iCol<0 ) iCol = pTab->iPKey;
1735 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
1736 if( iCol<0 ){
1737 zType = "INTEGER";
1738 zOrigCol = "rowid";
1739 }else{
1740 zOrigCol = pTab->aCol[iCol].zName;
1741 zType = sqlite3ColumnType(&pTab->aCol[iCol],0);
1742 }
1743 zOrigTab = pTab->zName;
1744 if( pNC->pParse && pTab->pSchema ){
1745 int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema);
1746 zOrigDb = pNC->pParse->db->aDb[iDb].zDbSName;
1747 }
1748 #else
1749 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
1750 if( iCol<0 ){
1751 zType = "INTEGER";
1752 }else{
1753 zType = sqlite3ColumnType(&pTab->aCol[iCol],0);
1754 }
1755 #endif
1756 }
1757 break;
1758 }
1759 #ifndef SQLITE_OMIT_SUBQUERY
1760 case TK_SELECT: {
1761 /* The expression is a sub-select. Return the declaration type and
1762 ** origin info for the single column in the result set of the SELECT
1763 ** statement.
1764 */
1765 NameContext sNC;
1766 Select *pS = pExpr->x.pSelect;
1767 Expr *p = pS->pEList->a[0].pExpr;
1768 assert( ExprHasProperty(pExpr, EP_xIsSelect) );
1769 sNC.pSrcList = pS->pSrc;
1770 sNC.pNext = pNC;
1771 sNC.pParse = pNC->pParse;
1772 zType = columnType(&sNC, p, &zOrigDb, &zOrigTab, &zOrigCol);
1773 break;
1774 }
1775 #endif
1776 }
1777
1778 #ifdef SQLITE_ENABLE_COLUMN_METADATA
1779 if( pzOrigDb ){
1780 assert( pzOrigTab && pzOrigCol );
1781 *pzOrigDb = zOrigDb;
1782 *pzOrigTab = zOrigTab;
1783 *pzOrigCol = zOrigCol;
1784 }
1785 #endif
1786 return zType;
1787 }
1788
1789 /*
1790 ** Generate code that will tell the VDBE the declaration types of columns
1791 ** in the result set.
1792 */
generateColumnTypes(Parse * pParse,SrcList * pTabList,ExprList * pEList)1793 static void generateColumnTypes(
1794 Parse *pParse, /* Parser context */
1795 SrcList *pTabList, /* List of tables */
1796 ExprList *pEList /* Expressions defining the result set */
1797 ){
1798 #ifndef SQLITE_OMIT_DECLTYPE
1799 Vdbe *v = pParse->pVdbe;
1800 int i;
1801 NameContext sNC;
1802 sNC.pSrcList = pTabList;
1803 sNC.pParse = pParse;
1804 sNC.pNext = 0;
1805 for(i=0; i<pEList->nExpr; i++){
1806 Expr *p = pEList->a[i].pExpr;
1807 const char *zType;
1808 #ifdef SQLITE_ENABLE_COLUMN_METADATA
1809 const char *zOrigDb = 0;
1810 const char *zOrigTab = 0;
1811 const char *zOrigCol = 0;
1812 zType = columnType(&sNC, p, &zOrigDb, &zOrigTab, &zOrigCol);
1813
1814 /* The vdbe must make its own copy of the column-type and other
1815 ** column specific strings, in case the schema is reset before this
1816 ** virtual machine is deleted.
1817 */
1818 sqlite3VdbeSetColName(v, i, COLNAME_DATABASE, zOrigDb, SQLITE_TRANSIENT);
1819 sqlite3VdbeSetColName(v, i, COLNAME_TABLE, zOrigTab, SQLITE_TRANSIENT);
1820 sqlite3VdbeSetColName(v, i, COLNAME_COLUMN, zOrigCol, SQLITE_TRANSIENT);
1821 #else
1822 zType = columnType(&sNC, p, 0, 0, 0);
1823 #endif
1824 sqlite3VdbeSetColName(v, i, COLNAME_DECLTYPE, zType, SQLITE_TRANSIENT);
1825 }
1826 #endif /* !defined(SQLITE_OMIT_DECLTYPE) */
1827 }
1828
1829
1830 /*
1831 ** Compute the column names for a SELECT statement.
1832 **
1833 ** The only guarantee that SQLite makes about column names is that if the
1834 ** column has an AS clause assigning it a name, that will be the name used.
1835 ** That is the only documented guarantee. However, countless applications
1836 ** developed over the years have made baseless assumptions about column names
1837 ** and will break if those assumptions changes. Hence, use extreme caution
1838 ** when modifying this routine to avoid breaking legacy.
1839 **
1840 ** See Also: sqlite3ColumnsFromExprList()
1841 **
1842 ** The PRAGMA short_column_names and PRAGMA full_column_names settings are
1843 ** deprecated. The default setting is short=ON, full=OFF. 99.9% of all
1844 ** applications should operate this way. Nevertheless, we need to support the
1845 ** other modes for legacy:
1846 **
1847 ** short=OFF, full=OFF: Column name is the text of the expression has it
1848 ** originally appears in the SELECT statement. In
1849 ** other words, the zSpan of the result expression.
1850 **
1851 ** short=ON, full=OFF: (This is the default setting). If the result
1852 ** refers directly to a table column, then the
1853 ** result column name is just the table column
1854 ** name: COLUMN. Otherwise use zSpan.
1855 **
1856 ** full=ON, short=ANY: If the result refers directly to a table column,
1857 ** then the result column name with the table name
1858 ** prefix, ex: TABLE.COLUMN. Otherwise use zSpan.
1859 */
generateColumnNames(Parse * pParse,Select * pSelect)1860 static void generateColumnNames(
1861 Parse *pParse, /* Parser context */
1862 Select *pSelect /* Generate column names for this SELECT statement */
1863 ){
1864 Vdbe *v = pParse->pVdbe;
1865 int i;
1866 Table *pTab;
1867 SrcList *pTabList;
1868 ExprList *pEList;
1869 sqlite3 *db = pParse->db;
1870 int fullName; /* TABLE.COLUMN if no AS clause and is a direct table ref */
1871 int srcName; /* COLUMN or TABLE.COLUMN if no AS clause and is direct */
1872
1873 #ifndef SQLITE_OMIT_EXPLAIN
1874 /* If this is an EXPLAIN, skip this step */
1875 if( pParse->explain ){
1876 return;
1877 }
1878 #endif
1879
1880 if( pParse->colNamesSet ) return;
1881 /* Column names are determined by the left-most term of a compound select */
1882 while( pSelect->pPrior ) pSelect = pSelect->pPrior;
1883 SELECTTRACE(1,pParse,pSelect,("generating column names\n"));
1884 pTabList = pSelect->pSrc;
1885 pEList = pSelect->pEList;
1886 assert( v!=0 );
1887 assert( pTabList!=0 );
1888 pParse->colNamesSet = 1;
1889 fullName = (db->flags & SQLITE_FullColNames)!=0;
1890 srcName = (db->flags & SQLITE_ShortColNames)!=0 || fullName;
1891 sqlite3VdbeSetNumCols(v, pEList->nExpr);
1892 for(i=0; i<pEList->nExpr; i++){
1893 Expr *p = pEList->a[i].pExpr;
1894
1895 assert( p!=0 );
1896 assert( p->op!=TK_AGG_COLUMN ); /* Agg processing has not run yet */
1897 assert( p->op!=TK_COLUMN || p->y.pTab!=0 ); /* Covering idx not yet coded */
1898 if( pEList->a[i].zEName && pEList->a[i].eEName==ENAME_NAME ){
1899 /* An AS clause always takes first priority */
1900 char *zName = pEList->a[i].zEName;
1901 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_TRANSIENT);
1902 }else if( srcName && p->op==TK_COLUMN ){
1903 char *zCol;
1904 int iCol = p->iColumn;
1905 pTab = p->y.pTab;
1906 assert( pTab!=0 );
1907 if( iCol<0 ) iCol = pTab->iPKey;
1908 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
1909 if( iCol<0 ){
1910 zCol = "rowid";
1911 }else{
1912 zCol = pTab->aCol[iCol].zName;
1913 }
1914 if( fullName ){
1915 char *zName = 0;
1916 zName = sqlite3MPrintf(db, "%s.%s", pTab->zName, zCol);
1917 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_DYNAMIC);
1918 }else{
1919 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zCol, SQLITE_TRANSIENT);
1920 }
1921 }else{
1922 const char *z = pEList->a[i].zEName;
1923 z = z==0 ? sqlite3MPrintf(db, "column%d", i+1) : sqlite3DbStrDup(db, z);
1924 sqlite3VdbeSetColName(v, i, COLNAME_NAME, z, SQLITE_DYNAMIC);
1925 }
1926 }
1927 generateColumnTypes(pParse, pTabList, pEList);
1928 }
1929
1930 /*
1931 ** Given an expression list (which is really the list of expressions
1932 ** that form the result set of a SELECT statement) compute appropriate
1933 ** column names for a table that would hold the expression list.
1934 **
1935 ** All column names will be unique.
1936 **
1937 ** Only the column names are computed. Column.zType, Column.zColl,
1938 ** and other fields of Column are zeroed.
1939 **
1940 ** Return SQLITE_OK on success. If a memory allocation error occurs,
1941 ** store NULL in *paCol and 0 in *pnCol and return SQLITE_NOMEM.
1942 **
1943 ** The only guarantee that SQLite makes about column names is that if the
1944 ** column has an AS clause assigning it a name, that will be the name used.
1945 ** That is the only documented guarantee. However, countless applications
1946 ** developed over the years have made baseless assumptions about column names
1947 ** and will break if those assumptions changes. Hence, use extreme caution
1948 ** when modifying this routine to avoid breaking legacy.
1949 **
1950 ** See Also: generateColumnNames()
1951 */
sqlite3ColumnsFromExprList(Parse * pParse,ExprList * pEList,i16 * pnCol,Column ** paCol)1952 int sqlite3ColumnsFromExprList(
1953 Parse *pParse, /* Parsing context */
1954 ExprList *pEList, /* Expr list from which to derive column names */
1955 i16 *pnCol, /* Write the number of columns here */
1956 Column **paCol /* Write the new column list here */
1957 ){
1958 sqlite3 *db = pParse->db; /* Database connection */
1959 int i, j; /* Loop counters */
1960 u32 cnt; /* Index added to make the name unique */
1961 Column *aCol, *pCol; /* For looping over result columns */
1962 int nCol; /* Number of columns in the result set */
1963 char *zName; /* Column name */
1964 int nName; /* Size of name in zName[] */
1965 Hash ht; /* Hash table of column names */
1966
1967 sqlite3HashInit(&ht);
1968 if( pEList ){
1969 nCol = pEList->nExpr;
1970 aCol = sqlite3DbMallocZero(db, sizeof(aCol[0])*nCol);
1971 testcase( aCol==0 );
1972 if( nCol>32767 ) nCol = 32767;
1973 }else{
1974 nCol = 0;
1975 aCol = 0;
1976 }
1977 assert( nCol==(i16)nCol );
1978 *pnCol = nCol;
1979 *paCol = aCol;
1980
1981 for(i=0, pCol=aCol; i<nCol && !db->mallocFailed; i++, pCol++){
1982 /* Get an appropriate name for the column
1983 */
1984 if( (zName = pEList->a[i].zEName)!=0 && pEList->a[i].eEName==ENAME_NAME ){
1985 /* If the column contains an "AS <name>" phrase, use <name> as the name */
1986 }else{
1987 Expr *pColExpr = sqlite3ExprSkipCollateAndLikely(pEList->a[i].pExpr);
1988 while( pColExpr->op==TK_DOT ){
1989 pColExpr = pColExpr->pRight;
1990 assert( pColExpr!=0 );
1991 }
1992 if( pColExpr->op==TK_COLUMN ){
1993 /* For columns use the column name name */
1994 int iCol = pColExpr->iColumn;
1995 Table *pTab = pColExpr->y.pTab;
1996 assert( pTab!=0 );
1997 if( iCol<0 ) iCol = pTab->iPKey;
1998 zName = iCol>=0 ? pTab->aCol[iCol].zName : "rowid";
1999 }else if( pColExpr->op==TK_ID ){
2000 assert( !ExprHasProperty(pColExpr, EP_IntValue) );
2001 zName = pColExpr->u.zToken;
2002 }else{
2003 /* Use the original text of the column expression as its name */
2004 zName = pEList->a[i].zEName;
2005 }
2006 }
2007 if( zName && !sqlite3IsTrueOrFalse(zName) ){
2008 zName = sqlite3DbStrDup(db, zName);
2009 }else{
2010 zName = sqlite3MPrintf(db,"column%d",i+1);
2011 }
2012
2013 /* Make sure the column name is unique. If the name is not unique,
2014 ** append an integer to the name so that it becomes unique.
2015 */
2016 cnt = 0;
2017 while( zName && sqlite3HashFind(&ht, zName)!=0 ){
2018 nName = sqlite3Strlen30(zName);
2019 if( nName>0 ){
2020 for(j=nName-1; j>0 && sqlite3Isdigit(zName[j]); j--){}
2021 if( zName[j]==':' ) nName = j;
2022 }
2023 zName = sqlite3MPrintf(db, "%.*z:%u", nName, zName, ++cnt);
2024 if( cnt>3 ) sqlite3_randomness(sizeof(cnt), &cnt);
2025 }
2026 pCol->zName = zName;
2027 sqlite3ColumnPropertiesFromName(0, pCol);
2028 if( zName && sqlite3HashInsert(&ht, zName, pCol)==pCol ){
2029 sqlite3OomFault(db);
2030 }
2031 }
2032 sqlite3HashClear(&ht);
2033 if( db->mallocFailed ){
2034 for(j=0; j<i; j++){
2035 sqlite3DbFree(db, aCol[j].zName);
2036 }
2037 sqlite3DbFree(db, aCol);
2038 *paCol = 0;
2039 *pnCol = 0;
2040 return SQLITE_NOMEM_BKPT;
2041 }
2042 return SQLITE_OK;
2043 }
2044
2045 /*
2046 ** Add type and collation information to a column list based on
2047 ** a SELECT statement.
2048 **
2049 ** The column list presumably came from selectColumnNamesFromExprList().
2050 ** The column list has only names, not types or collations. This
2051 ** routine goes through and adds the types and collations.
2052 **
2053 ** This routine requires that all identifiers in the SELECT
2054 ** statement be resolved.
2055 */
sqlite3SelectAddColumnTypeAndCollation(Parse * pParse,Table * pTab,Select * pSelect,char aff)2056 void sqlite3SelectAddColumnTypeAndCollation(
2057 Parse *pParse, /* Parsing contexts */
2058 Table *pTab, /* Add column type information to this table */
2059 Select *pSelect, /* SELECT used to determine types and collations */
2060 char aff /* Default affinity for columns */
2061 ){
2062 sqlite3 *db = pParse->db;
2063 NameContext sNC;
2064 Column *pCol;
2065 CollSeq *pColl;
2066 int i;
2067 Expr *p;
2068 struct ExprList_item *a;
2069
2070 assert( pSelect!=0 );
2071 assert( (pSelect->selFlags & SF_Resolved)!=0 );
2072 assert( pTab->nCol==pSelect->pEList->nExpr || db->mallocFailed );
2073 if( db->mallocFailed ) return;
2074 memset(&sNC, 0, sizeof(sNC));
2075 sNC.pSrcList = pSelect->pSrc;
2076 a = pSelect->pEList->a;
2077 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
2078 const char *zType;
2079 int n, m;
2080 p = a[i].pExpr;
2081 zType = columnType(&sNC, p, 0, 0, 0);
2082 /* pCol->szEst = ... // Column size est for SELECT tables never used */
2083 pCol->affinity = sqlite3ExprAffinity(p);
2084 if( zType ){
2085 m = sqlite3Strlen30(zType);
2086 n = sqlite3Strlen30(pCol->zName);
2087 pCol->zName = sqlite3DbReallocOrFree(db, pCol->zName, n+m+2);
2088 if( pCol->zName ){
2089 memcpy(&pCol->zName[n+1], zType, m+1);
2090 pCol->colFlags |= COLFLAG_HASTYPE;
2091 }
2092 }
2093 if( pCol->affinity<=SQLITE_AFF_NONE ) pCol->affinity = aff;
2094 pColl = sqlite3ExprCollSeq(pParse, p);
2095 if( pColl && pCol->zColl==0 ){
2096 pCol->zColl = sqlite3DbStrDup(db, pColl->zName);
2097 }
2098 }
2099 pTab->szTabRow = 1; /* Any non-zero value works */
2100 }
2101
2102 /*
2103 ** Given a SELECT statement, generate a Table structure that describes
2104 ** the result set of that SELECT.
2105 */
sqlite3ResultSetOfSelect(Parse * pParse,Select * pSelect,char aff)2106 Table *sqlite3ResultSetOfSelect(Parse *pParse, Select *pSelect, char aff){
2107 Table *pTab;
2108 sqlite3 *db = pParse->db;
2109 u64 savedFlags;
2110
2111 savedFlags = db->flags;
2112 db->flags &= ~(u64)SQLITE_FullColNames;
2113 db->flags |= SQLITE_ShortColNames;
2114 sqlite3SelectPrep(pParse, pSelect, 0);
2115 db->flags = savedFlags;
2116 if( pParse->nErr ) return 0;
2117 while( pSelect->pPrior ) pSelect = pSelect->pPrior;
2118 pTab = sqlite3DbMallocZero(db, sizeof(Table) );
2119 if( pTab==0 ){
2120 return 0;
2121 }
2122 pTab->nTabRef = 1;
2123 pTab->zName = 0;
2124 pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
2125 sqlite3ColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
2126 sqlite3SelectAddColumnTypeAndCollation(pParse, pTab, pSelect, aff);
2127 pTab->iPKey = -1;
2128 if( db->mallocFailed ){
2129 sqlite3DeleteTable(db, pTab);
2130 return 0;
2131 }
2132 return pTab;
2133 }
2134
2135 /*
2136 ** Get a VDBE for the given parser context. Create a new one if necessary.
2137 ** If an error occurs, return NULL and leave a message in pParse.
2138 */
sqlite3GetVdbe(Parse * pParse)2139 Vdbe *sqlite3GetVdbe(Parse *pParse){
2140 if( pParse->pVdbe ){
2141 return pParse->pVdbe;
2142 }
2143 if( pParse->pToplevel==0
2144 && OptimizationEnabled(pParse->db,SQLITE_FactorOutConst)
2145 ){
2146 pParse->okConstFactor = 1;
2147 }
2148 return sqlite3VdbeCreate(pParse);
2149 }
2150
2151
2152 /*
2153 ** Compute the iLimit and iOffset fields of the SELECT based on the
2154 ** pLimit expressions. pLimit->pLeft and pLimit->pRight hold the expressions
2155 ** that appear in the original SQL statement after the LIMIT and OFFSET
2156 ** keywords. Or NULL if those keywords are omitted. iLimit and iOffset
2157 ** are the integer memory register numbers for counters used to compute
2158 ** the limit and offset. If there is no limit and/or offset, then
2159 ** iLimit and iOffset are negative.
2160 **
2161 ** This routine changes the values of iLimit and iOffset only if
2162 ** a limit or offset is defined by pLimit->pLeft and pLimit->pRight. iLimit
2163 ** and iOffset should have been preset to appropriate default values (zero)
2164 ** prior to calling this routine.
2165 **
2166 ** The iOffset register (if it exists) is initialized to the value
2167 ** of the OFFSET. The iLimit register is initialized to LIMIT. Register
2168 ** iOffset+1 is initialized to LIMIT+OFFSET.
2169 **
2170 ** Only if pLimit->pLeft!=0 do the limit registers get
2171 ** redefined. The UNION ALL operator uses this property to force
2172 ** the reuse of the same limit and offset registers across multiple
2173 ** SELECT statements.
2174 */
computeLimitRegisters(Parse * pParse,Select * p,int iBreak)2175 static void computeLimitRegisters(Parse *pParse, Select *p, int iBreak){
2176 Vdbe *v = 0;
2177 int iLimit = 0;
2178 int iOffset;
2179 int n;
2180 Expr *pLimit = p->pLimit;
2181
2182 if( p->iLimit ) return;
2183
2184 /*
2185 ** "LIMIT -1" always shows all rows. There is some
2186 ** controversy about what the correct behavior should be.
2187 ** The current implementation interprets "LIMIT 0" to mean
2188 ** no rows.
2189 */
2190 if( pLimit ){
2191 assert( pLimit->op==TK_LIMIT );
2192 assert( pLimit->pLeft!=0 );
2193 p->iLimit = iLimit = ++pParse->nMem;
2194 v = sqlite3GetVdbe(pParse);
2195 assert( v!=0 );
2196 if( sqlite3ExprIsInteger(pLimit->pLeft, &n) ){
2197 sqlite3VdbeAddOp2(v, OP_Integer, n, iLimit);
2198 VdbeComment((v, "LIMIT counter"));
2199 if( n==0 ){
2200 sqlite3VdbeGoto(v, iBreak);
2201 }else if( n>=0 && p->nSelectRow>sqlite3LogEst((u64)n) ){
2202 p->nSelectRow = sqlite3LogEst((u64)n);
2203 p->selFlags |= SF_FixedLimit;
2204 }
2205 }else{
2206 sqlite3ExprCode(pParse, pLimit->pLeft, iLimit);
2207 sqlite3VdbeAddOp1(v, OP_MustBeInt, iLimit); VdbeCoverage(v);
2208 VdbeComment((v, "LIMIT counter"));
2209 sqlite3VdbeAddOp2(v, OP_IfNot, iLimit, iBreak); VdbeCoverage(v);
2210 }
2211 if( pLimit->pRight ){
2212 p->iOffset = iOffset = ++pParse->nMem;
2213 pParse->nMem++; /* Allocate an extra register for limit+offset */
2214 sqlite3ExprCode(pParse, pLimit->pRight, iOffset);
2215 sqlite3VdbeAddOp1(v, OP_MustBeInt, iOffset); VdbeCoverage(v);
2216 VdbeComment((v, "OFFSET counter"));
2217 sqlite3VdbeAddOp3(v, OP_OffsetLimit, iLimit, iOffset+1, iOffset);
2218 VdbeComment((v, "LIMIT+OFFSET"));
2219 }
2220 }
2221 }
2222
2223 #ifndef SQLITE_OMIT_COMPOUND_SELECT
2224 /*
2225 ** Return the appropriate collating sequence for the iCol-th column of
2226 ** the result set for the compound-select statement "p". Return NULL if
2227 ** the column has no default collating sequence.
2228 **
2229 ** The collating sequence for the compound select is taken from the
2230 ** left-most term of the select that has a collating sequence.
2231 */
multiSelectCollSeq(Parse * pParse,Select * p,int iCol)2232 static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){
2233 CollSeq *pRet;
2234 if( p->pPrior ){
2235 pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
2236 }else{
2237 pRet = 0;
2238 }
2239 assert( iCol>=0 );
2240 /* iCol must be less than p->pEList->nExpr. Otherwise an error would
2241 ** have been thrown during name resolution and we would not have gotten
2242 ** this far */
2243 if( pRet==0 && ALWAYS(iCol<p->pEList->nExpr) ){
2244 pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
2245 }
2246 return pRet;
2247 }
2248
2249 /*
2250 ** The select statement passed as the second parameter is a compound SELECT
2251 ** with an ORDER BY clause. This function allocates and returns a KeyInfo
2252 ** structure suitable for implementing the ORDER BY.
2253 **
2254 ** Space to hold the KeyInfo structure is obtained from malloc. The calling
2255 ** function is responsible for ensuring that this structure is eventually
2256 ** freed.
2257 */
multiSelectOrderByKeyInfo(Parse * pParse,Select * p,int nExtra)2258 static KeyInfo *multiSelectOrderByKeyInfo(Parse *pParse, Select *p, int nExtra){
2259 ExprList *pOrderBy = p->pOrderBy;
2260 int nOrderBy = p->pOrderBy->nExpr;
2261 sqlite3 *db = pParse->db;
2262 KeyInfo *pRet = sqlite3KeyInfoAlloc(db, nOrderBy+nExtra, 1);
2263 if( pRet ){
2264 int i;
2265 for(i=0; i<nOrderBy; i++){
2266 struct ExprList_item *pItem = &pOrderBy->a[i];
2267 Expr *pTerm = pItem->pExpr;
2268 CollSeq *pColl;
2269
2270 if( pTerm->flags & EP_Collate ){
2271 pColl = sqlite3ExprCollSeq(pParse, pTerm);
2272 }else{
2273 pColl = multiSelectCollSeq(pParse, p, pItem->u.x.iOrderByCol-1);
2274 if( pColl==0 ) pColl = db->pDfltColl;
2275 pOrderBy->a[i].pExpr =
2276 sqlite3ExprAddCollateString(pParse, pTerm, pColl->zName);
2277 }
2278 assert( sqlite3KeyInfoIsWriteable(pRet) );
2279 pRet->aColl[i] = pColl;
2280 pRet->aSortFlags[i] = pOrderBy->a[i].sortFlags;
2281 }
2282 }
2283
2284 return pRet;
2285 }
2286
2287 #ifndef SQLITE_OMIT_CTE
2288 /*
2289 ** This routine generates VDBE code to compute the content of a WITH RECURSIVE
2290 ** query of the form:
2291 **
2292 ** <recursive-table> AS (<setup-query> UNION [ALL] <recursive-query>)
2293 ** \___________/ \_______________/
2294 ** p->pPrior p
2295 **
2296 **
2297 ** There is exactly one reference to the recursive-table in the FROM clause
2298 ** of recursive-query, marked with the SrcList->a[].fg.isRecursive flag.
2299 **
2300 ** The setup-query runs once to generate an initial set of rows that go
2301 ** into a Queue table. Rows are extracted from the Queue table one by
2302 ** one. Each row extracted from Queue is output to pDest. Then the single
2303 ** extracted row (now in the iCurrent table) becomes the content of the
2304 ** recursive-table for a recursive-query run. The output of the recursive-query
2305 ** is added back into the Queue table. Then another row is extracted from Queue
2306 ** and the iteration continues until the Queue table is empty.
2307 **
2308 ** If the compound query operator is UNION then no duplicate rows are ever
2309 ** inserted into the Queue table. The iDistinct table keeps a copy of all rows
2310 ** that have ever been inserted into Queue and causes duplicates to be
2311 ** discarded. If the operator is UNION ALL, then duplicates are allowed.
2312 **
2313 ** If the query has an ORDER BY, then entries in the Queue table are kept in
2314 ** ORDER BY order and the first entry is extracted for each cycle. Without
2315 ** an ORDER BY, the Queue table is just a FIFO.
2316 **
2317 ** If a LIMIT clause is provided, then the iteration stops after LIMIT rows
2318 ** have been output to pDest. A LIMIT of zero means to output no rows and a
2319 ** negative LIMIT means to output all rows. If there is also an OFFSET clause
2320 ** with a positive value, then the first OFFSET outputs are discarded rather
2321 ** than being sent to pDest. The LIMIT count does not begin until after OFFSET
2322 ** rows have been skipped.
2323 */
generateWithRecursiveQuery(Parse * pParse,Select * p,SelectDest * pDest)2324 static void generateWithRecursiveQuery(
2325 Parse *pParse, /* Parsing context */
2326 Select *p, /* The recursive SELECT to be coded */
2327 SelectDest *pDest /* What to do with query results */
2328 ){
2329 SrcList *pSrc = p->pSrc; /* The FROM clause of the recursive query */
2330 int nCol = p->pEList->nExpr; /* Number of columns in the recursive table */
2331 Vdbe *v = pParse->pVdbe; /* The prepared statement under construction */
2332 Select *pSetup = p->pPrior; /* The setup query */
2333 int addrTop; /* Top of the loop */
2334 int addrCont, addrBreak; /* CONTINUE and BREAK addresses */
2335 int iCurrent = 0; /* The Current table */
2336 int regCurrent; /* Register holding Current table */
2337 int iQueue; /* The Queue table */
2338 int iDistinct = 0; /* To ensure unique results if UNION */
2339 int eDest = SRT_Fifo; /* How to write to Queue */
2340 SelectDest destQueue; /* SelectDest targetting the Queue table */
2341 int i; /* Loop counter */
2342 int rc; /* Result code */
2343 ExprList *pOrderBy; /* The ORDER BY clause */
2344 Expr *pLimit; /* Saved LIMIT and OFFSET */
2345 int regLimit, regOffset; /* Registers used by LIMIT and OFFSET */
2346
2347 #ifndef SQLITE_OMIT_WINDOWFUNC
2348 if( p->pWin ){
2349 sqlite3ErrorMsg(pParse, "cannot use window functions in recursive queries");
2350 return;
2351 }
2352 #endif
2353
2354 /* Obtain authorization to do a recursive query */
2355 if( sqlite3AuthCheck(pParse, SQLITE_RECURSIVE, 0, 0, 0) ) return;
2356
2357 /* Process the LIMIT and OFFSET clauses, if they exist */
2358 addrBreak = sqlite3VdbeMakeLabel(pParse);
2359 p->nSelectRow = 320; /* 4 billion rows */
2360 computeLimitRegisters(pParse, p, addrBreak);
2361 pLimit = p->pLimit;
2362 regLimit = p->iLimit;
2363 regOffset = p->iOffset;
2364 p->pLimit = 0;
2365 p->iLimit = p->iOffset = 0;
2366 pOrderBy = p->pOrderBy;
2367
2368 /* Locate the cursor number of the Current table */
2369 for(i=0; ALWAYS(i<pSrc->nSrc); i++){
2370 if( pSrc->a[i].fg.isRecursive ){
2371 iCurrent = pSrc->a[i].iCursor;
2372 break;
2373 }
2374 }
2375
2376 /* Allocate cursors numbers for Queue and Distinct. The cursor number for
2377 ** the Distinct table must be exactly one greater than Queue in order
2378 ** for the SRT_DistFifo and SRT_DistQueue destinations to work. */
2379 iQueue = pParse->nTab++;
2380 if( p->op==TK_UNION ){
2381 eDest = pOrderBy ? SRT_DistQueue : SRT_DistFifo;
2382 iDistinct = pParse->nTab++;
2383 }else{
2384 eDest = pOrderBy ? SRT_Queue : SRT_Fifo;
2385 }
2386 sqlite3SelectDestInit(&destQueue, eDest, iQueue);
2387
2388 /* Allocate cursors for Current, Queue, and Distinct. */
2389 regCurrent = ++pParse->nMem;
2390 sqlite3VdbeAddOp3(v, OP_OpenPseudo, iCurrent, regCurrent, nCol);
2391 if( pOrderBy ){
2392 KeyInfo *pKeyInfo = multiSelectOrderByKeyInfo(pParse, p, 1);
2393 sqlite3VdbeAddOp4(v, OP_OpenEphemeral, iQueue, pOrderBy->nExpr+2, 0,
2394 (char*)pKeyInfo, P4_KEYINFO);
2395 destQueue.pOrderBy = pOrderBy;
2396 }else{
2397 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iQueue, nCol);
2398 }
2399 VdbeComment((v, "Queue table"));
2400 if( iDistinct ){
2401 p->addrOpenEphm[0] = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iDistinct, 0);
2402 p->selFlags |= SF_UsesEphemeral;
2403 }
2404
2405 /* Detach the ORDER BY clause from the compound SELECT */
2406 p->pOrderBy = 0;
2407
2408 /* Store the results of the setup-query in Queue. */
2409 pSetup->pNext = 0;
2410 ExplainQueryPlan((pParse, 1, "SETUP"));
2411 rc = sqlite3Select(pParse, pSetup, &destQueue);
2412 pSetup->pNext = p;
2413 if( rc ) goto end_of_recursive_query;
2414
2415 /* Find the next row in the Queue and output that row */
2416 addrTop = sqlite3VdbeAddOp2(v, OP_Rewind, iQueue, addrBreak); VdbeCoverage(v);
2417
2418 /* Transfer the next row in Queue over to Current */
2419 sqlite3VdbeAddOp1(v, OP_NullRow, iCurrent); /* To reset column cache */
2420 if( pOrderBy ){
2421 sqlite3VdbeAddOp3(v, OP_Column, iQueue, pOrderBy->nExpr+1, regCurrent);
2422 }else{
2423 sqlite3VdbeAddOp2(v, OP_RowData, iQueue, regCurrent);
2424 }
2425 sqlite3VdbeAddOp1(v, OP_Delete, iQueue);
2426
2427 /* Output the single row in Current */
2428 addrCont = sqlite3VdbeMakeLabel(pParse);
2429 codeOffset(v, regOffset, addrCont);
2430 selectInnerLoop(pParse, p, iCurrent,
2431 0, 0, pDest, addrCont, addrBreak);
2432 if( regLimit ){
2433 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, regLimit, addrBreak);
2434 VdbeCoverage(v);
2435 }
2436 sqlite3VdbeResolveLabel(v, addrCont);
2437
2438 /* Execute the recursive SELECT taking the single row in Current as
2439 ** the value for the recursive-table. Store the results in the Queue.
2440 */
2441 if( p->selFlags & SF_Aggregate ){
2442 sqlite3ErrorMsg(pParse, "recursive aggregate queries not supported");
2443 }else{
2444 p->pPrior = 0;
2445 ExplainQueryPlan((pParse, 1, "RECURSIVE STEP"));
2446 sqlite3Select(pParse, p, &destQueue);
2447 assert( p->pPrior==0 );
2448 p->pPrior = pSetup;
2449 }
2450
2451 /* Keep running the loop until the Queue is empty */
2452 sqlite3VdbeGoto(v, addrTop);
2453 sqlite3VdbeResolveLabel(v, addrBreak);
2454
2455 end_of_recursive_query:
2456 sqlite3ExprListDelete(pParse->db, p->pOrderBy);
2457 p->pOrderBy = pOrderBy;
2458 p->pLimit = pLimit;
2459 return;
2460 }
2461 #endif /* SQLITE_OMIT_CTE */
2462
2463 /* Forward references */
2464 static int multiSelectOrderBy(
2465 Parse *pParse, /* Parsing context */
2466 Select *p, /* The right-most of SELECTs to be coded */
2467 SelectDest *pDest /* What to do with query results */
2468 );
2469
2470 /*
2471 ** Handle the special case of a compound-select that originates from a
2472 ** VALUES clause. By handling this as a special case, we avoid deep
2473 ** recursion, and thus do not need to enforce the SQLITE_LIMIT_COMPOUND_SELECT
2474 ** on a VALUES clause.
2475 **
2476 ** Because the Select object originates from a VALUES clause:
2477 ** (1) There is no LIMIT or OFFSET or else there is a LIMIT of exactly 1
2478 ** (2) All terms are UNION ALL
2479 ** (3) There is no ORDER BY clause
2480 **
2481 ** The "LIMIT of exactly 1" case of condition (1) comes about when a VALUES
2482 ** clause occurs within scalar expression (ex: "SELECT (VALUES(1),(2),(3))").
2483 ** The sqlite3CodeSubselect will have added the LIMIT 1 clause in tht case.
2484 ** Since the limit is exactly 1, we only need to evalutes the left-most VALUES.
2485 */
multiSelectValues(Parse * pParse,Select * p,SelectDest * pDest)2486 static int multiSelectValues(
2487 Parse *pParse, /* Parsing context */
2488 Select *p, /* The right-most of SELECTs to be coded */
2489 SelectDest *pDest /* What to do with query results */
2490 ){
2491 int nRow = 1;
2492 int rc = 0;
2493 int bShowAll = p->pLimit==0;
2494 assert( p->selFlags & SF_MultiValue );
2495 do{
2496 assert( p->selFlags & SF_Values );
2497 assert( p->op==TK_ALL || (p->op==TK_SELECT && p->pPrior==0) );
2498 assert( p->pNext==0 || p->pEList->nExpr==p->pNext->pEList->nExpr );
2499 #ifndef SQLITE_OMIT_WINDOWFUNC
2500 if( p->pWin ) return -1;
2501 #endif
2502 if( p->pPrior==0 ) break;
2503 assert( p->pPrior->pNext==p );
2504 p = p->pPrior;
2505 nRow += bShowAll;
2506 }while(1);
2507 ExplainQueryPlan((pParse, 0, "SCAN %d CONSTANT ROW%s", nRow,
2508 nRow==1 ? "" : "S"));
2509 while( p ){
2510 selectInnerLoop(pParse, p, -1, 0, 0, pDest, 1, 1);
2511 if( !bShowAll ) break;
2512 p->nSelectRow = nRow;
2513 p = p->pNext;
2514 }
2515 return rc;
2516 }
2517
2518 /*
2519 ** This routine is called to process a compound query form from
2520 ** two or more separate queries using UNION, UNION ALL, EXCEPT, or
2521 ** INTERSECT
2522 **
2523 ** "p" points to the right-most of the two queries. the query on the
2524 ** left is p->pPrior. The left query could also be a compound query
2525 ** in which case this routine will be called recursively.
2526 **
2527 ** The results of the total query are to be written into a destination
2528 ** of type eDest with parameter iParm.
2529 **
2530 ** Example 1: Consider a three-way compound SQL statement.
2531 **
2532 ** SELECT a FROM t1 UNION SELECT b FROM t2 UNION SELECT c FROM t3
2533 **
2534 ** This statement is parsed up as follows:
2535 **
2536 ** SELECT c FROM t3
2537 ** |
2538 ** `-----> SELECT b FROM t2
2539 ** |
2540 ** `------> SELECT a FROM t1
2541 **
2542 ** The arrows in the diagram above represent the Select.pPrior pointer.
2543 ** So if this routine is called with p equal to the t3 query, then
2544 ** pPrior will be the t2 query. p->op will be TK_UNION in this case.
2545 **
2546 ** Notice that because of the way SQLite parses compound SELECTs, the
2547 ** individual selects always group from left to right.
2548 */
multiSelect(Parse * pParse,Select * p,SelectDest * pDest)2549 static int multiSelect(
2550 Parse *pParse, /* Parsing context */
2551 Select *p, /* The right-most of SELECTs to be coded */
2552 SelectDest *pDest /* What to do with query results */
2553 ){
2554 int rc = SQLITE_OK; /* Success code from a subroutine */
2555 Select *pPrior; /* Another SELECT immediately to our left */
2556 Vdbe *v; /* Generate code to this VDBE */
2557 SelectDest dest; /* Alternative data destination */
2558 Select *pDelete = 0; /* Chain of simple selects to delete */
2559 sqlite3 *db; /* Database connection */
2560
2561 /* Make sure there is no ORDER BY or LIMIT clause on prior SELECTs. Only
2562 ** the last (right-most) SELECT in the series may have an ORDER BY or LIMIT.
2563 */
2564 assert( p && p->pPrior ); /* Calling function guarantees this much */
2565 assert( (p->selFlags & SF_Recursive)==0 || p->op==TK_ALL || p->op==TK_UNION );
2566 assert( p->selFlags & SF_Compound );
2567 db = pParse->db;
2568 pPrior = p->pPrior;
2569 dest = *pDest;
2570 if( pPrior->pOrderBy || pPrior->pLimit ){
2571 sqlite3ErrorMsg(pParse,"%s clause should come after %s not before",
2572 pPrior->pOrderBy!=0 ? "ORDER BY" : "LIMIT", selectOpName(p->op));
2573 rc = 1;
2574 goto multi_select_end;
2575 }
2576
2577 v = sqlite3GetVdbe(pParse);
2578 assert( v!=0 ); /* The VDBE already created by calling function */
2579
2580 /* Create the destination temporary table if necessary
2581 */
2582 if( dest.eDest==SRT_EphemTab ){
2583 assert( p->pEList );
2584 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, dest.iSDParm, p->pEList->nExpr);
2585 dest.eDest = SRT_Table;
2586 }
2587
2588 /* Special handling for a compound-select that originates as a VALUES clause.
2589 */
2590 if( p->selFlags & SF_MultiValue ){
2591 rc = multiSelectValues(pParse, p, &dest);
2592 if( rc>=0 ) goto multi_select_end;
2593 rc = SQLITE_OK;
2594 }
2595
2596 /* Make sure all SELECTs in the statement have the same number of elements
2597 ** in their result sets.
2598 */
2599 assert( p->pEList && pPrior->pEList );
2600 assert( p->pEList->nExpr==pPrior->pEList->nExpr );
2601
2602 #ifndef SQLITE_OMIT_CTE
2603 if( p->selFlags & SF_Recursive ){
2604 generateWithRecursiveQuery(pParse, p, &dest);
2605 }else
2606 #endif
2607
2608 /* Compound SELECTs that have an ORDER BY clause are handled separately.
2609 */
2610 if( p->pOrderBy ){
2611 return multiSelectOrderBy(pParse, p, pDest);
2612 }else{
2613
2614 #ifndef SQLITE_OMIT_EXPLAIN
2615 if( pPrior->pPrior==0 ){
2616 ExplainQueryPlan((pParse, 1, "COMPOUND QUERY"));
2617 ExplainQueryPlan((pParse, 1, "LEFT-MOST SUBQUERY"));
2618 }
2619 #endif
2620
2621 /* Generate code for the left and right SELECT statements.
2622 */
2623 switch( p->op ){
2624 case TK_ALL: {
2625 int addr = 0;
2626 int nLimit;
2627 assert( !pPrior->pLimit );
2628 pPrior->iLimit = p->iLimit;
2629 pPrior->iOffset = p->iOffset;
2630 pPrior->pLimit = p->pLimit;
2631 rc = sqlite3Select(pParse, pPrior, &dest);
2632 p->pLimit = 0;
2633 if( rc ){
2634 goto multi_select_end;
2635 }
2636 p->pPrior = 0;
2637 p->iLimit = pPrior->iLimit;
2638 p->iOffset = pPrior->iOffset;
2639 if( p->iLimit ){
2640 addr = sqlite3VdbeAddOp1(v, OP_IfNot, p->iLimit); VdbeCoverage(v);
2641 VdbeComment((v, "Jump ahead if LIMIT reached"));
2642 if( p->iOffset ){
2643 sqlite3VdbeAddOp3(v, OP_OffsetLimit,
2644 p->iLimit, p->iOffset+1, p->iOffset);
2645 }
2646 }
2647 ExplainQueryPlan((pParse, 1, "UNION ALL"));
2648 rc = sqlite3Select(pParse, p, &dest);
2649 testcase( rc!=SQLITE_OK );
2650 pDelete = p->pPrior;
2651 p->pPrior = pPrior;
2652 p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow);
2653 if( pPrior->pLimit
2654 && sqlite3ExprIsInteger(pPrior->pLimit->pLeft, &nLimit)
2655 && nLimit>0 && p->nSelectRow > sqlite3LogEst((u64)nLimit)
2656 ){
2657 p->nSelectRow = sqlite3LogEst((u64)nLimit);
2658 }
2659 if( addr ){
2660 sqlite3VdbeJumpHere(v, addr);
2661 }
2662 break;
2663 }
2664 case TK_EXCEPT:
2665 case TK_UNION: {
2666 int unionTab; /* Cursor number of the temp table holding result */
2667 u8 op = 0; /* One of the SRT_ operations to apply to self */
2668 int priorOp; /* The SRT_ operation to apply to prior selects */
2669 Expr *pLimit; /* Saved values of p->nLimit */
2670 int addr;
2671 SelectDest uniondest;
2672
2673 testcase( p->op==TK_EXCEPT );
2674 testcase( p->op==TK_UNION );
2675 priorOp = SRT_Union;
2676 if( dest.eDest==priorOp ){
2677 /* We can reuse a temporary table generated by a SELECT to our
2678 ** right.
2679 */
2680 assert( p->pLimit==0 ); /* Not allowed on leftward elements */
2681 unionTab = dest.iSDParm;
2682 }else{
2683 /* We will need to create our own temporary table to hold the
2684 ** intermediate results.
2685 */
2686 unionTab = pParse->nTab++;
2687 assert( p->pOrderBy==0 );
2688 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, unionTab, 0);
2689 assert( p->addrOpenEphm[0] == -1 );
2690 p->addrOpenEphm[0] = addr;
2691 findRightmost(p)->selFlags |= SF_UsesEphemeral;
2692 assert( p->pEList );
2693 }
2694
2695 /* Code the SELECT statements to our left
2696 */
2697 assert( !pPrior->pOrderBy );
2698 sqlite3SelectDestInit(&uniondest, priorOp, unionTab);
2699 rc = sqlite3Select(pParse, pPrior, &uniondest);
2700 if( rc ){
2701 goto multi_select_end;
2702 }
2703
2704 /* Code the current SELECT statement
2705 */
2706 if( p->op==TK_EXCEPT ){
2707 op = SRT_Except;
2708 }else{
2709 assert( p->op==TK_UNION );
2710 op = SRT_Union;
2711 }
2712 p->pPrior = 0;
2713 pLimit = p->pLimit;
2714 p->pLimit = 0;
2715 uniondest.eDest = op;
2716 ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE",
2717 selectOpName(p->op)));
2718 rc = sqlite3Select(pParse, p, &uniondest);
2719 testcase( rc!=SQLITE_OK );
2720 /* Query flattening in sqlite3Select() might refill p->pOrderBy.
2721 ** Be sure to delete p->pOrderBy, therefore, to avoid a memory leak. */
2722 sqlite3ExprListDelete(db, p->pOrderBy);
2723 pDelete = p->pPrior;
2724 p->pPrior = pPrior;
2725 p->pOrderBy = 0;
2726 if( p->op==TK_UNION ){
2727 p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow);
2728 }
2729 sqlite3ExprDelete(db, p->pLimit);
2730 p->pLimit = pLimit;
2731 p->iLimit = 0;
2732 p->iOffset = 0;
2733
2734 /* Convert the data in the temporary table into whatever form
2735 ** it is that we currently need.
2736 */
2737 assert( unionTab==dest.iSDParm || dest.eDest!=priorOp );
2738 assert( p->pEList || db->mallocFailed );
2739 if( dest.eDest!=priorOp && db->mallocFailed==0 ){
2740 int iCont, iBreak, iStart;
2741 iBreak = sqlite3VdbeMakeLabel(pParse);
2742 iCont = sqlite3VdbeMakeLabel(pParse);
2743 computeLimitRegisters(pParse, p, iBreak);
2744 sqlite3VdbeAddOp2(v, OP_Rewind, unionTab, iBreak); VdbeCoverage(v);
2745 iStart = sqlite3VdbeCurrentAddr(v);
2746 selectInnerLoop(pParse, p, unionTab,
2747 0, 0, &dest, iCont, iBreak);
2748 sqlite3VdbeResolveLabel(v, iCont);
2749 sqlite3VdbeAddOp2(v, OP_Next, unionTab, iStart); VdbeCoverage(v);
2750 sqlite3VdbeResolveLabel(v, iBreak);
2751 sqlite3VdbeAddOp2(v, OP_Close, unionTab, 0);
2752 }
2753 break;
2754 }
2755 default: assert( p->op==TK_INTERSECT ); {
2756 int tab1, tab2;
2757 int iCont, iBreak, iStart;
2758 Expr *pLimit;
2759 int addr;
2760 SelectDest intersectdest;
2761 int r1;
2762
2763 /* INTERSECT is different from the others since it requires
2764 ** two temporary tables. Hence it has its own case. Begin
2765 ** by allocating the tables we will need.
2766 */
2767 tab1 = pParse->nTab++;
2768 tab2 = pParse->nTab++;
2769 assert( p->pOrderBy==0 );
2770
2771 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab1, 0);
2772 assert( p->addrOpenEphm[0] == -1 );
2773 p->addrOpenEphm[0] = addr;
2774 findRightmost(p)->selFlags |= SF_UsesEphemeral;
2775 assert( p->pEList );
2776
2777 /* Code the SELECTs to our left into temporary table "tab1".
2778 */
2779 sqlite3SelectDestInit(&intersectdest, SRT_Union, tab1);
2780 rc = sqlite3Select(pParse, pPrior, &intersectdest);
2781 if( rc ){
2782 goto multi_select_end;
2783 }
2784
2785 /* Code the current SELECT into temporary table "tab2"
2786 */
2787 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab2, 0);
2788 assert( p->addrOpenEphm[1] == -1 );
2789 p->addrOpenEphm[1] = addr;
2790 p->pPrior = 0;
2791 pLimit = p->pLimit;
2792 p->pLimit = 0;
2793 intersectdest.iSDParm = tab2;
2794 ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE",
2795 selectOpName(p->op)));
2796 rc = sqlite3Select(pParse, p, &intersectdest);
2797 testcase( rc!=SQLITE_OK );
2798 pDelete = p->pPrior;
2799 p->pPrior = pPrior;
2800 if( p->nSelectRow>pPrior->nSelectRow ){
2801 p->nSelectRow = pPrior->nSelectRow;
2802 }
2803 sqlite3ExprDelete(db, p->pLimit);
2804 p->pLimit = pLimit;
2805
2806 /* Generate code to take the intersection of the two temporary
2807 ** tables.
2808 */
2809 assert( p->pEList );
2810 iBreak = sqlite3VdbeMakeLabel(pParse);
2811 iCont = sqlite3VdbeMakeLabel(pParse);
2812 computeLimitRegisters(pParse, p, iBreak);
2813 sqlite3VdbeAddOp2(v, OP_Rewind, tab1, iBreak); VdbeCoverage(v);
2814 r1 = sqlite3GetTempReg(pParse);
2815 iStart = sqlite3VdbeAddOp2(v, OP_RowData, tab1, r1);
2816 sqlite3VdbeAddOp4Int(v, OP_NotFound, tab2, iCont, r1, 0);
2817 VdbeCoverage(v);
2818 sqlite3ReleaseTempReg(pParse, r1);
2819 selectInnerLoop(pParse, p, tab1,
2820 0, 0, &dest, iCont, iBreak);
2821 sqlite3VdbeResolveLabel(v, iCont);
2822 sqlite3VdbeAddOp2(v, OP_Next, tab1, iStart); VdbeCoverage(v);
2823 sqlite3VdbeResolveLabel(v, iBreak);
2824 sqlite3VdbeAddOp2(v, OP_Close, tab2, 0);
2825 sqlite3VdbeAddOp2(v, OP_Close, tab1, 0);
2826 break;
2827 }
2828 }
2829
2830 #ifndef SQLITE_OMIT_EXPLAIN
2831 if( p->pNext==0 ){
2832 ExplainQueryPlanPop(pParse);
2833 }
2834 #endif
2835 }
2836 if( pParse->nErr ) goto multi_select_end;
2837
2838 /* Compute collating sequences used by
2839 ** temporary tables needed to implement the compound select.
2840 ** Attach the KeyInfo structure to all temporary tables.
2841 **
2842 ** This section is run by the right-most SELECT statement only.
2843 ** SELECT statements to the left always skip this part. The right-most
2844 ** SELECT might also skip this part if it has no ORDER BY clause and
2845 ** no temp tables are required.
2846 */
2847 if( p->selFlags & SF_UsesEphemeral ){
2848 int i; /* Loop counter */
2849 KeyInfo *pKeyInfo; /* Collating sequence for the result set */
2850 Select *pLoop; /* For looping through SELECT statements */
2851 CollSeq **apColl; /* For looping through pKeyInfo->aColl[] */
2852 int nCol; /* Number of columns in result set */
2853
2854 assert( p->pNext==0 );
2855 nCol = p->pEList->nExpr;
2856 pKeyInfo = sqlite3KeyInfoAlloc(db, nCol, 1);
2857 if( !pKeyInfo ){
2858 rc = SQLITE_NOMEM_BKPT;
2859 goto multi_select_end;
2860 }
2861 for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
2862 *apColl = multiSelectCollSeq(pParse, p, i);
2863 if( 0==*apColl ){
2864 *apColl = db->pDfltColl;
2865 }
2866 }
2867
2868 for(pLoop=p; pLoop; pLoop=pLoop->pPrior){
2869 for(i=0; i<2; i++){
2870 int addr = pLoop->addrOpenEphm[i];
2871 if( addr<0 ){
2872 /* If [0] is unused then [1] is also unused. So we can
2873 ** always safely abort as soon as the first unused slot is found */
2874 assert( pLoop->addrOpenEphm[1]<0 );
2875 break;
2876 }
2877 sqlite3VdbeChangeP2(v, addr, nCol);
2878 sqlite3VdbeChangeP4(v, addr, (char*)sqlite3KeyInfoRef(pKeyInfo),
2879 P4_KEYINFO);
2880 pLoop->addrOpenEphm[i] = -1;
2881 }
2882 }
2883 sqlite3KeyInfoUnref(pKeyInfo);
2884 }
2885
2886 multi_select_end:
2887 pDest->iSdst = dest.iSdst;
2888 pDest->nSdst = dest.nSdst;
2889 sqlite3SelectDelete(db, pDelete);
2890 return rc;
2891 }
2892 #endif /* SQLITE_OMIT_COMPOUND_SELECT */
2893
2894 /*
2895 ** Error message for when two or more terms of a compound select have different
2896 ** size result sets.
2897 */
sqlite3SelectWrongNumTermsError(Parse * pParse,Select * p)2898 void sqlite3SelectWrongNumTermsError(Parse *pParse, Select *p){
2899 if( p->selFlags & SF_Values ){
2900 sqlite3ErrorMsg(pParse, "all VALUES must have the same number of terms");
2901 }else{
2902 sqlite3ErrorMsg(pParse, "SELECTs to the left and right of %s"
2903 " do not have the same number of result columns", selectOpName(p->op));
2904 }
2905 }
2906
2907 /*
2908 ** Code an output subroutine for a coroutine implementation of a
2909 ** SELECT statment.
2910 **
2911 ** The data to be output is contained in pIn->iSdst. There are
2912 ** pIn->nSdst columns to be output. pDest is where the output should
2913 ** be sent.
2914 **
2915 ** regReturn is the number of the register holding the subroutine
2916 ** return address.
2917 **
2918 ** If regPrev>0 then it is the first register in a vector that
2919 ** records the previous output. mem[regPrev] is a flag that is false
2920 ** if there has been no previous output. If regPrev>0 then code is
2921 ** generated to suppress duplicates. pKeyInfo is used for comparing
2922 ** keys.
2923 **
2924 ** If the LIMIT found in p->iLimit is reached, jump immediately to
2925 ** iBreak.
2926 */
generateOutputSubroutine(Parse * pParse,Select * p,SelectDest * pIn,SelectDest * pDest,int regReturn,int regPrev,KeyInfo * pKeyInfo,int iBreak)2927 static int generateOutputSubroutine(
2928 Parse *pParse, /* Parsing context */
2929 Select *p, /* The SELECT statement */
2930 SelectDest *pIn, /* Coroutine supplying data */
2931 SelectDest *pDest, /* Where to send the data */
2932 int regReturn, /* The return address register */
2933 int regPrev, /* Previous result register. No uniqueness if 0 */
2934 KeyInfo *pKeyInfo, /* For comparing with previous entry */
2935 int iBreak /* Jump here if we hit the LIMIT */
2936 ){
2937 Vdbe *v = pParse->pVdbe;
2938 int iContinue;
2939 int addr;
2940
2941 addr = sqlite3VdbeCurrentAddr(v);
2942 iContinue = sqlite3VdbeMakeLabel(pParse);
2943
2944 /* Suppress duplicates for UNION, EXCEPT, and INTERSECT
2945 */
2946 if( regPrev ){
2947 int addr1, addr2;
2948 addr1 = sqlite3VdbeAddOp1(v, OP_IfNot, regPrev); VdbeCoverage(v);
2949 addr2 = sqlite3VdbeAddOp4(v, OP_Compare, pIn->iSdst, regPrev+1, pIn->nSdst,
2950 (char*)sqlite3KeyInfoRef(pKeyInfo), P4_KEYINFO);
2951 sqlite3VdbeAddOp3(v, OP_Jump, addr2+2, iContinue, addr2+2); VdbeCoverage(v);
2952 sqlite3VdbeJumpHere(v, addr1);
2953 sqlite3VdbeAddOp3(v, OP_Copy, pIn->iSdst, regPrev+1, pIn->nSdst-1);
2954 sqlite3VdbeAddOp2(v, OP_Integer, 1, regPrev);
2955 }
2956 if( pParse->db->mallocFailed ) return 0;
2957
2958 /* Suppress the first OFFSET entries if there is an OFFSET clause
2959 */
2960 codeOffset(v, p->iOffset, iContinue);
2961
2962 assert( pDest->eDest!=SRT_Exists );
2963 assert( pDest->eDest!=SRT_Table );
2964 switch( pDest->eDest ){
2965 /* Store the result as data using a unique key.
2966 */
2967 case SRT_EphemTab: {
2968 int r1 = sqlite3GetTempReg(pParse);
2969 int r2 = sqlite3GetTempReg(pParse);
2970 sqlite3VdbeAddOp3(v, OP_MakeRecord, pIn->iSdst, pIn->nSdst, r1);
2971 sqlite3VdbeAddOp2(v, OP_NewRowid, pDest->iSDParm, r2);
2972 sqlite3VdbeAddOp3(v, OP_Insert, pDest->iSDParm, r1, r2);
2973 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
2974 sqlite3ReleaseTempReg(pParse, r2);
2975 sqlite3ReleaseTempReg(pParse, r1);
2976 break;
2977 }
2978
2979 #ifndef SQLITE_OMIT_SUBQUERY
2980 /* If we are creating a set for an "expr IN (SELECT ...)".
2981 */
2982 case SRT_Set: {
2983 int r1;
2984 testcase( pIn->nSdst>1 );
2985 r1 = sqlite3GetTempReg(pParse);
2986 sqlite3VdbeAddOp4(v, OP_MakeRecord, pIn->iSdst, pIn->nSdst,
2987 r1, pDest->zAffSdst, pIn->nSdst);
2988 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, pDest->iSDParm, r1,
2989 pIn->iSdst, pIn->nSdst);
2990 sqlite3ReleaseTempReg(pParse, r1);
2991 break;
2992 }
2993
2994 /* If this is a scalar select that is part of an expression, then
2995 ** store the results in the appropriate memory cell and break out
2996 ** of the scan loop. Note that the select might return multiple columns
2997 ** if it is the RHS of a row-value IN operator.
2998 */
2999 case SRT_Mem: {
3000 if( pParse->nErr==0 ){
3001 testcase( pIn->nSdst>1 );
3002 sqlite3ExprCodeMove(pParse, pIn->iSdst, pDest->iSDParm, pIn->nSdst);
3003 }
3004 /* The LIMIT clause will jump out of the loop for us */
3005 break;
3006 }
3007 #endif /* #ifndef SQLITE_OMIT_SUBQUERY */
3008
3009 /* The results are stored in a sequence of registers
3010 ** starting at pDest->iSdst. Then the co-routine yields.
3011 */
3012 case SRT_Coroutine: {
3013 if( pDest->iSdst==0 ){
3014 pDest->iSdst = sqlite3GetTempRange(pParse, pIn->nSdst);
3015 pDest->nSdst = pIn->nSdst;
3016 }
3017 sqlite3ExprCodeMove(pParse, pIn->iSdst, pDest->iSdst, pIn->nSdst);
3018 sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm);
3019 break;
3020 }
3021
3022 /* If none of the above, then the result destination must be
3023 ** SRT_Output. This routine is never called with any other
3024 ** destination other than the ones handled above or SRT_Output.
3025 **
3026 ** For SRT_Output, results are stored in a sequence of registers.
3027 ** Then the OP_ResultRow opcode is used to cause sqlite3_step() to
3028 ** return the next row of result.
3029 */
3030 default: {
3031 assert( pDest->eDest==SRT_Output );
3032 sqlite3VdbeAddOp2(v, OP_ResultRow, pIn->iSdst, pIn->nSdst);
3033 break;
3034 }
3035 }
3036
3037 /* Jump to the end of the loop if the LIMIT is reached.
3038 */
3039 if( p->iLimit ){
3040 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak); VdbeCoverage(v);
3041 }
3042
3043 /* Generate the subroutine return
3044 */
3045 sqlite3VdbeResolveLabel(v, iContinue);
3046 sqlite3VdbeAddOp1(v, OP_Return, regReturn);
3047
3048 return addr;
3049 }
3050
3051 /*
3052 ** Alternative compound select code generator for cases when there
3053 ** is an ORDER BY clause.
3054 **
3055 ** We assume a query of the following form:
3056 **
3057 ** <selectA> <operator> <selectB> ORDER BY <orderbylist>
3058 **
3059 ** <operator> is one of UNION ALL, UNION, EXCEPT, or INTERSECT. The idea
3060 ** is to code both <selectA> and <selectB> with the ORDER BY clause as
3061 ** co-routines. Then run the co-routines in parallel and merge the results
3062 ** into the output. In addition to the two coroutines (called selectA and
3063 ** selectB) there are 7 subroutines:
3064 **
3065 ** outA: Move the output of the selectA coroutine into the output
3066 ** of the compound query.
3067 **
3068 ** outB: Move the output of the selectB coroutine into the output
3069 ** of the compound query. (Only generated for UNION and
3070 ** UNION ALL. EXCEPT and INSERTSECT never output a row that
3071 ** appears only in B.)
3072 **
3073 ** AltB: Called when there is data from both coroutines and A<B.
3074 **
3075 ** AeqB: Called when there is data from both coroutines and A==B.
3076 **
3077 ** AgtB: Called when there is data from both coroutines and A>B.
3078 **
3079 ** EofA: Called when data is exhausted from selectA.
3080 **
3081 ** EofB: Called when data is exhausted from selectB.
3082 **
3083 ** The implementation of the latter five subroutines depend on which
3084 ** <operator> is used:
3085 **
3086 **
3087 ** UNION ALL UNION EXCEPT INTERSECT
3088 ** ------------- ----------------- -------------- -----------------
3089 ** AltB: outA, nextA outA, nextA outA, nextA nextA
3090 **
3091 ** AeqB: outA, nextA nextA nextA outA, nextA
3092 **
3093 ** AgtB: outB, nextB outB, nextB nextB nextB
3094 **
3095 ** EofA: outB, nextB outB, nextB halt halt
3096 **
3097 ** EofB: outA, nextA outA, nextA outA, nextA halt
3098 **
3099 ** In the AltB, AeqB, and AgtB subroutines, an EOF on A following nextA
3100 ** causes an immediate jump to EofA and an EOF on B following nextB causes
3101 ** an immediate jump to EofB. Within EofA and EofB, and EOF on entry or
3102 ** following nextX causes a jump to the end of the select processing.
3103 **
3104 ** Duplicate removal in the UNION, EXCEPT, and INTERSECT cases is handled
3105 ** within the output subroutine. The regPrev register set holds the previously
3106 ** output value. A comparison is made against this value and the output
3107 ** is skipped if the next results would be the same as the previous.
3108 **
3109 ** The implementation plan is to implement the two coroutines and seven
3110 ** subroutines first, then put the control logic at the bottom. Like this:
3111 **
3112 ** goto Init
3113 ** coA: coroutine for left query (A)
3114 ** coB: coroutine for right query (B)
3115 ** outA: output one row of A
3116 ** outB: output one row of B (UNION and UNION ALL only)
3117 ** EofA: ...
3118 ** EofB: ...
3119 ** AltB: ...
3120 ** AeqB: ...
3121 ** AgtB: ...
3122 ** Init: initialize coroutine registers
3123 ** yield coA
3124 ** if eof(A) goto EofA
3125 ** yield coB
3126 ** if eof(B) goto EofB
3127 ** Cmpr: Compare A, B
3128 ** Jump AltB, AeqB, AgtB
3129 ** End: ...
3130 **
3131 ** We call AltB, AeqB, AgtB, EofA, and EofB "subroutines" but they are not
3132 ** actually called using Gosub and they do not Return. EofA and EofB loop
3133 ** until all data is exhausted then jump to the "end" labe. AltB, AeqB,
3134 ** and AgtB jump to either L2 or to one of EofA or EofB.
3135 */
3136 #ifndef SQLITE_OMIT_COMPOUND_SELECT
multiSelectOrderBy(Parse * pParse,Select * p,SelectDest * pDest)3137 static int multiSelectOrderBy(
3138 Parse *pParse, /* Parsing context */
3139 Select *p, /* The right-most of SELECTs to be coded */
3140 SelectDest *pDest /* What to do with query results */
3141 ){
3142 int i, j; /* Loop counters */
3143 Select *pPrior; /* Another SELECT immediately to our left */
3144 Vdbe *v; /* Generate code to this VDBE */
3145 SelectDest destA; /* Destination for coroutine A */
3146 SelectDest destB; /* Destination for coroutine B */
3147 int regAddrA; /* Address register for select-A coroutine */
3148 int regAddrB; /* Address register for select-B coroutine */
3149 int addrSelectA; /* Address of the select-A coroutine */
3150 int addrSelectB; /* Address of the select-B coroutine */
3151 int regOutA; /* Address register for the output-A subroutine */
3152 int regOutB; /* Address register for the output-B subroutine */
3153 int addrOutA; /* Address of the output-A subroutine */
3154 int addrOutB = 0; /* Address of the output-B subroutine */
3155 int addrEofA; /* Address of the select-A-exhausted subroutine */
3156 int addrEofA_noB; /* Alternate addrEofA if B is uninitialized */
3157 int addrEofB; /* Address of the select-B-exhausted subroutine */
3158 int addrAltB; /* Address of the A<B subroutine */
3159 int addrAeqB; /* Address of the A==B subroutine */
3160 int addrAgtB; /* Address of the A>B subroutine */
3161 int regLimitA; /* Limit register for select-A */
3162 int regLimitB; /* Limit register for select-A */
3163 int regPrev; /* A range of registers to hold previous output */
3164 int savedLimit; /* Saved value of p->iLimit */
3165 int savedOffset; /* Saved value of p->iOffset */
3166 int labelCmpr; /* Label for the start of the merge algorithm */
3167 int labelEnd; /* Label for the end of the overall SELECT stmt */
3168 int addr1; /* Jump instructions that get retargetted */
3169 int op; /* One of TK_ALL, TK_UNION, TK_EXCEPT, TK_INTERSECT */
3170 KeyInfo *pKeyDup = 0; /* Comparison information for duplicate removal */
3171 KeyInfo *pKeyMerge; /* Comparison information for merging rows */
3172 sqlite3 *db; /* Database connection */
3173 ExprList *pOrderBy; /* The ORDER BY clause */
3174 int nOrderBy; /* Number of terms in the ORDER BY clause */
3175 int *aPermute; /* Mapping from ORDER BY terms to result set columns */
3176
3177 assert( p->pOrderBy!=0 );
3178 assert( pKeyDup==0 ); /* "Managed" code needs this. Ticket #3382. */
3179 db = pParse->db;
3180 v = pParse->pVdbe;
3181 assert( v!=0 ); /* Already thrown the error if VDBE alloc failed */
3182 labelEnd = sqlite3VdbeMakeLabel(pParse);
3183 labelCmpr = sqlite3VdbeMakeLabel(pParse);
3184
3185
3186 /* Patch up the ORDER BY clause
3187 */
3188 op = p->op;
3189 pPrior = p->pPrior;
3190 assert( pPrior->pOrderBy==0 );
3191 pOrderBy = p->pOrderBy;
3192 assert( pOrderBy );
3193 nOrderBy = pOrderBy->nExpr;
3194
3195 /* For operators other than UNION ALL we have to make sure that
3196 ** the ORDER BY clause covers every term of the result set. Add
3197 ** terms to the ORDER BY clause as necessary.
3198 */
3199 if( op!=TK_ALL ){
3200 for(i=1; db->mallocFailed==0 && i<=p->pEList->nExpr; i++){
3201 struct ExprList_item *pItem;
3202 for(j=0, pItem=pOrderBy->a; j<nOrderBy; j++, pItem++){
3203 assert( pItem->u.x.iOrderByCol>0 );
3204 if( pItem->u.x.iOrderByCol==i ) break;
3205 }
3206 if( j==nOrderBy ){
3207 Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0);
3208 if( pNew==0 ) return SQLITE_NOMEM_BKPT;
3209 pNew->flags |= EP_IntValue;
3210 pNew->u.iValue = i;
3211 p->pOrderBy = pOrderBy = sqlite3ExprListAppend(pParse, pOrderBy, pNew);
3212 if( pOrderBy ) pOrderBy->a[nOrderBy++].u.x.iOrderByCol = (u16)i;
3213 }
3214 }
3215 }
3216
3217 /* Compute the comparison permutation and keyinfo that is used with
3218 ** the permutation used to determine if the next
3219 ** row of results comes from selectA or selectB. Also add explicit
3220 ** collations to the ORDER BY clause terms so that when the subqueries
3221 ** to the right and the left are evaluated, they use the correct
3222 ** collation.
3223 */
3224 aPermute = sqlite3DbMallocRawNN(db, sizeof(int)*(nOrderBy + 1));
3225 if( aPermute ){
3226 struct ExprList_item *pItem;
3227 aPermute[0] = nOrderBy;
3228 for(i=1, pItem=pOrderBy->a; i<=nOrderBy; i++, pItem++){
3229 assert( pItem->u.x.iOrderByCol>0 );
3230 assert( pItem->u.x.iOrderByCol<=p->pEList->nExpr );
3231 aPermute[i] = pItem->u.x.iOrderByCol - 1;
3232 }
3233 pKeyMerge = multiSelectOrderByKeyInfo(pParse, p, 1);
3234 }else{
3235 pKeyMerge = 0;
3236 }
3237
3238 /* Reattach the ORDER BY clause to the query.
3239 */
3240 p->pOrderBy = pOrderBy;
3241 pPrior->pOrderBy = sqlite3ExprListDup(pParse->db, pOrderBy, 0);
3242
3243 /* Allocate a range of temporary registers and the KeyInfo needed
3244 ** for the logic that removes duplicate result rows when the
3245 ** operator is UNION, EXCEPT, or INTERSECT (but not UNION ALL).
3246 */
3247 if( op==TK_ALL ){
3248 regPrev = 0;
3249 }else{
3250 int nExpr = p->pEList->nExpr;
3251 assert( nOrderBy>=nExpr || db->mallocFailed );
3252 regPrev = pParse->nMem+1;
3253 pParse->nMem += nExpr+1;
3254 sqlite3VdbeAddOp2(v, OP_Integer, 0, regPrev);
3255 pKeyDup = sqlite3KeyInfoAlloc(db, nExpr, 1);
3256 if( pKeyDup ){
3257 assert( sqlite3KeyInfoIsWriteable(pKeyDup) );
3258 for(i=0; i<nExpr; i++){
3259 pKeyDup->aColl[i] = multiSelectCollSeq(pParse, p, i);
3260 pKeyDup->aSortFlags[i] = 0;
3261 }
3262 }
3263 }
3264
3265 /* Separate the left and the right query from one another
3266 */
3267 p->pPrior = 0;
3268 pPrior->pNext = 0;
3269 sqlite3ResolveOrderGroupBy(pParse, p, p->pOrderBy, "ORDER");
3270 if( pPrior->pPrior==0 ){
3271 sqlite3ResolveOrderGroupBy(pParse, pPrior, pPrior->pOrderBy, "ORDER");
3272 }
3273
3274 /* Compute the limit registers */
3275 computeLimitRegisters(pParse, p, labelEnd);
3276 if( p->iLimit && op==TK_ALL ){
3277 regLimitA = ++pParse->nMem;
3278 regLimitB = ++pParse->nMem;
3279 sqlite3VdbeAddOp2(v, OP_Copy, p->iOffset ? p->iOffset+1 : p->iLimit,
3280 regLimitA);
3281 sqlite3VdbeAddOp2(v, OP_Copy, regLimitA, regLimitB);
3282 }else{
3283 regLimitA = regLimitB = 0;
3284 }
3285 sqlite3ExprDelete(db, p->pLimit);
3286 p->pLimit = 0;
3287
3288 regAddrA = ++pParse->nMem;
3289 regAddrB = ++pParse->nMem;
3290 regOutA = ++pParse->nMem;
3291 regOutB = ++pParse->nMem;
3292 sqlite3SelectDestInit(&destA, SRT_Coroutine, regAddrA);
3293 sqlite3SelectDestInit(&destB, SRT_Coroutine, regAddrB);
3294
3295 ExplainQueryPlan((pParse, 1, "MERGE (%s)", selectOpName(p->op)));
3296
3297 /* Generate a coroutine to evaluate the SELECT statement to the
3298 ** left of the compound operator - the "A" select.
3299 */
3300 addrSelectA = sqlite3VdbeCurrentAddr(v) + 1;
3301 addr1 = sqlite3VdbeAddOp3(v, OP_InitCoroutine, regAddrA, 0, addrSelectA);
3302 VdbeComment((v, "left SELECT"));
3303 pPrior->iLimit = regLimitA;
3304 ExplainQueryPlan((pParse, 1, "LEFT"));
3305 sqlite3Select(pParse, pPrior, &destA);
3306 sqlite3VdbeEndCoroutine(v, regAddrA);
3307 sqlite3VdbeJumpHere(v, addr1);
3308
3309 /* Generate a coroutine to evaluate the SELECT statement on
3310 ** the right - the "B" select
3311 */
3312 addrSelectB = sqlite3VdbeCurrentAddr(v) + 1;
3313 addr1 = sqlite3VdbeAddOp3(v, OP_InitCoroutine, regAddrB, 0, addrSelectB);
3314 VdbeComment((v, "right SELECT"));
3315 savedLimit = p->iLimit;
3316 savedOffset = p->iOffset;
3317 p->iLimit = regLimitB;
3318 p->iOffset = 0;
3319 ExplainQueryPlan((pParse, 1, "RIGHT"));
3320 sqlite3Select(pParse, p, &destB);
3321 p->iLimit = savedLimit;
3322 p->iOffset = savedOffset;
3323 sqlite3VdbeEndCoroutine(v, regAddrB);
3324
3325 /* Generate a subroutine that outputs the current row of the A
3326 ** select as the next output row of the compound select.
3327 */
3328 VdbeNoopComment((v, "Output routine for A"));
3329 addrOutA = generateOutputSubroutine(pParse,
3330 p, &destA, pDest, regOutA,
3331 regPrev, pKeyDup, labelEnd);
3332
3333 /* Generate a subroutine that outputs the current row of the B
3334 ** select as the next output row of the compound select.
3335 */
3336 if( op==TK_ALL || op==TK_UNION ){
3337 VdbeNoopComment((v, "Output routine for B"));
3338 addrOutB = generateOutputSubroutine(pParse,
3339 p, &destB, pDest, regOutB,
3340 regPrev, pKeyDup, labelEnd);
3341 }
3342 sqlite3KeyInfoUnref(pKeyDup);
3343
3344 /* Generate a subroutine to run when the results from select A
3345 ** are exhausted and only data in select B remains.
3346 */
3347 if( op==TK_EXCEPT || op==TK_INTERSECT ){
3348 addrEofA_noB = addrEofA = labelEnd;
3349 }else{
3350 VdbeNoopComment((v, "eof-A subroutine"));
3351 addrEofA = sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB);
3352 addrEofA_noB = sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, labelEnd);
3353 VdbeCoverage(v);
3354 sqlite3VdbeGoto(v, addrEofA);
3355 p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow);
3356 }
3357
3358 /* Generate a subroutine to run when the results from select B
3359 ** are exhausted and only data in select A remains.
3360 */
3361 if( op==TK_INTERSECT ){
3362 addrEofB = addrEofA;
3363 if( p->nSelectRow > pPrior->nSelectRow ) p->nSelectRow = pPrior->nSelectRow;
3364 }else{
3365 VdbeNoopComment((v, "eof-B subroutine"));
3366 addrEofB = sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA);
3367 sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, labelEnd); VdbeCoverage(v);
3368 sqlite3VdbeGoto(v, addrEofB);
3369 }
3370
3371 /* Generate code to handle the case of A<B
3372 */
3373 VdbeNoopComment((v, "A-lt-B subroutine"));
3374 addrAltB = sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA);
3375 sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, addrEofA); VdbeCoverage(v);
3376 sqlite3VdbeGoto(v, labelCmpr);
3377
3378 /* Generate code to handle the case of A==B
3379 */
3380 if( op==TK_ALL ){
3381 addrAeqB = addrAltB;
3382 }else if( op==TK_INTERSECT ){
3383 addrAeqB = addrAltB;
3384 addrAltB++;
3385 }else{
3386 VdbeNoopComment((v, "A-eq-B subroutine"));
3387 addrAeqB =
3388 sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, addrEofA); VdbeCoverage(v);
3389 sqlite3VdbeGoto(v, labelCmpr);
3390 }
3391
3392 /* Generate code to handle the case of A>B
3393 */
3394 VdbeNoopComment((v, "A-gt-B subroutine"));
3395 addrAgtB = sqlite3VdbeCurrentAddr(v);
3396 if( op==TK_ALL || op==TK_UNION ){
3397 sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB);
3398 }
3399 sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, addrEofB); VdbeCoverage(v);
3400 sqlite3VdbeGoto(v, labelCmpr);
3401
3402 /* This code runs once to initialize everything.
3403 */
3404 sqlite3VdbeJumpHere(v, addr1);
3405 sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, addrEofA_noB); VdbeCoverage(v);
3406 sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, addrEofB); VdbeCoverage(v);
3407
3408 /* Implement the main merge loop
3409 */
3410 sqlite3VdbeResolveLabel(v, labelCmpr);
3411 sqlite3VdbeAddOp4(v, OP_Permutation, 0, 0, 0, (char*)aPermute, P4_INTARRAY);
3412 sqlite3VdbeAddOp4(v, OP_Compare, destA.iSdst, destB.iSdst, nOrderBy,
3413 (char*)pKeyMerge, P4_KEYINFO);
3414 sqlite3VdbeChangeP5(v, OPFLAG_PERMUTE);
3415 sqlite3VdbeAddOp3(v, OP_Jump, addrAltB, addrAeqB, addrAgtB); VdbeCoverage(v);
3416
3417 /* Jump to the this point in order to terminate the query.
3418 */
3419 sqlite3VdbeResolveLabel(v, labelEnd);
3420
3421 /* Reassembly the compound query so that it will be freed correctly
3422 ** by the calling function */
3423 if( p->pPrior ){
3424 sqlite3SelectDelete(db, p->pPrior);
3425 }
3426 p->pPrior = pPrior;
3427 pPrior->pNext = p;
3428
3429 /*** TBD: Insert subroutine calls to close cursors on incomplete
3430 **** subqueries ****/
3431 ExplainQueryPlanPop(pParse);
3432 return pParse->nErr!=0;
3433 }
3434 #endif
3435
3436 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
3437
3438 /* An instance of the SubstContext object describes an substitution edit
3439 ** to be performed on a parse tree.
3440 **
3441 ** All references to columns in table iTable are to be replaced by corresponding
3442 ** expressions in pEList.
3443 */
3444 typedef struct SubstContext {
3445 Parse *pParse; /* The parsing context */
3446 int iTable; /* Replace references to this table */
3447 int iNewTable; /* New table number */
3448 int isLeftJoin; /* Add TK_IF_NULL_ROW opcodes on each replacement */
3449 ExprList *pEList; /* Replacement expressions */
3450 } SubstContext;
3451
3452 /* Forward Declarations */
3453 static void substExprList(SubstContext*, ExprList*);
3454 static void substSelect(SubstContext*, Select*, int);
3455
3456 /*
3457 ** Scan through the expression pExpr. Replace every reference to
3458 ** a column in table number iTable with a copy of the iColumn-th
3459 ** entry in pEList. (But leave references to the ROWID column
3460 ** unchanged.)
3461 **
3462 ** This routine is part of the flattening procedure. A subquery
3463 ** whose result set is defined by pEList appears as entry in the
3464 ** FROM clause of a SELECT such that the VDBE cursor assigned to that
3465 ** FORM clause entry is iTable. This routine makes the necessary
3466 ** changes to pExpr so that it refers directly to the source table
3467 ** of the subquery rather the result set of the subquery.
3468 */
substExpr(SubstContext * pSubst,Expr * pExpr)3469 static Expr *substExpr(
3470 SubstContext *pSubst, /* Description of the substitution */
3471 Expr *pExpr /* Expr in which substitution occurs */
3472 ){
3473 if( pExpr==0 ) return 0;
3474 if( ExprHasProperty(pExpr, EP_FromJoin)
3475 && pExpr->iRightJoinTable==pSubst->iTable
3476 ){
3477 pExpr->iRightJoinTable = pSubst->iNewTable;
3478 }
3479 if( pExpr->op==TK_COLUMN && pExpr->iTable==pSubst->iTable ){
3480 if( pExpr->iColumn<0 ){
3481 pExpr->op = TK_NULL;
3482 }else{
3483 Expr *pNew;
3484 Expr *pCopy = pSubst->pEList->a[pExpr->iColumn].pExpr;
3485 Expr ifNullRow;
3486 assert( pSubst->pEList!=0 && pExpr->iColumn<pSubst->pEList->nExpr );
3487 assert( pExpr->pRight==0 );
3488 if( sqlite3ExprIsVector(pCopy) ){
3489 sqlite3VectorErrorMsg(pSubst->pParse, pCopy);
3490 }else{
3491 sqlite3 *db = pSubst->pParse->db;
3492 if( pSubst->isLeftJoin && pCopy->op!=TK_COLUMN ){
3493 memset(&ifNullRow, 0, sizeof(ifNullRow));
3494 ifNullRow.op = TK_IF_NULL_ROW;
3495 ifNullRow.pLeft = pCopy;
3496 ifNullRow.iTable = pSubst->iNewTable;
3497 pCopy = &ifNullRow;
3498 }
3499 testcase( ExprHasProperty(pCopy, EP_Subquery) );
3500 pNew = sqlite3ExprDup(db, pCopy, 0);
3501 if( pNew && pSubst->isLeftJoin ){
3502 ExprSetProperty(pNew, EP_CanBeNull);
3503 }
3504 if( pNew && ExprHasProperty(pExpr,EP_FromJoin) ){
3505 pNew->iRightJoinTable = pExpr->iRightJoinTable;
3506 ExprSetProperty(pNew, EP_FromJoin);
3507 }
3508 sqlite3ExprDelete(db, pExpr);
3509 pExpr = pNew;
3510
3511 /* Ensure that the expression now has an implicit collation sequence,
3512 ** just as it did when it was a column of a view or sub-query. */
3513 if( pExpr ){
3514 if( pExpr->op!=TK_COLUMN && pExpr->op!=TK_COLLATE ){
3515 CollSeq *pColl = sqlite3ExprCollSeq(pSubst->pParse, pExpr);
3516 pExpr = sqlite3ExprAddCollateString(pSubst->pParse, pExpr,
3517 (pColl ? pColl->zName : "BINARY")
3518 );
3519 }
3520 ExprClearProperty(pExpr, EP_Collate);
3521 }
3522 }
3523 }
3524 }else{
3525 if( pExpr->op==TK_IF_NULL_ROW && pExpr->iTable==pSubst->iTable ){
3526 pExpr->iTable = pSubst->iNewTable;
3527 }
3528 pExpr->pLeft = substExpr(pSubst, pExpr->pLeft);
3529 pExpr->pRight = substExpr(pSubst, pExpr->pRight);
3530 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
3531 substSelect(pSubst, pExpr->x.pSelect, 1);
3532 }else{
3533 substExprList(pSubst, pExpr->x.pList);
3534 }
3535 #ifndef SQLITE_OMIT_WINDOWFUNC
3536 if( ExprHasProperty(pExpr, EP_WinFunc) ){
3537 Window *pWin = pExpr->y.pWin;
3538 pWin->pFilter = substExpr(pSubst, pWin->pFilter);
3539 substExprList(pSubst, pWin->pPartition);
3540 substExprList(pSubst, pWin->pOrderBy);
3541 }
3542 #endif
3543 }
3544 return pExpr;
3545 }
substExprList(SubstContext * pSubst,ExprList * pList)3546 static void substExprList(
3547 SubstContext *pSubst, /* Description of the substitution */
3548 ExprList *pList /* List to scan and in which to make substitutes */
3549 ){
3550 int i;
3551 if( pList==0 ) return;
3552 for(i=0; i<pList->nExpr; i++){
3553 pList->a[i].pExpr = substExpr(pSubst, pList->a[i].pExpr);
3554 }
3555 }
substSelect(SubstContext * pSubst,Select * p,int doPrior)3556 static void substSelect(
3557 SubstContext *pSubst, /* Description of the substitution */
3558 Select *p, /* SELECT statement in which to make substitutions */
3559 int doPrior /* Do substitutes on p->pPrior too */
3560 ){
3561 SrcList *pSrc;
3562 struct SrcList_item *pItem;
3563 int i;
3564 if( !p ) return;
3565 do{
3566 substExprList(pSubst, p->pEList);
3567 substExprList(pSubst, p->pGroupBy);
3568 substExprList(pSubst, p->pOrderBy);
3569 p->pHaving = substExpr(pSubst, p->pHaving);
3570 p->pWhere = substExpr(pSubst, p->pWhere);
3571 pSrc = p->pSrc;
3572 assert( pSrc!=0 );
3573 for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){
3574 substSelect(pSubst, pItem->pSelect, 1);
3575 if( pItem->fg.isTabFunc ){
3576 substExprList(pSubst, pItem->u1.pFuncArg);
3577 }
3578 }
3579 }while( doPrior && (p = p->pPrior)!=0 );
3580 }
3581 #endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
3582
3583 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
3584 /*
3585 ** This routine attempts to flatten subqueries as a performance optimization.
3586 ** This routine returns 1 if it makes changes and 0 if no flattening occurs.
3587 **
3588 ** To understand the concept of flattening, consider the following
3589 ** query:
3590 **
3591 ** SELECT a FROM (SELECT x+y AS a FROM t1 WHERE z<100) WHERE a>5
3592 **
3593 ** The default way of implementing this query is to execute the
3594 ** subquery first and store the results in a temporary table, then
3595 ** run the outer query on that temporary table. This requires two
3596 ** passes over the data. Furthermore, because the temporary table
3597 ** has no indices, the WHERE clause on the outer query cannot be
3598 ** optimized.
3599 **
3600 ** This routine attempts to rewrite queries such as the above into
3601 ** a single flat select, like this:
3602 **
3603 ** SELECT x+y AS a FROM t1 WHERE z<100 AND a>5
3604 **
3605 ** The code generated for this simplification gives the same result
3606 ** but only has to scan the data once. And because indices might
3607 ** exist on the table t1, a complete scan of the data might be
3608 ** avoided.
3609 **
3610 ** Flattening is subject to the following constraints:
3611 **
3612 ** (**) We no longer attempt to flatten aggregate subqueries. Was:
3613 ** The subquery and the outer query cannot both be aggregates.
3614 **
3615 ** (**) We no longer attempt to flatten aggregate subqueries. Was:
3616 ** (2) If the subquery is an aggregate then
3617 ** (2a) the outer query must not be a join and
3618 ** (2b) the outer query must not use subqueries
3619 ** other than the one FROM-clause subquery that is a candidate
3620 ** for flattening. (This is due to ticket [2f7170d73bf9abf80]
3621 ** from 2015-02-09.)
3622 **
3623 ** (3) If the subquery is the right operand of a LEFT JOIN then
3624 ** (3a) the subquery may not be a join and
3625 ** (3b) the FROM clause of the subquery may not contain a virtual
3626 ** table and
3627 ** (3c) the outer query may not be an aggregate.
3628 ** (3d) the outer query may not be DISTINCT.
3629 **
3630 ** (4) The subquery can not be DISTINCT.
3631 **
3632 ** (**) At one point restrictions (4) and (5) defined a subset of DISTINCT
3633 ** sub-queries that were excluded from this optimization. Restriction
3634 ** (4) has since been expanded to exclude all DISTINCT subqueries.
3635 **
3636 ** (**) We no longer attempt to flatten aggregate subqueries. Was:
3637 ** If the subquery is aggregate, the outer query may not be DISTINCT.
3638 **
3639 ** (7) The subquery must have a FROM clause. TODO: For subqueries without
3640 ** A FROM clause, consider adding a FROM clause with the special
3641 ** table sqlite_once that consists of a single row containing a
3642 ** single NULL.
3643 **
3644 ** (8) If the subquery uses LIMIT then the outer query may not be a join.
3645 **
3646 ** (9) If the subquery uses LIMIT then the outer query may not be aggregate.
3647 **
3648 ** (**) Restriction (10) was removed from the code on 2005-02-05 but we
3649 ** accidently carried the comment forward until 2014-09-15. Original
3650 ** constraint: "If the subquery is aggregate then the outer query
3651 ** may not use LIMIT."
3652 **
3653 ** (11) The subquery and the outer query may not both have ORDER BY clauses.
3654 **
3655 ** (**) Not implemented. Subsumed into restriction (3). Was previously
3656 ** a separate restriction deriving from ticket #350.
3657 **
3658 ** (13) The subquery and outer query may not both use LIMIT.
3659 **
3660 ** (14) The subquery may not use OFFSET.
3661 **
3662 ** (15) If the outer query is part of a compound select, then the
3663 ** subquery may not use LIMIT.
3664 ** (See ticket #2339 and ticket [02a8e81d44]).
3665 **
3666 ** (16) If the outer query is aggregate, then the subquery may not
3667 ** use ORDER BY. (Ticket #2942) This used to not matter
3668 ** until we introduced the group_concat() function.
3669 **
3670 ** (17) If the subquery is a compound select, then
3671 ** (17a) all compound operators must be a UNION ALL, and
3672 ** (17b) no terms within the subquery compound may be aggregate
3673 ** or DISTINCT, and
3674 ** (17c) every term within the subquery compound must have a FROM clause
3675 ** (17d) the outer query may not be
3676 ** (17d1) aggregate, or
3677 ** (17d2) DISTINCT, or
3678 ** (17d3) a join.
3679 ** (17e) the subquery may not contain window functions
3680 **
3681 ** The parent and sub-query may contain WHERE clauses. Subject to
3682 ** rules (11), (13) and (14), they may also contain ORDER BY,
3683 ** LIMIT and OFFSET clauses. The subquery cannot use any compound
3684 ** operator other than UNION ALL because all the other compound
3685 ** operators have an implied DISTINCT which is disallowed by
3686 ** restriction (4).
3687 **
3688 ** Also, each component of the sub-query must return the same number
3689 ** of result columns. This is actually a requirement for any compound
3690 ** SELECT statement, but all the code here does is make sure that no
3691 ** such (illegal) sub-query is flattened. The caller will detect the
3692 ** syntax error and return a detailed message.
3693 **
3694 ** (18) If the sub-query is a compound select, then all terms of the
3695 ** ORDER BY clause of the parent must be simple references to
3696 ** columns of the sub-query.
3697 **
3698 ** (19) If the subquery uses LIMIT then the outer query may not
3699 ** have a WHERE clause.
3700 **
3701 ** (20) If the sub-query is a compound select, then it must not use
3702 ** an ORDER BY clause. Ticket #3773. We could relax this constraint
3703 ** somewhat by saying that the terms of the ORDER BY clause must
3704 ** appear as unmodified result columns in the outer query. But we
3705 ** have other optimizations in mind to deal with that case.
3706 **
3707 ** (21) If the subquery uses LIMIT then the outer query may not be
3708 ** DISTINCT. (See ticket [752e1646fc]).
3709 **
3710 ** (22) The subquery may not be a recursive CTE.
3711 **
3712 ** (**) Subsumed into restriction (17d3). Was: If the outer query is
3713 ** a recursive CTE, then the sub-query may not be a compound query.
3714 ** This restriction is because transforming the
3715 ** parent to a compound query confuses the code that handles
3716 ** recursive queries in multiSelect().
3717 **
3718 ** (**) We no longer attempt to flatten aggregate subqueries. Was:
3719 ** The subquery may not be an aggregate that uses the built-in min() or
3720 ** or max() functions. (Without this restriction, a query like:
3721 ** "SELECT x FROM (SELECT max(y), x FROM t1)" would not necessarily
3722 ** return the value X for which Y was maximal.)
3723 **
3724 ** (25) If either the subquery or the parent query contains a window
3725 ** function in the select list or ORDER BY clause, flattening
3726 ** is not attempted.
3727 **
3728 **
3729 ** In this routine, the "p" parameter is a pointer to the outer query.
3730 ** The subquery is p->pSrc->a[iFrom]. isAgg is true if the outer query
3731 ** uses aggregates.
3732 **
3733 ** If flattening is not attempted, this routine is a no-op and returns 0.
3734 ** If flattening is attempted this routine returns 1.
3735 **
3736 ** All of the expression analysis must occur on both the outer query and
3737 ** the subquery before this routine runs.
3738 */
flattenSubquery(Parse * pParse,Select * p,int iFrom,int isAgg)3739 static int flattenSubquery(
3740 Parse *pParse, /* Parsing context */
3741 Select *p, /* The parent or outer SELECT statement */
3742 int iFrom, /* Index in p->pSrc->a[] of the inner subquery */
3743 int isAgg /* True if outer SELECT uses aggregate functions */
3744 ){
3745 const char *zSavedAuthContext = pParse->zAuthContext;
3746 Select *pParent; /* Current UNION ALL term of the other query */
3747 Select *pSub; /* The inner query or "subquery" */
3748 Select *pSub1; /* Pointer to the rightmost select in sub-query */
3749 SrcList *pSrc; /* The FROM clause of the outer query */
3750 SrcList *pSubSrc; /* The FROM clause of the subquery */
3751 int iParent; /* VDBE cursor number of the pSub result set temp table */
3752 int iNewParent = -1;/* Replacement table for iParent */
3753 int isLeftJoin = 0; /* True if pSub is the right side of a LEFT JOIN */
3754 int i; /* Loop counter */
3755 Expr *pWhere; /* The WHERE clause */
3756 struct SrcList_item *pSubitem; /* The subquery */
3757 sqlite3 *db = pParse->db;
3758
3759 /* Check to see if flattening is permitted. Return 0 if not.
3760 */
3761 assert( p!=0 );
3762 assert( p->pPrior==0 );
3763 if( OptimizationDisabled(db, SQLITE_QueryFlattener) ) return 0;
3764 pSrc = p->pSrc;
3765 assert( pSrc && iFrom>=0 && iFrom<pSrc->nSrc );
3766 pSubitem = &pSrc->a[iFrom];
3767 iParent = pSubitem->iCursor;
3768 pSub = pSubitem->pSelect;
3769 assert( pSub!=0 );
3770
3771 #ifndef SQLITE_OMIT_WINDOWFUNC
3772 if( p->pWin || pSub->pWin ) return 0; /* Restriction (25) */
3773 #endif
3774
3775 pSubSrc = pSub->pSrc;
3776 assert( pSubSrc );
3777 /* Prior to version 3.1.2, when LIMIT and OFFSET had to be simple constants,
3778 ** not arbitrary expressions, we allowed some combining of LIMIT and OFFSET
3779 ** because they could be computed at compile-time. But when LIMIT and OFFSET
3780 ** became arbitrary expressions, we were forced to add restrictions (13)
3781 ** and (14). */
3782 if( pSub->pLimit && p->pLimit ) return 0; /* Restriction (13) */
3783 if( pSub->pLimit && pSub->pLimit->pRight ) return 0; /* Restriction (14) */
3784 if( (p->selFlags & SF_Compound)!=0 && pSub->pLimit ){
3785 return 0; /* Restriction (15) */
3786 }
3787 if( pSubSrc->nSrc==0 ) return 0; /* Restriction (7) */
3788 if( pSub->selFlags & SF_Distinct ) return 0; /* Restriction (4) */
3789 if( pSub->pLimit && (pSrc->nSrc>1 || isAgg) ){
3790 return 0; /* Restrictions (8)(9) */
3791 }
3792 if( p->pOrderBy && pSub->pOrderBy ){
3793 return 0; /* Restriction (11) */
3794 }
3795 if( isAgg && pSub->pOrderBy ) return 0; /* Restriction (16) */
3796 if( pSub->pLimit && p->pWhere ) return 0; /* Restriction (19) */
3797 if( pSub->pLimit && (p->selFlags & SF_Distinct)!=0 ){
3798 return 0; /* Restriction (21) */
3799 }
3800 if( pSub->selFlags & (SF_Recursive) ){
3801 return 0; /* Restrictions (22) */
3802 }
3803
3804 /*
3805 ** If the subquery is the right operand of a LEFT JOIN, then the
3806 ** subquery may not be a join itself (3a). Example of why this is not
3807 ** allowed:
3808 **
3809 ** t1 LEFT OUTER JOIN (t2 JOIN t3)
3810 **
3811 ** If we flatten the above, we would get
3812 **
3813 ** (t1 LEFT OUTER JOIN t2) JOIN t3
3814 **
3815 ** which is not at all the same thing.
3816 **
3817 ** If the subquery is the right operand of a LEFT JOIN, then the outer
3818 ** query cannot be an aggregate. (3c) This is an artifact of the way
3819 ** aggregates are processed - there is no mechanism to determine if
3820 ** the LEFT JOIN table should be all-NULL.
3821 **
3822 ** See also tickets #306, #350, and #3300.
3823 */
3824 if( (pSubitem->fg.jointype & JT_OUTER)!=0 ){
3825 isLeftJoin = 1;
3826 if( pSubSrc->nSrc>1 /* (3a) */
3827 || isAgg /* (3b) */
3828 || IsVirtual(pSubSrc->a[0].pTab) /* (3c) */
3829 || (p->selFlags & SF_Distinct)!=0 /* (3d) */
3830 ){
3831 return 0;
3832 }
3833 }
3834 #ifdef SQLITE_EXTRA_IFNULLROW
3835 else if( iFrom>0 && !isAgg ){
3836 /* Setting isLeftJoin to -1 causes OP_IfNullRow opcodes to be generated for
3837 ** every reference to any result column from subquery in a join, even
3838 ** though they are not necessary. This will stress-test the OP_IfNullRow
3839 ** opcode. */
3840 isLeftJoin = -1;
3841 }
3842 #endif
3843
3844 /* Restriction (17): If the sub-query is a compound SELECT, then it must
3845 ** use only the UNION ALL operator. And none of the simple select queries
3846 ** that make up the compound SELECT are allowed to be aggregate or distinct
3847 ** queries.
3848 */
3849 if( pSub->pPrior ){
3850 if( pSub->pOrderBy ){
3851 return 0; /* Restriction (20) */
3852 }
3853 if( isAgg || (p->selFlags & SF_Distinct)!=0 || pSrc->nSrc!=1 ){
3854 return 0; /* (17d1), (17d2), or (17d3) */
3855 }
3856 for(pSub1=pSub; pSub1; pSub1=pSub1->pPrior){
3857 testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct );
3858 testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate );
3859 assert( pSub->pSrc!=0 );
3860 assert( pSub->pEList->nExpr==pSub1->pEList->nExpr );
3861 if( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))!=0 /* (17b) */
3862 || (pSub1->pPrior && pSub1->op!=TK_ALL) /* (17a) */
3863 || pSub1->pSrc->nSrc<1 /* (17c) */
3864 #ifndef SQLITE_OMIT_WINDOWFUNC
3865 || pSub1->pWin /* (17e) */
3866 #endif
3867 ){
3868 return 0;
3869 }
3870 testcase( pSub1->pSrc->nSrc>1 );
3871 }
3872
3873 /* Restriction (18). */
3874 if( p->pOrderBy ){
3875 int ii;
3876 for(ii=0; ii<p->pOrderBy->nExpr; ii++){
3877 if( p->pOrderBy->a[ii].u.x.iOrderByCol==0 ) return 0;
3878 }
3879 }
3880 }
3881
3882 /* Ex-restriction (23):
3883 ** The only way that the recursive part of a CTE can contain a compound
3884 ** subquery is for the subquery to be one term of a join. But if the
3885 ** subquery is a join, then the flattening has already been stopped by
3886 ** restriction (17d3)
3887 */
3888 assert( (p->selFlags & SF_Recursive)==0 || pSub->pPrior==0 );
3889
3890 /***** If we reach this point, flattening is permitted. *****/
3891 SELECTTRACE(1,pParse,p,("flatten %u.%p from term %d\n",
3892 pSub->selId, pSub, iFrom));
3893
3894 /* Authorize the subquery */
3895 pParse->zAuthContext = pSubitem->zName;
3896 TESTONLY(i =) sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0);
3897 testcase( i==SQLITE_DENY );
3898 pParse->zAuthContext = zSavedAuthContext;
3899
3900 /* If the sub-query is a compound SELECT statement, then (by restrictions
3901 ** 17 and 18 above) it must be a UNION ALL and the parent query must
3902 ** be of the form:
3903 **
3904 ** SELECT <expr-list> FROM (<sub-query>) <where-clause>
3905 **
3906 ** followed by any ORDER BY, LIMIT and/or OFFSET clauses. This block
3907 ** creates N-1 copies of the parent query without any ORDER BY, LIMIT or
3908 ** OFFSET clauses and joins them to the left-hand-side of the original
3909 ** using UNION ALL operators. In this case N is the number of simple
3910 ** select statements in the compound sub-query.
3911 **
3912 ** Example:
3913 **
3914 ** SELECT a+1 FROM (
3915 ** SELECT x FROM tab
3916 ** UNION ALL
3917 ** SELECT y FROM tab
3918 ** UNION ALL
3919 ** SELECT abs(z*2) FROM tab2
3920 ** ) WHERE a!=5 ORDER BY 1
3921 **
3922 ** Transformed into:
3923 **
3924 ** SELECT x+1 FROM tab WHERE x+1!=5
3925 ** UNION ALL
3926 ** SELECT y+1 FROM tab WHERE y+1!=5
3927 ** UNION ALL
3928 ** SELECT abs(z*2)+1 FROM tab2 WHERE abs(z*2)+1!=5
3929 ** ORDER BY 1
3930 **
3931 ** We call this the "compound-subquery flattening".
3932 */
3933 for(pSub=pSub->pPrior; pSub; pSub=pSub->pPrior){
3934 Select *pNew;
3935 ExprList *pOrderBy = p->pOrderBy;
3936 Expr *pLimit = p->pLimit;
3937 Select *pPrior = p->pPrior;
3938 p->pOrderBy = 0;
3939 p->pSrc = 0;
3940 p->pPrior = 0;
3941 p->pLimit = 0;
3942 pNew = sqlite3SelectDup(db, p, 0);
3943 p->pLimit = pLimit;
3944 p->pOrderBy = pOrderBy;
3945 p->pSrc = pSrc;
3946 p->op = TK_ALL;
3947 if( pNew==0 ){
3948 p->pPrior = pPrior;
3949 }else{
3950 pNew->pPrior = pPrior;
3951 if( pPrior ) pPrior->pNext = pNew;
3952 pNew->pNext = p;
3953 p->pPrior = pNew;
3954 SELECTTRACE(2,pParse,p,("compound-subquery flattener"
3955 " creates %u as peer\n",pNew->selId));
3956 }
3957 if( db->mallocFailed ) return 1;
3958 }
3959
3960 /* Begin flattening the iFrom-th entry of the FROM clause
3961 ** in the outer query.
3962 */
3963 pSub = pSub1 = pSubitem->pSelect;
3964
3965 /* Delete the transient table structure associated with the
3966 ** subquery
3967 */
3968 sqlite3DbFree(db, pSubitem->zDatabase);
3969 sqlite3DbFree(db, pSubitem->zName);
3970 sqlite3DbFree(db, pSubitem->zAlias);
3971 pSubitem->zDatabase = 0;
3972 pSubitem->zName = 0;
3973 pSubitem->zAlias = 0;
3974 pSubitem->pSelect = 0;
3975
3976 /* Defer deleting the Table object associated with the
3977 ** subquery until code generation is
3978 ** complete, since there may still exist Expr.pTab entries that
3979 ** refer to the subquery even after flattening. Ticket #3346.
3980 **
3981 ** pSubitem->pTab is always non-NULL by test restrictions and tests above.
3982 */
3983 if( ALWAYS(pSubitem->pTab!=0) ){
3984 Table *pTabToDel = pSubitem->pTab;
3985 if( pTabToDel->nTabRef==1 ){
3986 Parse *pToplevel = sqlite3ParseToplevel(pParse);
3987 pTabToDel->pNextZombie = pToplevel->pZombieTab;
3988 pToplevel->pZombieTab = pTabToDel;
3989 }else{
3990 pTabToDel->nTabRef--;
3991 }
3992 pSubitem->pTab = 0;
3993 }
3994
3995 /* The following loop runs once for each term in a compound-subquery
3996 ** flattening (as described above). If we are doing a different kind
3997 ** of flattening - a flattening other than a compound-subquery flattening -
3998 ** then this loop only runs once.
3999 **
4000 ** This loop moves all of the FROM elements of the subquery into the
4001 ** the FROM clause of the outer query. Before doing this, remember
4002 ** the cursor number for the original outer query FROM element in
4003 ** iParent. The iParent cursor will never be used. Subsequent code
4004 ** will scan expressions looking for iParent references and replace
4005 ** those references with expressions that resolve to the subquery FROM
4006 ** elements we are now copying in.
4007 */
4008 for(pParent=p; pParent; pParent=pParent->pPrior, pSub=pSub->pPrior){
4009 int nSubSrc;
4010 u8 jointype = 0;
4011 assert( pSub!=0 );
4012 pSubSrc = pSub->pSrc; /* FROM clause of subquery */
4013 nSubSrc = pSubSrc->nSrc; /* Number of terms in subquery FROM clause */
4014 pSrc = pParent->pSrc; /* FROM clause of the outer query */
4015
4016 if( pSrc ){
4017 assert( pParent==p ); /* First time through the loop */
4018 jointype = pSubitem->fg.jointype;
4019 }else{
4020 assert( pParent!=p ); /* 2nd and subsequent times through the loop */
4021 pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0);
4022 if( pSrc==0 ) break;
4023 pParent->pSrc = pSrc;
4024 }
4025
4026 /* The subquery uses a single slot of the FROM clause of the outer
4027 ** query. If the subquery has more than one element in its FROM clause,
4028 ** then expand the outer query to make space for it to hold all elements
4029 ** of the subquery.
4030 **
4031 ** Example:
4032 **
4033 ** SELECT * FROM tabA, (SELECT * FROM sub1, sub2), tabB;
4034 **
4035 ** The outer query has 3 slots in its FROM clause. One slot of the
4036 ** outer query (the middle slot) is used by the subquery. The next
4037 ** block of code will expand the outer query FROM clause to 4 slots.
4038 ** The middle slot is expanded to two slots in order to make space
4039 ** for the two elements in the FROM clause of the subquery.
4040 */
4041 if( nSubSrc>1 ){
4042 pSrc = sqlite3SrcListEnlarge(pParse, pSrc, nSubSrc-1,iFrom+1);
4043 if( pSrc==0 ) break;
4044 pParent->pSrc = pSrc;
4045 }
4046
4047 /* Transfer the FROM clause terms from the subquery into the
4048 ** outer query.
4049 */
4050 for(i=0; i<nSubSrc; i++){
4051 sqlite3IdListDelete(db, pSrc->a[i+iFrom].pUsing);
4052 assert( pSrc->a[i+iFrom].fg.isTabFunc==0 );
4053 pSrc->a[i+iFrom] = pSubSrc->a[i];
4054 iNewParent = pSubSrc->a[i].iCursor;
4055 memset(&pSubSrc->a[i], 0, sizeof(pSubSrc->a[i]));
4056 }
4057 pSrc->a[iFrom].fg.jointype = jointype;
4058
4059 /* Now begin substituting subquery result set expressions for
4060 ** references to the iParent in the outer query.
4061 **
4062 ** Example:
4063 **
4064 ** SELECT a+5, b*10 FROM (SELECT x*3 AS a, y+10 AS b FROM t1) WHERE a>b;
4065 ** \ \_____________ subquery __________/ /
4066 ** \_____________________ outer query ______________________________/
4067 **
4068 ** We look at every expression in the outer query and every place we see
4069 ** "a" we substitute "x*3" and every place we see "b" we substitute "y+10".
4070 */
4071 if( pSub->pOrderBy ){
4072 /* At this point, any non-zero iOrderByCol values indicate that the
4073 ** ORDER BY column expression is identical to the iOrderByCol'th
4074 ** expression returned by SELECT statement pSub. Since these values
4075 ** do not necessarily correspond to columns in SELECT statement pParent,
4076 ** zero them before transfering the ORDER BY clause.
4077 **
4078 ** Not doing this may cause an error if a subsequent call to this
4079 ** function attempts to flatten a compound sub-query into pParent
4080 ** (the only way this can happen is if the compound sub-query is
4081 ** currently part of pSub->pSrc). See ticket [d11a6e908f]. */
4082 ExprList *pOrderBy = pSub->pOrderBy;
4083 for(i=0; i<pOrderBy->nExpr; i++){
4084 pOrderBy->a[i].u.x.iOrderByCol = 0;
4085 }
4086 assert( pParent->pOrderBy==0 );
4087 pParent->pOrderBy = pOrderBy;
4088 pSub->pOrderBy = 0;
4089 }
4090 pWhere = pSub->pWhere;
4091 pSub->pWhere = 0;
4092 if( isLeftJoin>0 ){
4093 sqlite3SetJoinExpr(pWhere, iNewParent);
4094 }
4095 pParent->pWhere = sqlite3ExprAnd(pParse, pWhere, pParent->pWhere);
4096 if( db->mallocFailed==0 ){
4097 SubstContext x;
4098 x.pParse = pParse;
4099 x.iTable = iParent;
4100 x.iNewTable = iNewParent;
4101 x.isLeftJoin = isLeftJoin;
4102 x.pEList = pSub->pEList;
4103 substSelect(&x, pParent, 0);
4104 }
4105
4106 /* The flattened query is a compound if either the inner or the
4107 ** outer query is a compound. */
4108 pParent->selFlags |= pSub->selFlags & SF_Compound;
4109 assert( (pSub->selFlags & SF_Distinct)==0 ); /* restriction (17b) */
4110
4111 /*
4112 ** SELECT ... FROM (SELECT ... LIMIT a OFFSET b) LIMIT x OFFSET y;
4113 **
4114 ** One is tempted to try to add a and b to combine the limits. But this
4115 ** does not work if either limit is negative.
4116 */
4117 if( pSub->pLimit ){
4118 pParent->pLimit = pSub->pLimit;
4119 pSub->pLimit = 0;
4120 }
4121 }
4122
4123 /* Finially, delete what is left of the subquery and return
4124 ** success.
4125 */
4126 sqlite3SelectDelete(db, pSub1);
4127
4128 #if SELECTTRACE_ENABLED
4129 if( sqlite3SelectTrace & 0x100 ){
4130 SELECTTRACE(0x100,pParse,p,("After flattening:\n"));
4131 sqlite3TreeViewSelect(0, p, 0);
4132 }
4133 #endif
4134
4135 return 1;
4136 }
4137 #endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
4138
4139 /*
4140 ** A structure to keep track of all of the column values that are fixed to
4141 ** a known value due to WHERE clause constraints of the form COLUMN=VALUE.
4142 */
4143 typedef struct WhereConst WhereConst;
4144 struct WhereConst {
4145 Parse *pParse; /* Parsing context */
4146 int nConst; /* Number for COLUMN=CONSTANT terms */
4147 int nChng; /* Number of times a constant is propagated */
4148 Expr **apExpr; /* [i*2] is COLUMN and [i*2+1] is VALUE */
4149 };
4150
4151 /*
4152 ** Add a new entry to the pConst object. Except, do not add duplicate
4153 ** pColumn entires. Also, do not add if doing so would not be appropriate.
4154 **
4155 ** The caller guarantees the pColumn is a column and pValue is a constant.
4156 ** This routine has to do some additional checks before completing the
4157 ** insert.
4158 */
constInsert(WhereConst * pConst,Expr * pColumn,Expr * pValue,Expr * pExpr)4159 static void constInsert(
4160 WhereConst *pConst, /* The WhereConst into which we are inserting */
4161 Expr *pColumn, /* The COLUMN part of the constraint */
4162 Expr *pValue, /* The VALUE part of the constraint */
4163 Expr *pExpr /* Overall expression: COLUMN=VALUE or VALUE=COLUMN */
4164 ){
4165 int i;
4166 assert( pColumn->op==TK_COLUMN );
4167 assert( sqlite3ExprIsConstant(pValue) );
4168
4169 if( !ExprHasProperty(pValue, EP_FixedCol) && sqlite3ExprAffinity(pValue)!=0 ){
4170 return;
4171 }
4172 if( !sqlite3IsBinary(sqlite3ExprCompareCollSeq(pConst->pParse,pExpr)) ){
4173 return;
4174 }
4175
4176 /* 2018-10-25 ticket [cf5ed20f]
4177 ** Make sure the same pColumn is not inserted more than once */
4178 for(i=0; i<pConst->nConst; i++){
4179 const Expr *pE2 = pConst->apExpr[i*2];
4180 assert( pE2->op==TK_COLUMN );
4181 if( pE2->iTable==pColumn->iTable
4182 && pE2->iColumn==pColumn->iColumn
4183 ){
4184 return; /* Already present. Return without doing anything. */
4185 }
4186 }
4187
4188 pConst->nConst++;
4189 pConst->apExpr = sqlite3DbReallocOrFree(pConst->pParse->db, pConst->apExpr,
4190 pConst->nConst*2*sizeof(Expr*));
4191 if( pConst->apExpr==0 ){
4192 pConst->nConst = 0;
4193 }else{
4194 if( ExprHasProperty(pValue, EP_FixedCol) ){
4195 pValue = pValue->pLeft;
4196 }
4197 pConst->apExpr[pConst->nConst*2-2] = pColumn;
4198 pConst->apExpr[pConst->nConst*2-1] = pValue;
4199 }
4200 }
4201
4202 /*
4203 ** Find all terms of COLUMN=VALUE or VALUE=COLUMN in pExpr where VALUE
4204 ** is a constant expression and where the term must be true because it
4205 ** is part of the AND-connected terms of the expression. For each term
4206 ** found, add it to the pConst structure.
4207 */
findConstInWhere(WhereConst * pConst,Expr * pExpr)4208 static void findConstInWhere(WhereConst *pConst, Expr *pExpr){
4209 Expr *pRight, *pLeft;
4210 if( pExpr==0 ) return;
4211 if( ExprHasProperty(pExpr, EP_FromJoin) ) return;
4212 if( pExpr->op==TK_AND ){
4213 findConstInWhere(pConst, pExpr->pRight);
4214 findConstInWhere(pConst, pExpr->pLeft);
4215 return;
4216 }
4217 if( pExpr->op!=TK_EQ ) return;
4218 pRight = pExpr->pRight;
4219 pLeft = pExpr->pLeft;
4220 assert( pRight!=0 );
4221 assert( pLeft!=0 );
4222 if( pRight->op==TK_COLUMN && sqlite3ExprIsConstant(pLeft) ){
4223 constInsert(pConst,pRight,pLeft,pExpr);
4224 }
4225 if( pLeft->op==TK_COLUMN && sqlite3ExprIsConstant(pRight) ){
4226 constInsert(pConst,pLeft,pRight,pExpr);
4227 }
4228 }
4229
4230 /*
4231 ** This is a Walker expression callback. pExpr is a candidate expression
4232 ** to be replaced by a value. If pExpr is equivalent to one of the
4233 ** columns named in pWalker->u.pConst, then overwrite it with its
4234 ** corresponding value.
4235 */
propagateConstantExprRewrite(Walker * pWalker,Expr * pExpr)4236 static int propagateConstantExprRewrite(Walker *pWalker, Expr *pExpr){
4237 int i;
4238 WhereConst *pConst;
4239 if( pExpr->op!=TK_COLUMN ) return WRC_Continue;
4240 if( ExprHasProperty(pExpr, EP_FixedCol|EP_FromJoin) ){
4241 testcase( ExprHasProperty(pExpr, EP_FixedCol) );
4242 testcase( ExprHasProperty(pExpr, EP_FromJoin) );
4243 return WRC_Continue;
4244 }
4245 pConst = pWalker->u.pConst;
4246 for(i=0; i<pConst->nConst; i++){
4247 Expr *pColumn = pConst->apExpr[i*2];
4248 if( pColumn==pExpr ) continue;
4249 if( pColumn->iTable!=pExpr->iTable ) continue;
4250 if( pColumn->iColumn!=pExpr->iColumn ) continue;
4251 /* A match is found. Add the EP_FixedCol property */
4252 pConst->nChng++;
4253 ExprClearProperty(pExpr, EP_Leaf);
4254 ExprSetProperty(pExpr, EP_FixedCol);
4255 assert( pExpr->pLeft==0 );
4256 pExpr->pLeft = sqlite3ExprDup(pConst->pParse->db, pConst->apExpr[i*2+1], 0);
4257 break;
4258 }
4259 return WRC_Prune;
4260 }
4261
4262 /*
4263 ** The WHERE-clause constant propagation optimization.
4264 **
4265 ** If the WHERE clause contains terms of the form COLUMN=CONSTANT or
4266 ** CONSTANT=COLUMN that are top-level AND-connected terms that are not
4267 ** part of a ON clause from a LEFT JOIN, then throughout the query
4268 ** replace all other occurrences of COLUMN with CONSTANT.
4269 **
4270 ** For example, the query:
4271 **
4272 ** SELECT * FROM t1, t2, t3 WHERE t1.a=39 AND t2.b=t1.a AND t3.c=t2.b
4273 **
4274 ** Is transformed into
4275 **
4276 ** SELECT * FROM t1, t2, t3 WHERE t1.a=39 AND t2.b=39 AND t3.c=39
4277 **
4278 ** Return true if any transformations where made and false if not.
4279 **
4280 ** Implementation note: Constant propagation is tricky due to affinity
4281 ** and collating sequence interactions. Consider this example:
4282 **
4283 ** CREATE TABLE t1(a INT,b TEXT);
4284 ** INSERT INTO t1 VALUES(123,'0123');
4285 ** SELECT * FROM t1 WHERE a=123 AND b=a;
4286 ** SELECT * FROM t1 WHERE a=123 AND b=123;
4287 **
4288 ** The two SELECT statements above should return different answers. b=a
4289 ** is alway true because the comparison uses numeric affinity, but b=123
4290 ** is false because it uses text affinity and '0123' is not the same as '123'.
4291 ** To work around this, the expression tree is not actually changed from
4292 ** "b=a" to "b=123" but rather the "a" in "b=a" is tagged with EP_FixedCol
4293 ** and the "123" value is hung off of the pLeft pointer. Code generator
4294 ** routines know to generate the constant "123" instead of looking up the
4295 ** column value. Also, to avoid collation problems, this optimization is
4296 ** only attempted if the "a=123" term uses the default BINARY collation.
4297 */
propagateConstants(Parse * pParse,Select * p)4298 static int propagateConstants(
4299 Parse *pParse, /* The parsing context */
4300 Select *p /* The query in which to propagate constants */
4301 ){
4302 WhereConst x;
4303 Walker w;
4304 int nChng = 0;
4305 x.pParse = pParse;
4306 do{
4307 x.nConst = 0;
4308 x.nChng = 0;
4309 x.apExpr = 0;
4310 findConstInWhere(&x, p->pWhere);
4311 if( x.nConst ){
4312 memset(&w, 0, sizeof(w));
4313 w.pParse = pParse;
4314 w.xExprCallback = propagateConstantExprRewrite;
4315 w.xSelectCallback = sqlite3SelectWalkNoop;
4316 w.xSelectCallback2 = 0;
4317 w.walkerDepth = 0;
4318 w.u.pConst = &x;
4319 sqlite3WalkExpr(&w, p->pWhere);
4320 sqlite3DbFree(x.pParse->db, x.apExpr);
4321 nChng += x.nChng;
4322 }
4323 }while( x.nChng );
4324 return nChng;
4325 }
4326
4327 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
4328 /*
4329 ** Make copies of relevant WHERE clause terms of the outer query into
4330 ** the WHERE clause of subquery. Example:
4331 **
4332 ** SELECT * FROM (SELECT a AS x, c-d AS y FROM t1) WHERE x=5 AND y=10;
4333 **
4334 ** Transformed into:
4335 **
4336 ** SELECT * FROM (SELECT a AS x, c-d AS y FROM t1 WHERE a=5 AND c-d=10)
4337 ** WHERE x=5 AND y=10;
4338 **
4339 ** The hope is that the terms added to the inner query will make it more
4340 ** efficient.
4341 **
4342 ** Do not attempt this optimization if:
4343 **
4344 ** (1) (** This restriction was removed on 2017-09-29. We used to
4345 ** disallow this optimization for aggregate subqueries, but now
4346 ** it is allowed by putting the extra terms on the HAVING clause.
4347 ** The added HAVING clause is pointless if the subquery lacks
4348 ** a GROUP BY clause. But such a HAVING clause is also harmless
4349 ** so there does not appear to be any reason to add extra logic
4350 ** to suppress it. **)
4351 **
4352 ** (2) The inner query is the recursive part of a common table expression.
4353 **
4354 ** (3) The inner query has a LIMIT clause (since the changes to the WHERE
4355 ** clause would change the meaning of the LIMIT).
4356 **
4357 ** (4) The inner query is the right operand of a LEFT JOIN and the
4358 ** expression to be pushed down does not come from the ON clause
4359 ** on that LEFT JOIN.
4360 **
4361 ** (5) The WHERE clause expression originates in the ON or USING clause
4362 ** of a LEFT JOIN where iCursor is not the right-hand table of that
4363 ** left join. An example:
4364 **
4365 ** SELECT *
4366 ** FROM (SELECT 1 AS a1 UNION ALL SELECT 2) AS aa
4367 ** JOIN (SELECT 1 AS b2 UNION ALL SELECT 2) AS bb ON (a1=b2)
4368 ** LEFT JOIN (SELECT 8 AS c3 UNION ALL SELECT 9) AS cc ON (b2=2);
4369 **
4370 ** The correct answer is three rows: (1,1,NULL),(2,2,8),(2,2,9).
4371 ** But if the (b2=2) term were to be pushed down into the bb subquery,
4372 ** then the (1,1,NULL) row would be suppressed.
4373 **
4374 ** (6) The inner query features one or more window-functions (since
4375 ** changes to the WHERE clause of the inner query could change the
4376 ** window over which window functions are calculated).
4377 **
4378 ** Return 0 if no changes are made and non-zero if one or more WHERE clause
4379 ** terms are duplicated into the subquery.
4380 */
pushDownWhereTerms(Parse * pParse,Select * pSubq,Expr * pWhere,int iCursor,int isLeftJoin)4381 static int pushDownWhereTerms(
4382 Parse *pParse, /* Parse context (for malloc() and error reporting) */
4383 Select *pSubq, /* The subquery whose WHERE clause is to be augmented */
4384 Expr *pWhere, /* The WHERE clause of the outer query */
4385 int iCursor, /* Cursor number of the subquery */
4386 int isLeftJoin /* True if pSubq is the right term of a LEFT JOIN */
4387 ){
4388 Expr *pNew;
4389 int nChng = 0;
4390 if( pWhere==0 ) return 0;
4391 if( pSubq->selFlags & SF_Recursive ) return 0; /* restriction (2) */
4392
4393 #ifndef SQLITE_OMIT_WINDOWFUNC
4394 if( pSubq->pWin ) return 0; /* restriction (6) */
4395 #endif
4396
4397 #ifdef SQLITE_DEBUG
4398 /* Only the first term of a compound can have a WITH clause. But make
4399 ** sure no other terms are marked SF_Recursive in case something changes
4400 ** in the future.
4401 */
4402 {
4403 Select *pX;
4404 for(pX=pSubq; pX; pX=pX->pPrior){
4405 assert( (pX->selFlags & (SF_Recursive))==0 );
4406 }
4407 }
4408 #endif
4409
4410 if( pSubq->pLimit!=0 ){
4411 return 0; /* restriction (3) */
4412 }
4413 while( pWhere->op==TK_AND ){
4414 nChng += pushDownWhereTerms(pParse, pSubq, pWhere->pRight,
4415 iCursor, isLeftJoin);
4416 pWhere = pWhere->pLeft;
4417 }
4418 if( isLeftJoin
4419 && (ExprHasProperty(pWhere,EP_FromJoin)==0
4420 || pWhere->iRightJoinTable!=iCursor)
4421 ){
4422 return 0; /* restriction (4) */
4423 }
4424 if( ExprHasProperty(pWhere,EP_FromJoin) && pWhere->iRightJoinTable!=iCursor ){
4425 return 0; /* restriction (5) */
4426 }
4427 if( sqlite3ExprIsTableConstant(pWhere, iCursor) ){
4428 nChng++;
4429 while( pSubq ){
4430 SubstContext x;
4431 pNew = sqlite3ExprDup(pParse->db, pWhere, 0);
4432 unsetJoinExpr(pNew, -1);
4433 x.pParse = pParse;
4434 x.iTable = iCursor;
4435 x.iNewTable = iCursor;
4436 x.isLeftJoin = 0;
4437 x.pEList = pSubq->pEList;
4438 pNew = substExpr(&x, pNew);
4439 if( pSubq->selFlags & SF_Aggregate ){
4440 pSubq->pHaving = sqlite3ExprAnd(pParse, pSubq->pHaving, pNew);
4441 }else{
4442 pSubq->pWhere = sqlite3ExprAnd(pParse, pSubq->pWhere, pNew);
4443 }
4444 pSubq = pSubq->pPrior;
4445 }
4446 }
4447 return nChng;
4448 }
4449 #endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
4450
4451 /*
4452 ** The pFunc is the only aggregate function in the query. Check to see
4453 ** if the query is a candidate for the min/max optimization.
4454 **
4455 ** If the query is a candidate for the min/max optimization, then set
4456 ** *ppMinMax to be an ORDER BY clause to be used for the optimization
4457 ** and return either WHERE_ORDERBY_MIN or WHERE_ORDERBY_MAX depending on
4458 ** whether pFunc is a min() or max() function.
4459 **
4460 ** If the query is not a candidate for the min/max optimization, return
4461 ** WHERE_ORDERBY_NORMAL (which must be zero).
4462 **
4463 ** This routine must be called after aggregate functions have been
4464 ** located but before their arguments have been subjected to aggregate
4465 ** analysis.
4466 */
minMaxQuery(sqlite3 * db,Expr * pFunc,ExprList ** ppMinMax)4467 static u8 minMaxQuery(sqlite3 *db, Expr *pFunc, ExprList **ppMinMax){
4468 int eRet = WHERE_ORDERBY_NORMAL; /* Return value */
4469 ExprList *pEList = pFunc->x.pList; /* Arguments to agg function */
4470 const char *zFunc; /* Name of aggregate function pFunc */
4471 ExprList *pOrderBy;
4472 u8 sortFlags;
4473
4474 assert( *ppMinMax==0 );
4475 assert( pFunc->op==TK_AGG_FUNCTION );
4476 assert( !IsWindowFunc(pFunc) );
4477 if( pEList==0 || pEList->nExpr!=1 || ExprHasProperty(pFunc, EP_WinFunc) ){
4478 return eRet;
4479 }
4480 zFunc = pFunc->u.zToken;
4481 if( sqlite3StrICmp(zFunc, "min")==0 ){
4482 eRet = WHERE_ORDERBY_MIN;
4483 sortFlags = KEYINFO_ORDER_BIGNULL;
4484 }else if( sqlite3StrICmp(zFunc, "max")==0 ){
4485 eRet = WHERE_ORDERBY_MAX;
4486 sortFlags = KEYINFO_ORDER_DESC;
4487 }else{
4488 return eRet;
4489 }
4490 *ppMinMax = pOrderBy = sqlite3ExprListDup(db, pEList, 0);
4491 assert( pOrderBy!=0 || db->mallocFailed );
4492 if( pOrderBy ) pOrderBy->a[0].sortFlags = sortFlags;
4493 return eRet;
4494 }
4495
4496 /*
4497 ** The select statement passed as the first argument is an aggregate query.
4498 ** The second argument is the associated aggregate-info object. This
4499 ** function tests if the SELECT is of the form:
4500 **
4501 ** SELECT count(*) FROM <tbl>
4502 **
4503 ** where table is a database table, not a sub-select or view. If the query
4504 ** does match this pattern, then a pointer to the Table object representing
4505 ** <tbl> is returned. Otherwise, 0 is returned.
4506 */
isSimpleCount(Select * p,AggInfo * pAggInfo)4507 static Table *isSimpleCount(Select *p, AggInfo *pAggInfo){
4508 Table *pTab;
4509 Expr *pExpr;
4510
4511 assert( !p->pGroupBy );
4512
4513 if( p->pWhere || p->pEList->nExpr!=1
4514 || p->pSrc->nSrc!=1 || p->pSrc->a[0].pSelect
4515 ){
4516 return 0;
4517 }
4518 pTab = p->pSrc->a[0].pTab;
4519 pExpr = p->pEList->a[0].pExpr;
4520 assert( pTab && !pTab->pSelect && pExpr );
4521
4522 if( IsVirtual(pTab) ) return 0;
4523 if( pExpr->op!=TK_AGG_FUNCTION ) return 0;
4524 if( NEVER(pAggInfo->nFunc==0) ) return 0;
4525 if( (pAggInfo->aFunc[0].pFunc->funcFlags&SQLITE_FUNC_COUNT)==0 ) return 0;
4526 if( ExprHasProperty(pExpr, EP_Distinct|EP_WinFunc) ) return 0;
4527
4528 return pTab;
4529 }
4530
4531 /*
4532 ** If the source-list item passed as an argument was augmented with an
4533 ** INDEXED BY clause, then try to locate the specified index. If there
4534 ** was such a clause and the named index cannot be found, return
4535 ** SQLITE_ERROR and leave an error in pParse. Otherwise, populate
4536 ** pFrom->pIndex and return SQLITE_OK.
4537 */
sqlite3IndexedByLookup(Parse * pParse,struct SrcList_item * pFrom)4538 int sqlite3IndexedByLookup(Parse *pParse, struct SrcList_item *pFrom){
4539 if( pFrom->pTab && pFrom->fg.isIndexedBy ){
4540 Table *pTab = pFrom->pTab;
4541 char *zIndexedBy = pFrom->u1.zIndexedBy;
4542 Index *pIdx;
4543 for(pIdx=pTab->pIndex;
4544 pIdx && sqlite3StrICmp(pIdx->zName, zIndexedBy);
4545 pIdx=pIdx->pNext
4546 );
4547 if( !pIdx ){
4548 sqlite3ErrorMsg(pParse, "no such index: %s", zIndexedBy, 0);
4549 pParse->checkSchema = 1;
4550 return SQLITE_ERROR;
4551 }
4552 pFrom->pIBIndex = pIdx;
4553 }
4554 return SQLITE_OK;
4555 }
4556 /*
4557 ** Detect compound SELECT statements that use an ORDER BY clause with
4558 ** an alternative collating sequence.
4559 **
4560 ** SELECT ... FROM t1 EXCEPT SELECT ... FROM t2 ORDER BY .. COLLATE ...
4561 **
4562 ** These are rewritten as a subquery:
4563 **
4564 ** SELECT * FROM (SELECT ... FROM t1 EXCEPT SELECT ... FROM t2)
4565 ** ORDER BY ... COLLATE ...
4566 **
4567 ** This transformation is necessary because the multiSelectOrderBy() routine
4568 ** above that generates the code for a compound SELECT with an ORDER BY clause
4569 ** uses a merge algorithm that requires the same collating sequence on the
4570 ** result columns as on the ORDER BY clause. See ticket
4571 ** http://www.sqlite.org/src/info/6709574d2a
4572 **
4573 ** This transformation is only needed for EXCEPT, INTERSECT, and UNION.
4574 ** The UNION ALL operator works fine with multiSelectOrderBy() even when
4575 ** there are COLLATE terms in the ORDER BY.
4576 */
convertCompoundSelectToSubquery(Walker * pWalker,Select * p)4577 static int convertCompoundSelectToSubquery(Walker *pWalker, Select *p){
4578 int i;
4579 Select *pNew;
4580 Select *pX;
4581 sqlite3 *db;
4582 struct ExprList_item *a;
4583 SrcList *pNewSrc;
4584 Parse *pParse;
4585 Token dummy;
4586
4587 if( p->pPrior==0 ) return WRC_Continue;
4588 if( p->pOrderBy==0 ) return WRC_Continue;
4589 for(pX=p; pX && (pX->op==TK_ALL || pX->op==TK_SELECT); pX=pX->pPrior){}
4590 if( pX==0 ) return WRC_Continue;
4591 a = p->pOrderBy->a;
4592 for(i=p->pOrderBy->nExpr-1; i>=0; i--){
4593 if( a[i].pExpr->flags & EP_Collate ) break;
4594 }
4595 if( i<0 ) return WRC_Continue;
4596
4597 /* If we reach this point, that means the transformation is required. */
4598
4599 pParse = pWalker->pParse;
4600 db = pParse->db;
4601 pNew = sqlite3DbMallocZero(db, sizeof(*pNew) );
4602 if( pNew==0 ) return WRC_Abort;
4603 memset(&dummy, 0, sizeof(dummy));
4604 pNewSrc = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&dummy,pNew,0,0);
4605 if( pNewSrc==0 ) return WRC_Abort;
4606 *pNew = *p;
4607 p->pSrc = pNewSrc;
4608 p->pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ASTERISK, 0));
4609 p->op = TK_SELECT;
4610 p->pWhere = 0;
4611 pNew->pGroupBy = 0;
4612 pNew->pHaving = 0;
4613 pNew->pOrderBy = 0;
4614 p->pPrior = 0;
4615 p->pNext = 0;
4616 p->pWith = 0;
4617 #ifndef SQLITE_OMIT_WINDOWFUNC
4618 p->pWinDefn = 0;
4619 #endif
4620 p->selFlags &= ~SF_Compound;
4621 assert( (p->selFlags & SF_Converted)==0 );
4622 p->selFlags |= SF_Converted;
4623 assert( pNew->pPrior!=0 );
4624 pNew->pPrior->pNext = pNew;
4625 pNew->pLimit = 0;
4626 return WRC_Continue;
4627 }
4628
4629 /*
4630 ** Check to see if the FROM clause term pFrom has table-valued function
4631 ** arguments. If it does, leave an error message in pParse and return
4632 ** non-zero, since pFrom is not allowed to be a table-valued function.
4633 */
cannotBeFunction(Parse * pParse,struct SrcList_item * pFrom)4634 static int cannotBeFunction(Parse *pParse, struct SrcList_item *pFrom){
4635 if( pFrom->fg.isTabFunc ){
4636 sqlite3ErrorMsg(pParse, "'%s' is not a function", pFrom->zName);
4637 return 1;
4638 }
4639 return 0;
4640 }
4641
4642 #ifndef SQLITE_OMIT_CTE
4643 /*
4644 ** Argument pWith (which may be NULL) points to a linked list of nested
4645 ** WITH contexts, from inner to outermost. If the table identified by
4646 ** FROM clause element pItem is really a common-table-expression (CTE)
4647 ** then return a pointer to the CTE definition for that table. Otherwise
4648 ** return NULL.
4649 **
4650 ** If a non-NULL value is returned, set *ppContext to point to the With
4651 ** object that the returned CTE belongs to.
4652 */
searchWith(With * pWith,struct SrcList_item * pItem,With ** ppContext)4653 static struct Cte *searchWith(
4654 With *pWith, /* Current innermost WITH clause */
4655 struct SrcList_item *pItem, /* FROM clause element to resolve */
4656 With **ppContext /* OUT: WITH clause return value belongs to */
4657 ){
4658 const char *zName;
4659 if( pItem->zDatabase==0 && (zName = pItem->zName)!=0 ){
4660 With *p;
4661 for(p=pWith; p; p=p->pOuter){
4662 int i;
4663 for(i=0; i<p->nCte; i++){
4664 if( sqlite3StrICmp(zName, p->a[i].zName)==0 ){
4665 *ppContext = p;
4666 return &p->a[i];
4667 }
4668 }
4669 }
4670 }
4671 return 0;
4672 }
4673
4674 /* The code generator maintains a stack of active WITH clauses
4675 ** with the inner-most WITH clause being at the top of the stack.
4676 **
4677 ** This routine pushes the WITH clause passed as the second argument
4678 ** onto the top of the stack. If argument bFree is true, then this
4679 ** WITH clause will never be popped from the stack. In this case it
4680 ** should be freed along with the Parse object. In other cases, when
4681 ** bFree==0, the With object will be freed along with the SELECT
4682 ** statement with which it is associated.
4683 */
sqlite3WithPush(Parse * pParse,With * pWith,u8 bFree)4684 void sqlite3WithPush(Parse *pParse, With *pWith, u8 bFree){
4685 assert( bFree==0 || (pParse->pWith==0 && pParse->pWithToFree==0) );
4686 if( pWith ){
4687 assert( pParse->pWith!=pWith );
4688 pWith->pOuter = pParse->pWith;
4689 pParse->pWith = pWith;
4690 if( bFree ) pParse->pWithToFree = pWith;
4691 }
4692 }
4693
4694 /*
4695 ** This function checks if argument pFrom refers to a CTE declared by
4696 ** a WITH clause on the stack currently maintained by the parser. And,
4697 ** if currently processing a CTE expression, if it is a recursive
4698 ** reference to the current CTE.
4699 **
4700 ** If pFrom falls into either of the two categories above, pFrom->pTab
4701 ** and other fields are populated accordingly. The caller should check
4702 ** (pFrom->pTab!=0) to determine whether or not a successful match
4703 ** was found.
4704 **
4705 ** Whether or not a match is found, SQLITE_OK is returned if no error
4706 ** occurs. If an error does occur, an error message is stored in the
4707 ** parser and some error code other than SQLITE_OK returned.
4708 */
withExpand(Walker * pWalker,struct SrcList_item * pFrom)4709 static int withExpand(
4710 Walker *pWalker,
4711 struct SrcList_item *pFrom
4712 ){
4713 Parse *pParse = pWalker->pParse;
4714 sqlite3 *db = pParse->db;
4715 struct Cte *pCte; /* Matched CTE (or NULL if no match) */
4716 With *pWith; /* WITH clause that pCte belongs to */
4717
4718 assert( pFrom->pTab==0 );
4719 if( pParse->nErr ){
4720 return SQLITE_ERROR;
4721 }
4722
4723 pCte = searchWith(pParse->pWith, pFrom, &pWith);
4724 if( pCte ){
4725 Table *pTab;
4726 ExprList *pEList;
4727 Select *pSel;
4728 Select *pLeft; /* Left-most SELECT statement */
4729 int bMayRecursive; /* True if compound joined by UNION [ALL] */
4730 With *pSavedWith; /* Initial value of pParse->pWith */
4731
4732 /* If pCte->zCteErr is non-NULL at this point, then this is an illegal
4733 ** recursive reference to CTE pCte. Leave an error in pParse and return
4734 ** early. If pCte->zCteErr is NULL, then this is not a recursive reference.
4735 ** In this case, proceed. */
4736 if( pCte->zCteErr ){
4737 sqlite3ErrorMsg(pParse, pCte->zCteErr, pCte->zName);
4738 return SQLITE_ERROR;
4739 }
4740 if( cannotBeFunction(pParse, pFrom) ) return SQLITE_ERROR;
4741
4742 assert( pFrom->pTab==0 );
4743 pFrom->pTab = pTab = sqlite3DbMallocZero(db, sizeof(Table));
4744 if( pTab==0 ) return WRC_Abort;
4745 pTab->nTabRef = 1;
4746 pTab->zName = sqlite3DbStrDup(db, pCte->zName);
4747 pTab->iPKey = -1;
4748 pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
4749 pTab->tabFlags |= TF_Ephemeral | TF_NoVisibleRowid;
4750 pFrom->pSelect = sqlite3SelectDup(db, pCte->pSelect, 0);
4751 if( db->mallocFailed ) return SQLITE_NOMEM_BKPT;
4752 assert( pFrom->pSelect );
4753
4754 /* Check if this is a recursive CTE. */
4755 pSel = pFrom->pSelect;
4756 bMayRecursive = ( pSel->op==TK_ALL || pSel->op==TK_UNION );
4757 if( bMayRecursive ){
4758 int i;
4759 SrcList *pSrc = pFrom->pSelect->pSrc;
4760 for(i=0; i<pSrc->nSrc; i++){
4761 struct SrcList_item *pItem = &pSrc->a[i];
4762 if( pItem->zDatabase==0
4763 && pItem->zName!=0
4764 && 0==sqlite3StrICmp(pItem->zName, pCte->zName)
4765 ){
4766 pItem->pTab = pTab;
4767 pItem->fg.isRecursive = 1;
4768 pTab->nTabRef++;
4769 pSel->selFlags |= SF_Recursive;
4770 }
4771 }
4772 }
4773
4774 /* Only one recursive reference is permitted. */
4775 if( pTab->nTabRef>2 ){
4776 sqlite3ErrorMsg(
4777 pParse, "multiple references to recursive table: %s", pCte->zName
4778 );
4779 return SQLITE_ERROR;
4780 }
4781 assert( pTab->nTabRef==1 ||
4782 ((pSel->selFlags&SF_Recursive) && pTab->nTabRef==2 ));
4783
4784 pCte->zCteErr = "circular reference: %s";
4785 pSavedWith = pParse->pWith;
4786 pParse->pWith = pWith;
4787 if( bMayRecursive ){
4788 Select *pPrior = pSel->pPrior;
4789 assert( pPrior->pWith==0 );
4790 pPrior->pWith = pSel->pWith;
4791 sqlite3WalkSelect(pWalker, pPrior);
4792 pPrior->pWith = 0;
4793 }else{
4794 sqlite3WalkSelect(pWalker, pSel);
4795 }
4796 pParse->pWith = pWith;
4797
4798 for(pLeft=pSel; pLeft->pPrior; pLeft=pLeft->pPrior);
4799 pEList = pLeft->pEList;
4800 if( pCte->pCols ){
4801 if( pEList && pEList->nExpr!=pCte->pCols->nExpr ){
4802 sqlite3ErrorMsg(pParse, "table %s has %d values for %d columns",
4803 pCte->zName, pEList->nExpr, pCte->pCols->nExpr
4804 );
4805 pParse->pWith = pSavedWith;
4806 return SQLITE_ERROR;
4807 }
4808 pEList = pCte->pCols;
4809 }
4810
4811 sqlite3ColumnsFromExprList(pParse, pEList, &pTab->nCol, &pTab->aCol);
4812 if( bMayRecursive ){
4813 if( pSel->selFlags & SF_Recursive ){
4814 pCte->zCteErr = "multiple recursive references: %s";
4815 }else{
4816 pCte->zCteErr = "recursive reference in a subquery: %s";
4817 }
4818 sqlite3WalkSelect(pWalker, pSel);
4819 }
4820 pCte->zCteErr = 0;
4821 pParse->pWith = pSavedWith;
4822 }
4823
4824 return SQLITE_OK;
4825 }
4826 #endif
4827
4828 #ifndef SQLITE_OMIT_CTE
4829 /*
4830 ** If the SELECT passed as the second argument has an associated WITH
4831 ** clause, pop it from the stack stored as part of the Parse object.
4832 **
4833 ** This function is used as the xSelectCallback2() callback by
4834 ** sqlite3SelectExpand() when walking a SELECT tree to resolve table
4835 ** names and other FROM clause elements.
4836 */
selectPopWith(Walker * pWalker,Select * p)4837 static void selectPopWith(Walker *pWalker, Select *p){
4838 Parse *pParse = pWalker->pParse;
4839 if( OK_IF_ALWAYS_TRUE(pParse->pWith) && p->pPrior==0 ){
4840 With *pWith = findRightmost(p)->pWith;
4841 if( pWith!=0 ){
4842 assert( pParse->pWith==pWith || pParse->nErr );
4843 pParse->pWith = pWith->pOuter;
4844 }
4845 }
4846 }
4847 #else
4848 #define selectPopWith 0
4849 #endif
4850
4851 /*
4852 ** The SrcList_item structure passed as the second argument represents a
4853 ** sub-query in the FROM clause of a SELECT statement. This function
4854 ** allocates and populates the SrcList_item.pTab object. If successful,
4855 ** SQLITE_OK is returned. Otherwise, if an OOM error is encountered,
4856 ** SQLITE_NOMEM.
4857 */
sqlite3ExpandSubquery(Parse * pParse,struct SrcList_item * pFrom)4858 int sqlite3ExpandSubquery(Parse *pParse, struct SrcList_item *pFrom){
4859 Select *pSel = pFrom->pSelect;
4860 Table *pTab;
4861
4862 assert( pSel );
4863 pFrom->pTab = pTab = sqlite3DbMallocZero(pParse->db, sizeof(Table));
4864 if( pTab==0 ) return SQLITE_NOMEM;
4865 pTab->nTabRef = 1;
4866 if( pFrom->zAlias ){
4867 pTab->zName = sqlite3DbStrDup(pParse->db, pFrom->zAlias);
4868 }else{
4869 pTab->zName = sqlite3MPrintf(pParse->db, "subquery_%u", pSel->selId);
4870 }
4871 while( pSel->pPrior ){ pSel = pSel->pPrior; }
4872 sqlite3ColumnsFromExprList(pParse, pSel->pEList,&pTab->nCol,&pTab->aCol);
4873 pTab->iPKey = -1;
4874 pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
4875 pTab->tabFlags |= TF_Ephemeral;
4876
4877 return pParse->nErr ? SQLITE_ERROR : SQLITE_OK;
4878 }
4879
4880 /*
4881 ** This routine is a Walker callback for "expanding" a SELECT statement.
4882 ** "Expanding" means to do the following:
4883 **
4884 ** (1) Make sure VDBE cursor numbers have been assigned to every
4885 ** element of the FROM clause.
4886 **
4887 ** (2) Fill in the pTabList->a[].pTab fields in the SrcList that
4888 ** defines FROM clause. When views appear in the FROM clause,
4889 ** fill pTabList->a[].pSelect with a copy of the SELECT statement
4890 ** that implements the view. A copy is made of the view's SELECT
4891 ** statement so that we can freely modify or delete that statement
4892 ** without worrying about messing up the persistent representation
4893 ** of the view.
4894 **
4895 ** (3) Add terms to the WHERE clause to accommodate the NATURAL keyword
4896 ** on joins and the ON and USING clause of joins.
4897 **
4898 ** (4) Scan the list of columns in the result set (pEList) looking
4899 ** for instances of the "*" operator or the TABLE.* operator.
4900 ** If found, expand each "*" to be every column in every table
4901 ** and TABLE.* to be every column in TABLE.
4902 **
4903 */
selectExpander(Walker * pWalker,Select * p)4904 static int selectExpander(Walker *pWalker, Select *p){
4905 Parse *pParse = pWalker->pParse;
4906 int i, j, k;
4907 SrcList *pTabList;
4908 ExprList *pEList;
4909 struct SrcList_item *pFrom;
4910 sqlite3 *db = pParse->db;
4911 Expr *pE, *pRight, *pExpr;
4912 u16 selFlags = p->selFlags;
4913 u32 elistFlags = 0;
4914
4915 p->selFlags |= SF_Expanded;
4916 if( db->mallocFailed ){
4917 return WRC_Abort;
4918 }
4919 assert( p->pSrc!=0 );
4920 if( (selFlags & SF_Expanded)!=0 ){
4921 return WRC_Prune;
4922 }
4923 if( pWalker->eCode ){
4924 /* Renumber selId because it has been copied from a view */
4925 p->selId = ++pParse->nSelect;
4926 }
4927 pTabList = p->pSrc;
4928 pEList = p->pEList;
4929 sqlite3WithPush(pParse, p->pWith, 0);
4930
4931 /* Make sure cursor numbers have been assigned to all entries in
4932 ** the FROM clause of the SELECT statement.
4933 */
4934 sqlite3SrcListAssignCursors(pParse, pTabList);
4935
4936 /* Look up every table named in the FROM clause of the select. If
4937 ** an entry of the FROM clause is a subquery instead of a table or view,
4938 ** then create a transient table structure to describe the subquery.
4939 */
4940 for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
4941 Table *pTab;
4942 assert( pFrom->fg.isRecursive==0 || pFrom->pTab!=0 );
4943 if( pFrom->fg.isRecursive ) continue;
4944 assert( pFrom->pTab==0 );
4945 #ifndef SQLITE_OMIT_CTE
4946 if( withExpand(pWalker, pFrom) ) return WRC_Abort;
4947 if( pFrom->pTab ) {} else
4948 #endif
4949 if( pFrom->zName==0 ){
4950 #ifndef SQLITE_OMIT_SUBQUERY
4951 Select *pSel = pFrom->pSelect;
4952 /* A sub-query in the FROM clause of a SELECT */
4953 assert( pSel!=0 );
4954 assert( pFrom->pTab==0 );
4955 if( sqlite3WalkSelect(pWalker, pSel) ) return WRC_Abort;
4956 if( sqlite3ExpandSubquery(pParse, pFrom) ) return WRC_Abort;
4957 #endif
4958 }else{
4959 /* An ordinary table or view name in the FROM clause */
4960 assert( pFrom->pTab==0 );
4961 pFrom->pTab = pTab = sqlite3LocateTableItem(pParse, 0, pFrom);
4962 if( pTab==0 ) return WRC_Abort;
4963 if( pTab->nTabRef>=0xffff ){
4964 sqlite3ErrorMsg(pParse, "too many references to \"%s\": max 65535",
4965 pTab->zName);
4966 pFrom->pTab = 0;
4967 return WRC_Abort;
4968 }
4969 pTab->nTabRef++;
4970 if( !IsVirtual(pTab) && cannotBeFunction(pParse, pFrom) ){
4971 return WRC_Abort;
4972 }
4973 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
4974 if( IsVirtual(pTab) || pTab->pSelect ){
4975 i16 nCol;
4976 u8 eCodeOrig = pWalker->eCode;
4977 if( sqlite3ViewGetColumnNames(pParse, pTab) ) return WRC_Abort;
4978 assert( pFrom->pSelect==0 );
4979 if( pTab->pSelect && (db->flags & SQLITE_EnableView)==0 ){
4980 sqlite3ErrorMsg(pParse, "access to view \"%s\" prohibited",
4981 pTab->zName);
4982 }
4983 #ifndef SQLITE_OMIT_VIRTUALTABLE
4984 if( IsVirtual(pTab)
4985 && pFrom->fg.fromDDL
4986 && ALWAYS(pTab->pVTable!=0)
4987 && pTab->pVTable->eVtabRisk > ((db->flags & SQLITE_TrustedSchema)!=0)
4988 ){
4989 sqlite3ErrorMsg(pParse, "unsafe use of virtual table \"%s\"",
4990 pTab->zName);
4991 }
4992 #endif
4993 pFrom->pSelect = sqlite3SelectDup(db, pTab->pSelect, 0);
4994 nCol = pTab->nCol;
4995 pTab->nCol = -1;
4996 pWalker->eCode = 1; /* Turn on Select.selId renumbering */
4997 sqlite3WalkSelect(pWalker, pFrom->pSelect);
4998 pWalker->eCode = eCodeOrig;
4999 pTab->nCol = nCol;
5000 }
5001 #endif
5002 }
5003
5004 /* Locate the index named by the INDEXED BY clause, if any. */
5005 if( sqlite3IndexedByLookup(pParse, pFrom) ){
5006 return WRC_Abort;
5007 }
5008 }
5009
5010 /* Process NATURAL keywords, and ON and USING clauses of joins.
5011 */
5012 if( pParse->nErr || db->mallocFailed || sqliteProcessJoin(pParse, p) ){
5013 return WRC_Abort;
5014 }
5015
5016 /* For every "*" that occurs in the column list, insert the names of
5017 ** all columns in all tables. And for every TABLE.* insert the names
5018 ** of all columns in TABLE. The parser inserted a special expression
5019 ** with the TK_ASTERISK operator for each "*" that it found in the column
5020 ** list. The following code just has to locate the TK_ASTERISK
5021 ** expressions and expand each one to the list of all columns in
5022 ** all tables.
5023 **
5024 ** The first loop just checks to see if there are any "*" operators
5025 ** that need expanding.
5026 */
5027 for(k=0; k<pEList->nExpr; k++){
5028 pE = pEList->a[k].pExpr;
5029 if( pE->op==TK_ASTERISK ) break;
5030 assert( pE->op!=TK_DOT || pE->pRight!=0 );
5031 assert( pE->op!=TK_DOT || (pE->pLeft!=0 && pE->pLeft->op==TK_ID) );
5032 if( pE->op==TK_DOT && pE->pRight->op==TK_ASTERISK ) break;
5033 elistFlags |= pE->flags;
5034 }
5035 if( k<pEList->nExpr ){
5036 /*
5037 ** If we get here it means the result set contains one or more "*"
5038 ** operators that need to be expanded. Loop through each expression
5039 ** in the result set and expand them one by one.
5040 */
5041 struct ExprList_item *a = pEList->a;
5042 ExprList *pNew = 0;
5043 int flags = pParse->db->flags;
5044 int longNames = (flags & SQLITE_FullColNames)!=0
5045 && (flags & SQLITE_ShortColNames)==0;
5046
5047 for(k=0; k<pEList->nExpr; k++){
5048 pE = a[k].pExpr;
5049 elistFlags |= pE->flags;
5050 pRight = pE->pRight;
5051 assert( pE->op!=TK_DOT || pRight!=0 );
5052 if( pE->op!=TK_ASTERISK
5053 && (pE->op!=TK_DOT || pRight->op!=TK_ASTERISK)
5054 ){
5055 /* This particular expression does not need to be expanded.
5056 */
5057 pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr);
5058 if( pNew ){
5059 pNew->a[pNew->nExpr-1].zEName = a[k].zEName;
5060 pNew->a[pNew->nExpr-1].eEName = a[k].eEName;
5061 a[k].zEName = 0;
5062 }
5063 a[k].pExpr = 0;
5064 }else{
5065 /* This expression is a "*" or a "TABLE.*" and needs to be
5066 ** expanded. */
5067 int tableSeen = 0; /* Set to 1 when TABLE matches */
5068 char *zTName = 0; /* text of name of TABLE */
5069 if( pE->op==TK_DOT ){
5070 assert( pE->pLeft!=0 );
5071 assert( !ExprHasProperty(pE->pLeft, EP_IntValue) );
5072 zTName = pE->pLeft->u.zToken;
5073 }
5074 for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
5075 Table *pTab = pFrom->pTab;
5076 Select *pSub = pFrom->pSelect;
5077 char *zTabName = pFrom->zAlias;
5078 const char *zSchemaName = 0;
5079 int iDb;
5080 if( zTabName==0 ){
5081 zTabName = pTab->zName;
5082 }
5083 if( db->mallocFailed ) break;
5084 if( pSub==0 || (pSub->selFlags & SF_NestedFrom)==0 ){
5085 pSub = 0;
5086 if( zTName && sqlite3StrICmp(zTName, zTabName)!=0 ){
5087 continue;
5088 }
5089 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
5090 zSchemaName = iDb>=0 ? db->aDb[iDb].zDbSName : "*";
5091 }
5092 for(j=0; j<pTab->nCol; j++){
5093 char *zName = pTab->aCol[j].zName;
5094 char *zColname; /* The computed column name */
5095 char *zToFree; /* Malloced string that needs to be freed */
5096 Token sColname; /* Computed column name as a token */
5097
5098 assert( zName );
5099 if( zTName && pSub
5100 && sqlite3MatchEName(&pSub->pEList->a[j], 0, zTName, 0)==0
5101 ){
5102 continue;
5103 }
5104
5105 /* If a column is marked as 'hidden', omit it from the expanded
5106 ** result-set list unless the SELECT has the SF_IncludeHidden
5107 ** bit set.
5108 */
5109 if( (p->selFlags & SF_IncludeHidden)==0
5110 && IsHiddenColumn(&pTab->aCol[j])
5111 ){
5112 continue;
5113 }
5114 tableSeen = 1;
5115
5116 if( i>0 && zTName==0 ){
5117 if( (pFrom->fg.jointype & JT_NATURAL)!=0
5118 && tableAndColumnIndex(pTabList, i, zName, 0, 0, 1)
5119 ){
5120 /* In a NATURAL join, omit the join columns from the
5121 ** table to the right of the join */
5122 continue;
5123 }
5124 if( sqlite3IdListIndex(pFrom->pUsing, zName)>=0 ){
5125 /* In a join with a USING clause, omit columns in the
5126 ** using clause from the table on the right. */
5127 continue;
5128 }
5129 }
5130 pRight = sqlite3Expr(db, TK_ID, zName);
5131 zColname = zName;
5132 zToFree = 0;
5133 if( longNames || pTabList->nSrc>1 ){
5134 Expr *pLeft;
5135 pLeft = sqlite3Expr(db, TK_ID, zTabName);
5136 pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight);
5137 if( zSchemaName ){
5138 pLeft = sqlite3Expr(db, TK_ID, zSchemaName);
5139 pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pExpr);
5140 }
5141 if( longNames ){
5142 zColname = sqlite3MPrintf(db, "%s.%s", zTabName, zName);
5143 zToFree = zColname;
5144 }
5145 }else{
5146 pExpr = pRight;
5147 }
5148 pNew = sqlite3ExprListAppend(pParse, pNew, pExpr);
5149 sqlite3TokenInit(&sColname, zColname);
5150 sqlite3ExprListSetName(pParse, pNew, &sColname, 0);
5151 if( pNew && (p->selFlags & SF_NestedFrom)!=0 ){
5152 struct ExprList_item *pX = &pNew->a[pNew->nExpr-1];
5153 sqlite3DbFree(db, pX->zEName);
5154 if( pSub ){
5155 pX->zEName = sqlite3DbStrDup(db, pSub->pEList->a[j].zEName);
5156 testcase( pX->zEName==0 );
5157 }else{
5158 pX->zEName = sqlite3MPrintf(db, "%s.%s.%s",
5159 zSchemaName, zTabName, zColname);
5160 testcase( pX->zEName==0 );
5161 }
5162 pX->eEName = ENAME_TAB;
5163 }
5164 sqlite3DbFree(db, zToFree);
5165 }
5166 }
5167 if( !tableSeen ){
5168 if( zTName ){
5169 sqlite3ErrorMsg(pParse, "no such table: %s", zTName);
5170 }else{
5171 sqlite3ErrorMsg(pParse, "no tables specified");
5172 }
5173 }
5174 }
5175 }
5176 sqlite3ExprListDelete(db, pEList);
5177 p->pEList = pNew;
5178 }
5179 if( p->pEList ){
5180 if( p->pEList->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
5181 sqlite3ErrorMsg(pParse, "too many columns in result set");
5182 return WRC_Abort;
5183 }
5184 if( (elistFlags & (EP_HasFunc|EP_Subquery))!=0 ){
5185 p->selFlags |= SF_ComplexResult;
5186 }
5187 }
5188 return WRC_Continue;
5189 }
5190
5191 /*
5192 ** No-op routine for the parse-tree walker.
5193 **
5194 ** When this routine is the Walker.xExprCallback then expression trees
5195 ** are walked without any actions being taken at each node. Presumably,
5196 ** when this routine is used for Walker.xExprCallback then
5197 ** Walker.xSelectCallback is set to do something useful for every
5198 ** subquery in the parser tree.
5199 */
sqlite3ExprWalkNoop(Walker * NotUsed,Expr * NotUsed2)5200 int sqlite3ExprWalkNoop(Walker *NotUsed, Expr *NotUsed2){
5201 UNUSED_PARAMETER2(NotUsed, NotUsed2);
5202 return WRC_Continue;
5203 }
5204
5205 /*
5206 ** No-op routine for the parse-tree walker for SELECT statements.
5207 ** subquery in the parser tree.
5208 */
sqlite3SelectWalkNoop(Walker * NotUsed,Select * NotUsed2)5209 int sqlite3SelectWalkNoop(Walker *NotUsed, Select *NotUsed2){
5210 UNUSED_PARAMETER2(NotUsed, NotUsed2);
5211 return WRC_Continue;
5212 }
5213
5214 #if SQLITE_DEBUG
5215 /*
5216 ** Always assert. This xSelectCallback2 implementation proves that the
5217 ** xSelectCallback2 is never invoked.
5218 */
sqlite3SelectWalkAssert2(Walker * NotUsed,Select * NotUsed2)5219 void sqlite3SelectWalkAssert2(Walker *NotUsed, Select *NotUsed2){
5220 UNUSED_PARAMETER2(NotUsed, NotUsed2);
5221 assert( 0 );
5222 }
5223 #endif
5224 /*
5225 ** This routine "expands" a SELECT statement and all of its subqueries.
5226 ** For additional information on what it means to "expand" a SELECT
5227 ** statement, see the comment on the selectExpand worker callback above.
5228 **
5229 ** Expanding a SELECT statement is the first step in processing a
5230 ** SELECT statement. The SELECT statement must be expanded before
5231 ** name resolution is performed.
5232 **
5233 ** If anything goes wrong, an error message is written into pParse.
5234 ** The calling function can detect the problem by looking at pParse->nErr
5235 ** and/or pParse->db->mallocFailed.
5236 */
sqlite3SelectExpand(Parse * pParse,Select * pSelect)5237 static void sqlite3SelectExpand(Parse *pParse, Select *pSelect){
5238 Walker w;
5239 w.xExprCallback = sqlite3ExprWalkNoop;
5240 w.pParse = pParse;
5241 if( OK_IF_ALWAYS_TRUE(pParse->hasCompound) ){
5242 w.xSelectCallback = convertCompoundSelectToSubquery;
5243 w.xSelectCallback2 = 0;
5244 sqlite3WalkSelect(&w, pSelect);
5245 }
5246 w.xSelectCallback = selectExpander;
5247 w.xSelectCallback2 = selectPopWith;
5248 w.eCode = 0;
5249 sqlite3WalkSelect(&w, pSelect);
5250 }
5251
5252
5253 #ifndef SQLITE_OMIT_SUBQUERY
5254 /*
5255 ** This is a Walker.xSelectCallback callback for the sqlite3SelectTypeInfo()
5256 ** interface.
5257 **
5258 ** For each FROM-clause subquery, add Column.zType and Column.zColl
5259 ** information to the Table structure that represents the result set
5260 ** of that subquery.
5261 **
5262 ** The Table structure that represents the result set was constructed
5263 ** by selectExpander() but the type and collation information was omitted
5264 ** at that point because identifiers had not yet been resolved. This
5265 ** routine is called after identifier resolution.
5266 */
selectAddSubqueryTypeInfo(Walker * pWalker,Select * p)5267 static void selectAddSubqueryTypeInfo(Walker *pWalker, Select *p){
5268 Parse *pParse;
5269 int i;
5270 SrcList *pTabList;
5271 struct SrcList_item *pFrom;
5272
5273 assert( p->selFlags & SF_Resolved );
5274 if( p->selFlags & SF_HasTypeInfo ) return;
5275 p->selFlags |= SF_HasTypeInfo;
5276 pParse = pWalker->pParse;
5277 pTabList = p->pSrc;
5278 for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
5279 Table *pTab = pFrom->pTab;
5280 assert( pTab!=0 );
5281 if( (pTab->tabFlags & TF_Ephemeral)!=0 ){
5282 /* A sub-query in the FROM clause of a SELECT */
5283 Select *pSel = pFrom->pSelect;
5284 if( pSel ){
5285 while( pSel->pPrior ) pSel = pSel->pPrior;
5286 sqlite3SelectAddColumnTypeAndCollation(pParse, pTab, pSel,
5287 SQLITE_AFF_NONE);
5288 }
5289 }
5290 }
5291 }
5292 #endif
5293
5294
5295 /*
5296 ** This routine adds datatype and collating sequence information to
5297 ** the Table structures of all FROM-clause subqueries in a
5298 ** SELECT statement.
5299 **
5300 ** Use this routine after name resolution.
5301 */
sqlite3SelectAddTypeInfo(Parse * pParse,Select * pSelect)5302 static void sqlite3SelectAddTypeInfo(Parse *pParse, Select *pSelect){
5303 #ifndef SQLITE_OMIT_SUBQUERY
5304 Walker w;
5305 w.xSelectCallback = sqlite3SelectWalkNoop;
5306 w.xSelectCallback2 = selectAddSubqueryTypeInfo;
5307 w.xExprCallback = sqlite3ExprWalkNoop;
5308 w.pParse = pParse;
5309 sqlite3WalkSelect(&w, pSelect);
5310 #endif
5311 }
5312
5313
5314 /*
5315 ** This routine sets up a SELECT statement for processing. The
5316 ** following is accomplished:
5317 **
5318 ** * VDBE Cursor numbers are assigned to all FROM-clause terms.
5319 ** * Ephemeral Table objects are created for all FROM-clause subqueries.
5320 ** * ON and USING clauses are shifted into WHERE statements
5321 ** * Wildcards "*" and "TABLE.*" in result sets are expanded.
5322 ** * Identifiers in expression are matched to tables.
5323 **
5324 ** This routine acts recursively on all subqueries within the SELECT.
5325 */
sqlite3SelectPrep(Parse * pParse,Select * p,NameContext * pOuterNC)5326 void sqlite3SelectPrep(
5327 Parse *pParse, /* The parser context */
5328 Select *p, /* The SELECT statement being coded. */
5329 NameContext *pOuterNC /* Name context for container */
5330 ){
5331 assert( p!=0 || pParse->db->mallocFailed );
5332 if( pParse->db->mallocFailed ) return;
5333 if( p->selFlags & SF_HasTypeInfo ) return;
5334 sqlite3SelectExpand(pParse, p);
5335 if( pParse->nErr || pParse->db->mallocFailed ) return;
5336 sqlite3ResolveSelectNames(pParse, p, pOuterNC);
5337 if( pParse->nErr || pParse->db->mallocFailed ) return;
5338 sqlite3SelectAddTypeInfo(pParse, p);
5339 }
5340
5341 /*
5342 ** Reset the aggregate accumulator.
5343 **
5344 ** The aggregate accumulator is a set of memory cells that hold
5345 ** intermediate results while calculating an aggregate. This
5346 ** routine generates code that stores NULLs in all of those memory
5347 ** cells.
5348 */
resetAccumulator(Parse * pParse,AggInfo * pAggInfo)5349 static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){
5350 Vdbe *v = pParse->pVdbe;
5351 int i;
5352 struct AggInfo_func *pFunc;
5353 int nReg = pAggInfo->nFunc + pAggInfo->nColumn;
5354 if( nReg==0 ) return;
5355 if( pParse->nErr ) return;
5356 #ifdef SQLITE_DEBUG
5357 /* Verify that all AggInfo registers are within the range specified by
5358 ** AggInfo.mnReg..AggInfo.mxReg */
5359 assert( nReg==pAggInfo->mxReg-pAggInfo->mnReg+1 );
5360 for(i=0; i<pAggInfo->nColumn; i++){
5361 assert( pAggInfo->aCol[i].iMem>=pAggInfo->mnReg
5362 && pAggInfo->aCol[i].iMem<=pAggInfo->mxReg );
5363 }
5364 for(i=0; i<pAggInfo->nFunc; i++){
5365 assert( pAggInfo->aFunc[i].iMem>=pAggInfo->mnReg
5366 && pAggInfo->aFunc[i].iMem<=pAggInfo->mxReg );
5367 }
5368 #endif
5369 sqlite3VdbeAddOp3(v, OP_Null, 0, pAggInfo->mnReg, pAggInfo->mxReg);
5370 for(pFunc=pAggInfo->aFunc, i=0; i<pAggInfo->nFunc; i++, pFunc++){
5371 if( pFunc->iDistinct>=0 ){
5372 Expr *pE = pFunc->pExpr;
5373 assert( !ExprHasProperty(pE, EP_xIsSelect) );
5374 if( pE->x.pList==0 || pE->x.pList->nExpr!=1 ){
5375 sqlite3ErrorMsg(pParse, "DISTINCT aggregates must have exactly one "
5376 "argument");
5377 pFunc->iDistinct = -1;
5378 }else{
5379 KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pE->x.pList,0,0);
5380 sqlite3VdbeAddOp4(v, OP_OpenEphemeral, pFunc->iDistinct, 0, 0,
5381 (char*)pKeyInfo, P4_KEYINFO);
5382 }
5383 }
5384 }
5385 }
5386
5387 /*
5388 ** Invoke the OP_AggFinalize opcode for every aggregate function
5389 ** in the AggInfo structure.
5390 */
finalizeAggFunctions(Parse * pParse,AggInfo * pAggInfo)5391 static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){
5392 Vdbe *v = pParse->pVdbe;
5393 int i;
5394 struct AggInfo_func *pF;
5395 for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
5396 ExprList *pList = pF->pExpr->x.pList;
5397 assert( !ExprHasProperty(pF->pExpr, EP_xIsSelect) );
5398 sqlite3VdbeAddOp2(v, OP_AggFinal, pF->iMem, pList ? pList->nExpr : 0);
5399 sqlite3VdbeAppendP4(v, pF->pFunc, P4_FUNCDEF);
5400 }
5401 }
5402
5403
5404 /*
5405 ** Update the accumulator memory cells for an aggregate based on
5406 ** the current cursor position.
5407 **
5408 ** If regAcc is non-zero and there are no min() or max() aggregates
5409 ** in pAggInfo, then only populate the pAggInfo->nAccumulator accumulator
5410 ** registers if register regAcc contains 0. The caller will take care
5411 ** of setting and clearing regAcc.
5412 */
updateAccumulator(Parse * pParse,int regAcc,AggInfo * pAggInfo)5413 static void updateAccumulator(Parse *pParse, int regAcc, AggInfo *pAggInfo){
5414 Vdbe *v = pParse->pVdbe;
5415 int i;
5416 int regHit = 0;
5417 int addrHitTest = 0;
5418 struct AggInfo_func *pF;
5419 struct AggInfo_col *pC;
5420
5421 pAggInfo->directMode = 1;
5422 for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
5423 int nArg;
5424 int addrNext = 0;
5425 int regAgg;
5426 ExprList *pList = pF->pExpr->x.pList;
5427 assert( !ExprHasProperty(pF->pExpr, EP_xIsSelect) );
5428 assert( !IsWindowFunc(pF->pExpr) );
5429 if( ExprHasProperty(pF->pExpr, EP_WinFunc) ){
5430 Expr *pFilter = pF->pExpr->y.pWin->pFilter;
5431 if( pAggInfo->nAccumulator
5432 && (pF->pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL)
5433 ){
5434 if( regHit==0 ) regHit = ++pParse->nMem;
5435 /* If this is the first row of the group (regAcc==0), clear the
5436 ** "magnet" register regHit so that the accumulator registers
5437 ** are populated if the FILTER clause jumps over the the
5438 ** invocation of min() or max() altogether. Or, if this is not
5439 ** the first row (regAcc==1), set the magnet register so that the
5440 ** accumulators are not populated unless the min()/max() is invoked and
5441 ** indicates that they should be. */
5442 sqlite3VdbeAddOp2(v, OP_Copy, regAcc, regHit);
5443 }
5444 addrNext = sqlite3VdbeMakeLabel(pParse);
5445 sqlite3ExprIfFalse(pParse, pFilter, addrNext, SQLITE_JUMPIFNULL);
5446 }
5447 if( pList ){
5448 nArg = pList->nExpr;
5449 regAgg = sqlite3GetTempRange(pParse, nArg);
5450 sqlite3ExprCodeExprList(pParse, pList, regAgg, 0, SQLITE_ECEL_DUP);
5451 }else{
5452 nArg = 0;
5453 regAgg = 0;
5454 }
5455 if( pF->iDistinct>=0 ){
5456 if( addrNext==0 ){
5457 addrNext = sqlite3VdbeMakeLabel(pParse);
5458 }
5459 testcase( nArg==0 ); /* Error condition */
5460 testcase( nArg>1 ); /* Also an error */
5461 codeDistinct(pParse, pF->iDistinct, addrNext, 1, regAgg);
5462 }
5463 if( pF->pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL ){
5464 CollSeq *pColl = 0;
5465 struct ExprList_item *pItem;
5466 int j;
5467 assert( pList!=0 ); /* pList!=0 if pF->pFunc has NEEDCOLL */
5468 for(j=0, pItem=pList->a; !pColl && j<nArg; j++, pItem++){
5469 pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
5470 }
5471 if( !pColl ){
5472 pColl = pParse->db->pDfltColl;
5473 }
5474 if( regHit==0 && pAggInfo->nAccumulator ) regHit = ++pParse->nMem;
5475 sqlite3VdbeAddOp4(v, OP_CollSeq, regHit, 0, 0, (char *)pColl, P4_COLLSEQ);
5476 }
5477 sqlite3VdbeAddOp3(v, OP_AggStep, 0, regAgg, pF->iMem);
5478 sqlite3VdbeAppendP4(v, pF->pFunc, P4_FUNCDEF);
5479 sqlite3VdbeChangeP5(v, (u8)nArg);
5480 sqlite3ReleaseTempRange(pParse, regAgg, nArg);
5481 if( addrNext ){
5482 sqlite3VdbeResolveLabel(v, addrNext);
5483 }
5484 }
5485 if( regHit==0 && pAggInfo->nAccumulator ){
5486 regHit = regAcc;
5487 }
5488 if( regHit ){
5489 addrHitTest = sqlite3VdbeAddOp1(v, OP_If, regHit); VdbeCoverage(v);
5490 }
5491 for(i=0, pC=pAggInfo->aCol; i<pAggInfo->nAccumulator; i++, pC++){
5492 sqlite3ExprCode(pParse, pC->pExpr, pC->iMem);
5493 }
5494
5495 pAggInfo->directMode = 0;
5496 if( addrHitTest ){
5497 sqlite3VdbeJumpHere(v, addrHitTest);
5498 }
5499 }
5500
5501 /*
5502 ** Add a single OP_Explain instruction to the VDBE to explain a simple
5503 ** count(*) query ("SELECT count(*) FROM pTab").
5504 */
5505 #ifndef SQLITE_OMIT_EXPLAIN
explainSimpleCount(Parse * pParse,Table * pTab,Index * pIdx)5506 static void explainSimpleCount(
5507 Parse *pParse, /* Parse context */
5508 Table *pTab, /* Table being queried */
5509 Index *pIdx /* Index used to optimize scan, or NULL */
5510 ){
5511 if( pParse->explain==2 ){
5512 int bCover = (pIdx!=0 && (HasRowid(pTab) || !IsPrimaryKeyIndex(pIdx)));
5513 sqlite3VdbeExplain(pParse, 0, "SCAN TABLE %s%s%s",
5514 pTab->zName,
5515 bCover ? " USING COVERING INDEX " : "",
5516 bCover ? pIdx->zName : ""
5517 );
5518 }
5519 }
5520 #else
5521 # define explainSimpleCount(a,b,c)
5522 #endif
5523
5524 /*
5525 ** sqlite3WalkExpr() callback used by havingToWhere().
5526 **
5527 ** If the node passed to the callback is a TK_AND node, return
5528 ** WRC_Continue to tell sqlite3WalkExpr() to iterate through child nodes.
5529 **
5530 ** Otherwise, return WRC_Prune. In this case, also check if the
5531 ** sub-expression matches the criteria for being moved to the WHERE
5532 ** clause. If so, add it to the WHERE clause and replace the sub-expression
5533 ** within the HAVING expression with a constant "1".
5534 */
havingToWhereExprCb(Walker * pWalker,Expr * pExpr)5535 static int havingToWhereExprCb(Walker *pWalker, Expr *pExpr){
5536 if( pExpr->op!=TK_AND ){
5537 Select *pS = pWalker->u.pSelect;
5538 if( sqlite3ExprIsConstantOrGroupBy(pWalker->pParse, pExpr, pS->pGroupBy) ){
5539 sqlite3 *db = pWalker->pParse->db;
5540 Expr *pNew = sqlite3Expr(db, TK_INTEGER, "1");
5541 if( pNew ){
5542 Expr *pWhere = pS->pWhere;
5543 SWAP(Expr, *pNew, *pExpr);
5544 pNew = sqlite3ExprAnd(pWalker->pParse, pWhere, pNew);
5545 pS->pWhere = pNew;
5546 pWalker->eCode = 1;
5547 }
5548 }
5549 return WRC_Prune;
5550 }
5551 return WRC_Continue;
5552 }
5553
5554 /*
5555 ** Transfer eligible terms from the HAVING clause of a query, which is
5556 ** processed after grouping, to the WHERE clause, which is processed before
5557 ** grouping. For example, the query:
5558 **
5559 ** SELECT * FROM <tables> WHERE a=? GROUP BY b HAVING b=? AND c=?
5560 **
5561 ** can be rewritten as:
5562 **
5563 ** SELECT * FROM <tables> WHERE a=? AND b=? GROUP BY b HAVING c=?
5564 **
5565 ** A term of the HAVING expression is eligible for transfer if it consists
5566 ** entirely of constants and expressions that are also GROUP BY terms that
5567 ** use the "BINARY" collation sequence.
5568 */
havingToWhere(Parse * pParse,Select * p)5569 static void havingToWhere(Parse *pParse, Select *p){
5570 Walker sWalker;
5571 memset(&sWalker, 0, sizeof(sWalker));
5572 sWalker.pParse = pParse;
5573 sWalker.xExprCallback = havingToWhereExprCb;
5574 sWalker.u.pSelect = p;
5575 sqlite3WalkExpr(&sWalker, p->pHaving);
5576 #if SELECTTRACE_ENABLED
5577 if( sWalker.eCode && (sqlite3SelectTrace & 0x100)!=0 ){
5578 SELECTTRACE(0x100,pParse,p,("Move HAVING terms into WHERE:\n"));
5579 sqlite3TreeViewSelect(0, p, 0);
5580 }
5581 #endif
5582 }
5583
5584 /*
5585 ** Check to see if the pThis entry of pTabList is a self-join of a prior view.
5586 ** If it is, then return the SrcList_item for the prior view. If it is not,
5587 ** then return 0.
5588 */
isSelfJoinView(SrcList * pTabList,struct SrcList_item * pThis)5589 static struct SrcList_item *isSelfJoinView(
5590 SrcList *pTabList, /* Search for self-joins in this FROM clause */
5591 struct SrcList_item *pThis /* Search for prior reference to this subquery */
5592 ){
5593 struct SrcList_item *pItem;
5594 for(pItem = pTabList->a; pItem<pThis; pItem++){
5595 Select *pS1;
5596 if( pItem->pSelect==0 ) continue;
5597 if( pItem->fg.viaCoroutine ) continue;
5598 if( pItem->zName==0 ) continue;
5599 assert( pItem->pTab!=0 );
5600 assert( pThis->pTab!=0 );
5601 if( pItem->pTab->pSchema!=pThis->pTab->pSchema ) continue;
5602 if( sqlite3_stricmp(pItem->zName, pThis->zName)!=0 ) continue;
5603 pS1 = pItem->pSelect;
5604 if( pItem->pTab->pSchema==0 && pThis->pSelect->selId!=pS1->selId ){
5605 /* The query flattener left two different CTE tables with identical
5606 ** names in the same FROM clause. */
5607 continue;
5608 }
5609 if( sqlite3ExprCompare(0, pThis->pSelect->pWhere, pS1->pWhere, -1)
5610 || sqlite3ExprCompare(0, pThis->pSelect->pHaving, pS1->pHaving, -1)
5611 ){
5612 /* The view was modified by some other optimization such as
5613 ** pushDownWhereTerms() */
5614 continue;
5615 }
5616 return pItem;
5617 }
5618 return 0;
5619 }
5620
5621 #ifdef SQLITE_COUNTOFVIEW_OPTIMIZATION
5622 /*
5623 ** Attempt to transform a query of the form
5624 **
5625 ** SELECT count(*) FROM (SELECT x FROM t1 UNION ALL SELECT y FROM t2)
5626 **
5627 ** Into this:
5628 **
5629 ** SELECT (SELECT count(*) FROM t1)+(SELECT count(*) FROM t2)
5630 **
5631 ** The transformation only works if all of the following are true:
5632 **
5633 ** * The subquery is a UNION ALL of two or more terms
5634 ** * The subquery does not have a LIMIT clause
5635 ** * There is no WHERE or GROUP BY or HAVING clauses on the subqueries
5636 ** * The outer query is a simple count(*) with no WHERE clause or other
5637 ** extraneous syntax.
5638 **
5639 ** Return TRUE if the optimization is undertaken.
5640 */
countOfViewOptimization(Parse * pParse,Select * p)5641 static int countOfViewOptimization(Parse *pParse, Select *p){
5642 Select *pSub, *pPrior;
5643 Expr *pExpr;
5644 Expr *pCount;
5645 sqlite3 *db;
5646 if( (p->selFlags & SF_Aggregate)==0 ) return 0; /* This is an aggregate */
5647 if( p->pEList->nExpr!=1 ) return 0; /* Single result column */
5648 if( p->pWhere ) return 0;
5649 if( p->pGroupBy ) return 0;
5650 pExpr = p->pEList->a[0].pExpr;
5651 if( pExpr->op!=TK_AGG_FUNCTION ) return 0; /* Result is an aggregate */
5652 if( sqlite3_stricmp(pExpr->u.zToken,"count") ) return 0; /* Is count() */
5653 if( pExpr->x.pList!=0 ) return 0; /* Must be count(*) */
5654 if( p->pSrc->nSrc!=1 ) return 0; /* One table in FROM */
5655 pSub = p->pSrc->a[0].pSelect;
5656 if( pSub==0 ) return 0; /* The FROM is a subquery */
5657 if( pSub->pPrior==0 ) return 0; /* Must be a compound ry */
5658 do{
5659 if( pSub->op!=TK_ALL && pSub->pPrior ) return 0; /* Must be UNION ALL */
5660 if( pSub->pWhere ) return 0; /* No WHERE clause */
5661 if( pSub->pLimit ) return 0; /* No LIMIT clause */
5662 if( pSub->selFlags & SF_Aggregate ) return 0; /* Not an aggregate */
5663 pSub = pSub->pPrior; /* Repeat over compound */
5664 }while( pSub );
5665
5666 /* If we reach this point then it is OK to perform the transformation */
5667
5668 db = pParse->db;
5669 pCount = pExpr;
5670 pExpr = 0;
5671 pSub = p->pSrc->a[0].pSelect;
5672 p->pSrc->a[0].pSelect = 0;
5673 sqlite3SrcListDelete(db, p->pSrc);
5674 p->pSrc = sqlite3DbMallocZero(pParse->db, sizeof(*p->pSrc));
5675 while( pSub ){
5676 Expr *pTerm;
5677 pPrior = pSub->pPrior;
5678 pSub->pPrior = 0;
5679 pSub->pNext = 0;
5680 pSub->selFlags |= SF_Aggregate;
5681 pSub->selFlags &= ~SF_Compound;
5682 pSub->nSelectRow = 0;
5683 sqlite3ExprListDelete(db, pSub->pEList);
5684 pTerm = pPrior ? sqlite3ExprDup(db, pCount, 0) : pCount;
5685 pSub->pEList = sqlite3ExprListAppend(pParse, 0, pTerm);
5686 pTerm = sqlite3PExpr(pParse, TK_SELECT, 0, 0);
5687 sqlite3PExprAddSelect(pParse, pTerm, pSub);
5688 if( pExpr==0 ){
5689 pExpr = pTerm;
5690 }else{
5691 pExpr = sqlite3PExpr(pParse, TK_PLUS, pTerm, pExpr);
5692 }
5693 pSub = pPrior;
5694 }
5695 p->pEList->a[0].pExpr = pExpr;
5696 p->selFlags &= ~SF_Aggregate;
5697
5698 #if SELECTTRACE_ENABLED
5699 if( sqlite3SelectTrace & 0x400 ){
5700 SELECTTRACE(0x400,pParse,p,("After count-of-view optimization:\n"));
5701 sqlite3TreeViewSelect(0, p, 0);
5702 }
5703 #endif
5704 return 1;
5705 }
5706 #endif /* SQLITE_COUNTOFVIEW_OPTIMIZATION */
5707
5708 /*
5709 ** Generate code for the SELECT statement given in the p argument.
5710 **
5711 ** The results are returned according to the SelectDest structure.
5712 ** See comments in sqliteInt.h for further information.
5713 **
5714 ** This routine returns the number of errors. If any errors are
5715 ** encountered, then an appropriate error message is left in
5716 ** pParse->zErrMsg.
5717 **
5718 ** This routine does NOT free the Select structure passed in. The
5719 ** calling function needs to do that.
5720 */
sqlite3Select(Parse * pParse,Select * p,SelectDest * pDest)5721 int sqlite3Select(
5722 Parse *pParse, /* The parser context */
5723 Select *p, /* The SELECT statement being coded. */
5724 SelectDest *pDest /* What to do with the query results */
5725 ){
5726 int i, j; /* Loop counters */
5727 WhereInfo *pWInfo; /* Return from sqlite3WhereBegin() */
5728 Vdbe *v; /* The virtual machine under construction */
5729 int isAgg; /* True for select lists like "count(*)" */
5730 ExprList *pEList = 0; /* List of columns to extract. */
5731 SrcList *pTabList; /* List of tables to select from */
5732 Expr *pWhere; /* The WHERE clause. May be NULL */
5733 ExprList *pGroupBy; /* The GROUP BY clause. May be NULL */
5734 Expr *pHaving; /* The HAVING clause. May be NULL */
5735 int rc = 1; /* Value to return from this function */
5736 DistinctCtx sDistinct; /* Info on how to code the DISTINCT keyword */
5737 SortCtx sSort; /* Info on how to code the ORDER BY clause */
5738 AggInfo sAggInfo; /* Information used by aggregate queries */
5739 int iEnd; /* Address of the end of the query */
5740 sqlite3 *db; /* The database connection */
5741 ExprList *pMinMaxOrderBy = 0; /* Added ORDER BY for min/max queries */
5742 u8 minMaxFlag; /* Flag for min/max queries */
5743
5744 db = pParse->db;
5745 v = sqlite3GetVdbe(pParse);
5746 if( p==0 || db->mallocFailed || pParse->nErr ){
5747 return 1;
5748 }
5749 if( sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1;
5750 memset(&sAggInfo, 0, sizeof(sAggInfo));
5751 #if SELECTTRACE_ENABLED
5752 SELECTTRACE(1,pParse,p, ("begin processing:\n", pParse->addrExplain));
5753 if( sqlite3SelectTrace & 0x100 ){
5754 sqlite3TreeViewSelect(0, p, 0);
5755 }
5756 #endif
5757
5758 assert( p->pOrderBy==0 || pDest->eDest!=SRT_DistFifo );
5759 assert( p->pOrderBy==0 || pDest->eDest!=SRT_Fifo );
5760 assert( p->pOrderBy==0 || pDest->eDest!=SRT_DistQueue );
5761 assert( p->pOrderBy==0 || pDest->eDest!=SRT_Queue );
5762 if( IgnorableOrderby(pDest) ){
5763 assert(pDest->eDest==SRT_Exists || pDest->eDest==SRT_Union ||
5764 pDest->eDest==SRT_Except || pDest->eDest==SRT_Discard ||
5765 pDest->eDest==SRT_Queue || pDest->eDest==SRT_DistFifo ||
5766 pDest->eDest==SRT_DistQueue || pDest->eDest==SRT_Fifo);
5767 /* If ORDER BY makes no difference in the output then neither does
5768 ** DISTINCT so it can be removed too. */
5769 sqlite3ExprListDelete(db, p->pOrderBy);
5770 p->pOrderBy = 0;
5771 p->selFlags &= ~SF_Distinct;
5772 }
5773 sqlite3SelectPrep(pParse, p, 0);
5774 if( pParse->nErr || db->mallocFailed ){
5775 goto select_end;
5776 }
5777 assert( p->pEList!=0 );
5778 #if SELECTTRACE_ENABLED
5779 if( sqlite3SelectTrace & 0x104 ){
5780 SELECTTRACE(0x104,pParse,p, ("after name resolution:\n"));
5781 sqlite3TreeViewSelect(0, p, 0);
5782 }
5783 #endif
5784
5785 if( pDest->eDest==SRT_Output ){
5786 generateColumnNames(pParse, p);
5787 }
5788
5789 #ifndef SQLITE_OMIT_WINDOWFUNC
5790 rc = sqlite3WindowRewrite(pParse, p);
5791 if( rc ){
5792 assert( db->mallocFailed || pParse->nErr>0 );
5793 goto select_end;
5794 }
5795 #if SELECTTRACE_ENABLED
5796 if( p->pWin && (sqlite3SelectTrace & 0x108)!=0 ){
5797 SELECTTRACE(0x104,pParse,p, ("after window rewrite:\n"));
5798 sqlite3TreeViewSelect(0, p, 0);
5799 }
5800 #endif
5801 #endif /* SQLITE_OMIT_WINDOWFUNC */
5802 pTabList = p->pSrc;
5803 isAgg = (p->selFlags & SF_Aggregate)!=0;
5804 memset(&sSort, 0, sizeof(sSort));
5805 sSort.pOrderBy = p->pOrderBy;
5806
5807 /* Try to various optimizations (flattening subqueries, and strength
5808 ** reduction of join operators) in the FROM clause up into the main query
5809 */
5810 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
5811 for(i=0; !p->pPrior && i<pTabList->nSrc; i++){
5812 struct SrcList_item *pItem = &pTabList->a[i];
5813 Select *pSub = pItem->pSelect;
5814 Table *pTab = pItem->pTab;
5815
5816 /* Convert LEFT JOIN into JOIN if there are terms of the right table
5817 ** of the LEFT JOIN used in the WHERE clause.
5818 */
5819 if( (pItem->fg.jointype & JT_LEFT)!=0
5820 && sqlite3ExprImpliesNonNullRow(p->pWhere, pItem->iCursor)
5821 && OptimizationEnabled(db, SQLITE_SimplifyJoin)
5822 ){
5823 SELECTTRACE(0x100,pParse,p,
5824 ("LEFT-JOIN simplifies to JOIN on term %d\n",i));
5825 pItem->fg.jointype &= ~(JT_LEFT|JT_OUTER);
5826 unsetJoinExpr(p->pWhere, pItem->iCursor);
5827 }
5828
5829 /* No futher action if this term of the FROM clause is no a subquery */
5830 if( pSub==0 ) continue;
5831
5832 /* Catch mismatch in the declared columns of a view and the number of
5833 ** columns in the SELECT on the RHS */
5834 if( pTab->nCol!=pSub->pEList->nExpr ){
5835 sqlite3ErrorMsg(pParse, "expected %d columns for '%s' but got %d",
5836 pTab->nCol, pTab->zName, pSub->pEList->nExpr);
5837 goto select_end;
5838 }
5839
5840 /* Do not try to flatten an aggregate subquery.
5841 **
5842 ** Flattening an aggregate subquery is only possible if the outer query
5843 ** is not a join. But if the outer query is not a join, then the subquery
5844 ** will be implemented as a co-routine and there is no advantage to
5845 ** flattening in that case.
5846 */
5847 if( (pSub->selFlags & SF_Aggregate)!=0 ) continue;
5848 assert( pSub->pGroupBy==0 );
5849
5850 /* If the outer query contains a "complex" result set (that is,
5851 ** if the result set of the outer query uses functions or subqueries)
5852 ** and if the subquery contains an ORDER BY clause and if
5853 ** it will be implemented as a co-routine, then do not flatten. This
5854 ** restriction allows SQL constructs like this:
5855 **
5856 ** SELECT expensive_function(x)
5857 ** FROM (SELECT x FROM tab ORDER BY y LIMIT 10);
5858 **
5859 ** The expensive_function() is only computed on the 10 rows that
5860 ** are output, rather than every row of the table.
5861 **
5862 ** The requirement that the outer query have a complex result set
5863 ** means that flattening does occur on simpler SQL constraints without
5864 ** the expensive_function() like:
5865 **
5866 ** SELECT x FROM (SELECT x FROM tab ORDER BY y LIMIT 10);
5867 */
5868 if( pSub->pOrderBy!=0
5869 && i==0
5870 && (p->selFlags & SF_ComplexResult)!=0
5871 && (pTabList->nSrc==1
5872 || (pTabList->a[1].fg.jointype&(JT_LEFT|JT_CROSS))!=0)
5873 ){
5874 continue;
5875 }
5876
5877 if( flattenSubquery(pParse, p, i, isAgg) ){
5878 if( pParse->nErr ) goto select_end;
5879 /* This subquery can be absorbed into its parent. */
5880 i = -1;
5881 }
5882 pTabList = p->pSrc;
5883 if( db->mallocFailed ) goto select_end;
5884 if( !IgnorableOrderby(pDest) ){
5885 sSort.pOrderBy = p->pOrderBy;
5886 }
5887 }
5888 #endif
5889
5890 #ifndef SQLITE_OMIT_COMPOUND_SELECT
5891 /* Handle compound SELECT statements using the separate multiSelect()
5892 ** procedure.
5893 */
5894 if( p->pPrior ){
5895 rc = multiSelect(pParse, p, pDest);
5896 #if SELECTTRACE_ENABLED
5897 SELECTTRACE(0x1,pParse,p,("end compound-select processing\n"));
5898 if( (sqlite3SelectTrace & 0x2000)!=0 && ExplainQueryPlanParent(pParse)==0 ){
5899 sqlite3TreeViewSelect(0, p, 0);
5900 }
5901 #endif
5902 if( p->pNext==0 ) ExplainQueryPlanPop(pParse);
5903 return rc;
5904 }
5905 #endif
5906
5907 /* Do the WHERE-clause constant propagation optimization if this is
5908 ** a join. No need to speed time on this operation for non-join queries
5909 ** as the equivalent optimization will be handled by query planner in
5910 ** sqlite3WhereBegin().
5911 */
5912 if( pTabList->nSrc>1
5913 && OptimizationEnabled(db, SQLITE_PropagateConst)
5914 && propagateConstants(pParse, p)
5915 ){
5916 #if SELECTTRACE_ENABLED
5917 if( sqlite3SelectTrace & 0x100 ){
5918 SELECTTRACE(0x100,pParse,p,("After constant propagation:\n"));
5919 sqlite3TreeViewSelect(0, p, 0);
5920 }
5921 #endif
5922 }else{
5923 SELECTTRACE(0x100,pParse,p,("Constant propagation not helpful\n"));
5924 }
5925
5926 #ifdef SQLITE_COUNTOFVIEW_OPTIMIZATION
5927 if( OptimizationEnabled(db, SQLITE_QueryFlattener|SQLITE_CountOfView)
5928 && countOfViewOptimization(pParse, p)
5929 ){
5930 if( db->mallocFailed ) goto select_end;
5931 pEList = p->pEList;
5932 pTabList = p->pSrc;
5933 }
5934 #endif
5935
5936 /* For each term in the FROM clause, do two things:
5937 ** (1) Authorized unreferenced tables
5938 ** (2) Generate code for all sub-queries
5939 */
5940 for(i=0; i<pTabList->nSrc; i++){
5941 struct SrcList_item *pItem = &pTabList->a[i];
5942 SelectDest dest;
5943 Select *pSub;
5944 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
5945 const char *zSavedAuthContext;
5946 #endif
5947
5948 /* Issue SQLITE_READ authorizations with a fake column name for any
5949 ** tables that are referenced but from which no values are extracted.
5950 ** Examples of where these kinds of null SQLITE_READ authorizations
5951 ** would occur:
5952 **
5953 ** SELECT count(*) FROM t1; -- SQLITE_READ t1.""
5954 ** SELECT t1.* FROM t1, t2; -- SQLITE_READ t2.""
5955 **
5956 ** The fake column name is an empty string. It is possible for a table to
5957 ** have a column named by the empty string, in which case there is no way to
5958 ** distinguish between an unreferenced table and an actual reference to the
5959 ** "" column. The original design was for the fake column name to be a NULL,
5960 ** which would be unambiguous. But legacy authorization callbacks might
5961 ** assume the column name is non-NULL and segfault. The use of an empty
5962 ** string for the fake column name seems safer.
5963 */
5964 if( pItem->colUsed==0 && pItem->zName!=0 ){
5965 sqlite3AuthCheck(pParse, SQLITE_READ, pItem->zName, "", pItem->zDatabase);
5966 }
5967
5968 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
5969 /* Generate code for all sub-queries in the FROM clause
5970 */
5971 pSub = pItem->pSelect;
5972 if( pSub==0 ) continue;
5973
5974 /* The code for a subquery should only be generated once, though it is
5975 ** technically harmless for it to be generated multiple times. The
5976 ** following assert() will detect if something changes to cause
5977 ** the same subquery to be coded multiple times, as a signal to the
5978 ** developers to try to optimize the situation.
5979 **
5980 ** Update 2019-07-24:
5981 ** See ticket https://sqlite.org/src/tktview/c52b09c7f38903b1311cec40.
5982 ** The dbsqlfuzz fuzzer found a case where the same subquery gets
5983 ** coded twice. So this assert() now becomes a testcase(). It should
5984 ** be very rare, though.
5985 */
5986 testcase( pItem->addrFillSub!=0 );
5987
5988 /* Increment Parse.nHeight by the height of the largest expression
5989 ** tree referred to by this, the parent select. The child select
5990 ** may contain expression trees of at most
5991 ** (SQLITE_MAX_EXPR_DEPTH-Parse.nHeight) height. This is a bit
5992 ** more conservative than necessary, but much easier than enforcing
5993 ** an exact limit.
5994 */
5995 pParse->nHeight += sqlite3SelectExprHeight(p);
5996
5997 /* Make copies of constant WHERE-clause terms in the outer query down
5998 ** inside the subquery. This can help the subquery to run more efficiently.
5999 */
6000 if( OptimizationEnabled(db, SQLITE_PushDown)
6001 && pushDownWhereTerms(pParse, pSub, p->pWhere, pItem->iCursor,
6002 (pItem->fg.jointype & JT_OUTER)!=0)
6003 ){
6004 #if SELECTTRACE_ENABLED
6005 if( sqlite3SelectTrace & 0x100 ){
6006 SELECTTRACE(0x100,pParse,p,
6007 ("After WHERE-clause push-down into subquery %d:\n", pSub->selId));
6008 sqlite3TreeViewSelect(0, p, 0);
6009 }
6010 #endif
6011 }else{
6012 SELECTTRACE(0x100,pParse,p,("Push-down not possible\n"));
6013 }
6014
6015 zSavedAuthContext = pParse->zAuthContext;
6016 pParse->zAuthContext = pItem->zName;
6017
6018 /* Generate code to implement the subquery
6019 **
6020 ** The subquery is implemented as a co-routine if the subquery is
6021 ** guaranteed to be the outer loop (so that it does not need to be
6022 ** computed more than once)
6023 **
6024 ** TODO: Are there other reasons beside (1) to use a co-routine
6025 ** implementation?
6026 */
6027 if( i==0
6028 && (pTabList->nSrc==1
6029 || (pTabList->a[1].fg.jointype&(JT_LEFT|JT_CROSS))!=0) /* (1) */
6030 ){
6031 /* Implement a co-routine that will return a single row of the result
6032 ** set on each invocation.
6033 */
6034 int addrTop = sqlite3VdbeCurrentAddr(v)+1;
6035
6036 pItem->regReturn = ++pParse->nMem;
6037 sqlite3VdbeAddOp3(v, OP_InitCoroutine, pItem->regReturn, 0, addrTop);
6038 VdbeComment((v, "%s", pItem->pTab->zName));
6039 pItem->addrFillSub = addrTop;
6040 sqlite3SelectDestInit(&dest, SRT_Coroutine, pItem->regReturn);
6041 ExplainQueryPlan((pParse, 1, "CO-ROUTINE %u", pSub->selId));
6042 sqlite3Select(pParse, pSub, &dest);
6043 pItem->pTab->nRowLogEst = pSub->nSelectRow;
6044 pItem->fg.viaCoroutine = 1;
6045 pItem->regResult = dest.iSdst;
6046 sqlite3VdbeEndCoroutine(v, pItem->regReturn);
6047 sqlite3VdbeJumpHere(v, addrTop-1);
6048 sqlite3ClearTempRegCache(pParse);
6049 }else{
6050 /* Generate a subroutine that will fill an ephemeral table with
6051 ** the content of this subquery. pItem->addrFillSub will point
6052 ** to the address of the generated subroutine. pItem->regReturn
6053 ** is a register allocated to hold the subroutine return address
6054 */
6055 int topAddr;
6056 int onceAddr = 0;
6057 int retAddr;
6058 struct SrcList_item *pPrior;
6059
6060 testcase( pItem->addrFillSub==0 ); /* Ticket c52b09c7f38903b1311 */
6061 pItem->regReturn = ++pParse->nMem;
6062 topAddr = sqlite3VdbeAddOp2(v, OP_Integer, 0, pItem->regReturn);
6063 pItem->addrFillSub = topAddr+1;
6064 if( pItem->fg.isCorrelated==0 ){
6065 /* If the subquery is not correlated and if we are not inside of
6066 ** a trigger, then we only need to compute the value of the subquery
6067 ** once. */
6068 onceAddr = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
6069 VdbeComment((v, "materialize \"%s\"", pItem->pTab->zName));
6070 }else{
6071 VdbeNoopComment((v, "materialize \"%s\"", pItem->pTab->zName));
6072 }
6073 pPrior = isSelfJoinView(pTabList, pItem);
6074 if( pPrior ){
6075 sqlite3VdbeAddOp2(v, OP_OpenDup, pItem->iCursor, pPrior->iCursor);
6076 assert( pPrior->pSelect!=0 );
6077 pSub->nSelectRow = pPrior->pSelect->nSelectRow;
6078 }else{
6079 sqlite3SelectDestInit(&dest, SRT_EphemTab, pItem->iCursor);
6080 ExplainQueryPlan((pParse, 1, "MATERIALIZE %u", pSub->selId));
6081 sqlite3Select(pParse, pSub, &dest);
6082 }
6083 pItem->pTab->nRowLogEst = pSub->nSelectRow;
6084 if( onceAddr ) sqlite3VdbeJumpHere(v, onceAddr);
6085 retAddr = sqlite3VdbeAddOp1(v, OP_Return, pItem->regReturn);
6086 VdbeComment((v, "end %s", pItem->pTab->zName));
6087 sqlite3VdbeChangeP1(v, topAddr, retAddr);
6088 sqlite3ClearTempRegCache(pParse);
6089 }
6090 if( db->mallocFailed ) goto select_end;
6091 pParse->nHeight -= sqlite3SelectExprHeight(p);
6092 pParse->zAuthContext = zSavedAuthContext;
6093 #endif
6094 }
6095
6096 /* Various elements of the SELECT copied into local variables for
6097 ** convenience */
6098 pEList = p->pEList;
6099 pWhere = p->pWhere;
6100 pGroupBy = p->pGroupBy;
6101 pHaving = p->pHaving;
6102 sDistinct.isTnct = (p->selFlags & SF_Distinct)!=0;
6103
6104 #if SELECTTRACE_ENABLED
6105 if( sqlite3SelectTrace & 0x400 ){
6106 SELECTTRACE(0x400,pParse,p,("After all FROM-clause analysis:\n"));
6107 sqlite3TreeViewSelect(0, p, 0);
6108 }
6109 #endif
6110
6111 /* If the query is DISTINCT with an ORDER BY but is not an aggregate, and
6112 ** if the select-list is the same as the ORDER BY list, then this query
6113 ** can be rewritten as a GROUP BY. In other words, this:
6114 **
6115 ** SELECT DISTINCT xyz FROM ... ORDER BY xyz
6116 **
6117 ** is transformed to:
6118 **
6119 ** SELECT xyz FROM ... GROUP BY xyz ORDER BY xyz
6120 **
6121 ** The second form is preferred as a single index (or temp-table) may be
6122 ** used for both the ORDER BY and DISTINCT processing. As originally
6123 ** written the query must use a temp-table for at least one of the ORDER
6124 ** BY and DISTINCT, and an index or separate temp-table for the other.
6125 */
6126 if( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct
6127 && sqlite3ExprListCompare(sSort.pOrderBy, pEList, -1)==0
6128 #ifndef SQLITE_OMIT_WINDOWFUNC
6129 && p->pWin==0
6130 #endif
6131 ){
6132 p->selFlags &= ~SF_Distinct;
6133 pGroupBy = p->pGroupBy = sqlite3ExprListDup(db, pEList, 0);
6134 p->selFlags |= SF_Aggregate;
6135 /* Notice that even thought SF_Distinct has been cleared from p->selFlags,
6136 ** the sDistinct.isTnct is still set. Hence, isTnct represents the
6137 ** original setting of the SF_Distinct flag, not the current setting */
6138 assert( sDistinct.isTnct );
6139
6140 #if SELECTTRACE_ENABLED
6141 if( sqlite3SelectTrace & 0x400 ){
6142 SELECTTRACE(0x400,pParse,p,("Transform DISTINCT into GROUP BY:\n"));
6143 sqlite3TreeViewSelect(0, p, 0);
6144 }
6145 #endif
6146 }
6147
6148 /* If there is an ORDER BY clause, then create an ephemeral index to
6149 ** do the sorting. But this sorting ephemeral index might end up
6150 ** being unused if the data can be extracted in pre-sorted order.
6151 ** If that is the case, then the OP_OpenEphemeral instruction will be
6152 ** changed to an OP_Noop once we figure out that the sorting index is
6153 ** not needed. The sSort.addrSortIndex variable is used to facilitate
6154 ** that change.
6155 */
6156 if( sSort.pOrderBy ){
6157 KeyInfo *pKeyInfo;
6158 pKeyInfo = sqlite3KeyInfoFromExprList(
6159 pParse, sSort.pOrderBy, 0, pEList->nExpr);
6160 sSort.iECursor = pParse->nTab++;
6161 sSort.addrSortIndex =
6162 sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
6163 sSort.iECursor, sSort.pOrderBy->nExpr+1+pEList->nExpr, 0,
6164 (char*)pKeyInfo, P4_KEYINFO
6165 );
6166 }else{
6167 sSort.addrSortIndex = -1;
6168 }
6169
6170 /* If the output is destined for a temporary table, open that table.
6171 */
6172 if( pDest->eDest==SRT_EphemTab ){
6173 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pDest->iSDParm, pEList->nExpr);
6174 }
6175
6176 /* Set the limiter.
6177 */
6178 iEnd = sqlite3VdbeMakeLabel(pParse);
6179 if( (p->selFlags & SF_FixedLimit)==0 ){
6180 p->nSelectRow = 320; /* 4 billion rows */
6181 }
6182 computeLimitRegisters(pParse, p, iEnd);
6183 if( p->iLimit==0 && sSort.addrSortIndex>=0 ){
6184 sqlite3VdbeChangeOpcode(v, sSort.addrSortIndex, OP_SorterOpen);
6185 sSort.sortFlags |= SORTFLAG_UseSorter;
6186 }
6187
6188 /* Open an ephemeral index to use for the distinct set.
6189 */
6190 if( p->selFlags & SF_Distinct ){
6191 sDistinct.tabTnct = pParse->nTab++;
6192 sDistinct.addrTnct = sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
6193 sDistinct.tabTnct, 0, 0,
6194 (char*)sqlite3KeyInfoFromExprList(pParse, p->pEList,0,0),
6195 P4_KEYINFO);
6196 sqlite3VdbeChangeP5(v, BTREE_UNORDERED);
6197 sDistinct.eTnctType = WHERE_DISTINCT_UNORDERED;
6198 }else{
6199 sDistinct.eTnctType = WHERE_DISTINCT_NOOP;
6200 }
6201
6202 if( !isAgg && pGroupBy==0 ){
6203 /* No aggregate functions and no GROUP BY clause */
6204 u16 wctrlFlags = (sDistinct.isTnct ? WHERE_WANT_DISTINCT : 0)
6205 | (p->selFlags & SF_FixedLimit);
6206 #ifndef SQLITE_OMIT_WINDOWFUNC
6207 Window *pWin = p->pWin; /* Master window object (or NULL) */
6208 if( pWin ){
6209 sqlite3WindowCodeInit(pParse, p);
6210 }
6211 #endif
6212 assert( WHERE_USE_LIMIT==SF_FixedLimit );
6213
6214
6215 /* Begin the database scan. */
6216 SELECTTRACE(1,pParse,p,("WhereBegin\n"));
6217 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, sSort.pOrderBy,
6218 p->pEList, wctrlFlags, p->nSelectRow);
6219 if( pWInfo==0 ) goto select_end;
6220 if( sqlite3WhereOutputRowCount(pWInfo) < p->nSelectRow ){
6221 p->nSelectRow = sqlite3WhereOutputRowCount(pWInfo);
6222 }
6223 if( sDistinct.isTnct && sqlite3WhereIsDistinct(pWInfo) ){
6224 sDistinct.eTnctType = sqlite3WhereIsDistinct(pWInfo);
6225 }
6226 if( sSort.pOrderBy ){
6227 sSort.nOBSat = sqlite3WhereIsOrdered(pWInfo);
6228 sSort.labelOBLopt = sqlite3WhereOrderByLimitOptLabel(pWInfo);
6229 if( sSort.nOBSat==sSort.pOrderBy->nExpr ){
6230 sSort.pOrderBy = 0;
6231 }
6232 }
6233
6234 /* If sorting index that was created by a prior OP_OpenEphemeral
6235 ** instruction ended up not being needed, then change the OP_OpenEphemeral
6236 ** into an OP_Noop.
6237 */
6238 if( sSort.addrSortIndex>=0 && sSort.pOrderBy==0 ){
6239 sqlite3VdbeChangeToNoop(v, sSort.addrSortIndex);
6240 }
6241
6242 assert( p->pEList==pEList );
6243 #ifndef SQLITE_OMIT_WINDOWFUNC
6244 if( pWin ){
6245 int addrGosub = sqlite3VdbeMakeLabel(pParse);
6246 int iCont = sqlite3VdbeMakeLabel(pParse);
6247 int iBreak = sqlite3VdbeMakeLabel(pParse);
6248 int regGosub = ++pParse->nMem;
6249
6250 sqlite3WindowCodeStep(pParse, p, pWInfo, regGosub, addrGosub);
6251
6252 sqlite3VdbeAddOp2(v, OP_Goto, 0, iBreak);
6253 sqlite3VdbeResolveLabel(v, addrGosub);
6254 VdbeNoopComment((v, "inner-loop subroutine"));
6255 sSort.labelOBLopt = 0;
6256 selectInnerLoop(pParse, p, -1, &sSort, &sDistinct, pDest, iCont, iBreak);
6257 sqlite3VdbeResolveLabel(v, iCont);
6258 sqlite3VdbeAddOp1(v, OP_Return, regGosub);
6259 VdbeComment((v, "end inner-loop subroutine"));
6260 sqlite3VdbeResolveLabel(v, iBreak);
6261 }else
6262 #endif /* SQLITE_OMIT_WINDOWFUNC */
6263 {
6264 /* Use the standard inner loop. */
6265 selectInnerLoop(pParse, p, -1, &sSort, &sDistinct, pDest,
6266 sqlite3WhereContinueLabel(pWInfo),
6267 sqlite3WhereBreakLabel(pWInfo));
6268
6269 /* End the database scan loop.
6270 */
6271 sqlite3WhereEnd(pWInfo);
6272 }
6273 }else{
6274 /* This case when there exist aggregate functions or a GROUP BY clause
6275 ** or both */
6276 NameContext sNC; /* Name context for processing aggregate information */
6277 int iAMem; /* First Mem address for storing current GROUP BY */
6278 int iBMem; /* First Mem address for previous GROUP BY */
6279 int iUseFlag; /* Mem address holding flag indicating that at least
6280 ** one row of the input to the aggregator has been
6281 ** processed */
6282 int iAbortFlag; /* Mem address which causes query abort if positive */
6283 int groupBySort; /* Rows come from source in GROUP BY order */
6284 int addrEnd; /* End of processing for this SELECT */
6285 int sortPTab = 0; /* Pseudotable used to decode sorting results */
6286 int sortOut = 0; /* Output register from the sorter */
6287 int orderByGrp = 0; /* True if the GROUP BY and ORDER BY are the same */
6288
6289 /* Remove any and all aliases between the result set and the
6290 ** GROUP BY clause.
6291 */
6292 if( pGroupBy ){
6293 int k; /* Loop counter */
6294 struct ExprList_item *pItem; /* For looping over expression in a list */
6295
6296 for(k=p->pEList->nExpr, pItem=p->pEList->a; k>0; k--, pItem++){
6297 pItem->u.x.iAlias = 0;
6298 }
6299 for(k=pGroupBy->nExpr, pItem=pGroupBy->a; k>0; k--, pItem++){
6300 pItem->u.x.iAlias = 0;
6301 }
6302 assert( 66==sqlite3LogEst(100) );
6303 if( p->nSelectRow>66 ) p->nSelectRow = 66;
6304
6305 /* If there is both a GROUP BY and an ORDER BY clause and they are
6306 ** identical, then it may be possible to disable the ORDER BY clause
6307 ** on the grounds that the GROUP BY will cause elements to come out
6308 ** in the correct order. It also may not - the GROUP BY might use a
6309 ** database index that causes rows to be grouped together as required
6310 ** but not actually sorted. Either way, record the fact that the
6311 ** ORDER BY and GROUP BY clauses are the same by setting the orderByGrp
6312 ** variable. */
6313 if( sSort.pOrderBy && pGroupBy->nExpr==sSort.pOrderBy->nExpr ){
6314 int ii;
6315 /* The GROUP BY processing doesn't care whether rows are delivered in
6316 ** ASC or DESC order - only that each group is returned contiguously.
6317 ** So set the ASC/DESC flags in the GROUP BY to match those in the
6318 ** ORDER BY to maximize the chances of rows being delivered in an
6319 ** order that makes the ORDER BY redundant. */
6320 for(ii=0; ii<pGroupBy->nExpr; ii++){
6321 u8 sortFlags = sSort.pOrderBy->a[ii].sortFlags & KEYINFO_ORDER_DESC;
6322 pGroupBy->a[ii].sortFlags = sortFlags;
6323 }
6324 if( sqlite3ExprListCompare(pGroupBy, sSort.pOrderBy, -1)==0 ){
6325 orderByGrp = 1;
6326 }
6327 }
6328 }else{
6329 assert( 0==sqlite3LogEst(1) );
6330 p->nSelectRow = 0;
6331 }
6332
6333 /* Create a label to jump to when we want to abort the query */
6334 addrEnd = sqlite3VdbeMakeLabel(pParse);
6335
6336 /* Convert TK_COLUMN nodes into TK_AGG_COLUMN and make entries in
6337 ** sAggInfo for all TK_AGG_FUNCTION nodes in expressions of the
6338 ** SELECT statement.
6339 */
6340 memset(&sNC, 0, sizeof(sNC));
6341 sNC.pParse = pParse;
6342 sNC.pSrcList = pTabList;
6343 sNC.uNC.pAggInfo = &sAggInfo;
6344 VVA_ONLY( sNC.ncFlags = NC_UAggInfo; )
6345 sAggInfo.mnReg = pParse->nMem+1;
6346 sAggInfo.nSortingColumn = pGroupBy ? pGroupBy->nExpr : 0;
6347 sAggInfo.pGroupBy = pGroupBy;
6348 sqlite3ExprAnalyzeAggList(&sNC, pEList);
6349 sqlite3ExprAnalyzeAggList(&sNC, sSort.pOrderBy);
6350 if( pHaving ){
6351 if( pGroupBy ){
6352 assert( pWhere==p->pWhere );
6353 assert( pHaving==p->pHaving );
6354 assert( pGroupBy==p->pGroupBy );
6355 havingToWhere(pParse, p);
6356 pWhere = p->pWhere;
6357 }
6358 sqlite3ExprAnalyzeAggregates(&sNC, pHaving);
6359 }
6360 sAggInfo.nAccumulator = sAggInfo.nColumn;
6361 if( p->pGroupBy==0 && p->pHaving==0 && sAggInfo.nFunc==1 ){
6362 minMaxFlag = minMaxQuery(db, sAggInfo.aFunc[0].pExpr, &pMinMaxOrderBy);
6363 }else{
6364 minMaxFlag = WHERE_ORDERBY_NORMAL;
6365 }
6366 for(i=0; i<sAggInfo.nFunc; i++){
6367 Expr *pExpr = sAggInfo.aFunc[i].pExpr;
6368 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
6369 sNC.ncFlags |= NC_InAggFunc;
6370 sqlite3ExprAnalyzeAggList(&sNC, pExpr->x.pList);
6371 #ifndef SQLITE_OMIT_WINDOWFUNC
6372 assert( !IsWindowFunc(pExpr) );
6373 if( ExprHasProperty(pExpr, EP_WinFunc) ){
6374 sqlite3ExprAnalyzeAggregates(&sNC, pExpr->y.pWin->pFilter);
6375 }
6376 #endif
6377 sNC.ncFlags &= ~NC_InAggFunc;
6378 }
6379 sAggInfo.mxReg = pParse->nMem;
6380 if( db->mallocFailed ) goto select_end;
6381 #if SELECTTRACE_ENABLED
6382 if( sqlite3SelectTrace & 0x400 ){
6383 int ii;
6384 SELECTTRACE(0x400,pParse,p,("After aggregate analysis:\n"));
6385 sqlite3TreeViewSelect(0, p, 0);
6386 for(ii=0; ii<sAggInfo.nColumn; ii++){
6387 sqlite3DebugPrintf("agg-column[%d] iMem=%d\n",
6388 ii, sAggInfo.aCol[ii].iMem);
6389 sqlite3TreeViewExpr(0, sAggInfo.aCol[ii].pExpr, 0);
6390 }
6391 for(ii=0; ii<sAggInfo.nFunc; ii++){
6392 sqlite3DebugPrintf("agg-func[%d]: iMem=%d\n",
6393 ii, sAggInfo.aFunc[ii].iMem);
6394 sqlite3TreeViewExpr(0, sAggInfo.aFunc[ii].pExpr, 0);
6395 }
6396 }
6397 #endif
6398
6399
6400 /* Processing for aggregates with GROUP BY is very different and
6401 ** much more complex than aggregates without a GROUP BY.
6402 */
6403 if( pGroupBy ){
6404 KeyInfo *pKeyInfo; /* Keying information for the group by clause */
6405 int addr1; /* A-vs-B comparision jump */
6406 int addrOutputRow; /* Start of subroutine that outputs a result row */
6407 int regOutputRow; /* Return address register for output subroutine */
6408 int addrSetAbort; /* Set the abort flag and return */
6409 int addrTopOfLoop; /* Top of the input loop */
6410 int addrSortingIdx; /* The OP_OpenEphemeral for the sorting index */
6411 int addrReset; /* Subroutine for resetting the accumulator */
6412 int regReset; /* Return address register for reset subroutine */
6413
6414 /* If there is a GROUP BY clause we might need a sorting index to
6415 ** implement it. Allocate that sorting index now. If it turns out
6416 ** that we do not need it after all, the OP_SorterOpen instruction
6417 ** will be converted into a Noop.
6418 */
6419 sAggInfo.sortingIdx = pParse->nTab++;
6420 pKeyInfo = sqlite3KeyInfoFromExprList(pParse,pGroupBy,0,sAggInfo.nColumn);
6421 addrSortingIdx = sqlite3VdbeAddOp4(v, OP_SorterOpen,
6422 sAggInfo.sortingIdx, sAggInfo.nSortingColumn,
6423 0, (char*)pKeyInfo, P4_KEYINFO);
6424
6425 /* Initialize memory locations used by GROUP BY aggregate processing
6426 */
6427 iUseFlag = ++pParse->nMem;
6428 iAbortFlag = ++pParse->nMem;
6429 regOutputRow = ++pParse->nMem;
6430 addrOutputRow = sqlite3VdbeMakeLabel(pParse);
6431 regReset = ++pParse->nMem;
6432 addrReset = sqlite3VdbeMakeLabel(pParse);
6433 iAMem = pParse->nMem + 1;
6434 pParse->nMem += pGroupBy->nExpr;
6435 iBMem = pParse->nMem + 1;
6436 pParse->nMem += pGroupBy->nExpr;
6437 sqlite3VdbeAddOp2(v, OP_Integer, 0, iAbortFlag);
6438 VdbeComment((v, "clear abort flag"));
6439 sqlite3VdbeAddOp3(v, OP_Null, 0, iAMem, iAMem+pGroupBy->nExpr-1);
6440
6441 /* Begin a loop that will extract all source rows in GROUP BY order.
6442 ** This might involve two separate loops with an OP_Sort in between, or
6443 ** it might be a single loop that uses an index to extract information
6444 ** in the right order to begin with.
6445 */
6446 sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset);
6447 SELECTTRACE(1,pParse,p,("WhereBegin\n"));
6448 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pGroupBy, 0,
6449 WHERE_GROUPBY | (orderByGrp ? WHERE_SORTBYGROUP : 0), 0
6450 );
6451 if( pWInfo==0 ) goto select_end;
6452 if( sqlite3WhereIsOrdered(pWInfo)==pGroupBy->nExpr ){
6453 /* The optimizer is able to deliver rows in group by order so
6454 ** we do not have to sort. The OP_OpenEphemeral table will be
6455 ** cancelled later because we still need to use the pKeyInfo
6456 */
6457 groupBySort = 0;
6458 }else{
6459 /* Rows are coming out in undetermined order. We have to push
6460 ** each row into a sorting index, terminate the first loop,
6461 ** then loop over the sorting index in order to get the output
6462 ** in sorted order
6463 */
6464 int regBase;
6465 int regRecord;
6466 int nCol;
6467 int nGroupBy;
6468
6469 explainTempTable(pParse,
6470 (sDistinct.isTnct && (p->selFlags&SF_Distinct)==0) ?
6471 "DISTINCT" : "GROUP BY");
6472
6473 groupBySort = 1;
6474 nGroupBy = pGroupBy->nExpr;
6475 nCol = nGroupBy;
6476 j = nGroupBy;
6477 for(i=0; i<sAggInfo.nColumn; i++){
6478 if( sAggInfo.aCol[i].iSorterColumn>=j ){
6479 nCol++;
6480 j++;
6481 }
6482 }
6483 regBase = sqlite3GetTempRange(pParse, nCol);
6484 sqlite3ExprCodeExprList(pParse, pGroupBy, regBase, 0, 0);
6485 j = nGroupBy;
6486 for(i=0; i<sAggInfo.nColumn; i++){
6487 struct AggInfo_col *pCol = &sAggInfo.aCol[i];
6488 if( pCol->iSorterColumn>=j ){
6489 int r1 = j + regBase;
6490 sqlite3ExprCodeGetColumnOfTable(v,
6491 pCol->pTab, pCol->iTable, pCol->iColumn, r1);
6492 j++;
6493 }
6494 }
6495 regRecord = sqlite3GetTempReg(pParse);
6496 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord);
6497 sqlite3VdbeAddOp2(v, OP_SorterInsert, sAggInfo.sortingIdx, regRecord);
6498 sqlite3ReleaseTempReg(pParse, regRecord);
6499 sqlite3ReleaseTempRange(pParse, regBase, nCol);
6500 sqlite3WhereEnd(pWInfo);
6501 sAggInfo.sortingIdxPTab = sortPTab = pParse->nTab++;
6502 sortOut = sqlite3GetTempReg(pParse);
6503 sqlite3VdbeAddOp3(v, OP_OpenPseudo, sortPTab, sortOut, nCol);
6504 sqlite3VdbeAddOp2(v, OP_SorterSort, sAggInfo.sortingIdx, addrEnd);
6505 VdbeComment((v, "GROUP BY sort")); VdbeCoverage(v);
6506 sAggInfo.useSortingIdx = 1;
6507 }
6508
6509 /* If the index or temporary table used by the GROUP BY sort
6510 ** will naturally deliver rows in the order required by the ORDER BY
6511 ** clause, cancel the ephemeral table open coded earlier.
6512 **
6513 ** This is an optimization - the correct answer should result regardless.
6514 ** Use the SQLITE_GroupByOrder flag with SQLITE_TESTCTRL_OPTIMIZER to
6515 ** disable this optimization for testing purposes. */
6516 if( orderByGrp && OptimizationEnabled(db, SQLITE_GroupByOrder)
6517 && (groupBySort || sqlite3WhereIsSorted(pWInfo))
6518 ){
6519 sSort.pOrderBy = 0;
6520 sqlite3VdbeChangeToNoop(v, sSort.addrSortIndex);
6521 }
6522
6523 /* Evaluate the current GROUP BY terms and store in b0, b1, b2...
6524 ** (b0 is memory location iBMem+0, b1 is iBMem+1, and so forth)
6525 ** Then compare the current GROUP BY terms against the GROUP BY terms
6526 ** from the previous row currently stored in a0, a1, a2...
6527 */
6528 addrTopOfLoop = sqlite3VdbeCurrentAddr(v);
6529 if( groupBySort ){
6530 sqlite3VdbeAddOp3(v, OP_SorterData, sAggInfo.sortingIdx,
6531 sortOut, sortPTab);
6532 }
6533 for(j=0; j<pGroupBy->nExpr; j++){
6534 if( groupBySort ){
6535 sqlite3VdbeAddOp3(v, OP_Column, sortPTab, j, iBMem+j);
6536 }else{
6537 sAggInfo.directMode = 1;
6538 sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr, iBMem+j);
6539 }
6540 }
6541 sqlite3VdbeAddOp4(v, OP_Compare, iAMem, iBMem, pGroupBy->nExpr,
6542 (char*)sqlite3KeyInfoRef(pKeyInfo), P4_KEYINFO);
6543 addr1 = sqlite3VdbeCurrentAddr(v);
6544 sqlite3VdbeAddOp3(v, OP_Jump, addr1+1, 0, addr1+1); VdbeCoverage(v);
6545
6546 /* Generate code that runs whenever the GROUP BY changes.
6547 ** Changes in the GROUP BY are detected by the previous code
6548 ** block. If there were no changes, this block is skipped.
6549 **
6550 ** This code copies current group by terms in b0,b1,b2,...
6551 ** over to a0,a1,a2. It then calls the output subroutine
6552 ** and resets the aggregate accumulator registers in preparation
6553 ** for the next GROUP BY batch.
6554 */
6555 sqlite3ExprCodeMove(pParse, iBMem, iAMem, pGroupBy->nExpr);
6556 sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow);
6557 VdbeComment((v, "output one row"));
6558 sqlite3VdbeAddOp2(v, OP_IfPos, iAbortFlag, addrEnd); VdbeCoverage(v);
6559 VdbeComment((v, "check abort flag"));
6560 sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset);
6561 VdbeComment((v, "reset accumulator"));
6562
6563 /* Update the aggregate accumulators based on the content of
6564 ** the current row
6565 */
6566 sqlite3VdbeJumpHere(v, addr1);
6567 updateAccumulator(pParse, iUseFlag, &sAggInfo);
6568 sqlite3VdbeAddOp2(v, OP_Integer, 1, iUseFlag);
6569 VdbeComment((v, "indicate data in accumulator"));
6570
6571 /* End of the loop
6572 */
6573 if( groupBySort ){
6574 sqlite3VdbeAddOp2(v, OP_SorterNext, sAggInfo.sortingIdx, addrTopOfLoop);
6575 VdbeCoverage(v);
6576 }else{
6577 sqlite3WhereEnd(pWInfo);
6578 sqlite3VdbeChangeToNoop(v, addrSortingIdx);
6579 }
6580
6581 /* Output the final row of result
6582 */
6583 sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow);
6584 VdbeComment((v, "output final row"));
6585
6586 /* Jump over the subroutines
6587 */
6588 sqlite3VdbeGoto(v, addrEnd);
6589
6590 /* Generate a subroutine that outputs a single row of the result
6591 ** set. This subroutine first looks at the iUseFlag. If iUseFlag
6592 ** is less than or equal to zero, the subroutine is a no-op. If
6593 ** the processing calls for the query to abort, this subroutine
6594 ** increments the iAbortFlag memory location before returning in
6595 ** order to signal the caller to abort.
6596 */
6597 addrSetAbort = sqlite3VdbeCurrentAddr(v);
6598 sqlite3VdbeAddOp2(v, OP_Integer, 1, iAbortFlag);
6599 VdbeComment((v, "set abort flag"));
6600 sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);
6601 sqlite3VdbeResolveLabel(v, addrOutputRow);
6602 addrOutputRow = sqlite3VdbeCurrentAddr(v);
6603 sqlite3VdbeAddOp2(v, OP_IfPos, iUseFlag, addrOutputRow+2);
6604 VdbeCoverage(v);
6605 VdbeComment((v, "Groupby result generator entry point"));
6606 sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);
6607 finalizeAggFunctions(pParse, &sAggInfo);
6608 sqlite3ExprIfFalse(pParse, pHaving, addrOutputRow+1, SQLITE_JUMPIFNULL);
6609 selectInnerLoop(pParse, p, -1, &sSort,
6610 &sDistinct, pDest,
6611 addrOutputRow+1, addrSetAbort);
6612 sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);
6613 VdbeComment((v, "end groupby result generator"));
6614
6615 /* Generate a subroutine that will reset the group-by accumulator
6616 */
6617 sqlite3VdbeResolveLabel(v, addrReset);
6618 resetAccumulator(pParse, &sAggInfo);
6619 sqlite3VdbeAddOp2(v, OP_Integer, 0, iUseFlag);
6620 VdbeComment((v, "indicate accumulator empty"));
6621 sqlite3VdbeAddOp1(v, OP_Return, regReset);
6622
6623 } /* endif pGroupBy. Begin aggregate queries without GROUP BY: */
6624 else {
6625 #ifndef SQLITE_OMIT_BTREECOUNT
6626 Table *pTab;
6627 if( (pTab = isSimpleCount(p, &sAggInfo))!=0 ){
6628 /* If isSimpleCount() returns a pointer to a Table structure, then
6629 ** the SQL statement is of the form:
6630 **
6631 ** SELECT count(*) FROM <tbl>
6632 **
6633 ** where the Table structure returned represents table <tbl>.
6634 **
6635 ** This statement is so common that it is optimized specially. The
6636 ** OP_Count instruction is executed either on the intkey table that
6637 ** contains the data for table <tbl> or on one of its indexes. It
6638 ** is better to execute the op on an index, as indexes are almost
6639 ** always spread across less pages than their corresponding tables.
6640 */
6641 const int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
6642 const int iCsr = pParse->nTab++; /* Cursor to scan b-tree */
6643 Index *pIdx; /* Iterator variable */
6644 KeyInfo *pKeyInfo = 0; /* Keyinfo for scanned index */
6645 Index *pBest = 0; /* Best index found so far */
6646 int iRoot = pTab->tnum; /* Root page of scanned b-tree */
6647
6648 sqlite3CodeVerifySchema(pParse, iDb);
6649 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
6650
6651 /* Search for the index that has the lowest scan cost.
6652 **
6653 ** (2011-04-15) Do not do a full scan of an unordered index.
6654 **
6655 ** (2013-10-03) Do not count the entries in a partial index.
6656 **
6657 ** In practice the KeyInfo structure will not be used. It is only
6658 ** passed to keep OP_OpenRead happy.
6659 */
6660 if( !HasRowid(pTab) ) pBest = sqlite3PrimaryKeyIndex(pTab);
6661 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
6662 if( pIdx->bUnordered==0
6663 && pIdx->szIdxRow<pTab->szTabRow
6664 && pIdx->pPartIdxWhere==0
6665 && (!pBest || pIdx->szIdxRow<pBest->szIdxRow)
6666 ){
6667 pBest = pIdx;
6668 }
6669 }
6670 if( pBest ){
6671 iRoot = pBest->tnum;
6672 pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pBest);
6673 }
6674
6675 /* Open a read-only cursor, execute the OP_Count, close the cursor. */
6676 sqlite3VdbeAddOp4Int(v, OP_OpenRead, iCsr, iRoot, iDb, 1);
6677 if( pKeyInfo ){
6678 sqlite3VdbeChangeP4(v, -1, (char *)pKeyInfo, P4_KEYINFO);
6679 }
6680 sqlite3VdbeAddOp2(v, OP_Count, iCsr, sAggInfo.aFunc[0].iMem);
6681 sqlite3VdbeAddOp1(v, OP_Close, iCsr);
6682 explainSimpleCount(pParse, pTab, pBest);
6683 }else
6684 #endif /* SQLITE_OMIT_BTREECOUNT */
6685 {
6686 int regAcc = 0; /* "populate accumulators" flag */
6687
6688 /* If there are accumulator registers but no min() or max() functions
6689 ** without FILTER clauses, allocate register regAcc. Register regAcc
6690 ** will contain 0 the first time the inner loop runs, and 1 thereafter.
6691 ** The code generated by updateAccumulator() uses this to ensure
6692 ** that the accumulator registers are (a) updated only once if
6693 ** there are no min() or max functions or (b) always updated for the
6694 ** first row visited by the aggregate, so that they are updated at
6695 ** least once even if the FILTER clause means the min() or max()
6696 ** function visits zero rows. */
6697 if( sAggInfo.nAccumulator ){
6698 for(i=0; i<sAggInfo.nFunc; i++){
6699 if( ExprHasProperty(sAggInfo.aFunc[i].pExpr, EP_WinFunc) ) continue;
6700 if( sAggInfo.aFunc[i].pFunc->funcFlags&SQLITE_FUNC_NEEDCOLL ) break;
6701 }
6702 if( i==sAggInfo.nFunc ){
6703 regAcc = ++pParse->nMem;
6704 sqlite3VdbeAddOp2(v, OP_Integer, 0, regAcc);
6705 }
6706 }
6707
6708 /* This case runs if the aggregate has no GROUP BY clause. The
6709 ** processing is much simpler since there is only a single row
6710 ** of output.
6711 */
6712 assert( p->pGroupBy==0 );
6713 resetAccumulator(pParse, &sAggInfo);
6714
6715 /* If this query is a candidate for the min/max optimization, then
6716 ** minMaxFlag will have been previously set to either
6717 ** WHERE_ORDERBY_MIN or WHERE_ORDERBY_MAX and pMinMaxOrderBy will
6718 ** be an appropriate ORDER BY expression for the optimization.
6719 */
6720 assert( minMaxFlag==WHERE_ORDERBY_NORMAL || pMinMaxOrderBy!=0 );
6721 assert( pMinMaxOrderBy==0 || pMinMaxOrderBy->nExpr==1 );
6722
6723 SELECTTRACE(1,pParse,p,("WhereBegin\n"));
6724 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pMinMaxOrderBy,
6725 0, minMaxFlag, 0);
6726 if( pWInfo==0 ){
6727 goto select_end;
6728 }
6729 updateAccumulator(pParse, regAcc, &sAggInfo);
6730 if( regAcc ) sqlite3VdbeAddOp2(v, OP_Integer, 1, regAcc);
6731 if( sqlite3WhereIsOrdered(pWInfo)>0 ){
6732 sqlite3VdbeGoto(v, sqlite3WhereBreakLabel(pWInfo));
6733 VdbeComment((v, "%s() by index",
6734 (minMaxFlag==WHERE_ORDERBY_MIN?"min":"max")));
6735 }
6736 sqlite3WhereEnd(pWInfo);
6737 finalizeAggFunctions(pParse, &sAggInfo);
6738 }
6739
6740 sSort.pOrderBy = 0;
6741 sqlite3ExprIfFalse(pParse, pHaving, addrEnd, SQLITE_JUMPIFNULL);
6742 selectInnerLoop(pParse, p, -1, 0, 0,
6743 pDest, addrEnd, addrEnd);
6744 }
6745 sqlite3VdbeResolveLabel(v, addrEnd);
6746
6747 } /* endif aggregate query */
6748
6749 if( sDistinct.eTnctType==WHERE_DISTINCT_UNORDERED ){
6750 explainTempTable(pParse, "DISTINCT");
6751 }
6752
6753 /* If there is an ORDER BY clause, then we need to sort the results
6754 ** and send them to the callback one by one.
6755 */
6756 if( sSort.pOrderBy ){
6757 explainTempTable(pParse,
6758 sSort.nOBSat>0 ? "RIGHT PART OF ORDER BY":"ORDER BY");
6759 assert( p->pEList==pEList );
6760 generateSortTail(pParse, p, &sSort, pEList->nExpr, pDest);
6761 }
6762
6763 /* Jump here to skip this query
6764 */
6765 sqlite3VdbeResolveLabel(v, iEnd);
6766
6767 /* The SELECT has been coded. If there is an error in the Parse structure,
6768 ** set the return code to 1. Otherwise 0. */
6769 rc = (pParse->nErr>0);
6770
6771 /* Control jumps to here if an error is encountered above, or upon
6772 ** successful coding of the SELECT.
6773 */
6774 select_end:
6775 sqlite3ExprListDelete(db, pMinMaxOrderBy);
6776 sqlite3DbFree(db, sAggInfo.aCol);
6777 sqlite3DbFree(db, sAggInfo.aFunc);
6778 #if SELECTTRACE_ENABLED
6779 SELECTTRACE(0x1,pParse,p,("end processing\n"));
6780 if( (sqlite3SelectTrace & 0x2000)!=0 && ExplainQueryPlanParent(pParse)==0 ){
6781 sqlite3TreeViewSelect(0, p, 0);
6782 }
6783 #endif
6784 ExplainQueryPlanPop(pParse);
6785 return rc;
6786 }
6787