blob: 864e5a6e7c454e41969e368640e0e72f101b0b97 [file] [log] [blame]
drhcce7d172000-05-31 15:34:51 +00001/*
drhb19a2bc2001-09-16 00:13:26 +00002** 2001 September 15
drhcce7d172000-05-31 15:34:51 +00003**
drhb19a2bc2001-09-16 00:13:26 +00004** The author disclaims copyright to this source code. In place of
5** a legal notice, here is a blessing:
drhcce7d172000-05-31 15:34:51 +00006**
drhb19a2bc2001-09-16 00:13:26 +00007** May you do good and not evil.
8** May you find forgiveness for yourself and forgive others.
9** May you share freely, never taking more than you give.
drhcce7d172000-05-31 15:34:51 +000010**
11*************************************************************************
12** This file contains C code routines that are called by the parser
drhb19a2bc2001-09-16 00:13:26 +000013** to handle SELECT statements in SQLite.
drhcce7d172000-05-31 15:34:51 +000014*/
15#include "sqliteInt.h"
16
drh079a3072014-03-19 14:10:55 +000017/*
drhabd4c722014-09-20 18:18:33 +000018** Trace output macros
19*/
20#if SELECTTRACE_ENABLED
21/***/ int sqlite3SelectTrace = 0;
drheb9b8842014-09-21 00:27:26 +000022# define SELECTTRACE(K,P,S,X) \
23 if(sqlite3SelectTrace&(K)) \
drhfef37762018-07-10 19:48:35 +000024 sqlite3DebugPrintf("%u/%d/%p: ",(S)->selId,(P)->addrExplain,(S)),\
drheb9b8842014-09-21 00:27:26 +000025 sqlite3DebugPrintf X
drhabd4c722014-09-20 18:18:33 +000026#else
drheb9b8842014-09-21 00:27:26 +000027# define SELECTTRACE(K,P,S,X)
drhabd4c722014-09-20 18:18:33 +000028#endif
29
drh315555c2002-10-20 15:53:03 +000030
drhcce7d172000-05-31 15:34:51 +000031/*
drh079a3072014-03-19 14:10:55 +000032** 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.
drheda639e2006-01-22 00:42:09 +000035*/
drh079a3072014-03-19 14:10:55 +000036typedef struct DistinctCtx DistinctCtx;
37struct 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.
dan24e25d32018-04-14 18:46:20 +000047**
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.
drh079a3072014-03-19 14:10:55 +000061*/
62typedef struct SortCtx SortCtx;
63struct 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 */
drha04a8be2016-01-13 17:50:10 +000070 int labelDone; /* Jump here when done, ex: LIMIT reached */
drh6ee5a7b2018-09-08 20:09:46 +000071 int labelOBLopt; /* Jump here when sorter is full */
drh079a3072014-03-19 14:10:55 +000072 u8 sortFlags; /* Zero or more SORTFLAG_* bits */
dan24e25d32018-04-14 18:46:20 +000073#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
drhbbd4ae52018-04-30 19:32:49 +000081 struct RowLoadInfo *pDeferredRowLoad; /* Deferred row loading info or NULL */
drh079a3072014-03-19 14:10:55 +000082};
83#define SORTFLAG_UseSorter 0x01 /* Use SorterOpen instead of OpenEphemeral */
drhcce7d172000-05-31 15:34:51 +000084
85/*
drhb87fbed2015-01-05 15:48:45 +000086** Delete all the content of a Select structure. Deallocate the structure
87** itself only if bFree is true.
drheda639e2006-01-22 00:42:09 +000088*/
drhb87fbed2015-01-05 15:48:45 +000089static void clearSelect(sqlite3 *db, Select *p, int bFree){
90 while( p ){
91 Select *pPrior = p->pPrior;
92 sqlite3ExprListDelete(db, p->pEList);
93 sqlite3SrcListDelete(db, p->pSrc);
94 sqlite3ExprDelete(db, p->pWhere);
95 sqlite3ExprListDelete(db, p->pGroupBy);
96 sqlite3ExprDelete(db, p->pHaving);
97 sqlite3ExprListDelete(db, p->pOrderBy);
98 sqlite3ExprDelete(db, p->pLimit);
dan67a9b8e2018-06-22 20:51:35 +000099#ifndef SQLITE_OMIT_WINDOWFUNC
dane3bf6322018-06-08 20:58:27 +0000100 if( OK_IF_ALWAYS_TRUE(p->pWinDefn) ){
101 sqlite3WindowListDelete(db, p->pWinDefn);
102 }
dan67a9b8e2018-06-22 20:51:35 +0000103#endif
drh8906a4b2017-10-03 17:29:40 +0000104 if( OK_IF_ALWAYS_TRUE(p->pWith) ) sqlite3WithDelete(db, p->pWith);
drhdbd6a7d2017-04-05 12:39:49 +0000105 if( bFree ) sqlite3DbFreeNN(db, p);
drhb87fbed2015-01-05 15:48:45 +0000106 p = pPrior;
107 bFree = 1;
108 }
drheda639e2006-01-22 00:42:09 +0000109}
110
drh1013c932008-01-06 00:25:21 +0000111/*
112** Initialize a SelectDest structure.
113*/
114void sqlite3SelectDestInit(SelectDest *pDest, int eDest, int iParm){
drhea678832008-12-10 19:26:22 +0000115 pDest->eDest = (u8)eDest;
drh2b596da2012-07-23 21:43:19 +0000116 pDest->iSDParm = iParm;
dan71c57db2016-07-09 20:23:55 +0000117 pDest->zAffSdst = 0;
drh2b596da2012-07-23 21:43:19 +0000118 pDest->iSdst = 0;
119 pDest->nSdst = 0;
drh1013c932008-01-06 00:25:21 +0000120}
121
drheda639e2006-01-22 00:42:09 +0000122
123/*
drh9bb61fe2000-06-05 16:01:39 +0000124** Allocate a new Select structure and return a pointer to that
125** structure.
drhcce7d172000-05-31 15:34:51 +0000126*/
danielk19774adee202004-05-08 08:23:19 +0000127Select *sqlite3SelectNew(
drh17435752007-08-16 04:30:38 +0000128 Parse *pParse, /* Parsing context */
drhdaffd0e2001-04-11 14:28:42 +0000129 ExprList *pEList, /* which columns to include in the result */
drhad3cab52002-05-24 02:04:32 +0000130 SrcList *pSrc, /* the FROM clause -- which tables to scan */
drhdaffd0e2001-04-11 14:28:42 +0000131 Expr *pWhere, /* the WHERE clause */
132 ExprList *pGroupBy, /* the GROUP BY clause */
133 Expr *pHaving, /* the HAVING clause */
134 ExprList *pOrderBy, /* the ORDER BY clause */
drhc3489bb2016-02-25 16:04:59 +0000135 u32 selFlags, /* Flag parameters, such as SF_Distinct */
drh8c0833f2017-11-14 23:48:23 +0000136 Expr *pLimit /* LIMIT value. NULL means not used */
drh9bb61fe2000-06-05 16:01:39 +0000137){
138 Select *pNew;
drheda639e2006-01-22 00:42:09 +0000139 Select standin;
drhef90a6b2017-04-11 16:44:39 +0000140 pNew = sqlite3DbMallocRawNN(pParse->db, sizeof(*pNew) );
drhdaffd0e2001-04-11 14:28:42 +0000141 if( pNew==0 ){
drhef90a6b2017-04-11 16:44:39 +0000142 assert( pParse->db->mallocFailed );
drheda639e2006-01-22 00:42:09 +0000143 pNew = &standin;
drheda639e2006-01-22 00:42:09 +0000144 }
145 if( pEList==0 ){
drh3d240d22017-09-28 16:56:55 +0000146 pEList = sqlite3ExprListAppend(pParse, 0,
147 sqlite3Expr(pParse->db,TK_ASTERISK,0));
drheda639e2006-01-22 00:42:09 +0000148 }
149 pNew->pEList = pEList;
drhca3862d2016-01-08 12:46:39 +0000150 pNew->op = TK_SELECT;
151 pNew->selFlags = selFlags;
152 pNew->iLimit = 0;
153 pNew->iOffset = 0;
drhfef37762018-07-10 19:48:35 +0000154 pNew->selId = ++pParse->nSelect;
drhca3862d2016-01-08 12:46:39 +0000155 pNew->addrOpenEphm[0] = -1;
156 pNew->addrOpenEphm[1] = -1;
157 pNew->nSelectRow = 0;
drhef90a6b2017-04-11 16:44:39 +0000158 if( pSrc==0 ) pSrc = sqlite3DbMallocZero(pParse->db, sizeof(*pSrc));
drheda639e2006-01-22 00:42:09 +0000159 pNew->pSrc = pSrc;
160 pNew->pWhere = pWhere;
161 pNew->pGroupBy = pGroupBy;
162 pNew->pHaving = pHaving;
163 pNew->pOrderBy = pOrderBy;
drhca3862d2016-01-08 12:46:39 +0000164 pNew->pPrior = 0;
165 pNew->pNext = 0;
drheda639e2006-01-22 00:42:09 +0000166 pNew->pLimit = pLimit;
drhca3862d2016-01-08 12:46:39 +0000167 pNew->pWith = 0;
dan67a9b8e2018-06-22 20:51:35 +0000168#ifndef SQLITE_OMIT_WINDOWFUNC
dan86fb6e12018-05-16 20:58:07 +0000169 pNew->pWin = 0;
dane3bf6322018-06-08 20:58:27 +0000170 pNew->pWinDefn = 0;
dan67a9b8e2018-06-22 20:51:35 +0000171#endif
drhef90a6b2017-04-11 16:44:39 +0000172 if( pParse->db->mallocFailed ) {
173 clearSelect(pParse->db, pNew, pNew!=&standin);
drheda639e2006-01-22 00:42:09 +0000174 pNew = 0;
drha464c232011-09-16 19:04:03 +0000175 }else{
176 assert( pNew->pSrc!=0 || pParse->nErr>0 );
drhdaffd0e2001-04-11 14:28:42 +0000177 }
drh338ec3e2011-10-11 20:14:41 +0000178 assert( pNew!=&standin );
drh9bb61fe2000-06-05 16:01:39 +0000179 return pNew;
180}
181
drheb9b8842014-09-21 00:27:26 +0000182
drh9bb61fe2000-06-05 16:01:39 +0000183/*
drheda639e2006-01-22 00:42:09 +0000184** Delete the given Select structure and all of its substructures.
185*/
drh633e6d52008-07-28 19:34:53 +0000186void sqlite3SelectDelete(sqlite3 *db, Select *p){
drh8906a4b2017-10-03 17:29:40 +0000187 if( OK_IF_ALWAYS_TRUE(p) ) clearSelect(db, p, 1);
drheda639e2006-01-22 00:42:09 +0000188}
189
190/*
drhd227a292014-02-09 18:02:09 +0000191** Return a pointer to the right-most SELECT statement in a compound.
192*/
193static Select *findRightmost(Select *p){
194 while( p->pNext ) p = p->pNext;
195 return p;
drh9bb61fe2000-06-05 16:01:39 +0000196}
197
198/*
drhf7b54962013-05-28 12:11:54 +0000199** Given 1 to 3 identifiers preceding the JOIN keyword, determine the
drh01f3f252002-05-24 16:14:15 +0000200** type of join. Return an integer constant that expresses that type
201** in terms of the following bit values:
202**
203** JT_INNER
drh3dec2232005-09-10 15:28:09 +0000204** JT_CROSS
drh01f3f252002-05-24 16:14:15 +0000205** JT_OUTER
206** JT_NATURAL
207** JT_LEFT
208** JT_RIGHT
209**
210** A full outer join is the combination of JT_LEFT and JT_RIGHT.
211**
212** If an illegal or unsupported join type is seen, then still return
213** a join type, but put an error in the pParse structure.
214*/
danielk19774adee202004-05-08 08:23:19 +0000215int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){
drh01f3f252002-05-24 16:14:15 +0000216 int jointype = 0;
217 Token *apAll[3];
218 Token *p;
drh373cc2d2009-05-17 02:06:14 +0000219 /* 0123456789 123456789 123456789 123 */
220 static const char zKeyText[] = "naturaleftouterightfullinnercross";
drh57196282004-10-06 15:41:16 +0000221 static const struct {
drh373cc2d2009-05-17 02:06:14 +0000222 u8 i; /* Beginning of keyword text in zKeyText[] */
223 u8 nChar; /* Length of the keyword in characters */
224 u8 code; /* Join type mask */
225 } aKeyword[] = {
226 /* natural */ { 0, 7, JT_NATURAL },
227 /* left */ { 6, 4, JT_LEFT|JT_OUTER },
228 /* outer */ { 10, 5, JT_OUTER },
229 /* right */ { 14, 5, JT_RIGHT|JT_OUTER },
230 /* full */ { 19, 4, JT_LEFT|JT_RIGHT|JT_OUTER },
231 /* inner */ { 23, 5, JT_INNER },
232 /* cross */ { 28, 5, JT_INNER|JT_CROSS },
drh01f3f252002-05-24 16:14:15 +0000233 };
234 int i, j;
235 apAll[0] = pA;
236 apAll[1] = pB;
237 apAll[2] = pC;
drh195e6962002-05-25 00:18:20 +0000238 for(i=0; i<3 && apAll[i]; i++){
drh01f3f252002-05-24 16:14:15 +0000239 p = apAll[i];
drh373cc2d2009-05-17 02:06:14 +0000240 for(j=0; j<ArraySize(aKeyword); j++){
241 if( p->n==aKeyword[j].nChar
242 && sqlite3StrNICmp((char*)p->z, &zKeyText[aKeyword[j].i], p->n)==0 ){
243 jointype |= aKeyword[j].code;
drh01f3f252002-05-24 16:14:15 +0000244 break;
245 }
246 }
drh373cc2d2009-05-17 02:06:14 +0000247 testcase( j==0 || j==1 || j==2 || j==3 || j==4 || j==5 || j==6 );
248 if( j>=ArraySize(aKeyword) ){
drh01f3f252002-05-24 16:14:15 +0000249 jointype |= JT_ERROR;
250 break;
251 }
252 }
drhad2d8302002-05-24 20:31:36 +0000253 if(
254 (jointype & (JT_INNER|JT_OUTER))==(JT_INNER|JT_OUTER) ||
drh195e6962002-05-25 00:18:20 +0000255 (jointype & JT_ERROR)!=0
drhad2d8302002-05-24 20:31:36 +0000256 ){
drha9671a22008-07-08 23:40:20 +0000257 const char *zSp = " ";
258 assert( pB!=0 );
259 if( pC==0 ){ zSp++; }
drhae29ffb2004-09-25 14:39:18 +0000260 sqlite3ErrorMsg(pParse, "unknown or unsupported join type: "
drha9671a22008-07-08 23:40:20 +0000261 "%T %T%s%T", pA, pB, zSp, pC);
drh01f3f252002-05-24 16:14:15 +0000262 jointype = JT_INNER;
drh373cc2d2009-05-17 02:06:14 +0000263 }else if( (jointype & JT_OUTER)!=0
264 && (jointype & (JT_LEFT|JT_RIGHT))!=JT_LEFT ){
danielk19774adee202004-05-08 08:23:19 +0000265 sqlite3ErrorMsg(pParse,
drhda93d232003-03-31 02:12:46 +0000266 "RIGHT and FULL OUTER JOINs are not currently supported");
drh195e6962002-05-25 00:18:20 +0000267 jointype = JT_INNER;
drh01f3f252002-05-24 16:14:15 +0000268 }
269 return jointype;
270}
271
272/*
drhad2d8302002-05-24 20:31:36 +0000273** Return the index of a column in a table. Return -1 if the column
274** is not contained in the table.
275*/
276static int columnIndex(Table *pTab, const char *zCol){
277 int i;
278 for(i=0; i<pTab->nCol; i++){
danielk19774adee202004-05-08 08:23:19 +0000279 if( sqlite3StrICmp(pTab->aCol[i].zName, zCol)==0 ) return i;
drhad2d8302002-05-24 20:31:36 +0000280 }
281 return -1;
282}
283
284/*
drh2179b432009-12-09 17:36:39 +0000285** Search the first N tables in pSrc, from left to right, looking for a
286** table that has a column named zCol.
287**
288** When found, set *piTab and *piCol to the table index and column index
289** of the matching column and return TRUE.
290**
291** If not found, return FALSE.
292*/
293static int tableAndColumnIndex(
294 SrcList *pSrc, /* Array of tables to search */
295 int N, /* Number of tables in pSrc->a[] to search */
296 const char *zCol, /* Name of the column we are looking for */
297 int *piTab, /* Write index of pSrc->a[] here */
298 int *piCol /* Write index of pSrc->a[*piTab].pTab->aCol[] here */
299){
300 int i; /* For looping over tables in pSrc */
301 int iCol; /* Index of column matching zCol */
302
303 assert( (piTab==0)==(piCol==0) ); /* Both or neither are NULL */
304 for(i=0; i<N; i++){
305 iCol = columnIndex(pSrc->a[i].pTab, zCol);
306 if( iCol>=0 ){
307 if( piTab ){
308 *piTab = i;
309 *piCol = iCol;
310 }
311 return 1;
312 }
313 }
314 return 0;
315}
316
317/*
danf7b0b0a2009-10-19 15:52:32 +0000318** This function is used to add terms implied by JOIN syntax to the
319** WHERE clause expression of a SELECT statement. The new term, which
320** is ANDed with the existing WHERE clause, is of the form:
321**
322** (tab1.col1 = tab2.col2)
323**
324** where tab1 is the iSrc'th table in SrcList pSrc and tab2 is the
325** (iSrc+1)'th. Column col1 is column iColLeft of tab1, and col2 is
326** column iColRight of tab2.
drhad2d8302002-05-24 20:31:36 +0000327*/
328static void addWhereTerm(
danf7b0b0a2009-10-19 15:52:32 +0000329 Parse *pParse, /* Parsing context */
330 SrcList *pSrc, /* List of tables in FROM clause */
drh2179b432009-12-09 17:36:39 +0000331 int iLeft, /* Index of first table to join in pSrc */
danf7b0b0a2009-10-19 15:52:32 +0000332 int iColLeft, /* Index of column in first table */
drh2179b432009-12-09 17:36:39 +0000333 int iRight, /* Index of second table in pSrc */
danf7b0b0a2009-10-19 15:52:32 +0000334 int iColRight, /* Index of column in second table */
335 int isOuterJoin, /* True if this is an OUTER join */
336 Expr **ppWhere /* IN/OUT: The WHERE clause to add to */
drhad2d8302002-05-24 20:31:36 +0000337){
danf7b0b0a2009-10-19 15:52:32 +0000338 sqlite3 *db = pParse->db;
339 Expr *pE1;
340 Expr *pE2;
341 Expr *pEq;
drhad2d8302002-05-24 20:31:36 +0000342
drh2179b432009-12-09 17:36:39 +0000343 assert( iLeft<iRight );
344 assert( pSrc->nSrc>iRight );
345 assert( pSrc->a[iLeft].pTab );
346 assert( pSrc->a[iRight].pTab );
danf7b0b0a2009-10-19 15:52:32 +0000347
drh2179b432009-12-09 17:36:39 +0000348 pE1 = sqlite3CreateColumnExpr(db, pSrc, iLeft, iColLeft);
349 pE2 = sqlite3CreateColumnExpr(db, pSrc, iRight, iColRight);
danf7b0b0a2009-10-19 15:52:32 +0000350
drhabfd35e2016-12-06 22:47:23 +0000351 pEq = sqlite3PExpr(pParse, TK_EQ, pE1, pE2);
danf7b0b0a2009-10-19 15:52:32 +0000352 if( pEq && isOuterJoin ){
353 ExprSetProperty(pEq, EP_FromJoin);
drhc5cd1242013-09-12 16:50:49 +0000354 assert( !ExprHasProperty(pEq, EP_TokenOnly|EP_Reduced) );
drhebb6a652013-09-12 23:42:22 +0000355 ExprSetVVAProperty(pEq, EP_NoReduce);
danf7b0b0a2009-10-19 15:52:32 +0000356 pEq->iRightJoinTable = (i16)pE2->iTable;
drh030530d2005-01-18 17:40:04 +0000357 }
danf7b0b0a2009-10-19 15:52:32 +0000358 *ppWhere = sqlite3ExprAnd(db, *ppWhere, pEq);
drhad2d8302002-05-24 20:31:36 +0000359}
360
361/*
drh1f162302002-10-27 19:35:33 +0000362** Set the EP_FromJoin property on all terms of the given expression.
drh22d6a532005-09-19 21:05:48 +0000363** And set the Expr.iRightJoinTable to iTable for every term in the
364** expression.
drh1cc093c2002-06-24 22:01:57 +0000365**
drhe78e8282003-01-19 03:59:45 +0000366** The EP_FromJoin property is used on terms of an expression to tell
drh1cc093c2002-06-24 22:01:57 +0000367** the LEFT OUTER JOIN processing logic that this term is part of the
drh1f162302002-10-27 19:35:33 +0000368** join restriction specified in the ON or USING clause and not a part
369** of the more general WHERE clause. These terms are moved over to the
370** WHERE clause during join processing but we need to remember that they
371** originated in the ON or USING clause.
drh22d6a532005-09-19 21:05:48 +0000372**
373** The Expr.iRightJoinTable tells the WHERE clause processing that the
374** expression depends on table iRightJoinTable even if that table is not
375** explicitly mentioned in the expression. That information is needed
376** for cases like this:
377**
378** SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.b AND t1.x=5
379**
380** The where clause needs to defer the handling of the t1.x=5
381** term until after the t2 loop of the join. In that way, a
382** NULL t2 row will be inserted whenever t1.x!=5. If we do not
383** defer the handling of t1.x=5, it will be processed immediately
384** after the t1 loop and rows with t1.x!=5 will never appear in
385** the output, which is incorrect.
drh1cc093c2002-06-24 22:01:57 +0000386*/
drh22d6a532005-09-19 21:05:48 +0000387static void setJoinExpr(Expr *p, int iTable){
drh1cc093c2002-06-24 22:01:57 +0000388 while( p ){
drh1f162302002-10-27 19:35:33 +0000389 ExprSetProperty(p, EP_FromJoin);
drhc5cd1242013-09-12 16:50:49 +0000390 assert( !ExprHasProperty(p, EP_TokenOnly|EP_Reduced) );
drhebb6a652013-09-12 23:42:22 +0000391 ExprSetVVAProperty(p, EP_NoReduce);
shanecf697392009-06-01 16:53:09 +0000392 p->iRightJoinTable = (i16)iTable;
drh3d6bedf2018-09-19 14:54:38 +0000393 if( p->op==TK_FUNCTION && p->eX==EX_List ){
drh606f2342015-06-18 14:32:51 +0000394 int i;
395 for(i=0; i<p->x.pList->nExpr; i++){
396 setJoinExpr(p->x.pList->a[i].pExpr, iTable);
397 }
398 }
drh22d6a532005-09-19 21:05:48 +0000399 setJoinExpr(p->pLeft, iTable);
drh3d6bedf2018-09-19 14:54:38 +0000400 p = p->eX==EX_Right ? p->x.pRight : 0;
drh1cc093c2002-06-24 22:01:57 +0000401 }
402}
403
drh25897872018-03-20 21:16:15 +0000404/* Undo the work of setJoinExpr(). In the expression tree p, convert every
405** term that is marked with EP_FromJoin and iRightJoinTable==iTable into
406** an ordinary term that omits the EP_FromJoin mark.
407**
408** This happens when a LEFT JOIN is simplified into an ordinary JOIN.
409*/
410static void unsetJoinExpr(Expr *p, int iTable){
411 while( p ){
drh7fbb1012018-03-21 01:59:46 +0000412 if( ExprHasProperty(p, EP_FromJoin)
413 && (iTable<0 || p->iRightJoinTable==iTable) ){
drh25897872018-03-20 21:16:15 +0000414 ExprClearProperty(p, EP_FromJoin);
415 }
drh3d6bedf2018-09-19 14:54:38 +0000416 if( p->op==TK_FUNCTION && p->eX==EX_List ){
drh25897872018-03-20 21:16:15 +0000417 int i;
418 for(i=0; i<p->x.pList->nExpr; i++){
419 unsetJoinExpr(p->x.pList->a[i].pExpr, iTable);
420 }
421 }
422 unsetJoinExpr(p->pLeft, iTable);
drh3d6bedf2018-09-19 14:54:38 +0000423 p = p->eX==EX_Right ? p->x.pRight : 0;
drh25897872018-03-20 21:16:15 +0000424 }
425}
426
drh1cc093c2002-06-24 22:01:57 +0000427/*
drhad2d8302002-05-24 20:31:36 +0000428** This routine processes the join information for a SELECT statement.
429** ON and USING clauses are converted into extra terms of the WHERE clause.
430** NATURAL joins also create extra WHERE clause terms.
431**
drh91bb0ee2004-09-01 03:06:34 +0000432** The terms of a FROM clause are contained in the Select.pSrc structure.
433** The left most table is the first entry in Select.pSrc. The right-most
434** table is the last entry. The join operator is held in the entry to
435** the left. Thus entry 0 contains the join operator for the join between
436** entries 0 and 1. Any ON or USING clauses associated with the join are
437** also attached to the left entry.
438**
drhad2d8302002-05-24 20:31:36 +0000439** This routine returns the number of errors encountered.
440*/
441static int sqliteProcessJoin(Parse *pParse, Select *p){
drh91bb0ee2004-09-01 03:06:34 +0000442 SrcList *pSrc; /* All tables in the FROM clause */
443 int i, j; /* Loop counters */
444 struct SrcList_item *pLeft; /* Left table being joined */
445 struct SrcList_item *pRight; /* Right table being joined */
drhad2d8302002-05-24 20:31:36 +0000446
drh91bb0ee2004-09-01 03:06:34 +0000447 pSrc = p->pSrc;
448 pLeft = &pSrc->a[0];
449 pRight = &pLeft[1];
450 for(i=0; i<pSrc->nSrc-1; i++, pRight++, pLeft++){
drh91bb0ee2004-09-01 03:06:34 +0000451 Table *pRightTab = pRight->pTab;
drhad27e762008-03-26 12:46:23 +0000452 int isOuter;
drh91bb0ee2004-09-01 03:06:34 +0000453
drhce2c4822017-10-03 17:17:34 +0000454 if( NEVER(pLeft->pTab==0 || pRightTab==0) ) continue;
drh8a48b9c2015-08-19 15:20:00 +0000455 isOuter = (pRight->fg.jointype & JT_OUTER)!=0;
drhad2d8302002-05-24 20:31:36 +0000456
457 /* When the NATURAL keyword is present, add WHERE clause terms for
458 ** every column that the two tables have in common.
459 */
drh8a48b9c2015-08-19 15:20:00 +0000460 if( pRight->fg.jointype & JT_NATURAL ){
drh61dfc312006-12-16 16:25:15 +0000461 if( pRight->pOn || pRight->pUsing ){
danielk19774adee202004-05-08 08:23:19 +0000462 sqlite3ErrorMsg(pParse, "a NATURAL join may not have "
drhad2d8302002-05-24 20:31:36 +0000463 "an ON or USING clause", 0);
drhad2d8302002-05-24 20:31:36 +0000464 return 1;
465 }
drh2179b432009-12-09 17:36:39 +0000466 for(j=0; j<pRightTab->nCol; j++){
467 char *zName; /* Name of column in the right table */
468 int iLeft; /* Matching left table */
469 int iLeftCol; /* Matching column in the left table */
470
471 zName = pRightTab->aCol[j].zName;
472 if( tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol) ){
473 addWhereTerm(pParse, pSrc, iLeft, iLeftCol, i+1, j,
474 isOuter, &p->pWhere);
drhad2d8302002-05-24 20:31:36 +0000475 }
476 }
477 }
478
479 /* Disallow both ON and USING clauses in the same join
480 */
drh61dfc312006-12-16 16:25:15 +0000481 if( pRight->pOn && pRight->pUsing ){
danielk19774adee202004-05-08 08:23:19 +0000482 sqlite3ErrorMsg(pParse, "cannot have both ON and USING "
drhda93d232003-03-31 02:12:46 +0000483 "clauses in the same join");
drhad2d8302002-05-24 20:31:36 +0000484 return 1;
485 }
486
487 /* Add the ON clause to the end of the WHERE clause, connected by
drh91bb0ee2004-09-01 03:06:34 +0000488 ** an AND operator.
drhad2d8302002-05-24 20:31:36 +0000489 */
drh61dfc312006-12-16 16:25:15 +0000490 if( pRight->pOn ){
drhad27e762008-03-26 12:46:23 +0000491 if( isOuter ) setJoinExpr(pRight->pOn, pRight->iCursor);
drh17435752007-08-16 04:30:38 +0000492 p->pWhere = sqlite3ExprAnd(pParse->db, p->pWhere, pRight->pOn);
drh61dfc312006-12-16 16:25:15 +0000493 pRight->pOn = 0;
drhad2d8302002-05-24 20:31:36 +0000494 }
495
496 /* Create extra terms on the WHERE clause for each column named
497 ** in the USING clause. Example: If the two tables to be joined are
498 ** A and B and the USING clause names X, Y, and Z, then add this
499 ** to the WHERE clause: A.X=B.X AND A.Y=B.Y AND A.Z=B.Z
500 ** Report an error if any column mentioned in the USING clause is
501 ** not contained in both tables to be joined.
502 */
drh61dfc312006-12-16 16:25:15 +0000503 if( pRight->pUsing ){
504 IdList *pList = pRight->pUsing;
drhad2d8302002-05-24 20:31:36 +0000505 for(j=0; j<pList->nId; j++){
drh2179b432009-12-09 17:36:39 +0000506 char *zName; /* Name of the term in the USING clause */
507 int iLeft; /* Table on the left with matching column name */
508 int iLeftCol; /* Column number of matching column on the left */
509 int iRightCol; /* Column number of matching column on the right */
510
511 zName = pList->a[j].zName;
512 iRightCol = columnIndex(pRightTab, zName);
513 if( iRightCol<0
514 || !tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol)
515 ){
danielk19774adee202004-05-08 08:23:19 +0000516 sqlite3ErrorMsg(pParse, "cannot join using column %s - column "
drh91bb0ee2004-09-01 03:06:34 +0000517 "not present in both tables", zName);
drhad2d8302002-05-24 20:31:36 +0000518 return 1;
519 }
drh2179b432009-12-09 17:36:39 +0000520 addWhereTerm(pParse, pSrc, iLeft, iLeftCol, i+1, iRightCol,
521 isOuter, &p->pWhere);
drhad2d8302002-05-24 20:31:36 +0000522 }
523 }
524 }
525 return 0;
526}
527
528/*
drhbbd4ae52018-04-30 19:32:49 +0000529** An instance of this object holds information (beyond pParse and pSelect)
530** needed to load the next result row that is to be added to the sorter.
531*/
532typedef struct RowLoadInfo RowLoadInfo;
533struct RowLoadInfo {
534 int regResult; /* Store results in array of registers here */
535 u8 ecelFlags; /* Flag argument to ExprCodeExprList() */
536#ifdef SQLITE_ENABLE_SORTER_REFERENCES
537 ExprList *pExtra; /* Extra columns needed by sorter refs */
538 int regExtraResult; /* Where to load the extra columns */
539#endif
540};
541
542/*
543** This routine does the work of loading query data into an array of
544** registers so that it can be added to the sorter.
545*/
546static void innerLoopLoadRow(
547 Parse *pParse, /* Statement under construction */
548 Select *pSelect, /* The query being coded */
549 RowLoadInfo *pInfo /* Info needed to complete the row load */
550){
551 sqlite3ExprCodeExprList(pParse, pSelect->pEList, pInfo->regResult,
552 0, pInfo->ecelFlags);
553#ifdef SQLITE_ENABLE_SORTER_REFERENCES
554 if( pInfo->pExtra ){
555 sqlite3ExprCodeExprList(pParse, pInfo->pExtra, pInfo->regExtraResult, 0, 0);
556 sqlite3ExprListDelete(pParse->db, pInfo->pExtra);
557 }
558#endif
559}
560
561/*
562** Code the OP_MakeRecord instruction that generates the entry to be
563** added into the sorter.
564**
565** Return the register in which the result is stored.
566*/
567static int makeSorterRecord(
568 Parse *pParse,
569 SortCtx *pSort,
570 Select *pSelect,
571 int regBase,
572 int nBase
573){
574 int nOBSat = pSort->nOBSat;
575 Vdbe *v = pParse->pVdbe;
576 int regOut = ++pParse->nMem;
577 if( pSort->pDeferredRowLoad ){
578 innerLoopLoadRow(pParse, pSelect, pSort->pDeferredRowLoad);
579 }
580 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase+nOBSat, nBase-nOBSat, regOut);
581 return regOut;
582}
583
584/*
drhf45f2322014-03-23 17:45:03 +0000585** Generate code that will push the record in registers regData
586** through regData+nData-1 onto the sorter.
drhc926afb2002-06-20 03:38:26 +0000587*/
drhd59ba6c2006-01-08 05:02:54 +0000588static void pushOntoSorter(
589 Parse *pParse, /* Parser context */
drh079a3072014-03-19 14:10:55 +0000590 SortCtx *pSort, /* Information about the ORDER BY clause */
drhb7654112008-01-12 12:48:07 +0000591 Select *pSelect, /* The whole SELECT statement */
drhf45f2322014-03-23 17:45:03 +0000592 int regData, /* First register holding data to be sorted */
drh5579d592015-08-26 14:01:41 +0000593 int regOrigData, /* First register holding data before packing */
drhbbd4ae52018-04-30 19:32:49 +0000594 int nData, /* Number of elements in the regData data array */
drhfd0a2f92014-03-24 18:08:15 +0000595 int nPrefixReg /* No. of reg prior to regData available for use */
drhd59ba6c2006-01-08 05:02:54 +0000596){
drhf45f2322014-03-23 17:45:03 +0000597 Vdbe *v = pParse->pVdbe; /* Stmt under construction */
dan78d58432014-03-25 15:04:07 +0000598 int bSeq = ((pSort->sortFlags & SORTFLAG_UseSorter)==0);
drhf45f2322014-03-23 17:45:03 +0000599 int nExpr = pSort->pOrderBy->nExpr; /* No. of ORDER BY terms */
dan78d58432014-03-25 15:04:07 +0000600 int nBase = nExpr + bSeq + nData; /* Fields in sorter record */
drhfd0a2f92014-03-24 18:08:15 +0000601 int regBase; /* Regs for sorter record */
drhbbd4ae52018-04-30 19:32:49 +0000602 int regRecord = 0; /* Assembled sorter record */
dan78d58432014-03-25 15:04:07 +0000603 int nOBSat = pSort->nOBSat; /* ORDER BY terms to skip */
604 int op; /* Opcode to add sorter record to sorter */
drha04a8be2016-01-13 17:50:10 +0000605 int iLimit; /* LIMIT counter */
drhbbd4ae52018-04-30 19:32:49 +0000606 int iSkip = 0; /* End of the sorter insert loop */
drhf45f2322014-03-23 17:45:03 +0000607
dan78d58432014-03-25 15:04:07 +0000608 assert( bSeq==0 || bSeq==1 );
drhbbd4ae52018-04-30 19:32:49 +0000609
610 /* Three cases:
611 ** (1) The data to be sorted has already been packed into a Record
612 ** by a prior OP_MakeRecord. In this case nData==1 and regData
613 ** will be completely unrelated to regOrigData.
614 ** (2) All output columns are included in the sort record. In that
615 ** case regData==regOrigData.
616 ** (3) Some output columns are omitted from the sort record due to
617 ** the SQLITE_ENABLE_SORTER_REFERENCE optimization, or due to the
drhc6f36fa2018-05-05 16:50:35 +0000618 ** SQLITE_ECEL_OMITREF optimization, or due to the
619 ** SortCtx.pDeferredRowLoad optimiation. In any of these cases
620 ** regOrigData is 0 to prevent this routine from trying to copy
621 ** values that might not yet exist.
drhbbd4ae52018-04-30 19:32:49 +0000622 */
dan9af90b72016-11-11 18:08:59 +0000623 assert( nData==1 || regData==regOrigData || regOrigData==0 );
drhbbd4ae52018-04-30 19:32:49 +0000624
drhfd0a2f92014-03-24 18:08:15 +0000625 if( nPrefixReg ){
dan78d58432014-03-25 15:04:07 +0000626 assert( nPrefixReg==nExpr+bSeq );
drhbbd4ae52018-04-30 19:32:49 +0000627 regBase = regData - nPrefixReg;
drhfd0a2f92014-03-24 18:08:15 +0000628 }else{
drhfb0d6e52014-05-02 13:09:06 +0000629 regBase = pParse->nMem + 1;
630 pParse->nMem += nBase;
drhfd0a2f92014-03-24 18:08:15 +0000631 }
drha04a8be2016-01-13 17:50:10 +0000632 assert( pSelect->iOffset==0 || pSelect->iLimit!=0 );
633 iLimit = pSelect->iOffset ? pSelect->iOffset+1 : pSelect->iLimit;
634 pSort->labelDone = sqlite3VdbeMakeLabel(v);
drh5579d592015-08-26 14:01:41 +0000635 sqlite3ExprCodeExprList(pParse, pSort->pOrderBy, regBase, regOrigData,
dan9af90b72016-11-11 18:08:59 +0000636 SQLITE_ECEL_DUP | (regOrigData? SQLITE_ECEL_REF : 0));
dan78d58432014-03-25 15:04:07 +0000637 if( bSeq ){
638 sqlite3VdbeAddOp2(v, OP_Sequence, pSort->iECursor, regBase+nExpr);
drhfd0a2f92014-03-24 18:08:15 +0000639 }
dan257c13f2016-11-10 20:14:06 +0000640 if( nPrefixReg==0 && nData>0 ){
drh236241a2014-09-12 17:41:30 +0000641 sqlite3ExprCodeMove(pParse, regData, regBase+nExpr+bSeq, nData);
dan78d58432014-03-25 15:04:07 +0000642 }
drh079a3072014-03-19 14:10:55 +0000643 if( nOBSat>0 ){
644 int regPrevKey; /* The first nOBSat columns of the previous row */
645 int addrFirst; /* Address of the OP_IfNot opcode */
646 int addrJmp; /* Address of the OP_Jump opcode */
647 VdbeOp *pOp; /* Opcode that opens the sorter */
648 int nKey; /* Number of sorting key columns, including OP_Sequence */
drhdbfca2b2014-03-22 02:19:53 +0000649 KeyInfo *pKI; /* Original KeyInfo on the sorter table */
drh079a3072014-03-19 14:10:55 +0000650
drhbbd4ae52018-04-30 19:32:49 +0000651 regRecord = makeSorterRecord(pParse, pSort, pSelect, regBase, nBase);
drh26d7e7c2014-03-19 16:56:58 +0000652 regPrevKey = pParse->nMem+1;
653 pParse->nMem += pSort->nOBSat;
dan78d58432014-03-25 15:04:07 +0000654 nKey = nExpr - pSort->nOBSat + bSeq;
655 if( bSeq ){
656 addrFirst = sqlite3VdbeAddOp1(v, OP_IfNot, regBase+nExpr);
657 }else{
658 addrFirst = sqlite3VdbeAddOp1(v, OP_SequenceTest, pSort->iECursor);
659 }
660 VdbeCoverage(v);
drh26d7e7c2014-03-19 16:56:58 +0000661 sqlite3VdbeAddOp3(v, OP_Compare, regPrevKey, regBase, pSort->nOBSat);
drh079a3072014-03-19 14:10:55 +0000662 pOp = sqlite3VdbeGetOp(v, pSort->addrSortIndex);
drh59b8f2e2014-03-22 00:27:14 +0000663 if( pParse->db->mallocFailed ) return;
drhfb0d6e52014-05-02 13:09:06 +0000664 pOp->p2 = nKey + nData;
drhdbfca2b2014-03-22 02:19:53 +0000665 pKI = pOp->p4.pKeyInfo;
drha485ad12017-08-02 22:43:14 +0000666 memset(pKI->aSortOrder, 0, pKI->nKeyField); /* Makes OP_Jump testable */
drhdbfca2b2014-03-22 02:19:53 +0000667 sqlite3VdbeChangeP4(v, -1, (char*)pKI, P4_KEYINFO);
drha485ad12017-08-02 22:43:14 +0000668 testcase( pKI->nAllField > pKI->nKeyField+2 );
danf9eae182018-05-21 19:45:11 +0000669 pOp->p4.pKeyInfo = sqlite3KeyInfoFromExprList(pParse,pSort->pOrderBy,nOBSat,
drha485ad12017-08-02 22:43:14 +0000670 pKI->nAllField-pKI->nKeyField-1);
drh079a3072014-03-19 14:10:55 +0000671 addrJmp = sqlite3VdbeCurrentAddr(v);
672 sqlite3VdbeAddOp3(v, OP_Jump, addrJmp+1, 0, addrJmp+1); VdbeCoverage(v);
673 pSort->labelBkOut = sqlite3VdbeMakeLabel(v);
674 pSort->regReturn = ++pParse->nMem;
675 sqlite3VdbeAddOp2(v, OP_Gosub, pSort->regReturn, pSort->labelBkOut);
drh65ea12c2014-03-19 17:41:36 +0000676 sqlite3VdbeAddOp1(v, OP_ResetSorter, pSort->iECursor);
drha04a8be2016-01-13 17:50:10 +0000677 if( iLimit ){
678 sqlite3VdbeAddOp2(v, OP_IfNot, iLimit, pSort->labelDone);
679 VdbeCoverage(v);
680 }
drh079a3072014-03-19 14:10:55 +0000681 sqlite3VdbeJumpHere(v, addrFirst);
drh236241a2014-09-12 17:41:30 +0000682 sqlite3ExprCodeMove(pParse, regBase, regPrevKey, pSort->nOBSat);
drh079a3072014-03-19 14:10:55 +0000683 sqlite3VdbeJumpHere(v, addrJmp);
684 }
danf226f032018-04-26 16:13:47 +0000685 if( iLimit ){
686 /* At this point the values for the new sorter entry are stored
687 ** in an array of registers. They need to be composed into a record
688 ** and inserted into the sorter if either (a) there are currently
689 ** less than LIMIT+OFFSET items or (b) the new record is smaller than
690 ** the largest record currently in the sorter. If (b) is true and there
691 ** are already LIMIT+OFFSET items in the sorter, delete the largest
692 ** entry before inserting the new one. This way there are never more
693 ** than LIMIT+OFFSET items in the sorter.
694 **
695 ** If the new record does not need to be inserted into the sorter,
drh6ee5a7b2018-09-08 20:09:46 +0000696 ** jump to the next iteration of the loop. If the pSort->labelOBLopt
697 ** value is not zero, then it is a label of where to jump. Otherwise,
698 ** just bypass the row insert logic. See the header comment on the
699 ** sqlite3WhereOrderByLimitOptLabel() function for additional info.
danf226f032018-04-26 16:13:47 +0000700 */
701 int iCsr = pSort->iECursor;
danf226f032018-04-26 16:13:47 +0000702 sqlite3VdbeAddOp2(v, OP_IfNotZero, iLimit, sqlite3VdbeCurrentAddr(v)+4);
703 VdbeCoverage(v);
704 sqlite3VdbeAddOp2(v, OP_Last, iCsr, 0);
drhbbd4ae52018-04-30 19:32:49 +0000705 iSkip = sqlite3VdbeAddOp4Int(v, OP_IdxLE,
706 iCsr, 0, regBase+nOBSat, nExpr-nOBSat);
danf226f032018-04-26 16:13:47 +0000707 VdbeCoverage(v);
708 sqlite3VdbeAddOp1(v, OP_Delete, iCsr);
709 }
drhbbd4ae52018-04-30 19:32:49 +0000710 if( regRecord==0 ){
711 regRecord = makeSorterRecord(pParse, pSort, pSelect, regBase, nBase);
danf226f032018-04-26 16:13:47 +0000712 }
drh079a3072014-03-19 14:10:55 +0000713 if( pSort->sortFlags & SORTFLAG_UseSorter ){
drhc6aff302011-09-01 15:32:47 +0000714 op = OP_SorterInsert;
715 }else{
716 op = OP_IdxInsert;
717 }
drh4a8b0132016-11-09 01:38:56 +0000718 sqlite3VdbeAddOp4Int(v, op, pSort->iECursor, regRecord,
719 regBase+nOBSat, nBase-nOBSat);
drhbbd4ae52018-04-30 19:32:49 +0000720 if( iSkip ){
drhbbd4ae52018-04-30 19:32:49 +0000721 sqlite3VdbeChangeP2(v, iSkip,
drh6ee5a7b2018-09-08 20:09:46 +0000722 pSort->labelOBLopt ? pSort->labelOBLopt : sqlite3VdbeCurrentAddr(v));
drhbbd4ae52018-04-30 19:32:49 +0000723 }
drhc926afb2002-06-20 03:38:26 +0000724}
725
726/*
drhec7429a2005-10-06 16:53:14 +0000727** Add code to implement the OFFSET
drhea48eb22004-07-19 23:16:38 +0000728*/
drhec7429a2005-10-06 16:53:14 +0000729static void codeOffset(
drhbab39e12004-07-19 23:38:11 +0000730 Vdbe *v, /* Generate code into this VM */
drhaa9ce702014-01-22 18:07:04 +0000731 int iOffset, /* Register holding the offset counter */
drhb7654112008-01-12 12:48:07 +0000732 int iContinue /* Jump here to skip the current record */
drhea48eb22004-07-19 23:16:38 +0000733){
drha22a75e2014-03-21 18:16:23 +0000734 if( iOffset>0 ){
drh8b0cf382015-10-06 21:07:06 +0000735 sqlite3VdbeAddOp3(v, OP_IfPos, iOffset, iContinue, 1); VdbeCoverage(v);
736 VdbeComment((v, "OFFSET"));
drhea48eb22004-07-19 23:16:38 +0000737 }
drhea48eb22004-07-19 23:16:38 +0000738}
739
740/*
drh98757152008-01-09 23:04:12 +0000741** Add code that will check to make sure the N registers starting at iMem
742** form a distinct entry. iTab is a sorting index that holds previously
drha2a49dc2008-01-02 14:28:13 +0000743** seen combinations of the N values. A new entry is made in iTab
744** if the current N values are new.
745**
746** A jump to addrRepeat is made and the N+1 values are popped from the
747** stack if the top N elements are not distinct.
748*/
749static void codeDistinct(
drh2dcef112008-01-12 19:03:48 +0000750 Parse *pParse, /* Parsing and code generating context */
drha2a49dc2008-01-02 14:28:13 +0000751 int iTab, /* A sorting index used to test for distinctness */
752 int addrRepeat, /* Jump to here if not distinct */
drh477df4b2008-01-05 18:48:24 +0000753 int N, /* Number of elements */
drha2a49dc2008-01-02 14:28:13 +0000754 int iMem /* First element */
755){
drh2dcef112008-01-12 19:03:48 +0000756 Vdbe *v;
757 int r1;
758
759 v = pParse->pVdbe;
760 r1 = sqlite3GetTempReg(pParse);
drh688852a2014-02-17 22:40:43 +0000761 sqlite3VdbeAddOp4Int(v, OP_Found, iTab, addrRepeat, iMem, N); VdbeCoverage(v);
drh1db639c2008-01-17 02:36:28 +0000762 sqlite3VdbeAddOp3(v, OP_MakeRecord, iMem, N, r1);
drh9b4eaeb2016-11-09 00:10:33 +0000763 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iTab, r1, iMem, N);
drha67b5cb2017-01-07 00:56:01 +0000764 sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
drh2dcef112008-01-12 19:03:48 +0000765 sqlite3ReleaseTempReg(pParse, r1);
drha2a49dc2008-01-02 14:28:13 +0000766}
767
dan24e25d32018-04-14 18:46:20 +0000768#ifdef SQLITE_ENABLE_SORTER_REFERENCES
769/*
770** This function is called as part of inner-loop generation for a SELECT
771** statement with an ORDER BY that is not optimized by an index. It
772** determines the expressions, if any, that the sorter-reference
773** optimization should be used for. The sorter-reference optimization
774** is used for SELECT queries like:
775**
776** SELECT a, bigblob FROM t1 ORDER BY a LIMIT 10
777**
778** If the optimization is used for expression "bigblob", then instead of
779** storing values read from that column in the sorter records, the PK of
780** the row from table t1 is stored instead. Then, as records are extracted from
781** the sorter to return to the user, the required value of bigblob is
782** retrieved directly from table t1. If the values are very large, this
783** can be more efficient than storing them directly in the sorter records.
784**
785** The ExprList_item.bSorterRef flag is set for each expression in pEList
786** for which the sorter-reference optimization should be enabled.
787** Additionally, the pSort->aDefer[] array is populated with entries
788** for all cursors required to evaluate all selected expressions. Finally.
789** output variable (*ppExtra) is set to an expression list containing
790** expressions for all extra PK values that should be stored in the
791** sorter records.
792*/
793static void selectExprDefer(
794 Parse *pParse, /* Leave any error here */
795 SortCtx *pSort, /* Sorter context */
796 ExprList *pEList, /* Expressions destined for sorter */
797 ExprList **ppExtra /* Expressions to append to sorter record */
798){
799 int i;
800 int nDefer = 0;
801 ExprList *pExtra = 0;
802 for(i=0; i<pEList->nExpr; i++){
803 struct ExprList_item *pItem = &pEList->a[i];
804 if( pItem->u.x.iOrderByCol==0 ){
805 Expr *pExpr = pItem->pExpr;
806 Table *pTab = pExpr->pTab;
dan0f86c9d2018-06-01 13:30:45 +0000807 if( pExpr->op==TK_COLUMN && pExpr->iColumn>=0 && pTab && !IsVirtual(pTab)
dan2e3a5a82018-04-16 21:12:42 +0000808 && (pTab->aCol[pExpr->iColumn].colFlags & COLFLAG_SORTERREF)
dan24e25d32018-04-14 18:46:20 +0000809 ){
810 int j;
811 for(j=0; j<nDefer; j++){
812 if( pSort->aDefer[j].iCsr==pExpr->iTable ) break;
813 }
814 if( j==nDefer ){
815 if( nDefer==ArraySize(pSort->aDefer) ){
816 continue;
817 }else{
818 int nKey = 1;
819 int k;
820 Index *pPk = 0;
821 if( !HasRowid(pTab) ){
822 pPk = sqlite3PrimaryKeyIndex(pTab);
823 nKey = pPk->nKeyCol;
824 }
825 for(k=0; k<nKey; k++){
826 Expr *pNew = sqlite3PExpr(pParse, TK_COLUMN, 0, 0);
827 if( pNew ){
828 pNew->iTable = pExpr->iTable;
829 pNew->pTab = pExpr->pTab;
830 pNew->iColumn = pPk ? pPk->aiColumn[k] : -1;
831 pExtra = sqlite3ExprListAppend(pParse, pExtra, pNew);
832 }
833 }
834 pSort->aDefer[nDefer].pTab = pExpr->pTab;
835 pSort->aDefer[nDefer].iCsr = pExpr->iTable;
836 pSort->aDefer[nDefer].nKey = nKey;
837 nDefer++;
838 }
839 }
840 pItem->bSorterRef = 1;
841 }
842 }
843 }
844 pSort->nDefer = (u8)nDefer;
845 *ppExtra = pExtra;
846}
847#endif
848
drhc99130f2005-09-11 11:56:27 +0000849/*
drh22827922000-06-06 17:27:05 +0000850** This routine generates the code for the inside of the inner loop
851** of a SELECT.
drh82c3d632000-06-06 21:56:07 +0000852**
drh2def2f72017-09-15 17:40:34 +0000853** If srcTab is negative, then the p->pEList expressions
drh340309f2014-01-22 00:23:49 +0000854** are evaluated in order to get the data for this row. If srcTab is
drh2def2f72017-09-15 17:40:34 +0000855** zero or more, then data is pulled from srcTab and p->pEList is used only
dan257c13f2016-11-10 20:14:06 +0000856** to get the number of columns and the collation sequence for each column.
drh22827922000-06-06 17:27:05 +0000857*/
drhd2b3e232008-01-23 14:51:49 +0000858static void selectInnerLoop(
drh22827922000-06-06 17:27:05 +0000859 Parse *pParse, /* The parser context */
drhdf199a22002-06-14 22:38:41 +0000860 Select *p, /* The complete select statement being coded */
drh2def2f72017-09-15 17:40:34 +0000861 int srcTab, /* Pull data from this table if non-negative */
drh079a3072014-03-19 14:10:55 +0000862 SortCtx *pSort, /* If not NULL, info on how to process ORDER BY */
drhe8e4af72012-09-21 00:04:28 +0000863 DistinctCtx *pDistinct, /* If not NULL, info on how to process DISTINCT */
danielk19776c8c8ce2008-01-02 16:27:09 +0000864 SelectDest *pDest, /* How to dispose of the results */
drh22827922000-06-06 17:27:05 +0000865 int iContinue, /* Jump here to continue with next row */
drha9671a22008-07-08 23:40:20 +0000866 int iBreak /* Jump here to break out of the inner loop */
drh22827922000-06-06 17:27:05 +0000867){
868 Vdbe *v = pParse->pVdbe;
drhd847eaa2008-01-17 17:15:56 +0000869 int i;
dan9af90b72016-11-11 18:08:59 +0000870 int hasDistinct; /* True if the DISTINCT keyword is present */
drhd847eaa2008-01-17 17:15:56 +0000871 int eDest = pDest->eDest; /* How to dispose of results */
drh2b596da2012-07-23 21:43:19 +0000872 int iParm = pDest->iSDParm; /* First argument to disposal method */
drhd847eaa2008-01-17 17:15:56 +0000873 int nResultCol; /* Number of result columns */
drhfd0a2f92014-03-24 18:08:15 +0000874 int nPrefixReg = 0; /* Number of extra registers before regResult */
drhbbd4ae52018-04-30 19:32:49 +0000875 RowLoadInfo sRowLoadInfo; /* Info for deferred row loading */
drh38640e12002-07-05 21:42:36 +0000876
dan9af90b72016-11-11 18:08:59 +0000877 /* Usually, regResult is the first cell in an array of memory cells
878 ** containing the current result row. In this case regOrig is set to the
879 ** same value. However, if the results are being sent to the sorter, the
880 ** values for any expressions that are also part of the sort-key are omitted
881 ** from this array. In this case regOrig is set to zero. */
882 int regResult; /* Start of memory holding current results */
883 int regOrig; /* Start of memory holding full result (or 0) */
884
drh1c767f02009-01-09 02:49:31 +0000885 assert( v );
drh2def2f72017-09-15 17:40:34 +0000886 assert( p->pEList!=0 );
drhe8e4af72012-09-21 00:04:28 +0000887 hasDistinct = pDistinct ? pDistinct->eTnctType : WHERE_DISTINCT_NOOP;
drh079a3072014-03-19 14:10:55 +0000888 if( pSort && pSort->pOrderBy==0 ) pSort = 0;
889 if( pSort==0 && !hasDistinct ){
drha22a75e2014-03-21 18:16:23 +0000890 assert( iContinue!=0 );
drhaa9ce702014-01-22 18:07:04 +0000891 codeOffset(v, p->iOffset, iContinue);
drhdf199a22002-06-14 22:38:41 +0000892 }
893
drh967e8b72000-06-21 13:59:10 +0000894 /* Pull the requested columns.
drh22827922000-06-06 17:27:05 +0000895 */
drh2def2f72017-09-15 17:40:34 +0000896 nResultCol = p->pEList->nExpr;
drh05a86c52014-02-16 01:55:49 +0000897
drh2b596da2012-07-23 21:43:19 +0000898 if( pDest->iSdst==0 ){
drhfd0a2f92014-03-24 18:08:15 +0000899 if( pSort ){
dan78d58432014-03-25 15:04:07 +0000900 nPrefixReg = pSort->pOrderBy->nExpr;
901 if( !(pSort->sortFlags & SORTFLAG_UseSorter) ) nPrefixReg++;
drhfd0a2f92014-03-24 18:08:15 +0000902 pParse->nMem += nPrefixReg;
903 }
drh2b596da2012-07-23 21:43:19 +0000904 pDest->iSdst = pParse->nMem+1;
drh0acb7e42008-06-25 00:12:41 +0000905 pParse->nMem += nResultCol;
drh05a86c52014-02-16 01:55:49 +0000906 }else if( pDest->iSdst+nResultCol > pParse->nMem ){
907 /* This is an error condition that can result, for example, when a SELECT
908 ** on the right-hand side of an INSERT contains more result columns than
909 ** there are columns in the table on the left. The error will be caught
910 ** and reported later. But we need to make sure enough memory is allocated
911 ** to avoid other spurious errors in the meantime. */
912 pParse->nMem += nResultCol;
drh1013c932008-01-06 00:25:21 +0000913 }
drh05a86c52014-02-16 01:55:49 +0000914 pDest->nSdst = nResultCol;
dan9af90b72016-11-11 18:08:59 +0000915 regOrig = regResult = pDest->iSdst;
drh340309f2014-01-22 00:23:49 +0000916 if( srcTab>=0 ){
917 for(i=0; i<nResultCol; i++){
drhd847eaa2008-01-17 17:15:56 +0000918 sqlite3VdbeAddOp3(v, OP_Column, srcTab, i, regResult+i);
drh2def2f72017-09-15 17:40:34 +0000919 VdbeComment((v, "%s", p->pEList->a[i].zName));
drh82c3d632000-06-06 21:56:07 +0000920 }
danielk19779ed1dfa2008-01-02 17:11:14 +0000921 }else if( eDest!=SRT_Exists ){
dan24e25d32018-04-14 18:46:20 +0000922#ifdef SQLITE_ENABLE_SORTER_REFERENCES
923 ExprList *pExtra = 0;
924#endif
danielk19779ed1dfa2008-01-02 17:11:14 +0000925 /* If the destination is an EXISTS(...) expression, the actual
926 ** values returned by the SELECT are not required.
927 */
drhbbd4ae52018-04-30 19:32:49 +0000928 u8 ecelFlags; /* "ecel" is an abbreviation of "ExprCodeExprList" */
929 ExprList *pEList;
drhdf553652015-05-18 04:24:27 +0000930 if( eDest==SRT_Mem || eDest==SRT_Output || eDest==SRT_Coroutine ){
931 ecelFlags = SQLITE_ECEL_DUP;
932 }else{
933 ecelFlags = 0;
934 }
danac56ab72017-01-05 17:23:11 +0000935 if( pSort && hasDistinct==0 && eDest!=SRT_EphemTab && eDest!=SRT_Table ){
drh2def2f72017-09-15 17:40:34 +0000936 /* For each expression in p->pEList that is a copy of an expression in
dan257c13f2016-11-10 20:14:06 +0000937 ** the ORDER BY clause (pSort->pOrderBy), set the associated
938 ** iOrderByCol value to one more than the index of the ORDER BY
939 ** expression within the sort-key that pushOntoSorter() will generate.
drh2def2f72017-09-15 17:40:34 +0000940 ** This allows the p->pEList field to be omitted from the sorted record,
dan257c13f2016-11-10 20:14:06 +0000941 ** saving space and CPU cycles. */
942 ecelFlags |= (SQLITE_ECEL_OMITREF|SQLITE_ECEL_REF);
drhbbd4ae52018-04-30 19:32:49 +0000943
dan257c13f2016-11-10 20:14:06 +0000944 for(i=pSort->nOBSat; i<pSort->pOrderBy->nExpr; i++){
945 int j;
946 if( (j = pSort->pOrderBy->a[i].u.x.iOrderByCol)>0 ){
drh2def2f72017-09-15 17:40:34 +0000947 p->pEList->a[j-1].u.x.iOrderByCol = i+1-pSort->nOBSat;
dan257c13f2016-11-10 20:14:06 +0000948 }
949 }
dan24e25d32018-04-14 18:46:20 +0000950#ifdef SQLITE_ENABLE_SORTER_REFERENCES
951 selectExprDefer(pParse, pSort, p->pEList, &pExtra);
drh5a2e65e2018-04-18 19:08:44 +0000952 if( pExtra && pParse->db->mallocFailed==0 ){
dan24e25d32018-04-14 18:46:20 +0000953 /* If there are any extra PK columns to add to the sorter records,
954 ** allocate extra memory cells and adjust the OpenEphemeral
955 ** instruction to account for the larger records. This is only
956 ** required if there are one or more WITHOUT ROWID tables with
957 ** composite primary keys in the SortCtx.aDefer[] array. */
958 VdbeOp *pOp = sqlite3VdbeGetOp(v, pSort->addrSortIndex);
959 pOp->p2 += (pExtra->nExpr - pSort->nDefer);
960 pOp->p4.pKeyInfo->nAllField += (pExtra->nExpr - pSort->nDefer);
961 pParse->nMem += pExtra->nExpr;
962 }
963#endif
drhbbd4ae52018-04-30 19:32:49 +0000964
965 /* Adjust nResultCol to account for columns that are omitted
966 ** from the sorter by the optimizations in this branch */
967 pEList = p->pEList;
968 for(i=0; i<pEList->nExpr; i++){
969 if( pEList->a[i].u.x.iOrderByCol>0
970#ifdef SQLITE_ENABLE_SORTER_REFERENCES
971 || pEList->a[i].bSorterRef
972#endif
973 ){
974 nResultCol--;
975 regOrig = 0;
976 }
977 }
978
979 testcase( regOrig );
980 testcase( eDest==SRT_Set );
981 testcase( eDest==SRT_Mem );
982 testcase( eDest==SRT_Coroutine );
983 testcase( eDest==SRT_Output );
dan257c13f2016-11-10 20:14:06 +0000984 assert( eDest==SRT_Set || eDest==SRT_Mem
985 || eDest==SRT_Coroutine || eDest==SRT_Output );
986 }
drhbbd4ae52018-04-30 19:32:49 +0000987 sRowLoadInfo.regResult = regResult;
988 sRowLoadInfo.ecelFlags = ecelFlags;
dan24e25d32018-04-14 18:46:20 +0000989#ifdef SQLITE_ENABLE_SORTER_REFERENCES
drhbbd4ae52018-04-30 19:32:49 +0000990 sRowLoadInfo.pExtra = pExtra;
991 sRowLoadInfo.regExtraResult = regResult + nResultCol;
992 if( pExtra ) nResultCol += pExtra->nExpr;
dan24e25d32018-04-14 18:46:20 +0000993#endif
drhbbd4ae52018-04-30 19:32:49 +0000994 if( p->iLimit
995 && (ecelFlags & SQLITE_ECEL_OMITREF)!=0
996 && nPrefixReg>0
997 ){
998 assert( pSort!=0 );
999 assert( hasDistinct==0 );
1000 pSort->pDeferredRowLoad = &sRowLoadInfo;
drhc6f36fa2018-05-05 16:50:35 +00001001 regOrig = 0;
drhbbd4ae52018-04-30 19:32:49 +00001002 }else{
1003 innerLoopLoadRow(pParse, p, &sRowLoadInfo);
1004 }
drh22827922000-06-06 17:27:05 +00001005 }
1006
drhdaffd0e2001-04-11 14:28:42 +00001007 /* If the DISTINCT keyword was present on the SELECT statement
1008 ** and this row has been seen before, then do not make this row
1009 ** part of the result.
drh22827922000-06-06 17:27:05 +00001010 */
drhea48eb22004-07-19 23:16:38 +00001011 if( hasDistinct ){
drhe8e4af72012-09-21 00:04:28 +00001012 switch( pDistinct->eTnctType ){
1013 case WHERE_DISTINCT_ORDERED: {
1014 VdbeOp *pOp; /* No longer required OpenEphemeral instr. */
1015 int iJump; /* Jump destination */
1016 int regPrev; /* Previous row content */
1017
1018 /* Allocate space for the previous row */
1019 regPrev = pParse->nMem+1;
drh340309f2014-01-22 00:23:49 +00001020 pParse->nMem += nResultCol;
drhe8e4af72012-09-21 00:04:28 +00001021
1022 /* Change the OP_OpenEphemeral coded earlier to an OP_Null
1023 ** sets the MEM_Cleared bit on the first register of the
1024 ** previous value. This will cause the OP_Ne below to always
1025 ** fail on the first iteration of the loop even if the first
1026 ** row is all NULLs.
1027 */
1028 sqlite3VdbeChangeToNoop(v, pDistinct->addrTnct);
1029 pOp = sqlite3VdbeGetOp(v, pDistinct->addrTnct);
1030 pOp->opcode = OP_Null;
1031 pOp->p1 = 1;
1032 pOp->p2 = regPrev;
1033
drh340309f2014-01-22 00:23:49 +00001034 iJump = sqlite3VdbeCurrentAddr(v) + nResultCol;
1035 for(i=0; i<nResultCol; i++){
drh2def2f72017-09-15 17:40:34 +00001036 CollSeq *pColl = sqlite3ExprCollSeq(pParse, p->pEList->a[i].pExpr);
drh340309f2014-01-22 00:23:49 +00001037 if( i<nResultCol-1 ){
drhe8e4af72012-09-21 00:04:28 +00001038 sqlite3VdbeAddOp3(v, OP_Ne, regResult+i, iJump, regPrev+i);
drh688852a2014-02-17 22:40:43 +00001039 VdbeCoverage(v);
drhe8e4af72012-09-21 00:04:28 +00001040 }else{
1041 sqlite3VdbeAddOp3(v, OP_Eq, regResult+i, iContinue, regPrev+i);
drh688852a2014-02-17 22:40:43 +00001042 VdbeCoverage(v);
1043 }
drhe8e4af72012-09-21 00:04:28 +00001044 sqlite3VdbeChangeP4(v, -1, (const char *)pColl, P4_COLLSEQ);
1045 sqlite3VdbeChangeP5(v, SQLITE_NULLEQ);
1046 }
drhfcf2a772014-08-12 01:23:07 +00001047 assert( sqlite3VdbeCurrentAddr(v)==iJump || pParse->db->mallocFailed );
drh340309f2014-01-22 00:23:49 +00001048 sqlite3VdbeAddOp3(v, OP_Copy, regResult, regPrev, nResultCol-1);
drhe8e4af72012-09-21 00:04:28 +00001049 break;
1050 }
1051
1052 case WHERE_DISTINCT_UNIQUE: {
1053 sqlite3VdbeChangeToNoop(v, pDistinct->addrTnct);
1054 break;
1055 }
1056
1057 default: {
1058 assert( pDistinct->eTnctType==WHERE_DISTINCT_UNORDERED );
drh38b41492015-06-08 15:08:15 +00001059 codeDistinct(pParse, pDistinct->tabTnct, iContinue, nResultCol,
1060 regResult);
drhe8e4af72012-09-21 00:04:28 +00001061 break;
1062 }
1063 }
drh079a3072014-03-19 14:10:55 +00001064 if( pSort==0 ){
drhaa9ce702014-01-22 18:07:04 +00001065 codeOffset(v, p->iOffset, iContinue);
drhea48eb22004-07-19 23:16:38 +00001066 }
drh22827922000-06-06 17:27:05 +00001067 }
drh82c3d632000-06-06 21:56:07 +00001068
drhc926afb2002-06-20 03:38:26 +00001069 switch( eDest ){
1070 /* In this mode, write each query result to the key of the temporary
1071 ** table iParm.
1072 */
drh13449892005-09-07 21:22:45 +00001073#ifndef SQLITE_OMIT_COMPOUND_SELECT
drhc926afb2002-06-20 03:38:26 +00001074 case SRT_Union: {
drh9cbf3422008-01-17 16:22:13 +00001075 int r1;
1076 r1 = sqlite3GetTempReg(pParse);
drh340309f2014-01-22 00:23:49 +00001077 sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r1);
drh9b4eaeb2016-11-09 00:10:33 +00001078 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regResult, nResultCol);
drh9cbf3422008-01-17 16:22:13 +00001079 sqlite3ReleaseTempReg(pParse, r1);
drhc926afb2002-06-20 03:38:26 +00001080 break;
drh22827922000-06-06 17:27:05 +00001081 }
drh22827922000-06-06 17:27:05 +00001082
drhc926afb2002-06-20 03:38:26 +00001083 /* Construct a record from the query result, but instead of
1084 ** saving that record, use it as a key to delete elements from
1085 ** the temporary table iParm.
1086 */
1087 case SRT_Except: {
drh340309f2014-01-22 00:23:49 +00001088 sqlite3VdbeAddOp3(v, OP_IdxDelete, iParm, regResult, nResultCol);
drhc926afb2002-06-20 03:38:26 +00001089 break;
1090 }
drh781def22014-01-22 13:35:53 +00001091#endif /* SQLITE_OMIT_COMPOUND_SELECT */
danielk19775338a5f2005-01-20 13:03:10 +00001092
1093 /* Store the result as data using a unique key.
1094 */
drh8e1ee882014-03-21 19:56:09 +00001095 case SRT_Fifo:
1096 case SRT_DistFifo:
danielk19775338a5f2005-01-20 13:03:10 +00001097 case SRT_Table:
drhb9bb7c12006-06-11 23:41:55 +00001098 case SRT_EphemTab: {
drhfd0a2f92014-03-24 18:08:15 +00001099 int r1 = sqlite3GetTempRange(pParse, nPrefixReg+1);
drh373cc2d2009-05-17 02:06:14 +00001100 testcase( eDest==SRT_Table );
1101 testcase( eDest==SRT_EphemTab );
drhe2248cf2015-05-22 17:29:27 +00001102 testcase( eDest==SRT_Fifo );
1103 testcase( eDest==SRT_DistFifo );
drhfd0a2f92014-03-24 18:08:15 +00001104 sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r1+nPrefixReg);
dan8ce71842014-01-14 20:14:09 +00001105#ifndef SQLITE_OMIT_CTE
drh8e1ee882014-03-21 19:56:09 +00001106 if( eDest==SRT_DistFifo ){
1107 /* If the destination is DistFifo, then cursor (iParm+1) is open
dan8ce71842014-01-14 20:14:09 +00001108 ** on an ephemeral index. If the current row is already present
1109 ** in the index, do not write it to the output. If not, add the
1110 ** current row to the index and proceed with writing it to the
1111 ** output table as well. */
1112 int addr = sqlite3VdbeCurrentAddr(v) + 4;
drh38b41492015-06-08 15:08:15 +00001113 sqlite3VdbeAddOp4Int(v, OP_Found, iParm+1, addr, r1, 0);
1114 VdbeCoverage(v);
drh9b4eaeb2016-11-09 00:10:33 +00001115 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm+1, r1,regResult,nResultCol);
drh079a3072014-03-19 14:10:55 +00001116 assert( pSort==0 );
dan8ce71842014-01-14 20:14:09 +00001117 }
1118#endif
drh079a3072014-03-19 14:10:55 +00001119 if( pSort ){
drhbbd4ae52018-04-30 19:32:49 +00001120 assert( regResult==regOrig );
1121 pushOntoSorter(pParse, pSort, p, r1+nPrefixReg, regOrig, 1, nPrefixReg);
danielk19775338a5f2005-01-20 13:03:10 +00001122 }else{
drhb7654112008-01-12 12:48:07 +00001123 int r2 = sqlite3GetTempReg(pParse);
1124 sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, r2);
1125 sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, r2);
1126 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
1127 sqlite3ReleaseTempReg(pParse, r2);
danielk19775338a5f2005-01-20 13:03:10 +00001128 }
drhfd0a2f92014-03-24 18:08:15 +00001129 sqlite3ReleaseTempRange(pParse, r1, nPrefixReg+1);
danielk19775338a5f2005-01-20 13:03:10 +00001130 break;
1131 }
drh5974a302000-06-07 14:42:26 +00001132
danielk197793758c82005-01-21 08:13:14 +00001133#ifndef SQLITE_OMIT_SUBQUERY
drhc926afb2002-06-20 03:38:26 +00001134 /* If we are creating a set for an "expr IN (SELECT ...)" construct,
1135 ** then there should be a single item on the stack. Write this
1136 ** item into the set table with bogus data.
1137 */
1138 case SRT_Set: {
drh079a3072014-03-19 14:10:55 +00001139 if( pSort ){
drhde941c62005-08-28 01:34:21 +00001140 /* At first glance you would think we could optimize out the
1141 ** ORDER BY in this case since the order of entries in the set
1142 ** does not matter. But there might be a LIMIT clause, in which
1143 ** case the order does matter */
dan51d82d12016-08-02 18:50:15 +00001144 pushOntoSorter(
dan9af90b72016-11-11 18:08:59 +00001145 pParse, pSort, p, regResult, regOrig, nResultCol, nPrefixReg);
drhc926afb2002-06-20 03:38:26 +00001146 }else{
drhb7654112008-01-12 12:48:07 +00001147 int r1 = sqlite3GetTempReg(pParse);
dan71c57db2016-07-09 20:23:55 +00001148 assert( sqlite3Strlen30(pDest->zAffSdst)==nResultCol );
1149 sqlite3VdbeAddOp4(v, OP_MakeRecord, regResult, nResultCol,
dan553168c2016-08-01 20:14:31 +00001150 r1, pDest->zAffSdst, nResultCol);
drh9b4eaeb2016-11-09 00:10:33 +00001151 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regResult, nResultCol);
drhb7654112008-01-12 12:48:07 +00001152 sqlite3ReleaseTempReg(pParse, r1);
drhc926afb2002-06-20 03:38:26 +00001153 }
1154 break;
1155 }
drh22827922000-06-06 17:27:05 +00001156
drh504b6982006-01-22 21:52:56 +00001157 /* If any row exist in the result set, record that fact and abort.
drhec7429a2005-10-06 16:53:14 +00001158 */
1159 case SRT_Exists: {
drh4c583122008-01-04 22:01:03 +00001160 sqlite3VdbeAddOp2(v, OP_Integer, 1, iParm);
drhec7429a2005-10-06 16:53:14 +00001161 /* The LIMIT clause will terminate the loop for us */
1162 break;
1163 }
1164
drhc926afb2002-06-20 03:38:26 +00001165 /* If this is a scalar select that is part of an expression, then
dan870a0702016-08-01 16:37:43 +00001166 ** store the results in the appropriate memory cell or array of
1167 ** memory cells and break out of the scan loop.
drhc926afb2002-06-20 03:38:26 +00001168 */
1169 case SRT_Mem: {
drh079a3072014-03-19 14:10:55 +00001170 if( pSort ){
dan257c13f2016-11-10 20:14:06 +00001171 assert( nResultCol<=pDest->nSdst );
dan870a0702016-08-01 16:37:43 +00001172 pushOntoSorter(
dan9af90b72016-11-11 18:08:59 +00001173 pParse, pSort, p, regResult, regOrig, nResultCol, nPrefixReg);
drhc926afb2002-06-20 03:38:26 +00001174 }else{
dan257c13f2016-11-10 20:14:06 +00001175 assert( nResultCol==pDest->nSdst );
drh53932ce2014-08-29 12:29:39 +00001176 assert( regResult==iParm );
drhec7429a2005-10-06 16:53:14 +00001177 /* The LIMIT clause will jump out of the loop for us */
drhc926afb2002-06-20 03:38:26 +00001178 }
1179 break;
1180 }
danielk197793758c82005-01-21 08:13:14 +00001181#endif /* #ifndef SQLITE_OMIT_SUBQUERY */
drh22827922000-06-06 17:27:05 +00001182
drh81cf13e2014-02-07 18:27:53 +00001183 case SRT_Coroutine: /* Send data to a co-routine */
1184 case SRT_Output: { /* Return the results */
drh373cc2d2009-05-17 02:06:14 +00001185 testcase( eDest==SRT_Coroutine );
1186 testcase( eDest==SRT_Output );
drh079a3072014-03-19 14:10:55 +00001187 if( pSort ){
dan9af90b72016-11-11 18:08:59 +00001188 pushOntoSorter(pParse, pSort, p, regResult, regOrig, nResultCol,
drh5579d592015-08-26 14:01:41 +00001189 nPrefixReg);
drhe00ee6e2008-06-20 15:24:01 +00001190 }else if( eDest==SRT_Coroutine ){
drh2b596da2012-07-23 21:43:19 +00001191 sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm);
drhc182d162005-08-14 20:47:16 +00001192 }else{
drh340309f2014-01-22 00:23:49 +00001193 sqlite3VdbeAddOp2(v, OP_ResultRow, regResult, nResultCol);
drhac82fcf2002-09-08 17:23:41 +00001194 }
drh142e30d2002-08-28 03:00:58 +00001195 break;
1196 }
1197
drhfe1c6bb2014-01-22 17:28:35 +00001198#ifndef SQLITE_OMIT_CTE
1199 /* Write the results into a priority queue that is order according to
1200 ** pDest->pOrderBy (in pSO). pDest->iSDParm (in iParm) is the cursor for an
1201 ** index with pSO->nExpr+2 columns. Build a key using pSO for the first
1202 ** pSO->nExpr columns, then make sure all keys are unique by adding a
1203 ** final OP_Sequence column. The last column is the record as a blob.
1204 */
1205 case SRT_DistQueue:
1206 case SRT_Queue: {
1207 int nKey;
1208 int r1, r2, r3;
1209 int addrTest = 0;
1210 ExprList *pSO;
1211 pSO = pDest->pOrderBy;
1212 assert( pSO );
1213 nKey = pSO->nExpr;
1214 r1 = sqlite3GetTempReg(pParse);
1215 r2 = sqlite3GetTempRange(pParse, nKey+2);
1216 r3 = r2+nKey+1;
drhfe1c6bb2014-01-22 17:28:35 +00001217 if( eDest==SRT_DistQueue ){
1218 /* If the destination is DistQueue, then cursor (iParm+1) is open
1219 ** on a second ephemeral index that holds all values every previously
drh7e4efae2014-02-26 21:35:31 +00001220 ** added to the queue. */
1221 addrTest = sqlite3VdbeAddOp4Int(v, OP_Found, iParm+1, 0,
1222 regResult, nResultCol);
drh688852a2014-02-17 22:40:43 +00001223 VdbeCoverage(v);
drh7e4efae2014-02-26 21:35:31 +00001224 }
1225 sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r3);
1226 if( eDest==SRT_DistQueue ){
drhfe1c6bb2014-01-22 17:28:35 +00001227 sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm+1, r3);
dancfe24582014-01-22 19:23:30 +00001228 sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
drhfe1c6bb2014-01-22 17:28:35 +00001229 }
1230 for(i=0; i<nKey; i++){
1231 sqlite3VdbeAddOp2(v, OP_SCopy,
1232 regResult + pSO->a[i].u.x.iOrderByCol - 1,
1233 r2+i);
1234 }
1235 sqlite3VdbeAddOp2(v, OP_Sequence, iParm, r2+nKey);
1236 sqlite3VdbeAddOp3(v, OP_MakeRecord, r2, nKey+2, r1);
drh9b4eaeb2016-11-09 00:10:33 +00001237 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, r2, nKey+2);
drhfe1c6bb2014-01-22 17:28:35 +00001238 if( addrTest ) sqlite3VdbeJumpHere(v, addrTest);
1239 sqlite3ReleaseTempReg(pParse, r1);
1240 sqlite3ReleaseTempRange(pParse, r2, nKey+2);
1241 break;
1242 }
1243#endif /* SQLITE_OMIT_CTE */
1244
1245
1246
danielk19776a67fe82005-02-04 04:07:16 +00001247#if !defined(SQLITE_OMIT_TRIGGER)
drhc926afb2002-06-20 03:38:26 +00001248 /* Discard the results. This is used for SELECT statements inside
1249 ** the body of a TRIGGER. The purpose of such selects is to call
1250 ** user-defined functions that have side effects. We do not care
1251 ** about the actual results of the select.
1252 */
drhc926afb2002-06-20 03:38:26 +00001253 default: {
drhf46f9052002-06-22 02:33:38 +00001254 assert( eDest==SRT_Discard );
drhc926afb2002-06-20 03:38:26 +00001255 break;
1256 }
danielk197793758c82005-01-21 08:13:14 +00001257#endif
drh82c3d632000-06-06 21:56:07 +00001258 }
drhec7429a2005-10-06 16:53:14 +00001259
drh5e87be82010-10-06 18:55:37 +00001260 /* Jump to the end of the loop if the LIMIT is reached. Except, if
1261 ** there is a sorter, in which case the sorter has already limited
1262 ** the output for us.
drhec7429a2005-10-06 16:53:14 +00001263 */
drh079a3072014-03-19 14:10:55 +00001264 if( pSort==0 && p->iLimit ){
drh16897072015-03-07 00:57:37 +00001265 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak); VdbeCoverage(v);
drhec7429a2005-10-06 16:53:14 +00001266 }
drh82c3d632000-06-06 21:56:07 +00001267}
1268
1269/*
drhad124322013-10-23 13:30:58 +00001270** Allocate a KeyInfo object sufficient for an index of N key columns and
1271** X extra columns.
drh323df792013-08-05 19:11:29 +00001272*/
drhad124322013-10-23 13:30:58 +00001273KeyInfo *sqlite3KeyInfoAlloc(sqlite3 *db, int N, int X){
drhd4ab0032017-05-31 13:45:59 +00001274 int nExtra = (N+X)*(sizeof(CollSeq*)+1) - sizeof(CollSeq*);
drhd8e4b132016-10-01 19:21:56 +00001275 KeyInfo *p = sqlite3DbMallocRawNN(db, sizeof(KeyInfo) + nExtra);
drh323df792013-08-05 19:11:29 +00001276 if( p ){
drhad124322013-10-23 13:30:58 +00001277 p->aSortOrder = (u8*)&p->aColl[N+X];
drha485ad12017-08-02 22:43:14 +00001278 p->nKeyField = (u16)N;
1279 p->nAllField = (u16)(N+X);
drh323df792013-08-05 19:11:29 +00001280 p->enc = ENC(db);
1281 p->db = db;
drh2ec2fb22013-11-06 19:59:23 +00001282 p->nRef = 1;
drhc263f7c2016-01-18 13:18:54 +00001283 memset(&p[1], 0, nExtra);
drh2ec2fb22013-11-06 19:59:23 +00001284 }else{
drh4a642b62016-02-05 01:55:27 +00001285 sqlite3OomFault(db);
drh323df792013-08-05 19:11:29 +00001286 }
1287 return p;
1288}
1289
1290/*
drh2ec2fb22013-11-06 19:59:23 +00001291** Deallocate a KeyInfo object
1292*/
1293void sqlite3KeyInfoUnref(KeyInfo *p){
1294 if( p ){
1295 assert( p->nRef>0 );
drh2ec2fb22013-11-06 19:59:23 +00001296 p->nRef--;
drhdbd6a7d2017-04-05 12:39:49 +00001297 if( p->nRef==0 ) sqlite3DbFreeNN(p->db, p);
drh2ec2fb22013-11-06 19:59:23 +00001298 }
1299}
1300
1301/*
1302** Make a new pointer to a KeyInfo object
1303*/
1304KeyInfo *sqlite3KeyInfoRef(KeyInfo *p){
1305 if( p ){
1306 assert( p->nRef>0 );
1307 p->nRef++;
1308 }
1309 return p;
1310}
1311
1312#ifdef SQLITE_DEBUG
1313/*
1314** Return TRUE if a KeyInfo object can be change. The KeyInfo object
1315** can only be changed if this is just a single reference to the object.
1316**
1317** This routine is used only inside of assert() statements.
1318*/
1319int sqlite3KeyInfoIsWriteable(KeyInfo *p){ return p->nRef==1; }
1320#endif /* SQLITE_DEBUG */
1321
1322/*
drhdece1a82005-08-31 18:20:00 +00001323** Given an expression list, generate a KeyInfo structure that records
1324** the collating sequence for each expression in that expression list.
1325**
drh0342b1f2005-09-01 03:07:44 +00001326** If the ExprList is an ORDER BY or GROUP BY clause then the resulting
1327** KeyInfo structure is appropriate for initializing a virtual index to
1328** implement that clause. If the ExprList is the result set of a SELECT
1329** then the KeyInfo structure is appropriate for initializing a virtual
1330** index to implement a DISTINCT test.
1331**
peter.d.reid60ec9142014-09-06 16:39:46 +00001332** Space to hold the KeyInfo structure is obtained from malloc. The calling
drhdece1a82005-08-31 18:20:00 +00001333** function is responsible for seeing that this structure is eventually
drh2ec2fb22013-11-06 19:59:23 +00001334** freed.
drhdece1a82005-08-31 18:20:00 +00001335*/
danf9eae182018-05-21 19:45:11 +00001336KeyInfo *sqlite3KeyInfoFromExprList(
drh079a3072014-03-19 14:10:55 +00001337 Parse *pParse, /* Parsing context */
1338 ExprList *pList, /* Form the KeyInfo object from this ExprList */
1339 int iStart, /* Begin with this column of pList */
1340 int nExtra /* Add this many extra columns to the end */
1341){
drhdece1a82005-08-31 18:20:00 +00001342 int nExpr;
1343 KeyInfo *pInfo;
1344 struct ExprList_item *pItem;
drh323df792013-08-05 19:11:29 +00001345 sqlite3 *db = pParse->db;
drhdece1a82005-08-31 18:20:00 +00001346 int i;
1347
1348 nExpr = pList->nExpr;
drh3f39bcf2015-01-19 20:59:34 +00001349 pInfo = sqlite3KeyInfoAlloc(db, nExpr-iStart, nExtra+1);
drhdece1a82005-08-31 18:20:00 +00001350 if( pInfo ){
drh2ec2fb22013-11-06 19:59:23 +00001351 assert( sqlite3KeyInfoIsWriteable(pInfo) );
drh6284db92014-03-19 23:24:49 +00001352 for(i=iStart, pItem=pList->a+iStart; i<nExpr; i++, pItem++){
drh70efa842017-09-28 01:58:23 +00001353 pInfo->aColl[i-iStart] = sqlite3ExprNNCollSeq(pParse, pItem->pExpr);
drh6284db92014-03-19 23:24:49 +00001354 pInfo->aSortOrder[i-iStart] = pItem->sortOrder;
drhdece1a82005-08-31 18:20:00 +00001355 }
1356 }
1357 return pInfo;
1358}
1359
dan7f61e922010-11-11 16:46:40 +00001360/*
1361** Name of the connection operator, used for error messages.
1362*/
1363static const char *selectOpName(int id){
1364 char *z;
1365 switch( id ){
1366 case TK_ALL: z = "UNION ALL"; break;
1367 case TK_INTERSECT: z = "INTERSECT"; break;
1368 case TK_EXCEPT: z = "EXCEPT"; break;
1369 default: z = "UNION"; break;
1370 }
1371 return z;
1372}
dan7f61e922010-11-11 16:46:40 +00001373
dan2ce22452010-11-08 19:01:16 +00001374#ifndef SQLITE_OMIT_EXPLAIN
dan17c0bc02010-11-09 17:35:19 +00001375/*
1376** Unless an "EXPLAIN QUERY PLAN" command is being processed, this function
1377** is a no-op. Otherwise, it adds a single row of output to the EQP result,
1378** where the caption is of the form:
1379**
1380** "USE TEMP B-TREE FOR xxx"
1381**
1382** where xxx is one of "DISTINCT", "ORDER BY" or "GROUP BY". Exactly which
1383** is determined by the zUsage argument.
1384*/
dan2ce22452010-11-08 19:01:16 +00001385static void explainTempTable(Parse *pParse, const char *zUsage){
drhe2ca99c2018-05-02 00:33:43 +00001386 ExplainQueryPlan((pParse, 0, "USE TEMP B-TREE FOR %s", zUsage));
dan2ce22452010-11-08 19:01:16 +00001387}
dan17c0bc02010-11-09 17:35:19 +00001388
1389/*
danbb2b4412011-04-06 17:54:31 +00001390** Assign expression b to lvalue a. A second, no-op, version of this macro
1391** is provided when SQLITE_OMIT_EXPLAIN is defined. This allows the code
1392** in sqlite3Select() to assign values to structure member variables that
1393** only exist if SQLITE_OMIT_EXPLAIN is not defined without polluting the
1394** code with #ifndef directives.
1395*/
1396# define explainSetInteger(a, b) a = b
1397
1398#else
1399/* No-op versions of the explainXXX() functions and macros. */
1400# define explainTempTable(y,z)
1401# define explainSetInteger(y,z)
1402#endif
1403
drhdece1a82005-08-31 18:20:00 +00001404
1405/*
drhd8bc7082000-06-07 23:51:50 +00001406** If the inner loop was generated using a non-null pOrderBy argument,
1407** then the results were placed in a sorter. After the loop is terminated
1408** we need to run the sorter and output the results. The following
1409** routine generates the code needed to do that.
1410*/
drhc926afb2002-06-20 03:38:26 +00001411static void generateSortTail(
danielk19776c8c8ce2008-01-02 16:27:09 +00001412 Parse *pParse, /* Parsing context */
1413 Select *p, /* The SELECT statement */
drh079a3072014-03-19 14:10:55 +00001414 SortCtx *pSort, /* Information on the ORDER BY clause */
danielk19776c8c8ce2008-01-02 16:27:09 +00001415 int nColumn, /* Number of columns of data */
1416 SelectDest *pDest /* Write the sorted results here */
drhc926afb2002-06-20 03:38:26 +00001417){
drhddba0c22014-03-18 20:33:42 +00001418 Vdbe *v = pParse->pVdbe; /* The prepared statement */
drha04a8be2016-01-13 17:50:10 +00001419 int addrBreak = pSort->labelDone; /* Jump here to exit loop */
drhdc5ea5c2008-12-10 17:19:59 +00001420 int addrContinue = sqlite3VdbeMakeLabel(v); /* Jump here for next cycle */
dan24e25d32018-04-14 18:46:20 +00001421 int addr; /* Top of output loop. Jump for Next. */
drh079a3072014-03-19 14:10:55 +00001422 int addrOnce = 0;
drh0342b1f2005-09-01 03:07:44 +00001423 int iTab;
drh079a3072014-03-19 14:10:55 +00001424 ExprList *pOrderBy = pSort->pOrderBy;
danielk19776c8c8ce2008-01-02 16:27:09 +00001425 int eDest = pDest->eDest;
drh2b596da2012-07-23 21:43:19 +00001426 int iParm = pDest->iSDParm;
drh2d401ab2008-01-10 23:50:11 +00001427 int regRow;
1428 int regRowid;
dan257c13f2016-11-10 20:14:06 +00001429 int iCol;
dan24e25d32018-04-14 18:46:20 +00001430 int nKey; /* Number of key columns in sorter record */
drhf45f2322014-03-23 17:45:03 +00001431 int iSortTab; /* Sorter cursor to read from */
drhf45f2322014-03-23 17:45:03 +00001432 int i;
dan78d58432014-03-25 15:04:07 +00001433 int bSeq; /* True if sorter record includes seq. no. */
dan24e25d32018-04-14 18:46:20 +00001434 int nRefKey = 0;
drh70f624c2014-03-24 01:43:50 +00001435 struct ExprList_item *aOutEx = p->pEList->a;
drh2d401ab2008-01-10 23:50:11 +00001436
drha04a8be2016-01-13 17:50:10 +00001437 assert( addrBreak<0 );
drh079a3072014-03-19 14:10:55 +00001438 if( pSort->labelBkOut ){
1439 sqlite3VdbeAddOp2(v, OP_Gosub, pSort->regReturn, pSort->labelBkOut);
drh076e85f2015-09-03 13:46:12 +00001440 sqlite3VdbeGoto(v, addrBreak);
drh079a3072014-03-19 14:10:55 +00001441 sqlite3VdbeResolveLabel(v, pSort->labelBkOut);
drh079a3072014-03-19 14:10:55 +00001442 }
dan24e25d32018-04-14 18:46:20 +00001443
1444#ifdef SQLITE_ENABLE_SORTER_REFERENCES
1445 /* Open any cursors needed for sorter-reference expressions */
1446 for(i=0; i<pSort->nDefer; i++){
1447 Table *pTab = pSort->aDefer[i].pTab;
1448 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
1449 sqlite3OpenTable(pParse, pSort->aDefer[i].iCsr, iDb, pTab, OP_OpenRead);
1450 nRefKey = MAX(nRefKey, pSort->aDefer[i].nKey);
1451 }
1452#endif
1453
drh079a3072014-03-19 14:10:55 +00001454 iTab = pSort->iECursor;
dan71c57db2016-07-09 20:23:55 +00001455 if( eDest==SRT_Output || eDest==SRT_Coroutine || eDest==SRT_Mem ){
drh3e9ca092009-09-08 01:14:48 +00001456 regRowid = 0;
drhf45f2322014-03-23 17:45:03 +00001457 regRow = pDest->iSdst;
drhed24da42016-09-06 14:37:05 +00001458 }else{
dan51d82d12016-08-02 18:50:15 +00001459 regRowid = sqlite3GetTempReg(pParse);
1460 regRow = sqlite3GetTempRange(pParse, nColumn);
drhcdd536f2006-03-17 00:04:03 +00001461 }
drh079a3072014-03-19 14:10:55 +00001462 nKey = pOrderBy->nExpr - pSort->nOBSat;
1463 if( pSort->sortFlags & SORTFLAG_UseSorter ){
drhc2bb3282011-09-04 01:11:46 +00001464 int regSortOut = ++pParse->nMem;
drhf45f2322014-03-23 17:45:03 +00001465 iSortTab = pParse->nTab++;
drh83553ee2014-03-24 02:20:53 +00001466 if( pSort->labelBkOut ){
drh511f9e82016-09-22 18:53:13 +00001467 addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
drh83553ee2014-03-24 02:20:53 +00001468 }
dan24e25d32018-04-14 18:46:20 +00001469 sqlite3VdbeAddOp3(v, OP_OpenPseudo, iSortTab, regSortOut,
1470 nKey+1+nColumn+nRefKey);
drh079a3072014-03-19 14:10:55 +00001471 if( addrOnce ) sqlite3VdbeJumpHere(v, addrOnce);
drhc6aff302011-09-01 15:32:47 +00001472 addr = 1 + sqlite3VdbeAddOp2(v, OP_SorterSort, iTab, addrBreak);
drh688852a2014-02-17 22:40:43 +00001473 VdbeCoverage(v);
drhaa9ce702014-01-22 18:07:04 +00001474 codeOffset(v, p->iOffset, addrContinue);
drh6cf4a7d2014-10-13 13:00:58 +00001475 sqlite3VdbeAddOp3(v, OP_SorterData, iTab, regSortOut, iSortTab);
dan78d58432014-03-25 15:04:07 +00001476 bSeq = 0;
drhc6aff302011-09-01 15:32:47 +00001477 }else{
drh688852a2014-02-17 22:40:43 +00001478 addr = 1 + sqlite3VdbeAddOp2(v, OP_Sort, iTab, addrBreak); VdbeCoverage(v);
drhaa9ce702014-01-22 18:07:04 +00001479 codeOffset(v, p->iOffset, addrContinue);
drhf45f2322014-03-23 17:45:03 +00001480 iSortTab = iTab;
dan78d58432014-03-25 15:04:07 +00001481 bSeq = 1;
drhf45f2322014-03-23 17:45:03 +00001482 }
dand6189ea2018-04-11 14:11:53 +00001483 for(i=0, iCol=nKey+bSeq-1; i<nColumn; i++){
dan24e25d32018-04-14 18:46:20 +00001484#ifdef SQLITE_ENABLE_SORTER_REFERENCES
1485 if( aOutEx[i].bSorterRef ) continue;
1486#endif
drh9f895232018-01-24 20:42:42 +00001487 if( aOutEx[i].u.x.iOrderByCol==0 ) iCol++;
1488 }
dan24e25d32018-04-14 18:46:20 +00001489#ifdef SQLITE_ENABLE_SORTER_REFERENCES
1490 if( pSort->nDefer ){
1491 int iKey = iCol+1;
1492 int regKey = sqlite3GetTempRange(pParse, nRefKey);
1493
1494 for(i=0; i<pSort->nDefer; i++){
1495 int iCsr = pSort->aDefer[i].iCsr;
1496 Table *pTab = pSort->aDefer[i].pTab;
1497 int nKey = pSort->aDefer[i].nKey;
1498
1499 sqlite3VdbeAddOp1(v, OP_NullRow, iCsr);
1500 if( HasRowid(pTab) ){
1501 sqlite3VdbeAddOp3(v, OP_Column, iSortTab, iKey++, regKey);
1502 sqlite3VdbeAddOp3(v, OP_SeekRowid, iCsr,
1503 sqlite3VdbeCurrentAddr(v)+1, regKey);
1504 }else{
dan24e25d32018-04-14 18:46:20 +00001505 int k;
1506 int iJmp;
drh7590d092018-04-18 14:04:19 +00001507 assert( sqlite3PrimaryKeyIndex(pTab)->nKeyCol==nKey );
dan24e25d32018-04-14 18:46:20 +00001508 for(k=0; k<nKey; k++){
1509 sqlite3VdbeAddOp3(v, OP_Column, iSortTab, iKey++, regKey+k);
1510 }
1511 iJmp = sqlite3VdbeCurrentAddr(v);
1512 sqlite3VdbeAddOp4Int(v, OP_SeekGE, iCsr, iJmp+2, regKey, nKey);
1513 sqlite3VdbeAddOp4Int(v, OP_IdxLE, iCsr, iJmp+3, regKey, nKey);
1514 sqlite3VdbeAddOp1(v, OP_NullRow, iCsr);
1515 }
dan257c13f2016-11-10 20:14:06 +00001516 }
dan24e25d32018-04-14 18:46:20 +00001517 sqlite3ReleaseTempRange(pParse, regKey, nRefKey);
1518 }
1519#endif
1520 for(i=nColumn-1; i>=0; i--){
1521#ifdef SQLITE_ENABLE_SORTER_REFERENCES
1522 if( aOutEx[i].bSorterRef ){
1523 sqlite3ExprCode(pParse, aOutEx[i].pExpr, regRow+i);
1524 }else
1525#endif
1526 {
1527 int iRead;
1528 if( aOutEx[i].u.x.iOrderByCol ){
1529 iRead = aOutEx[i].u.x.iOrderByCol-1;
1530 }else{
1531 iRead = iCol--;
1532 }
1533 sqlite3VdbeAddOp3(v, OP_Column, iSortTab, iRead, regRow+i);
1534 VdbeComment((v, "%s", aOutEx[i].zName?aOutEx[i].zName : aOutEx[i].zSpan));
1535 }
drhc6aff302011-09-01 15:32:47 +00001536 }
drhc926afb2002-06-20 03:38:26 +00001537 switch( eDest ){
danac56ab72017-01-05 17:23:11 +00001538 case SRT_Table:
drhb9bb7c12006-06-11 23:41:55 +00001539 case SRT_EphemTab: {
drh2d401ab2008-01-10 23:50:11 +00001540 sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, regRowid);
1541 sqlite3VdbeAddOp3(v, OP_Insert, iParm, regRow, regRowid);
1542 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
drhc926afb2002-06-20 03:38:26 +00001543 break;
1544 }
danielk197793758c82005-01-21 08:13:14 +00001545#ifndef SQLITE_OMIT_SUBQUERY
drhc926afb2002-06-20 03:38:26 +00001546 case SRT_Set: {
dan71c57db2016-07-09 20:23:55 +00001547 assert( nColumn==sqlite3Strlen30(pDest->zAffSdst) );
1548 sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, nColumn, regRowid,
dan553168c2016-08-01 20:14:31 +00001549 pDest->zAffSdst, nColumn);
drh9b4eaeb2016-11-09 00:10:33 +00001550 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, regRowid, regRow, nColumn);
drhc926afb2002-06-20 03:38:26 +00001551 break;
1552 }
1553 case SRT_Mem: {
drhec7429a2005-10-06 16:53:14 +00001554 /* The LIMIT clause will terminate the loop for us */
drhc926afb2002-06-20 03:38:26 +00001555 break;
1556 }
danielk197793758c82005-01-21 08:13:14 +00001557#endif
drh373cc2d2009-05-17 02:06:14 +00001558 default: {
drh373cc2d2009-05-17 02:06:14 +00001559 assert( eDest==SRT_Output || eDest==SRT_Coroutine );
drh1c767f02009-01-09 02:49:31 +00001560 testcase( eDest==SRT_Output );
1561 testcase( eDest==SRT_Coroutine );
drh7d10d5a2008-08-20 16:35:10 +00001562 if( eDest==SRT_Output ){
drh2b596da2012-07-23 21:43:19 +00001563 sqlite3VdbeAddOp2(v, OP_ResultRow, pDest->iSdst, nColumn);
drha9671a22008-07-08 23:40:20 +00001564 }else{
drh2b596da2012-07-23 21:43:19 +00001565 sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm);
drhce665cf2004-05-21 03:01:58 +00001566 }
drhac82fcf2002-09-08 17:23:41 +00001567 break;
1568 }
drhc926afb2002-06-20 03:38:26 +00001569 }
drhf45f2322014-03-23 17:45:03 +00001570 if( regRowid ){
dan51d82d12016-08-02 18:50:15 +00001571 if( eDest==SRT_Set ){
1572 sqlite3ReleaseTempRange(pParse, regRow, nColumn);
1573 }else{
1574 sqlite3ReleaseTempReg(pParse, regRow);
1575 }
drhf45f2322014-03-23 17:45:03 +00001576 sqlite3ReleaseTempReg(pParse, regRowid);
1577 }
drhec7429a2005-10-06 16:53:14 +00001578 /* The bottom of the loop
1579 */
drhdc5ea5c2008-12-10 17:19:59 +00001580 sqlite3VdbeResolveLabel(v, addrContinue);
drh079a3072014-03-19 14:10:55 +00001581 if( pSort->sortFlags & SORTFLAG_UseSorter ){
drh688852a2014-02-17 22:40:43 +00001582 sqlite3VdbeAddOp2(v, OP_SorterNext, iTab, addr); VdbeCoverage(v);
drhc6aff302011-09-01 15:32:47 +00001583 }else{
drh688852a2014-02-17 22:40:43 +00001584 sqlite3VdbeAddOp2(v, OP_Next, iTab, addr); VdbeCoverage(v);
drhc6aff302011-09-01 15:32:47 +00001585 }
drh079a3072014-03-19 14:10:55 +00001586 if( pSort->regReturn ) sqlite3VdbeAddOp1(v, OP_Return, pSort->regReturn);
drhdc5ea5c2008-12-10 17:19:59 +00001587 sqlite3VdbeResolveLabel(v, addrBreak);
drhd8bc7082000-06-07 23:51:50 +00001588}
1589
1590/*
danielk1977517eb642004-06-07 10:00:31 +00001591** Return a pointer to a string containing the 'declaration type' of the
1592** expression pExpr. The string may be treated as static by the caller.
drhe78e8282003-01-19 03:59:45 +00001593**
drh5f3e5e72013-10-08 20:01:35 +00001594** Also try to estimate the size of the returned value and return that
1595** result in *pEstWidth.
1596**
danielk1977955de522006-02-10 02:27:42 +00001597** The declaration type is the exact datatype definition extracted from the
1598** original CREATE TABLE statement if the expression is a column. The
1599** declaration type for a ROWID field is INTEGER. Exactly when an expression
1600** is considered a column can be complex in the presence of subqueries. The
1601** result-set expression in all of the following SELECT statements is
1602** considered a column by this function.
1603**
1604** SELECT col FROM tbl;
1605** SELECT (SELECT col FROM tbl;
1606** SELECT (SELECT col FROM tbl);
1607** SELECT abc FROM (SELECT col AS abc FROM tbl);
danielk1977517eb642004-06-07 10:00:31 +00001608**
danielk1977955de522006-02-10 02:27:42 +00001609** The declaration type for any expression other than a column is NULL.
drh5f3e5e72013-10-08 20:01:35 +00001610**
1611** This routine has either 3 or 6 parameters depending on whether or not
1612** the SQLITE_ENABLE_COLUMN_METADATA compile-time option is used.
danielk1977517eb642004-06-07 10:00:31 +00001613*/
drh5f3e5e72013-10-08 20:01:35 +00001614#ifdef SQLITE_ENABLE_COLUMN_METADATA
drhcafc2f72017-10-03 03:01:09 +00001615# define columnType(A,B,C,D,E) columnTypeImpl(A,B,C,D,E)
drhb121dd12015-06-06 18:30:17 +00001616#else /* if !defined(SQLITE_ENABLE_COLUMN_METADATA) */
drhcafc2f72017-10-03 03:01:09 +00001617# define columnType(A,B,C,D,E) columnTypeImpl(A,B)
drhb121dd12015-06-06 18:30:17 +00001618#endif
drh5f3e5e72013-10-08 20:01:35 +00001619static const char *columnTypeImpl(
danielk1977955de522006-02-10 02:27:42 +00001620 NameContext *pNC,
drhcafc2f72017-10-03 03:01:09 +00001621#ifndef SQLITE_ENABLE_COLUMN_METADATA
1622 Expr *pExpr
1623#else
danielk1977955de522006-02-10 02:27:42 +00001624 Expr *pExpr,
drh5f3e5e72013-10-08 20:01:35 +00001625 const char **pzOrigDb,
1626 const char **pzOrigTab,
drhcafc2f72017-10-03 03:01:09 +00001627 const char **pzOrigCol
drhb121dd12015-06-06 18:30:17 +00001628#endif
danielk1977955de522006-02-10 02:27:42 +00001629){
1630 char const *zType = 0;
danielk1977517eb642004-06-07 10:00:31 +00001631 int j;
drhb121dd12015-06-06 18:30:17 +00001632#ifdef SQLITE_ENABLE_COLUMN_METADATA
1633 char const *zOrigDb = 0;
1634 char const *zOrigTab = 0;
1635 char const *zOrigCol = 0;
1636#endif
danielk19775338a5f2005-01-20 13:03:10 +00001637
drhf7ce4292015-12-02 19:46:12 +00001638 assert( pExpr!=0 );
1639 assert( pNC->pSrcList!=0 );
drh755b0fd2017-12-23 12:33:40 +00001640 assert( pExpr->op!=TK_AGG_COLUMN ); /* This routine runes before aggregates
1641 ** are processed */
danielk197700e279d2004-06-21 07:36:32 +00001642 switch( pExpr->op ){
1643 case TK_COLUMN: {
danielk1977955de522006-02-10 02:27:42 +00001644 /* The expression is a column. Locate the table the column is being
1645 ** extracted from in NameContext.pSrcList. This table may be real
1646 ** database table or a subquery.
1647 */
1648 Table *pTab = 0; /* Table structure column is extracted from */
1649 Select *pS = 0; /* Select the column is extracted from */
1650 int iCol = pExpr->iColumn; /* Index of column in pTab */
dan43bc88b2009-09-10 10:15:59 +00001651 while( pNC && !pTab ){
danielk1977b3bce662005-01-29 08:32:43 +00001652 SrcList *pTabList = pNC->pSrcList;
1653 for(j=0;j<pTabList->nSrc && pTabList->a[j].iCursor!=pExpr->iTable;j++);
1654 if( j<pTabList->nSrc ){
1655 pTab = pTabList->a[j].pTab;
danielk1977955de522006-02-10 02:27:42 +00001656 pS = pTabList->a[j].pSelect;
danielk1977b3bce662005-01-29 08:32:43 +00001657 }else{
1658 pNC = pNC->pNext;
1659 }
1660 }
danielk1977955de522006-02-10 02:27:42 +00001661
dan43bc88b2009-09-10 10:15:59 +00001662 if( pTab==0 ){
drh417168a2009-09-07 18:14:02 +00001663 /* At one time, code such as "SELECT new.x" within a trigger would
1664 ** cause this condition to run. Since then, we have restructured how
1665 ** trigger code is generated and so this condition is no longer
dan43bc88b2009-09-10 10:15:59 +00001666 ** possible. However, it can still be true for statements like
1667 ** the following:
1668 **
1669 ** CREATE TABLE t1(col INTEGER);
1670 ** SELECT (SELECT t1.col) FROM FROM t1;
1671 **
1672 ** when columnType() is called on the expression "t1.col" in the
1673 ** sub-select. In this case, set the column type to NULL, even
1674 ** though it should really be "INTEGER".
1675 **
1676 ** This is not a problem, as the column type of "t1.col" is never
1677 ** used. When columnType() is called on the expression
1678 ** "(SELECT t1.col)", the correct type is returned (see the TK_SELECT
1679 ** branch below. */
drh7e627792005-04-29 02:10:00 +00001680 break;
1681 }
danielk1977955de522006-02-10 02:27:42 +00001682
dan43bc88b2009-09-10 10:15:59 +00001683 assert( pTab && pExpr->pTab==pTab );
danielk1977955de522006-02-10 02:27:42 +00001684 if( pS ){
1685 /* The "table" is actually a sub-select or a view in the FROM clause
1686 ** of the SELECT statement. Return the declaration type and origin
1687 ** data for the result-set column of the sub-select.
1688 */
drhf35f2f92017-07-29 16:01:55 +00001689 if( iCol>=0 && iCol<pS->pEList->nExpr ){
danielk1977955de522006-02-10 02:27:42 +00001690 /* If iCol is less than zero, then the expression requests the
1691 ** rowid of the sub-select or view. This expression is legal (see
1692 ** test case misc2.2.2) - it always evaluates to NULL.
1693 */
1694 NameContext sNC;
1695 Expr *p = pS->pEList->a[iCol].pExpr;
1696 sNC.pSrcList = pS->pSrc;
dan43bc88b2009-09-10 10:15:59 +00001697 sNC.pNext = pNC;
danielk1977955de522006-02-10 02:27:42 +00001698 sNC.pParse = pNC->pParse;
drhcafc2f72017-10-03 03:01:09 +00001699 zType = columnType(&sNC, p,&zOrigDb,&zOrigTab,&zOrigCol);
danielk1977955de522006-02-10 02:27:42 +00001700 }
drha78d7572017-10-03 16:57:33 +00001701 }else{
1702 /* A real table or a CTE table */
danielk1977955de522006-02-10 02:27:42 +00001703 assert( !pS );
drh5f3e5e72013-10-08 20:01:35 +00001704#ifdef SQLITE_ENABLE_COLUMN_METADATA
drha78d7572017-10-03 16:57:33 +00001705 if( iCol<0 ) iCol = pTab->iPKey;
1706 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
danielk1977955de522006-02-10 02:27:42 +00001707 if( iCol<0 ){
1708 zType = "INTEGER";
drh5f3e5e72013-10-08 20:01:35 +00001709 zOrigCol = "rowid";
danielk1977955de522006-02-10 02:27:42 +00001710 }else{
drh5f3e5e72013-10-08 20:01:35 +00001711 zOrigCol = pTab->aCol[iCol].zName;
drhd7564862016-03-22 20:05:09 +00001712 zType = sqlite3ColumnType(&pTab->aCol[iCol],0);
danielk1977955de522006-02-10 02:27:42 +00001713 }
drh5f3e5e72013-10-08 20:01:35 +00001714 zOrigTab = pTab->zName;
drha78d7572017-10-03 16:57:33 +00001715 if( pNC->pParse && pTab->pSchema ){
danielk1977955de522006-02-10 02:27:42 +00001716 int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema);
drhe59be012016-08-18 20:56:39 +00001717 zOrigDb = pNC->pParse->db->aDb[iDb].zDbSName;
danielk1977955de522006-02-10 02:27:42 +00001718 }
drh5f3e5e72013-10-08 20:01:35 +00001719#else
drha78d7572017-10-03 16:57:33 +00001720 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
drh5f3e5e72013-10-08 20:01:35 +00001721 if( iCol<0 ){
1722 zType = "INTEGER";
1723 }else{
drhd7564862016-03-22 20:05:09 +00001724 zType = sqlite3ColumnType(&pTab->aCol[iCol],0);
drh5f3e5e72013-10-08 20:01:35 +00001725 }
1726#endif
danielk197700e279d2004-06-21 07:36:32 +00001727 }
1728 break;
danielk1977517eb642004-06-07 10:00:31 +00001729 }
danielk197793758c82005-01-21 08:13:14 +00001730#ifndef SQLITE_OMIT_SUBQUERY
danielk197700e279d2004-06-21 07:36:32 +00001731 case TK_SELECT: {
danielk1977955de522006-02-10 02:27:42 +00001732 /* The expression is a sub-select. Return the declaration type and
1733 ** origin info for the single column in the result set of the SELECT
1734 ** statement.
1735 */
danielk1977b3bce662005-01-29 08:32:43 +00001736 NameContext sNC;
danielk19776ab3a2e2009-02-19 14:39:25 +00001737 Select *pS = pExpr->x.pSelect;
danielk1977955de522006-02-10 02:27:42 +00001738 Expr *p = pS->pEList->a[0].pExpr;
drh3b3c86a2018-09-18 21:35:31 +00001739 assert( pExpr->eX==EX_Select );
danielk1977955de522006-02-10 02:27:42 +00001740 sNC.pSrcList = pS->pSrc;
danielk1977b3bce662005-01-29 08:32:43 +00001741 sNC.pNext = pNC;
danielk1977955de522006-02-10 02:27:42 +00001742 sNC.pParse = pNC->pParse;
drhcafc2f72017-10-03 03:01:09 +00001743 zType = columnType(&sNC, p, &zOrigDb, &zOrigTab, &zOrigCol);
danielk197700e279d2004-06-21 07:36:32 +00001744 break;
danielk1977517eb642004-06-07 10:00:31 +00001745 }
danielk197793758c82005-01-21 08:13:14 +00001746#endif
danielk1977517eb642004-06-07 10:00:31 +00001747 }
drh5f3e5e72013-10-08 20:01:35 +00001748
1749#ifdef SQLITE_ENABLE_COLUMN_METADATA
1750 if( pzOrigDb ){
1751 assert( pzOrigTab && pzOrigCol );
1752 *pzOrigDb = zOrigDb;
1753 *pzOrigTab = zOrigTab;
1754 *pzOrigCol = zOrigCol;
danielk1977955de522006-02-10 02:27:42 +00001755 }
drh5f3e5e72013-10-08 20:01:35 +00001756#endif
danielk1977517eb642004-06-07 10:00:31 +00001757 return zType;
1758}
1759
1760/*
1761** Generate code that will tell the VDBE the declaration types of columns
1762** in the result set.
drhfcb78a42003-01-18 20:11:05 +00001763*/
1764static void generateColumnTypes(
1765 Parse *pParse, /* Parser context */
drhfcb78a42003-01-18 20:11:05 +00001766 SrcList *pTabList, /* List of tables */
1767 ExprList *pEList /* Expressions defining the result set */
1768){
drh3f913572008-03-22 01:07:17 +00001769#ifndef SQLITE_OMIT_DECLTYPE
drhfcb78a42003-01-18 20:11:05 +00001770 Vdbe *v = pParse->pVdbe;
danielk1977517eb642004-06-07 10:00:31 +00001771 int i;
danielk1977b3bce662005-01-29 08:32:43 +00001772 NameContext sNC;
1773 sNC.pSrcList = pTabList;
danielk1977955de522006-02-10 02:27:42 +00001774 sNC.pParse = pParse;
drheac5fc02017-04-11 01:01:27 +00001775 sNC.pNext = 0;
drhfcb78a42003-01-18 20:11:05 +00001776 for(i=0; i<pEList->nExpr; i++){
1777 Expr *p = pEList->a[i].pExpr;
drh3f913572008-03-22 01:07:17 +00001778 const char *zType;
1779#ifdef SQLITE_ENABLE_COLUMN_METADATA
danielk1977955de522006-02-10 02:27:42 +00001780 const char *zOrigDb = 0;
1781 const char *zOrigTab = 0;
1782 const char *zOrigCol = 0;
drhcafc2f72017-10-03 03:01:09 +00001783 zType = columnType(&sNC, p, &zOrigDb, &zOrigTab, &zOrigCol);
danielk1977955de522006-02-10 02:27:42 +00001784
drh85b623f2007-12-13 21:54:09 +00001785 /* The vdbe must make its own copy of the column-type and other
danielk19774b1ae992006-02-10 03:06:10 +00001786 ** column specific strings, in case the schema is reset before this
1787 ** virtual machine is deleted.
danielk1977fbcd5852004-06-15 02:44:18 +00001788 */
danielk197710fb7492008-10-31 10:53:22 +00001789 sqlite3VdbeSetColName(v, i, COLNAME_DATABASE, zOrigDb, SQLITE_TRANSIENT);
1790 sqlite3VdbeSetColName(v, i, COLNAME_TABLE, zOrigTab, SQLITE_TRANSIENT);
1791 sqlite3VdbeSetColName(v, i, COLNAME_COLUMN, zOrigCol, SQLITE_TRANSIENT);
drh3f913572008-03-22 01:07:17 +00001792#else
drhcafc2f72017-10-03 03:01:09 +00001793 zType = columnType(&sNC, p, 0, 0, 0);
drh3f913572008-03-22 01:07:17 +00001794#endif
danielk197710fb7492008-10-31 10:53:22 +00001795 sqlite3VdbeSetColName(v, i, COLNAME_DECLTYPE, zType, SQLITE_TRANSIENT);
drhfcb78a42003-01-18 20:11:05 +00001796 }
drh5f3e5e72013-10-08 20:01:35 +00001797#endif /* !defined(SQLITE_OMIT_DECLTYPE) */
drhfcb78a42003-01-18 20:11:05 +00001798}
1799
drheac5fc02017-04-11 01:01:27 +00001800
1801/*
drhec360a82017-07-12 14:10:19 +00001802** Compute the column names for a SELECT statement.
1803**
1804** The only guarantee that SQLite makes about column names is that if the
1805** column has an AS clause assigning it a name, that will be the name used.
1806** That is the only documented guarantee. However, countless applications
1807** developed over the years have made baseless assumptions about column names
1808** and will break if those assumptions changes. Hence, use extreme caution
1809** when modifying this routine to avoid breaking legacy.
1810**
1811** See Also: sqlite3ColumnsFromExprList()
1812**
1813** The PRAGMA short_column_names and PRAGMA full_column_names settings are
1814** deprecated. The default setting is short=ON, full=OFF. 99.9% of all
1815** applications should operate this way. Nevertheless, we need to support the
1816** other modes for legacy:
1817**
1818** short=OFF, full=OFF: Column name is the text of the expression has it
1819** originally appears in the SELECT statement. In
1820** other words, the zSpan of the result expression.
1821**
1822** short=ON, full=OFF: (This is the default setting). If the result
drh3d240d22017-09-28 16:56:55 +00001823** refers directly to a table column, then the
1824** result column name is just the table column
1825** name: COLUMN. Otherwise use zSpan.
drhec360a82017-07-12 14:10:19 +00001826**
1827** full=ON, short=ANY: If the result refers directly to a table column,
1828** then the result column name with the table name
1829** prefix, ex: TABLE.COLUMN. Otherwise use zSpan.
drh82c3d632000-06-06 21:56:07 +00001830*/
drh832508b2002-03-02 17:04:07 +00001831static void generateColumnNames(
1832 Parse *pParse, /* Parser context */
drhf35f2f92017-07-29 16:01:55 +00001833 Select *pSelect /* Generate column names for this SELECT statement */
drh832508b2002-03-02 17:04:07 +00001834){
drhd8bc7082000-06-07 23:51:50 +00001835 Vdbe *v = pParse->pVdbe;
drheac5fc02017-04-11 01:01:27 +00001836 int i;
1837 Table *pTab;
drhf35f2f92017-07-29 16:01:55 +00001838 SrcList *pTabList;
1839 ExprList *pEList;
drh9bb575f2004-09-06 17:24:11 +00001840 sqlite3 *db = pParse->db;
drhf35f2f92017-07-29 16:01:55 +00001841 int fullName; /* TABLE.COLUMN if no AS clause and is a direct table ref */
1842 int srcName; /* COLUMN or TABLE.COLUMN if no AS clause and is direct */
drhfcabd462004-02-20 14:50:58 +00001843
drhfe2093d2005-01-20 22:48:47 +00001844#ifndef SQLITE_OMIT_EXPLAIN
danielk19773cf86062004-05-26 10:11:05 +00001845 /* If this is an EXPLAIN, skip this step */
1846 if( pParse->explain ){
danielk197761de0d12004-05-27 23:56:16 +00001847 return;
danielk19773cf86062004-05-26 10:11:05 +00001848 }
danielk19775338a5f2005-01-20 13:03:10 +00001849#endif
danielk19773cf86062004-05-26 10:11:05 +00001850
drh5e8b9852018-05-03 22:52:56 +00001851 if( pParse->colNamesSet ) return;
drhf35f2f92017-07-29 16:01:55 +00001852 /* Column names are determined by the left-most term of a compound select */
1853 while( pSelect->pPrior ) pSelect = pSelect->pPrior;
drh07859482017-12-23 11:51:40 +00001854 SELECTTRACE(1,pParse,pSelect,("generating column names\n"));
drhf35f2f92017-07-29 16:01:55 +00001855 pTabList = pSelect->pSrc;
1856 pEList = pSelect->pEList;
drh98029472015-12-03 21:47:30 +00001857 assert( v!=0 );
drhf7ce4292015-12-02 19:46:12 +00001858 assert( pTabList!=0 );
drhd8bc7082000-06-07 23:51:50 +00001859 pParse->colNamesSet = 1;
drhec360a82017-07-12 14:10:19 +00001860 fullName = (db->flags & SQLITE_FullColNames)!=0;
1861 srcName = (db->flags & SQLITE_ShortColNames)!=0 || fullName;
danielk197722322fd2004-05-25 23:35:17 +00001862 sqlite3VdbeSetNumCols(v, pEList->nExpr);
drh82c3d632000-06-06 21:56:07 +00001863 for(i=0; i<pEList->nExpr; i++){
drhec360a82017-07-12 14:10:19 +00001864 Expr *p = pEList->a[i].pExpr;
1865
1866 assert( p!=0 );
drh4dd89d52017-08-14 14:53:24 +00001867 assert( p->op!=TK_AGG_COLUMN ); /* Agg processing has not run yet */
drh3d240d22017-09-28 16:56:55 +00001868 assert( p->op!=TK_COLUMN || p->pTab!=0 ); /* Covering idx not yet coded */
drh82c3d632000-06-06 21:56:07 +00001869 if( pEList->a[i].zName ){
drhec360a82017-07-12 14:10:19 +00001870 /* An AS clause always takes first priority */
drh82c3d632000-06-06 21:56:07 +00001871 char *zName = pEList->a[i].zName;
danielk197710fb7492008-10-31 10:53:22 +00001872 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_TRANSIENT);
drhf35f2f92017-07-29 16:01:55 +00001873 }else if( srcName && p->op==TK_COLUMN ){
drh97665872002-02-13 23:22:53 +00001874 char *zCol;
drh8aff1012001-12-22 14:49:24 +00001875 int iCol = p->iColumn;
drhf35f2f92017-07-29 16:01:55 +00001876 pTab = p->pTab;
1877 assert( pTab!=0 );
drh8aff1012001-12-22 14:49:24 +00001878 if( iCol<0 ) iCol = pTab->iPKey;
drh97665872002-02-13 23:22:53 +00001879 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
drhb1363202002-06-26 02:45:03 +00001880 if( iCol<0 ){
drh47a6db22005-01-18 16:02:40 +00001881 zCol = "rowid";
drhb1363202002-06-26 02:45:03 +00001882 }else{
1883 zCol = pTab->aCol[iCol].zName;
drhb1363202002-06-26 02:45:03 +00001884 }
drhec360a82017-07-12 14:10:19 +00001885 if( fullName ){
drh82c3d632000-06-06 21:56:07 +00001886 char *zName = 0;
drh1c767f02009-01-09 02:49:31 +00001887 zName = sqlite3MPrintf(db, "%s.%s", pTab->zName, zCol);
danielk197710fb7492008-10-31 10:53:22 +00001888 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_DYNAMIC);
drh82c3d632000-06-06 21:56:07 +00001889 }else{
danielk197710fb7492008-10-31 10:53:22 +00001890 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zCol, SQLITE_TRANSIENT);
drh82c3d632000-06-06 21:56:07 +00001891 }
drh1bee3d72001-10-15 00:44:35 +00001892 }else{
drh859bc542014-01-13 20:32:18 +00001893 const char *z = pEList->a[i].zSpan;
1894 z = z==0 ? sqlite3MPrintf(db, "column%d", i+1) : sqlite3DbStrDup(db, z);
1895 sqlite3VdbeSetColName(v, i, COLNAME_NAME, z, SQLITE_DYNAMIC);
drh82c3d632000-06-06 21:56:07 +00001896 }
1897 }
danielk197776d505b2004-05-28 13:13:02 +00001898 generateColumnTypes(pParse, pTabList, pEList);
drh82c3d632000-06-06 21:56:07 +00001899}
1900
drhd8bc7082000-06-07 23:51:50 +00001901/*
peter.d.reid60ec9142014-09-06 16:39:46 +00001902** Given an expression list (which is really the list of expressions
drh7d10d5a2008-08-20 16:35:10 +00001903** that form the result set of a SELECT statement) compute appropriate
1904** column names for a table that would hold the expression list.
1905**
1906** All column names will be unique.
1907**
1908** Only the column names are computed. Column.zType, Column.zColl,
1909** and other fields of Column are zeroed.
1910**
1911** Return SQLITE_OK on success. If a memory allocation error occurs,
1912** store NULL in *paCol and 0 in *pnCol and return SQLITE_NOMEM.
drhec360a82017-07-12 14:10:19 +00001913**
1914** The only guarantee that SQLite makes about column names is that if the
1915** column has an AS clause assigning it a name, that will be the name used.
1916** That is the only documented guarantee. However, countless applications
1917** developed over the years have made baseless assumptions about column names
1918** and will break if those assumptions changes. Hence, use extreme caution
1919** when modifying this routine to avoid breaking legacy.
1920**
1921** See Also: generateColumnNames()
drh315555c2002-10-20 15:53:03 +00001922*/
drh8981b902015-08-24 17:42:49 +00001923int sqlite3ColumnsFromExprList(
drh7d10d5a2008-08-20 16:35:10 +00001924 Parse *pParse, /* Parsing context */
1925 ExprList *pEList, /* Expr list from which to derive column names */
drhd815f172012-09-13 14:42:43 +00001926 i16 *pnCol, /* Write the number of columns here */
drh7d10d5a2008-08-20 16:35:10 +00001927 Column **paCol /* Write the new column list here */
1928){
drhdc5ea5c2008-12-10 17:19:59 +00001929 sqlite3 *db = pParse->db; /* Database connection */
1930 int i, j; /* Loop counters */
drhebed3fa2015-11-14 16:47:23 +00001931 u32 cnt; /* Index added to make the name unique */
drhdc5ea5c2008-12-10 17:19:59 +00001932 Column *aCol, *pCol; /* For looping over result columns */
1933 int nCol; /* Number of columns in the result set */
drhdc5ea5c2008-12-10 17:19:59 +00001934 char *zName; /* Column name */
1935 int nName; /* Size of name in zName[] */
drh0315e3c2015-11-14 20:52:43 +00001936 Hash ht; /* Hash table of column names */
drh22f70c32002-02-18 01:17:00 +00001937
drh0315e3c2015-11-14 20:52:43 +00001938 sqlite3HashInit(&ht);
dan8c2e0f02012-03-31 15:08:56 +00001939 if( pEList ){
1940 nCol = pEList->nExpr;
1941 aCol = sqlite3DbMallocZero(db, sizeof(aCol[0])*nCol);
1942 testcase( aCol==0 );
drh6fe37332017-10-21 14:17:31 +00001943 if( nCol>32767 ) nCol = 32767;
dan8c2e0f02012-03-31 15:08:56 +00001944 }else{
1945 nCol = 0;
1946 aCol = 0;
1947 }
dan8836cbb2015-11-21 19:43:29 +00001948 assert( nCol==(i16)nCol );
dan8c2e0f02012-03-31 15:08:56 +00001949 *pnCol = nCol;
1950 *paCol = aCol;
1951
drh0315e3c2015-11-14 20:52:43 +00001952 for(i=0, pCol=aCol; i<nCol && !db->mallocFailed; i++, pCol++){
drh79d5f632005-01-18 17:20:10 +00001953 /* Get an appropriate name for the column
1954 */
drh91bb0ee2004-09-01 03:06:34 +00001955 if( (zName = pEList->a[i].zName)!=0 ){
drh79d5f632005-01-18 17:20:10 +00001956 /* If the column contains an "AS <name>" phrase, use <name> as the name */
drh93a960a2008-07-10 00:32:42 +00001957 }else{
drhec360a82017-07-12 14:10:19 +00001958 Expr *pColExpr = sqlite3ExprSkipCollate(pEList->a[i].pExpr);
drhb07028f2011-10-14 21:49:18 +00001959 while( pColExpr->op==TK_DOT ){
drh3d6bedf2018-09-19 14:54:38 +00001960 assert( pColExpr->eX==EX_Right );
1961 pColExpr = pColExpr->x.pRight;
drhb07028f2011-10-14 21:49:18 +00001962 assert( pColExpr!=0 );
1963 }
drh755b0fd2017-12-23 12:33:40 +00001964 assert( pColExpr->op!=TK_AGG_COLUMN );
1965 if( pColExpr->op==TK_COLUMN ){
drh7d10d5a2008-08-20 16:35:10 +00001966 /* For columns use the column name name */
drhdc5ea5c2008-12-10 17:19:59 +00001967 int iCol = pColExpr->iColumn;
drhec360a82017-07-12 14:10:19 +00001968 Table *pTab = pColExpr->pTab;
drh755b0fd2017-12-23 12:33:40 +00001969 assert( pTab!=0 );
drhf0209f72008-08-21 14:54:28 +00001970 if( iCol<0 ) iCol = pTab->iPKey;
drh96ceaf82015-11-14 22:04:22 +00001971 zName = iCol>=0 ? pTab->aCol[iCol].zName : "rowid";
drhb7916a72009-05-27 10:31:29 +00001972 }else if( pColExpr->op==TK_ID ){
drh33e619f2009-05-28 01:00:55 +00001973 assert( !ExprHasProperty(pColExpr, EP_IntValue) );
drh96ceaf82015-11-14 22:04:22 +00001974 zName = pColExpr->u.zToken;
drh7d10d5a2008-08-20 16:35:10 +00001975 }else{
1976 /* Use the original text of the column expression as its name */
drh96ceaf82015-11-14 22:04:22 +00001977 zName = pEList->a[i].zSpan;
drh7d10d5a2008-08-20 16:35:10 +00001978 }
drh22f70c32002-02-18 01:17:00 +00001979 }
drhd7ca6002017-07-09 00:30:58 +00001980 if( zName ){
1981 zName = sqlite3DbStrDup(db, zName);
1982 }else{
drh155507b2017-07-09 18:55:29 +00001983 zName = sqlite3MPrintf(db,"column%d",i+1);
drhd7ca6002017-07-09 00:30:58 +00001984 }
drh79d5f632005-01-18 17:20:10 +00001985
1986 /* Make sure the column name is unique. If the name is not unique,
peter.d.reid60ec9142014-09-06 16:39:46 +00001987 ** append an integer to the name so that it becomes unique.
drh79d5f632005-01-18 17:20:10 +00001988 */
drh0315e3c2015-11-14 20:52:43 +00001989 cnt = 0;
1990 while( zName && sqlite3HashFind(&ht, zName)!=0 ){
drh0315e3c2015-11-14 20:52:43 +00001991 nName = sqlite3Strlen30(zName);
drhf7ee8962015-11-15 11:13:49 +00001992 if( nName>0 ){
1993 for(j=nName-1; j>0 && sqlite3Isdigit(zName[j]); j--){}
1994 if( zName[j]==':' ) nName = j;
1995 }
drh96ceaf82015-11-14 22:04:22 +00001996 zName = sqlite3MPrintf(db, "%.*z:%u", nName, zName, ++cnt);
drh0315e3c2015-11-14 20:52:43 +00001997 if( cnt>3 ) sqlite3_randomness(sizeof(cnt), &cnt);
drh79d5f632005-01-18 17:20:10 +00001998 }
drh91bb0ee2004-09-01 03:06:34 +00001999 pCol->zName = zName;
danba68f8f2015-11-19 16:46:46 +00002000 sqlite3ColumnPropertiesFromName(0, pCol);
drh03d69a62015-11-19 13:53:57 +00002001 if( zName && sqlite3HashInsert(&ht, zName, pCol)==pCol ){
drh4a642b62016-02-05 01:55:27 +00002002 sqlite3OomFault(db);
drh0315e3c2015-11-14 20:52:43 +00002003 }
drh7d10d5a2008-08-20 16:35:10 +00002004 }
drh0315e3c2015-11-14 20:52:43 +00002005 sqlite3HashClear(&ht);
drh7d10d5a2008-08-20 16:35:10 +00002006 if( db->mallocFailed ){
drh7d10d5a2008-08-20 16:35:10 +00002007 for(j=0; j<i; j++){
2008 sqlite3DbFree(db, aCol[j].zName);
2009 }
2010 sqlite3DbFree(db, aCol);
2011 *paCol = 0;
2012 *pnCol = 0;
mistachkinfad30392016-02-13 23:43:46 +00002013 return SQLITE_NOMEM_BKPT;
drh7d10d5a2008-08-20 16:35:10 +00002014 }
2015 return SQLITE_OK;
2016}
danielk1977517eb642004-06-07 10:00:31 +00002017
drh7d10d5a2008-08-20 16:35:10 +00002018/*
2019** Add type and collation information to a column list based on
2020** a SELECT statement.
2021**
2022** The column list presumably came from selectColumnNamesFromExprList().
2023** The column list has only names, not types or collations. This
2024** routine goes through and adds the types and collations.
2025**
shaneb08a67a2009-03-31 03:41:56 +00002026** This routine requires that all identifiers in the SELECT
drh7d10d5a2008-08-20 16:35:10 +00002027** statement be resolved.
2028*/
drhed06a132016-04-05 20:59:12 +00002029void sqlite3SelectAddColumnTypeAndCollation(
drh7d10d5a2008-08-20 16:35:10 +00002030 Parse *pParse, /* Parsing contexts */
drh186ad8c2013-10-08 18:40:37 +00002031 Table *pTab, /* Add column type information to this table */
drh7d10d5a2008-08-20 16:35:10 +00002032 Select *pSelect /* SELECT used to determine types and collations */
2033){
2034 sqlite3 *db = pParse->db;
2035 NameContext sNC;
2036 Column *pCol;
2037 CollSeq *pColl;
2038 int i;
2039 Expr *p;
2040 struct ExprList_item *a;
2041
2042 assert( pSelect!=0 );
2043 assert( (pSelect->selFlags & SF_Resolved)!=0 );
drh186ad8c2013-10-08 18:40:37 +00002044 assert( pTab->nCol==pSelect->pEList->nExpr || db->mallocFailed );
drh7d10d5a2008-08-20 16:35:10 +00002045 if( db->mallocFailed ) return;
2046 memset(&sNC, 0, sizeof(sNC));
2047 sNC.pSrcList = pSelect->pSrc;
2048 a = pSelect->pEList->a;
drh186ad8c2013-10-08 18:40:37 +00002049 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
drhed06a132016-04-05 20:59:12 +00002050 const char *zType;
2051 int n, m;
drh7d10d5a2008-08-20 16:35:10 +00002052 p = a[i].pExpr;
drhcafc2f72017-10-03 03:01:09 +00002053 zType = columnType(&sNC, p, 0, 0, 0);
2054 /* pCol->szEst = ... // Column size est for SELECT tables never used */
danielk1977c60e9b82005-01-31 12:42:29 +00002055 pCol->affinity = sqlite3ExprAffinity(p);
drh0c4db032017-10-03 19:53:12 +00002056 if( zType ){
2057 m = sqlite3Strlen30(zType);
drhed06a132016-04-05 20:59:12 +00002058 n = sqlite3Strlen30(pCol->zName);
2059 pCol->zName = sqlite3DbReallocOrFree(db, pCol->zName, n+m+2);
2060 if( pCol->zName ){
2061 memcpy(&pCol->zName[n+1], zType, m+1);
2062 pCol->colFlags |= COLFLAG_HASTYPE;
2063 }
2064 }
drh05883a32015-06-02 15:32:08 +00002065 if( pCol->affinity==0 ) pCol->affinity = SQLITE_AFF_BLOB;
danielk1977b3bf5562006-01-10 17:58:23 +00002066 pColl = sqlite3ExprCollSeq(pParse, p);
drh1cb50c82015-04-21 17:17:47 +00002067 if( pColl && pCol->zColl==0 ){
drh17435752007-08-16 04:30:38 +00002068 pCol->zColl = sqlite3DbStrDup(db, pColl->zName);
danielk19770202b292004-06-09 09:55:16 +00002069 }
drh22f70c32002-02-18 01:17:00 +00002070 }
drhcafc2f72017-10-03 03:01:09 +00002071 pTab->szTabRow = 1; /* Any non-zero value works */
drh7d10d5a2008-08-20 16:35:10 +00002072}
2073
2074/*
2075** Given a SELECT statement, generate a Table structure that describes
2076** the result set of that SELECT.
2077*/
2078Table *sqlite3ResultSetOfSelect(Parse *pParse, Select *pSelect){
2079 Table *pTab;
2080 sqlite3 *db = pParse->db;
2081 int savedFlags;
2082
2083 savedFlags = db->flags;
2084 db->flags &= ~SQLITE_FullColNames;
2085 db->flags |= SQLITE_ShortColNames;
2086 sqlite3SelectPrep(pParse, pSelect, 0);
2087 if( pParse->nErr ) return 0;
2088 while( pSelect->pPrior ) pSelect = pSelect->pPrior;
2089 db->flags = savedFlags;
2090 pTab = sqlite3DbMallocZero(db, sizeof(Table) );
2091 if( pTab==0 ){
2092 return 0;
2093 }
drh373cc2d2009-05-17 02:06:14 +00002094 /* The sqlite3ResultSetOfSelect() is only used n contexts where lookaside
drhb2468952010-07-23 17:06:32 +00002095 ** is disabled */
drh4a642b62016-02-05 01:55:27 +00002096 assert( db->lookaside.bDisable );
drh79df7782016-12-14 14:07:35 +00002097 pTab->nTabRef = 1;
drh7d10d5a2008-08-20 16:35:10 +00002098 pTab->zName = 0;
dancfc9df72014-04-25 15:01:01 +00002099 pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
drh8981b902015-08-24 17:42:49 +00002100 sqlite3ColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
drhed06a132016-04-05 20:59:12 +00002101 sqlite3SelectAddColumnTypeAndCollation(pParse, pTab, pSelect);
drh22f70c32002-02-18 01:17:00 +00002102 pTab->iPKey = -1;
drh7ce72f62008-07-24 15:50:41 +00002103 if( db->mallocFailed ){
dan1feeaed2010-07-23 15:41:47 +00002104 sqlite3DeleteTable(db, pTab);
drh7ce72f62008-07-24 15:50:41 +00002105 return 0;
2106 }
drh22f70c32002-02-18 01:17:00 +00002107 return pTab;
2108}
2109
2110/*
drhd8bc7082000-06-07 23:51:50 +00002111** Get a VDBE for the given parser context. Create a new one if necessary.
2112** If an error occurs, return NULL and leave a message in pParse.
2113*/
drh55965612017-09-16 20:58:41 +00002114Vdbe *sqlite3GetVdbe(Parse *pParse){
2115 if( pParse->pVdbe ){
2116 return pParse->pVdbe;
2117 }
drh6f077342016-04-12 00:26:59 +00002118 if( pParse->pToplevel==0
2119 && OptimizationEnabled(pParse->db,SQLITE_FactorOutConst)
2120 ){
2121 pParse->okConstFactor = 1;
drhd8bc7082000-06-07 23:51:50 +00002122 }
drh55965612017-09-16 20:58:41 +00002123 return sqlite3VdbeCreate(pParse);
drh6f077342016-04-12 00:26:59 +00002124}
drhfcb78a42003-01-18 20:11:05 +00002125
drh15007a92006-01-08 18:10:17 +00002126
drhd8bc7082000-06-07 23:51:50 +00002127/*
drh7b58dae2003-07-20 01:16:46 +00002128** Compute the iLimit and iOffset fields of the SELECT based on the
drh3d6bedf2018-09-19 14:54:38 +00002129** pLimit expressions. pLimit->pLeft and pLimit->x,pRight hold the expressions
drh7b58dae2003-07-20 01:16:46 +00002130** that appear in the original SQL statement after the LIMIT and OFFSET
danielk1977a2dc3b12005-02-05 12:48:48 +00002131** keywords. Or NULL if those keywords are omitted. iLimit and iOffset
2132** are the integer memory register numbers for counters used to compute
2133** the limit and offset. If there is no limit and/or offset, then
2134** iLimit and iOffset are negative.
drh7b58dae2003-07-20 01:16:46 +00002135**
drhd59ba6c2006-01-08 05:02:54 +00002136** This routine changes the values of iLimit and iOffset only if
drh3d6bedf2018-09-19 14:54:38 +00002137** a limit or offset is defined by pLimit->pLeft and pLimit->x.pRight. iLimit
drh8c0833f2017-11-14 23:48:23 +00002138** and iOffset should have been preset to appropriate default values (zero)
drhaa9ce702014-01-22 18:07:04 +00002139** prior to calling this routine.
2140**
2141** The iOffset register (if it exists) is initialized to the value
2142** of the OFFSET. The iLimit register is initialized to LIMIT. Register
2143** iOffset+1 is initialized to LIMIT+OFFSET.
2144**
drh8c0833f2017-11-14 23:48:23 +00002145** Only if pLimit->pLeft!=0 do the limit registers get
drh7b58dae2003-07-20 01:16:46 +00002146** redefined. The UNION ALL operator uses this property to force
2147** the reuse of the same limit and offset registers across multiple
2148** SELECT statements.
2149*/
drhec7429a2005-10-06 16:53:14 +00002150static void computeLimitRegisters(Parse *pParse, Select *p, int iBreak){
drh02afc862006-01-20 18:10:57 +00002151 Vdbe *v = 0;
2152 int iLimit = 0;
drh15007a92006-01-08 18:10:17 +00002153 int iOffset;
drh8b0cf382015-10-06 21:07:06 +00002154 int n;
drh8c0833f2017-11-14 23:48:23 +00002155 Expr *pLimit = p->pLimit;
2156
drh0acb7e42008-06-25 00:12:41 +00002157 if( p->iLimit ) return;
drh15007a92006-01-08 18:10:17 +00002158
drh7b58dae2003-07-20 01:16:46 +00002159 /*
drh7b58dae2003-07-20 01:16:46 +00002160 ** "LIMIT -1" always shows all rows. There is some
drhf7b54962013-05-28 12:11:54 +00002161 ** controversy about what the correct behavior should be.
drh7b58dae2003-07-20 01:16:46 +00002162 ** The current implementation interprets "LIMIT 0" to mean
2163 ** no rows.
2164 */
drh8c0833f2017-11-14 23:48:23 +00002165 if( pLimit ){
2166 assert( pLimit->op==TK_LIMIT );
2167 assert( pLimit->pLeft!=0 );
drh0a07c102008-01-03 18:03:08 +00002168 p->iLimit = iLimit = ++pParse->nMem;
drh15007a92006-01-08 18:10:17 +00002169 v = sqlite3GetVdbe(pParse);
drhaa9ce702014-01-22 18:07:04 +00002170 assert( v!=0 );
drh8c0833f2017-11-14 23:48:23 +00002171 if( sqlite3ExprIsInteger(pLimit->pLeft, &n) ){
drh456e4e42009-11-20 16:13:15 +00002172 sqlite3VdbeAddOp2(v, OP_Integer, n, iLimit);
2173 VdbeComment((v, "LIMIT counter"));
drh9b918ed2009-11-12 03:13:26 +00002174 if( n==0 ){
drh076e85f2015-09-03 13:46:12 +00002175 sqlite3VdbeGoto(v, iBreak);
drhc3489bb2016-02-25 16:04:59 +00002176 }else if( n>=0 && p->nSelectRow>sqlite3LogEst((u64)n) ){
2177 p->nSelectRow = sqlite3LogEst((u64)n);
2178 p->selFlags |= SF_FixedLimit;
drh9b918ed2009-11-12 03:13:26 +00002179 }
2180 }else{
drh8c0833f2017-11-14 23:48:23 +00002181 sqlite3ExprCode(pParse, pLimit->pLeft, iLimit);
drh688852a2014-02-17 22:40:43 +00002182 sqlite3VdbeAddOp1(v, OP_MustBeInt, iLimit); VdbeCoverage(v);
drh9b918ed2009-11-12 03:13:26 +00002183 VdbeComment((v, "LIMIT counter"));
drh16897072015-03-07 00:57:37 +00002184 sqlite3VdbeAddOp2(v, OP_IfNot, iLimit, iBreak); VdbeCoverage(v);
drh9b918ed2009-11-12 03:13:26 +00002185 }
drh3d6bedf2018-09-19 14:54:38 +00002186 if( pLimit->eX==EX_Right ){
drh373cc2d2009-05-17 02:06:14 +00002187 p->iOffset = iOffset = ++pParse->nMem;
drhb7654112008-01-12 12:48:07 +00002188 pParse->nMem++; /* Allocate an extra register for limit+offset */
drh3d6bedf2018-09-19 14:54:38 +00002189 sqlite3ExprCode(pParse, pLimit->x.pRight, iOffset);
drh688852a2014-02-17 22:40:43 +00002190 sqlite3VdbeAddOp1(v, OP_MustBeInt, iOffset); VdbeCoverage(v);
drh373cc2d2009-05-17 02:06:14 +00002191 VdbeComment((v, "OFFSET counter"));
drhcc2fa4c2016-01-25 15:57:29 +00002192 sqlite3VdbeAddOp3(v, OP_OffsetLimit, iLimit, iOffset+1, iOffset);
drhb7654112008-01-12 12:48:07 +00002193 VdbeComment((v, "LIMIT+OFFSET"));
drhd59ba6c2006-01-08 05:02:54 +00002194 }
drh7b58dae2003-07-20 01:16:46 +00002195 }
2196}
2197
drhb7f91642004-10-31 02:22:47 +00002198#ifndef SQLITE_OMIT_COMPOUND_SELECT
drhfbc4ee72004-08-29 01:31:05 +00002199/*
drhfbc4ee72004-08-29 01:31:05 +00002200** Return the appropriate collating sequence for the iCol-th column of
2201** the result set for the compound-select statement "p". Return NULL if
2202** the column has no default collating sequence.
2203**
2204** The collating sequence for the compound select is taken from the
2205** left-most term of the select that has a collating sequence.
2206*/
danielk1977dc1bdc42004-06-11 10:51:27 +00002207static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){
drhfbc4ee72004-08-29 01:31:05 +00002208 CollSeq *pRet;
danielk1977dc1bdc42004-06-11 10:51:27 +00002209 if( p->pPrior ){
2210 pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
drhfbc4ee72004-08-29 01:31:05 +00002211 }else{
2212 pRet = 0;
danielk1977dc1bdc42004-06-11 10:51:27 +00002213 }
drh10c081a2009-04-16 00:24:23 +00002214 assert( iCol>=0 );
drh2ec18a32015-06-23 23:31:52 +00002215 /* iCol must be less than p->pEList->nExpr. Otherwise an error would
2216 ** have been thrown during name resolution and we would not have gotten
2217 ** this far */
2218 if( pRet==0 && ALWAYS(iCol<p->pEList->nExpr) ){
danielk1977dc1bdc42004-06-11 10:51:27 +00002219 pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
2220 }
2221 return pRet;
drhd3d39e92004-05-20 22:16:29 +00002222}
2223
dan53bed452014-01-24 20:37:18 +00002224/*
2225** The select statement passed as the second parameter is a compound SELECT
2226** with an ORDER BY clause. This function allocates and returns a KeyInfo
2227** structure suitable for implementing the ORDER BY.
2228**
2229** Space to hold the KeyInfo structure is obtained from malloc. The calling
2230** function is responsible for ensuring that this structure is eventually
2231** freed.
2232*/
2233static KeyInfo *multiSelectOrderByKeyInfo(Parse *pParse, Select *p, int nExtra){
2234 ExprList *pOrderBy = p->pOrderBy;
2235 int nOrderBy = p->pOrderBy->nExpr;
2236 sqlite3 *db = pParse->db;
2237 KeyInfo *pRet = sqlite3KeyInfoAlloc(db, nOrderBy+nExtra, 1);
2238 if( pRet ){
2239 int i;
2240 for(i=0; i<nOrderBy; i++){
2241 struct ExprList_item *pItem = &pOrderBy->a[i];
2242 Expr *pTerm = pItem->pExpr;
2243 CollSeq *pColl;
2244
2245 if( pTerm->flags & EP_Collate ){
2246 pColl = sqlite3ExprCollSeq(pParse, pTerm);
2247 }else{
2248 pColl = multiSelectCollSeq(pParse, p, pItem->u.x.iOrderByCol-1);
2249 if( pColl==0 ) pColl = db->pDfltColl;
2250 pOrderBy->a[i].pExpr =
2251 sqlite3ExprAddCollateString(pParse, pTerm, pColl->zName);
2252 }
2253 assert( sqlite3KeyInfoIsWriteable(pRet) );
2254 pRet->aColl[i] = pColl;
2255 pRet->aSortOrder[i] = pOrderBy->a[i].sortOrder;
2256 }
2257 }
2258
2259 return pRet;
2260}
drhd3d39e92004-05-20 22:16:29 +00002261
drh781def22014-01-22 13:35:53 +00002262#ifndef SQLITE_OMIT_CTE
2263/*
2264** This routine generates VDBE code to compute the content of a WITH RECURSIVE
2265** query of the form:
2266**
2267** <recursive-table> AS (<setup-query> UNION [ALL] <recursive-query>)
2268** \___________/ \_______________/
2269** p->pPrior p
2270**
2271**
2272** There is exactly one reference to the recursive-table in the FROM clause
drh8a48b9c2015-08-19 15:20:00 +00002273** of recursive-query, marked with the SrcList->a[].fg.isRecursive flag.
drh781def22014-01-22 13:35:53 +00002274**
2275** The setup-query runs once to generate an initial set of rows that go
2276** into a Queue table. Rows are extracted from the Queue table one by
drhfe1c6bb2014-01-22 17:28:35 +00002277** one. Each row extracted from Queue is output to pDest. Then the single
2278** extracted row (now in the iCurrent table) becomes the content of the
2279** recursive-table for a recursive-query run. The output of the recursive-query
drh781def22014-01-22 13:35:53 +00002280** is added back into the Queue table. Then another row is extracted from Queue
2281** and the iteration continues until the Queue table is empty.
2282**
2283** If the compound query operator is UNION then no duplicate rows are ever
2284** inserted into the Queue table. The iDistinct table keeps a copy of all rows
2285** that have ever been inserted into Queue and causes duplicates to be
2286** discarded. If the operator is UNION ALL, then duplicates are allowed.
2287**
2288** If the query has an ORDER BY, then entries in the Queue table are kept in
2289** ORDER BY order and the first entry is extracted for each cycle. Without
2290** an ORDER BY, the Queue table is just a FIFO.
2291**
2292** If a LIMIT clause is provided, then the iteration stops after LIMIT rows
2293** have been output to pDest. A LIMIT of zero means to output no rows and a
2294** negative LIMIT means to output all rows. If there is also an OFFSET clause
2295** with a positive value, then the first OFFSET outputs are discarded rather
2296** than being sent to pDest. The LIMIT count does not begin until after OFFSET
2297** rows have been skipped.
2298*/
2299static void generateWithRecursiveQuery(
2300 Parse *pParse, /* Parsing context */
2301 Select *p, /* The recursive SELECT to be coded */
2302 SelectDest *pDest /* What to do with query results */
2303){
2304 SrcList *pSrc = p->pSrc; /* The FROM clause of the recursive query */
2305 int nCol = p->pEList->nExpr; /* Number of columns in the recursive table */
2306 Vdbe *v = pParse->pVdbe; /* The prepared statement under construction */
2307 Select *pSetup = p->pPrior; /* The setup query */
2308 int addrTop; /* Top of the loop */
2309 int addrCont, addrBreak; /* CONTINUE and BREAK addresses */
drhedf83d12014-01-22 18:31:27 +00002310 int iCurrent = 0; /* The Current table */
drh781def22014-01-22 13:35:53 +00002311 int regCurrent; /* Register holding Current table */
2312 int iQueue; /* The Queue table */
2313 int iDistinct = 0; /* To ensure unique results if UNION */
drh8e1ee882014-03-21 19:56:09 +00002314 int eDest = SRT_Fifo; /* How to write to Queue */
drh781def22014-01-22 13:35:53 +00002315 SelectDest destQueue; /* SelectDest targetting the Queue table */
2316 int i; /* Loop counter */
2317 int rc; /* Result code */
drhfe1c6bb2014-01-22 17:28:35 +00002318 ExprList *pOrderBy; /* The ORDER BY clause */
drh8c0833f2017-11-14 23:48:23 +00002319 Expr *pLimit; /* Saved LIMIT and OFFSET */
drhaa9ce702014-01-22 18:07:04 +00002320 int regLimit, regOffset; /* Registers used by LIMIT and OFFSET */
drh781def22014-01-22 13:35:53 +00002321
2322 /* Obtain authorization to do a recursive query */
2323 if( sqlite3AuthCheck(pParse, SQLITE_RECURSIVE, 0, 0, 0) ) return;
drh781def22014-01-22 13:35:53 +00002324
drhaa9ce702014-01-22 18:07:04 +00002325 /* Process the LIMIT and OFFSET clauses, if they exist */
2326 addrBreak = sqlite3VdbeMakeLabel(v);
dan69b93832016-12-16 15:05:40 +00002327 p->nSelectRow = 320; /* 4 billion rows */
drhaa9ce702014-01-22 18:07:04 +00002328 computeLimitRegisters(pParse, p, addrBreak);
2329 pLimit = p->pLimit;
drhaa9ce702014-01-22 18:07:04 +00002330 regLimit = p->iLimit;
2331 regOffset = p->iOffset;
drh8c0833f2017-11-14 23:48:23 +00002332 p->pLimit = 0;
drhaa9ce702014-01-22 18:07:04 +00002333 p->iLimit = p->iOffset = 0;
dan53bed452014-01-24 20:37:18 +00002334 pOrderBy = p->pOrderBy;
drh781def22014-01-22 13:35:53 +00002335
2336 /* Locate the cursor number of the Current table */
2337 for(i=0; ALWAYS(i<pSrc->nSrc); i++){
drh8a48b9c2015-08-19 15:20:00 +00002338 if( pSrc->a[i].fg.isRecursive ){
drh781def22014-01-22 13:35:53 +00002339 iCurrent = pSrc->a[i].iCursor;
2340 break;
2341 }
2342 }
2343
drhfe1c6bb2014-01-22 17:28:35 +00002344 /* Allocate cursors numbers for Queue and Distinct. The cursor number for
drh781def22014-01-22 13:35:53 +00002345 ** the Distinct table must be exactly one greater than Queue in order
drh8e1ee882014-03-21 19:56:09 +00002346 ** for the SRT_DistFifo and SRT_DistQueue destinations to work. */
drh781def22014-01-22 13:35:53 +00002347 iQueue = pParse->nTab++;
2348 if( p->op==TK_UNION ){
drh8e1ee882014-03-21 19:56:09 +00002349 eDest = pOrderBy ? SRT_DistQueue : SRT_DistFifo;
drh781def22014-01-22 13:35:53 +00002350 iDistinct = pParse->nTab++;
drhfe1c6bb2014-01-22 17:28:35 +00002351 }else{
drh8e1ee882014-03-21 19:56:09 +00002352 eDest = pOrderBy ? SRT_Queue : SRT_Fifo;
drh781def22014-01-22 13:35:53 +00002353 }
2354 sqlite3SelectDestInit(&destQueue, eDest, iQueue);
2355
2356 /* Allocate cursors for Current, Queue, and Distinct. */
2357 regCurrent = ++pParse->nMem;
2358 sqlite3VdbeAddOp3(v, OP_OpenPseudo, iCurrent, regCurrent, nCol);
drhfe1c6bb2014-01-22 17:28:35 +00002359 if( pOrderBy ){
dan53bed452014-01-24 20:37:18 +00002360 KeyInfo *pKeyInfo = multiSelectOrderByKeyInfo(pParse, p, 1);
drhfe1c6bb2014-01-22 17:28:35 +00002361 sqlite3VdbeAddOp4(v, OP_OpenEphemeral, iQueue, pOrderBy->nExpr+2, 0,
2362 (char*)pKeyInfo, P4_KEYINFO);
2363 destQueue.pOrderBy = pOrderBy;
2364 }else{
2365 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iQueue, nCol);
2366 }
2367 VdbeComment((v, "Queue table"));
drh781def22014-01-22 13:35:53 +00002368 if( iDistinct ){
2369 p->addrOpenEphm[0] = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iDistinct, 0);
2370 p->selFlags |= SF_UsesEphemeral;
2371 }
2372
dan53bed452014-01-24 20:37:18 +00002373 /* Detach the ORDER BY clause from the compound SELECT */
2374 p->pOrderBy = 0;
2375
drh781def22014-01-22 13:35:53 +00002376 /* Store the results of the setup-query in Queue. */
drhd227a292014-02-09 18:02:09 +00002377 pSetup->pNext = 0;
drh84a01de2018-05-02 16:13:48 +00002378 ExplainQueryPlan((pParse, 1, "SETUP"));
drh781def22014-01-22 13:35:53 +00002379 rc = sqlite3Select(pParse, pSetup, &destQueue);
drhd227a292014-02-09 18:02:09 +00002380 pSetup->pNext = p;
drhfe1c6bb2014-01-22 17:28:35 +00002381 if( rc ) goto end_of_recursive_query;
drh781def22014-01-22 13:35:53 +00002382
2383 /* Find the next row in the Queue and output that row */
drh688852a2014-02-17 22:40:43 +00002384 addrTop = sqlite3VdbeAddOp2(v, OP_Rewind, iQueue, addrBreak); VdbeCoverage(v);
drh781def22014-01-22 13:35:53 +00002385
2386 /* Transfer the next row in Queue over to Current */
2387 sqlite3VdbeAddOp1(v, OP_NullRow, iCurrent); /* To reset column cache */
drhfe1c6bb2014-01-22 17:28:35 +00002388 if( pOrderBy ){
2389 sqlite3VdbeAddOp3(v, OP_Column, iQueue, pOrderBy->nExpr+1, regCurrent);
2390 }else{
2391 sqlite3VdbeAddOp2(v, OP_RowData, iQueue, regCurrent);
2392 }
drh781def22014-01-22 13:35:53 +00002393 sqlite3VdbeAddOp1(v, OP_Delete, iQueue);
2394
drhfe1c6bb2014-01-22 17:28:35 +00002395 /* Output the single row in Current */
2396 addrCont = sqlite3VdbeMakeLabel(v);
drhaa9ce702014-01-22 18:07:04 +00002397 codeOffset(v, regOffset, addrCont);
drh2def2f72017-09-15 17:40:34 +00002398 selectInnerLoop(pParse, p, iCurrent,
drh079a3072014-03-19 14:10:55 +00002399 0, 0, pDest, addrCont, addrBreak);
drh688852a2014-02-17 22:40:43 +00002400 if( regLimit ){
drh16897072015-03-07 00:57:37 +00002401 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, regLimit, addrBreak);
drh688852a2014-02-17 22:40:43 +00002402 VdbeCoverage(v);
2403 }
drhfe1c6bb2014-01-22 17:28:35 +00002404 sqlite3VdbeResolveLabel(v, addrCont);
2405
drh781def22014-01-22 13:35:53 +00002406 /* Execute the recursive SELECT taking the single row in Current as
2407 ** the value for the recursive-table. Store the results in the Queue.
2408 */
drhb63ce022015-07-05 22:15:10 +00002409 if( p->selFlags & SF_Aggregate ){
2410 sqlite3ErrorMsg(pParse, "recursive aggregate queries not supported");
2411 }else{
2412 p->pPrior = 0;
drh84a01de2018-05-02 16:13:48 +00002413 ExplainQueryPlan((pParse, 1, "RECURSIVE STEP"));
drhb63ce022015-07-05 22:15:10 +00002414 sqlite3Select(pParse, p, &destQueue);
2415 assert( p->pPrior==0 );
2416 p->pPrior = pSetup;
2417 }
drh781def22014-01-22 13:35:53 +00002418
2419 /* Keep running the loop until the Queue is empty */
drh076e85f2015-09-03 13:46:12 +00002420 sqlite3VdbeGoto(v, addrTop);
drh781def22014-01-22 13:35:53 +00002421 sqlite3VdbeResolveLabel(v, addrBreak);
drhfe1c6bb2014-01-22 17:28:35 +00002422
2423end_of_recursive_query:
dan9afccba2014-03-21 19:27:54 +00002424 sqlite3ExprListDelete(pParse->db, p->pOrderBy);
drhfe1c6bb2014-01-22 17:28:35 +00002425 p->pOrderBy = pOrderBy;
drhaa9ce702014-01-22 18:07:04 +00002426 p->pLimit = pLimit;
drhfe1c6bb2014-01-22 17:28:35 +00002427 return;
drh781def22014-01-22 13:35:53 +00002428}
danb68b9772014-01-25 12:16:53 +00002429#endif /* SQLITE_OMIT_CTE */
drh781def22014-01-22 13:35:53 +00002430
2431/* Forward references */
drhb21e7c72008-06-22 12:37:57 +00002432static int multiSelectOrderBy(
2433 Parse *pParse, /* Parsing context */
2434 Select *p, /* The right-most of SELECTs to be coded */
drha9671a22008-07-08 23:40:20 +00002435 SelectDest *pDest /* What to do with query results */
drhb21e7c72008-06-22 12:37:57 +00002436);
2437
drh45f54a52015-01-05 19:16:42 +00002438/*
drh45f54a52015-01-05 19:16:42 +00002439** Handle the special case of a compound-select that originates from a
2440** VALUES clause. By handling this as a special case, we avoid deep
2441** recursion, and thus do not need to enforce the SQLITE_LIMIT_COMPOUND_SELECT
2442** on a VALUES clause.
2443**
2444** Because the Select object originates from a VALUES clause:
drhb058d052018-01-14 20:12:23 +00002445** (1) There is no LIMIT or OFFSET or else there is a LIMIT of exactly 1
drh45f54a52015-01-05 19:16:42 +00002446** (2) All terms are UNION ALL
2447** (3) There is no ORDER BY clause
drhb058d052018-01-14 20:12:23 +00002448**
2449** The "LIMIT of exactly 1" case of condition (1) comes about when a VALUES
2450** clause occurs within scalar expression (ex: "SELECT (VALUES(1),(2),(3))").
2451** The sqlite3CodeSubselect will have added the LIMIT 1 clause in tht case.
2452** Since the limit is exactly 1, we only need to evalutes the left-most VALUES.
drh45f54a52015-01-05 19:16:42 +00002453*/
2454static int multiSelectValues(
2455 Parse *pParse, /* Parsing context */
2456 Select *p, /* The right-most of SELECTs to be coded */
2457 SelectDest *pDest /* What to do with query results */
2458){
drh45f54a52015-01-05 19:16:42 +00002459 int nRow = 1;
2460 int rc = 0;
drhfa16f5d2018-05-03 01:37:13 +00002461 int bShowAll = p->pLimit==0;
drh772460f2015-04-16 14:13:12 +00002462 assert( p->selFlags & SF_MultiValue );
drh45f54a52015-01-05 19:16:42 +00002463 do{
2464 assert( p->selFlags & SF_Values );
2465 assert( p->op==TK_ALL || (p->op==TK_SELECT && p->pPrior==0) );
dan923cadb2015-06-23 12:19:55 +00002466 assert( p->pNext==0 || p->pEList->nExpr==p->pNext->pEList->nExpr );
drh45f54a52015-01-05 19:16:42 +00002467 if( p->pPrior==0 ) break;
2468 assert( p->pPrior->pNext==p );
2469 p = p->pPrior;
drhfa16f5d2018-05-03 01:37:13 +00002470 nRow += bShowAll;
drh45f54a52015-01-05 19:16:42 +00002471 }while(1);
drhfa16f5d2018-05-03 01:37:13 +00002472 ExplainQueryPlan((pParse, 0, "SCAN %d CONSTANT ROW%s", nRow,
2473 nRow==1 ? "" : "S"));
drh45f54a52015-01-05 19:16:42 +00002474 while( p ){
drhfa16f5d2018-05-03 01:37:13 +00002475 selectInnerLoop(pParse, p, -1, 0, 0, pDest, 1, 1);
2476 if( !bShowAll ) break;
drh45f54a52015-01-05 19:16:42 +00002477 p->nSelectRow = nRow;
2478 p = p->pNext;
2479 }
2480 return rc;
2481}
drhb21e7c72008-06-22 12:37:57 +00002482
drhd3d39e92004-05-20 22:16:29 +00002483/*
drh16ee60f2008-06-20 18:13:25 +00002484** This routine is called to process a compound query form from
2485** two or more separate queries using UNION, UNION ALL, EXCEPT, or
2486** INTERSECT
drhc926afb2002-06-20 03:38:26 +00002487**
drhe78e8282003-01-19 03:59:45 +00002488** "p" points to the right-most of the two queries. the query on the
2489** left is p->pPrior. The left query could also be a compound query
2490** in which case this routine will be called recursively.
2491**
2492** The results of the total query are to be written into a destination
2493** of type eDest with parameter iParm.
2494**
2495** Example 1: Consider a three-way compound SQL statement.
2496**
2497** SELECT a FROM t1 UNION SELECT b FROM t2 UNION SELECT c FROM t3
2498**
2499** This statement is parsed up as follows:
2500**
2501** SELECT c FROM t3
2502** |
2503** `-----> SELECT b FROM t2
2504** |
jplyon4b11c6d2004-01-19 04:57:53 +00002505** `------> SELECT a FROM t1
drhe78e8282003-01-19 03:59:45 +00002506**
2507** The arrows in the diagram above represent the Select.pPrior pointer.
2508** So if this routine is called with p equal to the t3 query, then
2509** pPrior will be the t2 query. p->op will be TK_UNION in this case.
2510**
2511** Notice that because of the way SQLite parses compound SELECTs, the
2512** individual selects always group from left to right.
drh82c3d632000-06-06 21:56:07 +00002513*/
danielk197784ac9d02004-05-18 09:58:06 +00002514static int multiSelect(
drhfbc4ee72004-08-29 01:31:05 +00002515 Parse *pParse, /* Parsing context */
2516 Select *p, /* The right-most of SELECTs to be coded */
drha9671a22008-07-08 23:40:20 +00002517 SelectDest *pDest /* What to do with query results */
danielk197784ac9d02004-05-18 09:58:06 +00002518){
drhfbc4ee72004-08-29 01:31:05 +00002519 int rc = SQLITE_OK; /* Success code from a subroutine */
2520 Select *pPrior; /* Another SELECT immediately to our left */
2521 Vdbe *v; /* Generate code to this VDBE */
drh1013c932008-01-06 00:25:21 +00002522 SelectDest dest; /* Alternative data destination */
danielk1977eca7e012008-07-01 16:05:25 +00002523 Select *pDelete = 0; /* Chain of simple selects to delete */
drh633e6d52008-07-28 19:34:53 +00002524 sqlite3 *db; /* Database connection */
drh82c3d632000-06-06 21:56:07 +00002525
drh7b58dae2003-07-20 01:16:46 +00002526 /* Make sure there is no ORDER BY or LIMIT clause on prior SELECTs. Only
drhfbc4ee72004-08-29 01:31:05 +00002527 ** the last (right-most) SELECT in the series may have an ORDER BY or LIMIT.
drh82c3d632000-06-06 21:56:07 +00002528 */
drh701bb3b2008-08-02 03:50:39 +00002529 assert( p && p->pPrior ); /* Calling function guarantees this much */
daneae73fb2014-01-16 18:34:33 +00002530 assert( (p->selFlags & SF_Recursive)==0 || p->op==TK_ALL || p->op==TK_UNION );
drh633e6d52008-07-28 19:34:53 +00002531 db = pParse->db;
drhd8bc7082000-06-07 23:51:50 +00002532 pPrior = p->pPrior;
drhbc103772008-08-08 18:06:25 +00002533 dest = *pDest;
drh63347e72017-09-18 13:16:10 +00002534 if( pPrior->pOrderBy || pPrior->pLimit ){
2535 sqlite3ErrorMsg(pParse,"%s clause should come after %s not before",
2536 pPrior->pOrderBy!=0 ? "ORDER BY" : "LIMIT", selectOpName(p->op));
danielk197784ac9d02004-05-18 09:58:06 +00002537 rc = 1;
2538 goto multi_select_end;
drh7b58dae2003-07-20 01:16:46 +00002539 }
drh82c3d632000-06-06 21:56:07 +00002540
danielk19774adee202004-05-08 08:23:19 +00002541 v = sqlite3GetVdbe(pParse);
drh701bb3b2008-08-02 03:50:39 +00002542 assert( v!=0 ); /* The VDBE already created by calling function */
drhd8bc7082000-06-07 23:51:50 +00002543
drh1cc3d752002-03-23 00:31:29 +00002544 /* Create the destination temporary table if necessary
2545 */
danielk19776c8c8ce2008-01-02 16:27:09 +00002546 if( dest.eDest==SRT_EphemTab ){
danielk1977b4964b72004-05-18 01:23:38 +00002547 assert( p->pEList );
drh2b596da2012-07-23 21:43:19 +00002548 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, dest.iSDParm, p->pEList->nExpr);
danielk19776c8c8ce2008-01-02 16:27:09 +00002549 dest.eDest = SRT_Table;
drh1cc3d752002-03-23 00:31:29 +00002550 }
2551
drh45f54a52015-01-05 19:16:42 +00002552 /* Special handling for a compound-select that originates as a VALUES clause.
2553 */
drh772460f2015-04-16 14:13:12 +00002554 if( p->selFlags & SF_MultiValue ){
drh45f54a52015-01-05 19:16:42 +00002555 rc = multiSelectValues(pParse, p, &dest);
2556 goto multi_select_end;
2557 }
2558
drhf6e369a2008-06-24 12:46:30 +00002559 /* Make sure all SELECTs in the statement have the same number of elements
2560 ** in their result sets.
2561 */
2562 assert( p->pEList && pPrior->pEList );
dan923cadb2015-06-23 12:19:55 +00002563 assert( p->pEList->nExpr==pPrior->pEList->nExpr );
drhf6e369a2008-06-24 12:46:30 +00002564
daneede6a52014-01-15 19:42:23 +00002565#ifndef SQLITE_OMIT_CTE
daneae73fb2014-01-16 18:34:33 +00002566 if( p->selFlags & SF_Recursive ){
drh781def22014-01-22 13:35:53 +00002567 generateWithRecursiveQuery(pParse, p, &dest);
dan8ce71842014-01-14 20:14:09 +00002568 }else
2569#endif
drhf6e369a2008-06-24 12:46:30 +00002570
drha9671a22008-07-08 23:40:20 +00002571 /* Compound SELECTs that have an ORDER BY clause are handled separately.
2572 */
drhf6e369a2008-06-24 12:46:30 +00002573 if( p->pOrderBy ){
drha9671a22008-07-08 23:40:20 +00002574 return multiSelectOrderBy(pParse, p, pDest);
drh03c39052018-05-02 14:24:34 +00002575 }else{
drhf6e369a2008-06-24 12:46:30 +00002576
drhc631ded2018-05-02 02:22:22 +00002577#ifndef SQLITE_OMIT_EXPLAIN
drh03c39052018-05-02 14:24:34 +00002578 if( pPrior->pPrior==0 ){
drh4d799832018-05-03 19:47:14 +00002579 ExplainQueryPlan((pParse, 1, "COMPOUND QUERY"));
drh03c39052018-05-02 14:24:34 +00002580 ExplainQueryPlan((pParse, 1, "LEFT-MOST SUBQUERY"));
drh03c39052018-05-02 14:24:34 +00002581 }
drhc631ded2018-05-02 02:22:22 +00002582#endif
2583
drh03c39052018-05-02 14:24:34 +00002584 /* Generate code for the left and right SELECT statements.
2585 */
2586 switch( p->op ){
2587 case TK_ALL: {
2588 int addr = 0;
2589 int nLimit;
2590 assert( !pPrior->pLimit );
2591 pPrior->iLimit = p->iLimit;
2592 pPrior->iOffset = p->iOffset;
2593 pPrior->pLimit = p->pLimit;
2594 rc = sqlite3Select(pParse, pPrior, &dest);
2595 p->pLimit = 0;
2596 if( rc ){
2597 goto multi_select_end;
drh9f1ef452015-10-06 17:27:18 +00002598 }
drh03c39052018-05-02 14:24:34 +00002599 p->pPrior = 0;
2600 p->iLimit = pPrior->iLimit;
2601 p->iOffset = pPrior->iOffset;
2602 if( p->iLimit ){
2603 addr = sqlite3VdbeAddOp1(v, OP_IfNot, p->iLimit); VdbeCoverage(v);
2604 VdbeComment((v, "Jump ahead if LIMIT reached"));
2605 if( p->iOffset ){
2606 sqlite3VdbeAddOp3(v, OP_OffsetLimit,
2607 p->iLimit, p->iOffset+1, p->iOffset);
2608 }
2609 }
2610 ExplainQueryPlan((pParse, 1, "UNION ALL"));
drh03c39052018-05-02 14:24:34 +00002611 rc = sqlite3Select(pParse, p, &dest);
2612 testcase( rc!=SQLITE_OK );
2613 pDelete = p->pPrior;
2614 p->pPrior = pPrior;
2615 p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow);
2616 if( pPrior->pLimit
2617 && sqlite3ExprIsInteger(pPrior->pLimit->pLeft, &nLimit)
2618 && nLimit>0 && p->nSelectRow > sqlite3LogEst((u64)nLimit)
2619 ){
2620 p->nSelectRow = sqlite3LogEst((u64)nLimit);
2621 }
2622 if( addr ){
2623 sqlite3VdbeJumpHere(v, addr);
2624 }
2625 break;
drha9671a22008-07-08 23:40:20 +00002626 }
drh03c39052018-05-02 14:24:34 +00002627 case TK_EXCEPT:
2628 case TK_UNION: {
2629 int unionTab; /* Cursor number of the temp table holding result */
2630 u8 op = 0; /* One of the SRT_ operations to apply to self */
2631 int priorOp; /* The SRT_ operation to apply to prior selects */
2632 Expr *pLimit; /* Saved values of p->nLimit */
2633 int addr;
2634 SelectDest uniondest;
2635
2636 testcase( p->op==TK_EXCEPT );
2637 testcase( p->op==TK_UNION );
2638 priorOp = SRT_Union;
2639 if( dest.eDest==priorOp ){
2640 /* We can reuse a temporary table generated by a SELECT to our
2641 ** right.
2642 */
2643 assert( p->pLimit==0 ); /* Not allowed on leftward elements */
2644 unionTab = dest.iSDParm;
2645 }else{
2646 /* We will need to create our own temporary table to hold the
2647 ** intermediate results.
2648 */
2649 unionTab = pParse->nTab++;
2650 assert( p->pOrderBy==0 );
2651 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, unionTab, 0);
2652 assert( p->addrOpenEphm[0] == -1 );
2653 p->addrOpenEphm[0] = addr;
2654 findRightmost(p)->selFlags |= SF_UsesEphemeral;
2655 assert( p->pEList );
2656 }
2657
2658 /* Code the SELECT statements to our left
drhd8bc7082000-06-07 23:51:50 +00002659 */
drh03c39052018-05-02 14:24:34 +00002660 assert( !pPrior->pOrderBy );
2661 sqlite3SelectDestInit(&uniondest, priorOp, unionTab);
2662 rc = sqlite3Select(pParse, pPrior, &uniondest);
2663 if( rc ){
2664 goto multi_select_end;
2665 }
2666
2667 /* Code the current SELECT statement
drhd8bc7082000-06-07 23:51:50 +00002668 */
drh03c39052018-05-02 14:24:34 +00002669 if( p->op==TK_EXCEPT ){
2670 op = SRT_Except;
2671 }else{
2672 assert( p->op==TK_UNION );
2673 op = SRT_Union;
2674 }
2675 p->pPrior = 0;
2676 pLimit = p->pLimit;
2677 p->pLimit = 0;
2678 uniondest.eDest = op;
2679 ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE",
2680 selectOpName(p->op)));
drh03c39052018-05-02 14:24:34 +00002681 rc = sqlite3Select(pParse, p, &uniondest);
2682 testcase( rc!=SQLITE_OK );
2683 /* Query flattening in sqlite3Select() might refill p->pOrderBy.
2684 ** Be sure to delete p->pOrderBy, therefore, to avoid a memory leak. */
2685 sqlite3ExprListDelete(db, p->pOrderBy);
2686 pDelete = p->pPrior;
2687 p->pPrior = pPrior;
2688 p->pOrderBy = 0;
2689 if( p->op==TK_UNION ){
2690 p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow);
2691 }
2692 sqlite3ExprDelete(db, p->pLimit);
2693 p->pLimit = pLimit;
2694 p->iLimit = 0;
2695 p->iOffset = 0;
2696
2697 /* Convert the data in the temporary table into whatever form
2698 ** it is that we currently need.
2699 */
2700 assert( unionTab==dest.iSDParm || dest.eDest!=priorOp );
2701 if( dest.eDest!=priorOp ){
2702 int iCont, iBreak, iStart;
2703 assert( p->pEList );
2704 iBreak = sqlite3VdbeMakeLabel(v);
2705 iCont = sqlite3VdbeMakeLabel(v);
2706 computeLimitRegisters(pParse, p, iBreak);
2707 sqlite3VdbeAddOp2(v, OP_Rewind, unionTab, iBreak); VdbeCoverage(v);
2708 iStart = sqlite3VdbeCurrentAddr(v);
2709 selectInnerLoop(pParse, p, unionTab,
2710 0, 0, &dest, iCont, iBreak);
2711 sqlite3VdbeResolveLabel(v, iCont);
2712 sqlite3VdbeAddOp2(v, OP_Next, unionTab, iStart); VdbeCoverage(v);
2713 sqlite3VdbeResolveLabel(v, iBreak);
2714 sqlite3VdbeAddOp2(v, OP_Close, unionTab, 0);
2715 }
2716 break;
2717 }
2718 default: assert( p->op==TK_INTERSECT ); {
2719 int tab1, tab2;
2720 int iCont, iBreak, iStart;
2721 Expr *pLimit;
2722 int addr;
2723 SelectDest intersectdest;
2724 int r1;
2725
2726 /* INTERSECT is different from the others since it requires
2727 ** two temporary tables. Hence it has its own case. Begin
2728 ** by allocating the tables we will need.
2729 */
2730 tab1 = pParse->nTab++;
2731 tab2 = pParse->nTab++;
drh93a960a2008-07-10 00:32:42 +00002732 assert( p->pOrderBy==0 );
drh03c39052018-05-02 14:24:34 +00002733
2734 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab1, 0);
drh93a960a2008-07-10 00:32:42 +00002735 assert( p->addrOpenEphm[0] == -1 );
2736 p->addrOpenEphm[0] = addr;
drhd227a292014-02-09 18:02:09 +00002737 findRightmost(p)->selFlags |= SF_UsesEphemeral;
danielk197784ac9d02004-05-18 09:58:06 +00002738 assert( p->pEList );
drh03c39052018-05-02 14:24:34 +00002739
2740 /* Code the SELECTs to our left into temporary table "tab1".
2741 */
2742 sqlite3SelectDestInit(&intersectdest, SRT_Union, tab1);
2743 rc = sqlite3Select(pParse, pPrior, &intersectdest);
2744 if( rc ){
2745 goto multi_select_end;
2746 }
2747
2748 /* Code the current SELECT into temporary table "tab2"
2749 */
2750 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab2, 0);
2751 assert( p->addrOpenEphm[1] == -1 );
2752 p->addrOpenEphm[1] = addr;
2753 p->pPrior = 0;
2754 pLimit = p->pLimit;
2755 p->pLimit = 0;
2756 intersectdest.iSDParm = tab2;
2757 ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE",
2758 selectOpName(p->op)));
drh03c39052018-05-02 14:24:34 +00002759 rc = sqlite3Select(pParse, p, &intersectdest);
2760 testcase( rc!=SQLITE_OK );
2761 pDelete = p->pPrior;
2762 p->pPrior = pPrior;
2763 if( p->nSelectRow>pPrior->nSelectRow ){
2764 p->nSelectRow = pPrior->nSelectRow;
2765 }
2766 sqlite3ExprDelete(db, p->pLimit);
2767 p->pLimit = pLimit;
2768
2769 /* Generate code to take the intersection of the two temporary
2770 ** tables.
2771 */
drh82c3d632000-06-06 21:56:07 +00002772 assert( p->pEList );
danielk19774adee202004-05-08 08:23:19 +00002773 iBreak = sqlite3VdbeMakeLabel(v);
2774 iCont = sqlite3VdbeMakeLabel(v);
drhec7429a2005-10-06 16:53:14 +00002775 computeLimitRegisters(pParse, p, iBreak);
drh03c39052018-05-02 14:24:34 +00002776 sqlite3VdbeAddOp2(v, OP_Rewind, tab1, iBreak); VdbeCoverage(v);
2777 r1 = sqlite3GetTempReg(pParse);
2778 iStart = sqlite3VdbeAddOp2(v, OP_RowData, tab1, r1);
2779 sqlite3VdbeAddOp4Int(v, OP_NotFound, tab2, iCont, r1, 0);
2780 VdbeCoverage(v);
2781 sqlite3ReleaseTempReg(pParse, r1);
2782 selectInnerLoop(pParse, p, tab1,
drhe8e4af72012-09-21 00:04:28 +00002783 0, 0, &dest, iCont, iBreak);
danielk19774adee202004-05-08 08:23:19 +00002784 sqlite3VdbeResolveLabel(v, iCont);
drh03c39052018-05-02 14:24:34 +00002785 sqlite3VdbeAddOp2(v, OP_Next, tab1, iStart); VdbeCoverage(v);
danielk19774adee202004-05-08 08:23:19 +00002786 sqlite3VdbeResolveLabel(v, iBreak);
drh03c39052018-05-02 14:24:34 +00002787 sqlite3VdbeAddOp2(v, OP_Close, tab2, 0);
2788 sqlite3VdbeAddOp2(v, OP_Close, tab1, 0);
2789 break;
drh82c3d632000-06-06 21:56:07 +00002790 }
drh82c3d632000-06-06 21:56:07 +00002791 }
drh03c39052018-05-02 14:24:34 +00002792
2793 #ifndef SQLITE_OMIT_EXPLAIN
2794 if( p->pNext==0 ){
2795 ExplainQueryPlanPop(pParse);
drh82c3d632000-06-06 21:56:07 +00002796 }
drh03c39052018-05-02 14:24:34 +00002797 #endif
drh82c3d632000-06-06 21:56:07 +00002798 }
drh03c39052018-05-02 14:24:34 +00002799
drha9671a22008-07-08 23:40:20 +00002800 /* Compute collating sequences used by
2801 ** temporary tables needed to implement the compound select.
2802 ** Attach the KeyInfo structure to all temporary tables.
drh8cdbf832004-08-29 16:25:03 +00002803 **
2804 ** This section is run by the right-most SELECT statement only.
2805 ** SELECT statements to the left always skip this part. The right-most
2806 ** SELECT might also skip this part if it has no ORDER BY clause and
2807 ** no temp tables are required.
drhfbc4ee72004-08-29 01:31:05 +00002808 */
drh7d10d5a2008-08-20 16:35:10 +00002809 if( p->selFlags & SF_UsesEphemeral ){
drhfbc4ee72004-08-29 01:31:05 +00002810 int i; /* Loop counter */
2811 KeyInfo *pKeyInfo; /* Collating sequence for the result set */
drh0342b1f2005-09-01 03:07:44 +00002812 Select *pLoop; /* For looping through SELECT statements */
drhf68d7d12007-05-03 13:02:26 +00002813 CollSeq **apColl; /* For looping through pKeyInfo->aColl[] */
drh93a960a2008-07-10 00:32:42 +00002814 int nCol; /* Number of columns in result set */
drhfbc4ee72004-08-29 01:31:05 +00002815
drhd227a292014-02-09 18:02:09 +00002816 assert( p->pNext==0 );
drh93a960a2008-07-10 00:32:42 +00002817 nCol = p->pEList->nExpr;
drhad124322013-10-23 13:30:58 +00002818 pKeyInfo = sqlite3KeyInfoAlloc(db, nCol, 1);
danielk1977dc1bdc42004-06-11 10:51:27 +00002819 if( !pKeyInfo ){
mistachkinfad30392016-02-13 23:43:46 +00002820 rc = SQLITE_NOMEM_BKPT;
danielk1977dc1bdc42004-06-11 10:51:27 +00002821 goto multi_select_end;
2822 }
drh0342b1f2005-09-01 03:07:44 +00002823 for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
2824 *apColl = multiSelectCollSeq(pParse, p, i);
2825 if( 0==*apColl ){
drh633e6d52008-07-28 19:34:53 +00002826 *apColl = db->pDfltColl;
danielk1977dc1bdc42004-06-11 10:51:27 +00002827 }
2828 }
2829
drh0342b1f2005-09-01 03:07:44 +00002830 for(pLoop=p; pLoop; pLoop=pLoop->pPrior){
2831 for(i=0; i<2; i++){
drhb9bb7c12006-06-11 23:41:55 +00002832 int addr = pLoop->addrOpenEphm[i];
drh0342b1f2005-09-01 03:07:44 +00002833 if( addr<0 ){
2834 /* If [0] is unused then [1] is also unused. So we can
2835 ** always safely abort as soon as the first unused slot is found */
drhb9bb7c12006-06-11 23:41:55 +00002836 assert( pLoop->addrOpenEphm[1]<0 );
drh0342b1f2005-09-01 03:07:44 +00002837 break;
2838 }
2839 sqlite3VdbeChangeP2(v, addr, nCol);
drh2ec2fb22013-11-06 19:59:23 +00002840 sqlite3VdbeChangeP4(v, addr, (char*)sqlite3KeyInfoRef(pKeyInfo),
2841 P4_KEYINFO);
drh0ee5a1e2007-01-26 19:04:00 +00002842 pLoop->addrOpenEphm[i] = -1;
drh0342b1f2005-09-01 03:07:44 +00002843 }
danielk1977dc1bdc42004-06-11 10:51:27 +00002844 }
drh2ec2fb22013-11-06 19:59:23 +00002845 sqlite3KeyInfoUnref(pKeyInfo);
danielk197784ac9d02004-05-18 09:58:06 +00002846 }
danielk1977dc1bdc42004-06-11 10:51:27 +00002847
2848multi_select_end:
drh2b596da2012-07-23 21:43:19 +00002849 pDest->iSdst = dest.iSdst;
2850 pDest->nSdst = dest.nSdst;
drh633e6d52008-07-28 19:34:53 +00002851 sqlite3SelectDelete(db, pDelete);
danielk197784ac9d02004-05-18 09:58:06 +00002852 return rc;
drh22827922000-06-06 17:27:05 +00002853}
drhb7f91642004-10-31 02:22:47 +00002854#endif /* SQLITE_OMIT_COMPOUND_SELECT */
drh22827922000-06-06 17:27:05 +00002855
drhb21e7c72008-06-22 12:37:57 +00002856/*
mistachkin89b31d72015-07-16 17:29:27 +00002857** Error message for when two or more terms of a compound select have different
2858** size result sets.
2859*/
2860void sqlite3SelectWrongNumTermsError(Parse *pParse, Select *p){
2861 if( p->selFlags & SF_Values ){
2862 sqlite3ErrorMsg(pParse, "all VALUES must have the same number of terms");
2863 }else{
2864 sqlite3ErrorMsg(pParse, "SELECTs to the left and right of %s"
2865 " do not have the same number of result columns", selectOpName(p->op));
2866 }
2867}
2868
2869/*
drhb21e7c72008-06-22 12:37:57 +00002870** Code an output subroutine for a coroutine implementation of a
2871** SELECT statment.
drh0acb7e42008-06-25 00:12:41 +00002872**
drh2b596da2012-07-23 21:43:19 +00002873** The data to be output is contained in pIn->iSdst. There are
2874** pIn->nSdst columns to be output. pDest is where the output should
drh0acb7e42008-06-25 00:12:41 +00002875** be sent.
2876**
2877** regReturn is the number of the register holding the subroutine
2878** return address.
2879**
drhf053d5b2010-08-09 14:26:32 +00002880** If regPrev>0 then it is the first register in a vector that
drh0acb7e42008-06-25 00:12:41 +00002881** records the previous output. mem[regPrev] is a flag that is false
2882** if there has been no previous output. If regPrev>0 then code is
2883** generated to suppress duplicates. pKeyInfo is used for comparing
2884** keys.
2885**
2886** If the LIMIT found in p->iLimit is reached, jump immediately to
2887** iBreak.
drhb21e7c72008-06-22 12:37:57 +00002888*/
drh0acb7e42008-06-25 00:12:41 +00002889static int generateOutputSubroutine(
drh92b01d52008-06-24 00:32:35 +00002890 Parse *pParse, /* Parsing context */
2891 Select *p, /* The SELECT statement */
2892 SelectDest *pIn, /* Coroutine supplying data */
2893 SelectDest *pDest, /* Where to send the data */
2894 int regReturn, /* The return address register */
drh0acb7e42008-06-25 00:12:41 +00002895 int regPrev, /* Previous result register. No uniqueness if 0 */
2896 KeyInfo *pKeyInfo, /* For comparing with previous entry */
drh92b01d52008-06-24 00:32:35 +00002897 int iBreak /* Jump here if we hit the LIMIT */
drhb21e7c72008-06-22 12:37:57 +00002898){
2899 Vdbe *v = pParse->pVdbe;
drh92b01d52008-06-24 00:32:35 +00002900 int iContinue;
2901 int addr;
drhb21e7c72008-06-22 12:37:57 +00002902
drh92b01d52008-06-24 00:32:35 +00002903 addr = sqlite3VdbeCurrentAddr(v);
2904 iContinue = sqlite3VdbeMakeLabel(v);
drh0acb7e42008-06-25 00:12:41 +00002905
2906 /* Suppress duplicates for UNION, EXCEPT, and INTERSECT
2907 */
2908 if( regPrev ){
drh728e0f92015-10-10 14:41:28 +00002909 int addr1, addr2;
2910 addr1 = sqlite3VdbeAddOp1(v, OP_IfNot, regPrev); VdbeCoverage(v);
2911 addr2 = sqlite3VdbeAddOp4(v, OP_Compare, pIn->iSdst, regPrev+1, pIn->nSdst,
drh2ec2fb22013-11-06 19:59:23 +00002912 (char*)sqlite3KeyInfoRef(pKeyInfo), P4_KEYINFO);
drh728e0f92015-10-10 14:41:28 +00002913 sqlite3VdbeAddOp3(v, OP_Jump, addr2+2, iContinue, addr2+2); VdbeCoverage(v);
2914 sqlite3VdbeJumpHere(v, addr1);
drhe8e4af72012-09-21 00:04:28 +00002915 sqlite3VdbeAddOp3(v, OP_Copy, pIn->iSdst, regPrev+1, pIn->nSdst-1);
drhec86c722011-12-09 17:27:51 +00002916 sqlite3VdbeAddOp2(v, OP_Integer, 1, regPrev);
drh0acb7e42008-06-25 00:12:41 +00002917 }
danielk19771f9caa42008-07-02 16:10:45 +00002918 if( pParse->db->mallocFailed ) return 0;
drh0acb7e42008-06-25 00:12:41 +00002919
mistachkind5578432012-08-25 10:01:29 +00002920 /* Suppress the first OFFSET entries if there is an OFFSET clause
drh0acb7e42008-06-25 00:12:41 +00002921 */
drhaa9ce702014-01-22 18:07:04 +00002922 codeOffset(v, p->iOffset, iContinue);
drhb21e7c72008-06-22 12:37:57 +00002923
drhe2248cf2015-05-22 17:29:27 +00002924 assert( pDest->eDest!=SRT_Exists );
2925 assert( pDest->eDest!=SRT_Table );
drhb21e7c72008-06-22 12:37:57 +00002926 switch( pDest->eDest ){
2927 /* Store the result as data using a unique key.
2928 */
drhb21e7c72008-06-22 12:37:57 +00002929 case SRT_EphemTab: {
2930 int r1 = sqlite3GetTempReg(pParse);
2931 int r2 = sqlite3GetTempReg(pParse);
drh2b596da2012-07-23 21:43:19 +00002932 sqlite3VdbeAddOp3(v, OP_MakeRecord, pIn->iSdst, pIn->nSdst, r1);
2933 sqlite3VdbeAddOp2(v, OP_NewRowid, pDest->iSDParm, r2);
2934 sqlite3VdbeAddOp3(v, OP_Insert, pDest->iSDParm, r1, r2);
drhb21e7c72008-06-22 12:37:57 +00002935 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
2936 sqlite3ReleaseTempReg(pParse, r2);
2937 sqlite3ReleaseTempReg(pParse, r1);
2938 break;
2939 }
2940
2941#ifndef SQLITE_OMIT_SUBQUERY
drh14318072016-09-06 18:51:25 +00002942 /* If we are creating a set for an "expr IN (SELECT ...)".
drhb21e7c72008-06-22 12:37:57 +00002943 */
2944 case SRT_Set: {
drh6fccc352008-06-27 00:52:45 +00002945 int r1;
drh63cecc42016-09-06 19:08:21 +00002946 testcase( pIn->nSdst>1 );
drhb21e7c72008-06-22 12:37:57 +00002947 r1 = sqlite3GetTempReg(pParse);
dan71c57db2016-07-09 20:23:55 +00002948 sqlite3VdbeAddOp4(v, OP_MakeRecord, pIn->iSdst, pIn->nSdst,
drh14318072016-09-06 18:51:25 +00002949 r1, pDest->zAffSdst, pIn->nSdst);
drh9b4eaeb2016-11-09 00:10:33 +00002950 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, pDest->iSDParm, r1,
2951 pIn->iSdst, pIn->nSdst);
drhb21e7c72008-06-22 12:37:57 +00002952 sqlite3ReleaseTempReg(pParse, r1);
drhb21e7c72008-06-22 12:37:57 +00002953 break;
2954 }
2955
drhb21e7c72008-06-22 12:37:57 +00002956 /* If this is a scalar select that is part of an expression, then
2957 ** store the results in the appropriate memory cell and break out
2958 ** of the scan loop.
2959 */
2960 case SRT_Mem: {
drha276e3f2015-04-16 16:22:27 +00002961 assert( pIn->nSdst==1 || pParse->nErr>0 ); testcase( pIn->nSdst!=1 );
drh2b596da2012-07-23 21:43:19 +00002962 sqlite3ExprCodeMove(pParse, pIn->iSdst, pDest->iSDParm, 1);
drhb21e7c72008-06-22 12:37:57 +00002963 /* The LIMIT clause will jump out of the loop for us */
2964 break;
2965 }
2966#endif /* #ifndef SQLITE_OMIT_SUBQUERY */
2967
drh7d10d5a2008-08-20 16:35:10 +00002968 /* The results are stored in a sequence of registers
drh2b596da2012-07-23 21:43:19 +00002969 ** starting at pDest->iSdst. Then the co-routine yields.
drhb21e7c72008-06-22 12:37:57 +00002970 */
drh92b01d52008-06-24 00:32:35 +00002971 case SRT_Coroutine: {
drh2b596da2012-07-23 21:43:19 +00002972 if( pDest->iSdst==0 ){
2973 pDest->iSdst = sqlite3GetTempRange(pParse, pIn->nSdst);
2974 pDest->nSdst = pIn->nSdst;
drhb21e7c72008-06-22 12:37:57 +00002975 }
dan4b79bde2015-04-21 15:49:04 +00002976 sqlite3ExprCodeMove(pParse, pIn->iSdst, pDest->iSdst, pIn->nSdst);
drh2b596da2012-07-23 21:43:19 +00002977 sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm);
drh92b01d52008-06-24 00:32:35 +00002978 break;
2979 }
2980
drhccfcbce2009-05-18 15:46:07 +00002981 /* If none of the above, then the result destination must be
2982 ** SRT_Output. This routine is never called with any other
2983 ** destination other than the ones handled above or SRT_Output.
2984 **
2985 ** For SRT_Output, results are stored in a sequence of registers.
2986 ** Then the OP_ResultRow opcode is used to cause sqlite3_step() to
2987 ** return the next row of result.
drh7d10d5a2008-08-20 16:35:10 +00002988 */
drhccfcbce2009-05-18 15:46:07 +00002989 default: {
2990 assert( pDest->eDest==SRT_Output );
drh2b596da2012-07-23 21:43:19 +00002991 sqlite3VdbeAddOp2(v, OP_ResultRow, pIn->iSdst, pIn->nSdst);
drhb21e7c72008-06-22 12:37:57 +00002992 break;
2993 }
drhb21e7c72008-06-22 12:37:57 +00002994 }
drh92b01d52008-06-24 00:32:35 +00002995
2996 /* Jump to the end of the loop if the LIMIT is reached.
2997 */
2998 if( p->iLimit ){
drh16897072015-03-07 00:57:37 +00002999 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak); VdbeCoverage(v);
drh92b01d52008-06-24 00:32:35 +00003000 }
3001
drh92b01d52008-06-24 00:32:35 +00003002 /* Generate the subroutine return
3003 */
drh0acb7e42008-06-25 00:12:41 +00003004 sqlite3VdbeResolveLabel(v, iContinue);
drh92b01d52008-06-24 00:32:35 +00003005 sqlite3VdbeAddOp1(v, OP_Return, regReturn);
3006
3007 return addr;
drhb21e7c72008-06-22 12:37:57 +00003008}
3009
3010/*
3011** Alternative compound select code generator for cases when there
3012** is an ORDER BY clause.
3013**
3014** We assume a query of the following form:
3015**
3016** <selectA> <operator> <selectB> ORDER BY <orderbylist>
3017**
3018** <operator> is one of UNION ALL, UNION, EXCEPT, or INTERSECT. The idea
3019** is to code both <selectA> and <selectB> with the ORDER BY clause as
3020** co-routines. Then run the co-routines in parallel and merge the results
3021** into the output. In addition to the two coroutines (called selectA and
3022** selectB) there are 7 subroutines:
3023**
3024** outA: Move the output of the selectA coroutine into the output
3025** of the compound query.
3026**
3027** outB: Move the output of the selectB coroutine into the output
3028** of the compound query. (Only generated for UNION and
3029** UNION ALL. EXCEPT and INSERTSECT never output a row that
3030** appears only in B.)
3031**
3032** AltB: Called when there is data from both coroutines and A<B.
3033**
3034** AeqB: Called when there is data from both coroutines and A==B.
3035**
3036** AgtB: Called when there is data from both coroutines and A>B.
3037**
3038** EofA: Called when data is exhausted from selectA.
3039**
3040** EofB: Called when data is exhausted from selectB.
3041**
3042** The implementation of the latter five subroutines depend on which
3043** <operator> is used:
3044**
3045**
3046** UNION ALL UNION EXCEPT INTERSECT
3047** ------------- ----------------- -------------- -----------------
drh0acb7e42008-06-25 00:12:41 +00003048** AltB: outA, nextA outA, nextA outA, nextA nextA
drhb21e7c72008-06-22 12:37:57 +00003049**
drh0acb7e42008-06-25 00:12:41 +00003050** AeqB: outA, nextA nextA nextA outA, nextA
drhb21e7c72008-06-22 12:37:57 +00003051**
drh0acb7e42008-06-25 00:12:41 +00003052** AgtB: outB, nextB outB, nextB nextB nextB
drhb21e7c72008-06-22 12:37:57 +00003053**
drh0acb7e42008-06-25 00:12:41 +00003054** EofA: outB, nextB outB, nextB halt halt
drhb21e7c72008-06-22 12:37:57 +00003055**
drh0acb7e42008-06-25 00:12:41 +00003056** EofB: outA, nextA outA, nextA outA, nextA halt
3057**
3058** In the AltB, AeqB, and AgtB subroutines, an EOF on A following nextA
3059** causes an immediate jump to EofA and an EOF on B following nextB causes
3060** an immediate jump to EofB. Within EofA and EofB, and EOF on entry or
3061** following nextX causes a jump to the end of the select processing.
3062**
3063** Duplicate removal in the UNION, EXCEPT, and INTERSECT cases is handled
3064** within the output subroutine. The regPrev register set holds the previously
3065** output value. A comparison is made against this value and the output
3066** is skipped if the next results would be the same as the previous.
drhb21e7c72008-06-22 12:37:57 +00003067**
3068** The implementation plan is to implement the two coroutines and seven
3069** subroutines first, then put the control logic at the bottom. Like this:
3070**
3071** goto Init
3072** coA: coroutine for left query (A)
3073** coB: coroutine for right query (B)
3074** outA: output one row of A
3075** outB: output one row of B (UNION and UNION ALL only)
3076** EofA: ...
3077** EofB: ...
3078** AltB: ...
3079** AeqB: ...
3080** AgtB: ...
3081** Init: initialize coroutine registers
3082** yield coA
3083** if eof(A) goto EofA
3084** yield coB
3085** if eof(B) goto EofB
3086** Cmpr: Compare A, B
3087** Jump AltB, AeqB, AgtB
3088** End: ...
3089**
3090** We call AltB, AeqB, AgtB, EofA, and EofB "subroutines" but they are not
3091** actually called using Gosub and they do not Return. EofA and EofB loop
3092** until all data is exhausted then jump to the "end" labe. AltB, AeqB,
3093** and AgtB jump to either L2 or to one of EofA or EofB.
3094*/
danielk1977de3e41e2008-08-04 03:51:24 +00003095#ifndef SQLITE_OMIT_COMPOUND_SELECT
drhb21e7c72008-06-22 12:37:57 +00003096static int multiSelectOrderBy(
3097 Parse *pParse, /* Parsing context */
3098 Select *p, /* The right-most of SELECTs to be coded */
drha9671a22008-07-08 23:40:20 +00003099 SelectDest *pDest /* What to do with query results */
drhb21e7c72008-06-22 12:37:57 +00003100){
drh0acb7e42008-06-25 00:12:41 +00003101 int i, j; /* Loop counters */
drhb21e7c72008-06-22 12:37:57 +00003102 Select *pPrior; /* Another SELECT immediately to our left */
3103 Vdbe *v; /* Generate code to this VDBE */
drhb21e7c72008-06-22 12:37:57 +00003104 SelectDest destA; /* Destination for coroutine A */
3105 SelectDest destB; /* Destination for coroutine B */
drh92b01d52008-06-24 00:32:35 +00003106 int regAddrA; /* Address register for select-A coroutine */
drh92b01d52008-06-24 00:32:35 +00003107 int regAddrB; /* Address register for select-B coroutine */
drh92b01d52008-06-24 00:32:35 +00003108 int addrSelectA; /* Address of the select-A coroutine */
3109 int addrSelectB; /* Address of the select-B coroutine */
3110 int regOutA; /* Address register for the output-A subroutine */
3111 int regOutB; /* Address register for the output-B subroutine */
3112 int addrOutA; /* Address of the output-A subroutine */
drhb27b7f52008-12-10 18:03:45 +00003113 int addrOutB = 0; /* Address of the output-B subroutine */
drh92b01d52008-06-24 00:32:35 +00003114 int addrEofA; /* Address of the select-A-exhausted subroutine */
drh81cf13e2014-02-07 18:27:53 +00003115 int addrEofA_noB; /* Alternate addrEofA if B is uninitialized */
drh92b01d52008-06-24 00:32:35 +00003116 int addrEofB; /* Address of the select-B-exhausted subroutine */
3117 int addrAltB; /* Address of the A<B subroutine */
3118 int addrAeqB; /* Address of the A==B subroutine */
3119 int addrAgtB; /* Address of the A>B subroutine */
3120 int regLimitA; /* Limit register for select-A */
3121 int regLimitB; /* Limit register for select-A */
drh0acb7e42008-06-25 00:12:41 +00003122 int regPrev; /* A range of registers to hold previous output */
drh92b01d52008-06-24 00:32:35 +00003123 int savedLimit; /* Saved value of p->iLimit */
3124 int savedOffset; /* Saved value of p->iOffset */
3125 int labelCmpr; /* Label for the start of the merge algorithm */
3126 int labelEnd; /* Label for the end of the overall SELECT stmt */
drh728e0f92015-10-10 14:41:28 +00003127 int addr1; /* Jump instructions that get retargetted */
drh92b01d52008-06-24 00:32:35 +00003128 int op; /* One of TK_ALL, TK_UNION, TK_EXCEPT, TK_INTERSECT */
drh96067812008-09-23 09:36:10 +00003129 KeyInfo *pKeyDup = 0; /* Comparison information for duplicate removal */
drh0acb7e42008-06-25 00:12:41 +00003130 KeyInfo *pKeyMerge; /* Comparison information for merging rows */
3131 sqlite3 *db; /* Database connection */
3132 ExprList *pOrderBy; /* The ORDER BY clause */
3133 int nOrderBy; /* Number of terms in the ORDER BY clause */
3134 int *aPermute; /* Mapping from ORDER BY terms to result set columns */
drhb21e7c72008-06-22 12:37:57 +00003135
drh92b01d52008-06-24 00:32:35 +00003136 assert( p->pOrderBy!=0 );
drh96067812008-09-23 09:36:10 +00003137 assert( pKeyDup==0 ); /* "Managed" code needs this. Ticket #3382. */
drh0acb7e42008-06-25 00:12:41 +00003138 db = pParse->db;
drh92b01d52008-06-24 00:32:35 +00003139 v = pParse->pVdbe;
drhccfcbce2009-05-18 15:46:07 +00003140 assert( v!=0 ); /* Already thrown the error if VDBE alloc failed */
drh92b01d52008-06-24 00:32:35 +00003141 labelEnd = sqlite3VdbeMakeLabel(v);
3142 labelCmpr = sqlite3VdbeMakeLabel(v);
drh0acb7e42008-06-25 00:12:41 +00003143
drh92b01d52008-06-24 00:32:35 +00003144
3145 /* Patch up the ORDER BY clause
3146 */
3147 op = p->op;
drhb21e7c72008-06-22 12:37:57 +00003148 pPrior = p->pPrior;
drh92b01d52008-06-24 00:32:35 +00003149 assert( pPrior->pOrderBy==0 );
drh0acb7e42008-06-25 00:12:41 +00003150 pOrderBy = p->pOrderBy;
drh93a960a2008-07-10 00:32:42 +00003151 assert( pOrderBy );
drh93a960a2008-07-10 00:32:42 +00003152 nOrderBy = pOrderBy->nExpr;
3153
drh0acb7e42008-06-25 00:12:41 +00003154 /* For operators other than UNION ALL we have to make sure that
3155 ** the ORDER BY clause covers every term of the result set. Add
3156 ** terms to the ORDER BY clause as necessary.
3157 */
3158 if( op!=TK_ALL ){
3159 for(i=1; db->mallocFailed==0 && i<=p->pEList->nExpr; i++){
drh7d10d5a2008-08-20 16:35:10 +00003160 struct ExprList_item *pItem;
3161 for(j=0, pItem=pOrderBy->a; j<nOrderBy; j++, pItem++){
drhc2acc4e2013-11-15 18:15:19 +00003162 assert( pItem->u.x.iOrderByCol>0 );
3163 if( pItem->u.x.iOrderByCol==i ) break;
drh0acb7e42008-06-25 00:12:41 +00003164 }
3165 if( j==nOrderBy ){
drhb7916a72009-05-27 10:31:29 +00003166 Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0);
mistachkinfad30392016-02-13 23:43:46 +00003167 if( pNew==0 ) return SQLITE_NOMEM_BKPT;
drh0acb7e42008-06-25 00:12:41 +00003168 pNew->flags |= EP_IntValue;
drh33e619f2009-05-28 01:00:55 +00003169 pNew->u.iValue = i;
drh43606172017-04-05 11:32:13 +00003170 p->pOrderBy = pOrderBy = sqlite3ExprListAppend(pParse, pOrderBy, pNew);
drhc2acc4e2013-11-15 18:15:19 +00003171 if( pOrderBy ) pOrderBy->a[nOrderBy++].u.x.iOrderByCol = (u16)i;
drh0acb7e42008-06-25 00:12:41 +00003172 }
3173 }
3174 }
3175
3176 /* Compute the comparison permutation and keyinfo that is used with
drh10c081a2009-04-16 00:24:23 +00003177 ** the permutation used to determine if the next
drh0acb7e42008-06-25 00:12:41 +00003178 ** row of results comes from selectA or selectB. Also add explicit
3179 ** collations to the ORDER BY clause terms so that when the subqueries
3180 ** to the right and the left are evaluated, they use the correct
3181 ** collation.
3182 */
drh575fad62016-02-05 13:38:36 +00003183 aPermute = sqlite3DbMallocRawNN(db, sizeof(int)*(nOrderBy + 1));
drh0acb7e42008-06-25 00:12:41 +00003184 if( aPermute ){
drh7d10d5a2008-08-20 16:35:10 +00003185 struct ExprList_item *pItem;
drhb1702022016-01-30 00:45:18 +00003186 aPermute[0] = nOrderBy;
3187 for(i=1, pItem=pOrderBy->a; i<=nOrderBy; i++, pItem++){
drh67366182015-04-16 14:33:35 +00003188 assert( pItem->u.x.iOrderByCol>0 );
drh2ec18a32015-06-23 23:31:52 +00003189 assert( pItem->u.x.iOrderByCol<=p->pEList->nExpr );
drhc2acc4e2013-11-15 18:15:19 +00003190 aPermute[i] = pItem->u.x.iOrderByCol - 1;
drh0acb7e42008-06-25 00:12:41 +00003191 }
dan53bed452014-01-24 20:37:18 +00003192 pKeyMerge = multiSelectOrderByKeyInfo(pParse, p, 1);
drh0acb7e42008-06-25 00:12:41 +00003193 }else{
3194 pKeyMerge = 0;
3195 }
3196
3197 /* Reattach the ORDER BY clause to the query.
3198 */
3199 p->pOrderBy = pOrderBy;
danielk19776ab3a2e2009-02-19 14:39:25 +00003200 pPrior->pOrderBy = sqlite3ExprListDup(pParse->db, pOrderBy, 0);
drh0acb7e42008-06-25 00:12:41 +00003201
3202 /* Allocate a range of temporary registers and the KeyInfo needed
3203 ** for the logic that removes duplicate result rows when the
3204 ** operator is UNION, EXCEPT, or INTERSECT (but not UNION ALL).
3205 */
3206 if( op==TK_ALL ){
3207 regPrev = 0;
3208 }else{
3209 int nExpr = p->pEList->nExpr;
drh1c0dc822008-10-30 22:13:23 +00003210 assert( nOrderBy>=nExpr || db->mallocFailed );
drhc8ac0d12013-02-16 02:41:01 +00003211 regPrev = pParse->nMem+1;
3212 pParse->nMem += nExpr+1;
drh0acb7e42008-06-25 00:12:41 +00003213 sqlite3VdbeAddOp2(v, OP_Integer, 0, regPrev);
drhad124322013-10-23 13:30:58 +00003214 pKeyDup = sqlite3KeyInfoAlloc(db, nExpr, 1);
drh0acb7e42008-06-25 00:12:41 +00003215 if( pKeyDup ){
drh2ec2fb22013-11-06 19:59:23 +00003216 assert( sqlite3KeyInfoIsWriteable(pKeyDup) );
drh0acb7e42008-06-25 00:12:41 +00003217 for(i=0; i<nExpr; i++){
3218 pKeyDup->aColl[i] = multiSelectCollSeq(pParse, p, i);
3219 pKeyDup->aSortOrder[i] = 0;
3220 }
3221 }
3222 }
drh92b01d52008-06-24 00:32:35 +00003223
3224 /* Separate the left and the right query from one another
3225 */
3226 p->pPrior = 0;
drhd227a292014-02-09 18:02:09 +00003227 pPrior->pNext = 0;
drh7d10d5a2008-08-20 16:35:10 +00003228 sqlite3ResolveOrderGroupBy(pParse, p, p->pOrderBy, "ORDER");
drh0acb7e42008-06-25 00:12:41 +00003229 if( pPrior->pPrior==0 ){
drh7d10d5a2008-08-20 16:35:10 +00003230 sqlite3ResolveOrderGroupBy(pParse, pPrior, pPrior->pOrderBy, "ORDER");
drh0acb7e42008-06-25 00:12:41 +00003231 }
3232
drh92b01d52008-06-24 00:32:35 +00003233 /* Compute the limit registers */
3234 computeLimitRegisters(pParse, p, labelEnd);
drh0acb7e42008-06-25 00:12:41 +00003235 if( p->iLimit && op==TK_ALL ){
drh92b01d52008-06-24 00:32:35 +00003236 regLimitA = ++pParse->nMem;
3237 regLimitB = ++pParse->nMem;
3238 sqlite3VdbeAddOp2(v, OP_Copy, p->iOffset ? p->iOffset+1 : p->iLimit,
3239 regLimitA);
3240 sqlite3VdbeAddOp2(v, OP_Copy, regLimitA, regLimitB);
3241 }else{
3242 regLimitA = regLimitB = 0;
3243 }
drh633e6d52008-07-28 19:34:53 +00003244 sqlite3ExprDelete(db, p->pLimit);
drh0acb7e42008-06-25 00:12:41 +00003245 p->pLimit = 0;
drh92b01d52008-06-24 00:32:35 +00003246
drhb21e7c72008-06-22 12:37:57 +00003247 regAddrA = ++pParse->nMem;
drhb21e7c72008-06-22 12:37:57 +00003248 regAddrB = ++pParse->nMem;
drhb21e7c72008-06-22 12:37:57 +00003249 regOutA = ++pParse->nMem;
3250 regOutB = ++pParse->nMem;
3251 sqlite3SelectDestInit(&destA, SRT_Coroutine, regAddrA);
3252 sqlite3SelectDestInit(&destB, SRT_Coroutine, regAddrB);
drhe2ca99c2018-05-02 00:33:43 +00003253
drhc631ded2018-05-02 02:22:22 +00003254 ExplainQueryPlan((pParse, 1, "MERGE (%s)", selectOpName(p->op)));
drhb21e7c72008-06-22 12:37:57 +00003255
drh92b01d52008-06-24 00:32:35 +00003256 /* Generate a coroutine to evaluate the SELECT statement to the
drh0acb7e42008-06-25 00:12:41 +00003257 ** left of the compound operator - the "A" select.
3258 */
drhed71a832014-02-07 19:18:10 +00003259 addrSelectA = sqlite3VdbeCurrentAddr(v) + 1;
drh728e0f92015-10-10 14:41:28 +00003260 addr1 = sqlite3VdbeAddOp3(v, OP_InitCoroutine, regAddrA, 0, addrSelectA);
drhed71a832014-02-07 19:18:10 +00003261 VdbeComment((v, "left SELECT"));
drh92b01d52008-06-24 00:32:35 +00003262 pPrior->iLimit = regLimitA;
drhc631ded2018-05-02 02:22:22 +00003263 ExplainQueryPlan((pParse, 1, "LEFT"));
drh7d10d5a2008-08-20 16:35:10 +00003264 sqlite3Select(pParse, pPrior, &destA);
drh2fade2f2016-02-09 02:12:20 +00003265 sqlite3VdbeEndCoroutine(v, regAddrA);
drh728e0f92015-10-10 14:41:28 +00003266 sqlite3VdbeJumpHere(v, addr1);
drhb21e7c72008-06-22 12:37:57 +00003267
drh92b01d52008-06-24 00:32:35 +00003268 /* Generate a coroutine to evaluate the SELECT statement on
3269 ** the right - the "B" select
3270 */
drhed71a832014-02-07 19:18:10 +00003271 addrSelectB = sqlite3VdbeCurrentAddr(v) + 1;
drh728e0f92015-10-10 14:41:28 +00003272 addr1 = sqlite3VdbeAddOp3(v, OP_InitCoroutine, regAddrB, 0, addrSelectB);
drhed71a832014-02-07 19:18:10 +00003273 VdbeComment((v, "right SELECT"));
drh92b01d52008-06-24 00:32:35 +00003274 savedLimit = p->iLimit;
3275 savedOffset = p->iOffset;
3276 p->iLimit = regLimitB;
3277 p->iOffset = 0;
drhc631ded2018-05-02 02:22:22 +00003278 ExplainQueryPlan((pParse, 1, "RIGHT"));
drh7d10d5a2008-08-20 16:35:10 +00003279 sqlite3Select(pParse, p, &destB);
drh92b01d52008-06-24 00:32:35 +00003280 p->iLimit = savedLimit;
3281 p->iOffset = savedOffset;
drh2fade2f2016-02-09 02:12:20 +00003282 sqlite3VdbeEndCoroutine(v, regAddrB);
drhb21e7c72008-06-22 12:37:57 +00003283
drh92b01d52008-06-24 00:32:35 +00003284 /* Generate a subroutine that outputs the current row of the A
drh0acb7e42008-06-25 00:12:41 +00003285 ** select as the next output row of the compound select.
drh92b01d52008-06-24 00:32:35 +00003286 */
drhb21e7c72008-06-22 12:37:57 +00003287 VdbeNoopComment((v, "Output routine for A"));
drh0acb7e42008-06-25 00:12:41 +00003288 addrOutA = generateOutputSubroutine(pParse,
3289 p, &destA, pDest, regOutA,
drh2ec2fb22013-11-06 19:59:23 +00003290 regPrev, pKeyDup, labelEnd);
drhb21e7c72008-06-22 12:37:57 +00003291
drh92b01d52008-06-24 00:32:35 +00003292 /* Generate a subroutine that outputs the current row of the B
drh0acb7e42008-06-25 00:12:41 +00003293 ** select as the next output row of the compound select.
drh92b01d52008-06-24 00:32:35 +00003294 */
drh0acb7e42008-06-25 00:12:41 +00003295 if( op==TK_ALL || op==TK_UNION ){
3296 VdbeNoopComment((v, "Output routine for B"));
3297 addrOutB = generateOutputSubroutine(pParse,
3298 p, &destB, pDest, regOutB,
drh2ec2fb22013-11-06 19:59:23 +00003299 regPrev, pKeyDup, labelEnd);
drh0acb7e42008-06-25 00:12:41 +00003300 }
drh2ec2fb22013-11-06 19:59:23 +00003301 sqlite3KeyInfoUnref(pKeyDup);
drhb21e7c72008-06-22 12:37:57 +00003302
drh92b01d52008-06-24 00:32:35 +00003303 /* Generate a subroutine to run when the results from select A
3304 ** are exhausted and only data in select B remains.
3305 */
drhb21e7c72008-06-22 12:37:57 +00003306 if( op==TK_EXCEPT || op==TK_INTERSECT ){
drh81cf13e2014-02-07 18:27:53 +00003307 addrEofA_noB = addrEofA = labelEnd;
drhb21e7c72008-06-22 12:37:57 +00003308 }else{
drh81cf13e2014-02-07 18:27:53 +00003309 VdbeNoopComment((v, "eof-A subroutine"));
3310 addrEofA = sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB);
3311 addrEofA_noB = sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, labelEnd);
drh688852a2014-02-17 22:40:43 +00003312 VdbeCoverage(v);
drh076e85f2015-09-03 13:46:12 +00003313 sqlite3VdbeGoto(v, addrEofA);
drhc3489bb2016-02-25 16:04:59 +00003314 p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow);
drhb21e7c72008-06-22 12:37:57 +00003315 }
3316
drh92b01d52008-06-24 00:32:35 +00003317 /* Generate a subroutine to run when the results from select B
3318 ** are exhausted and only data in select A remains.
3319 */
drhb21e7c72008-06-22 12:37:57 +00003320 if( op==TK_INTERSECT ){
drh92b01d52008-06-24 00:32:35 +00003321 addrEofB = addrEofA;
drh95aa47b2010-11-16 02:49:15 +00003322 if( p->nSelectRow > pPrior->nSelectRow ) p->nSelectRow = pPrior->nSelectRow;
drhb21e7c72008-06-22 12:37:57 +00003323 }else{
drh92b01d52008-06-24 00:32:35 +00003324 VdbeNoopComment((v, "eof-B subroutine"));
drh81cf13e2014-02-07 18:27:53 +00003325 addrEofB = sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA);
drh688852a2014-02-17 22:40:43 +00003326 sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, labelEnd); VdbeCoverage(v);
drh076e85f2015-09-03 13:46:12 +00003327 sqlite3VdbeGoto(v, addrEofB);
drhb21e7c72008-06-22 12:37:57 +00003328 }
3329
drh92b01d52008-06-24 00:32:35 +00003330 /* Generate code to handle the case of A<B
3331 */
drhb21e7c72008-06-22 12:37:57 +00003332 VdbeNoopComment((v, "A-lt-B subroutine"));
drh0acb7e42008-06-25 00:12:41 +00003333 addrAltB = sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA);
drh688852a2014-02-17 22:40:43 +00003334 sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, addrEofA); VdbeCoverage(v);
drh076e85f2015-09-03 13:46:12 +00003335 sqlite3VdbeGoto(v, labelCmpr);
drhb21e7c72008-06-22 12:37:57 +00003336
drh92b01d52008-06-24 00:32:35 +00003337 /* Generate code to handle the case of A==B
3338 */
drhb21e7c72008-06-22 12:37:57 +00003339 if( op==TK_ALL ){
3340 addrAeqB = addrAltB;
drh0acb7e42008-06-25 00:12:41 +00003341 }else if( op==TK_INTERSECT ){
3342 addrAeqB = addrAltB;
3343 addrAltB++;
drh92b01d52008-06-24 00:32:35 +00003344 }else{
drhb21e7c72008-06-22 12:37:57 +00003345 VdbeNoopComment((v, "A-eq-B subroutine"));
drh0acb7e42008-06-25 00:12:41 +00003346 addrAeqB =
drh688852a2014-02-17 22:40:43 +00003347 sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, addrEofA); VdbeCoverage(v);
drh076e85f2015-09-03 13:46:12 +00003348 sqlite3VdbeGoto(v, labelCmpr);
drhb21e7c72008-06-22 12:37:57 +00003349 }
3350
drh92b01d52008-06-24 00:32:35 +00003351 /* Generate code to handle the case of A>B
3352 */
drhb21e7c72008-06-22 12:37:57 +00003353 VdbeNoopComment((v, "A-gt-B subroutine"));
3354 addrAgtB = sqlite3VdbeCurrentAddr(v);
3355 if( op==TK_ALL || op==TK_UNION ){
3356 sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB);
3357 }
drh688852a2014-02-17 22:40:43 +00003358 sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, addrEofB); VdbeCoverage(v);
drh076e85f2015-09-03 13:46:12 +00003359 sqlite3VdbeGoto(v, labelCmpr);
drhb21e7c72008-06-22 12:37:57 +00003360
drh92b01d52008-06-24 00:32:35 +00003361 /* This code runs once to initialize everything.
3362 */
drh728e0f92015-10-10 14:41:28 +00003363 sqlite3VdbeJumpHere(v, addr1);
drh688852a2014-02-17 22:40:43 +00003364 sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, addrEofA_noB); VdbeCoverage(v);
3365 sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, addrEofB); VdbeCoverage(v);
drh92b01d52008-06-24 00:32:35 +00003366
3367 /* Implement the main merge loop
3368 */
3369 sqlite3VdbeResolveLabel(v, labelCmpr);
drh0acb7e42008-06-25 00:12:41 +00003370 sqlite3VdbeAddOp4(v, OP_Permutation, 0, 0, 0, (char*)aPermute, P4_INTARRAY);
drh2b596da2012-07-23 21:43:19 +00003371 sqlite3VdbeAddOp4(v, OP_Compare, destA.iSdst, destB.iSdst, nOrderBy,
drh2ec2fb22013-11-06 19:59:23 +00003372 (char*)pKeyMerge, P4_KEYINFO);
drh953f7612012-12-07 22:18:54 +00003373 sqlite3VdbeChangeP5(v, OPFLAG_PERMUTE);
drh688852a2014-02-17 22:40:43 +00003374 sqlite3VdbeAddOp3(v, OP_Jump, addrAltB, addrAeqB, addrAgtB); VdbeCoverage(v);
drh92b01d52008-06-24 00:32:35 +00003375
3376 /* Jump to the this point in order to terminate the query.
3377 */
drhb21e7c72008-06-22 12:37:57 +00003378 sqlite3VdbeResolveLabel(v, labelEnd);
drh92b01d52008-06-24 00:32:35 +00003379
drh0acb7e42008-06-25 00:12:41 +00003380 /* Reassembly the compound query so that it will be freed correctly
3381 ** by the calling function */
danielk19775e7ad502008-07-01 17:39:27 +00003382 if( p->pPrior ){
drh633e6d52008-07-28 19:34:53 +00003383 sqlite3SelectDelete(db, p->pPrior);
danielk19775e7ad502008-07-01 17:39:27 +00003384 }
drh0acb7e42008-06-25 00:12:41 +00003385 p->pPrior = pPrior;
drhd227a292014-02-09 18:02:09 +00003386 pPrior->pNext = p;
drh92b01d52008-06-24 00:32:35 +00003387
drh92b01d52008-06-24 00:32:35 +00003388 /*** TBD: Insert subroutine calls to close cursors on incomplete
3389 **** subqueries ****/
drhe2ca99c2018-05-02 00:33:43 +00003390 ExplainQueryPlanPop(pParse);
drh3dc4cc62015-04-15 07:10:25 +00003391 return pParse->nErr!=0;
drhb21e7c72008-06-22 12:37:57 +00003392}
danielk1977de3e41e2008-08-04 03:51:24 +00003393#endif
drhb21e7c72008-06-22 12:37:57 +00003394
shane3514b6f2008-07-22 05:00:55 +00003395#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
drh46967de2017-04-14 12:39:37 +00003396
3397/* An instance of the SubstContext object describes an substitution edit
3398** to be performed on a parse tree.
3399**
3400** All references to columns in table iTable are to be replaced by corresponding
3401** expressions in pEList.
3402*/
3403typedef struct SubstContext {
3404 Parse *pParse; /* The parsing context */
3405 int iTable; /* Replace references to this table */
drh31d6fd52017-04-14 19:03:10 +00003406 int iNewTable; /* New table number */
3407 int isLeftJoin; /* Add TK_IF_NULL_ROW opcodes on each replacement */
drh46967de2017-04-14 12:39:37 +00003408 ExprList *pEList; /* Replacement expressions */
3409} SubstContext;
3410
drh17435752007-08-16 04:30:38 +00003411/* Forward Declarations */
drh46967de2017-04-14 12:39:37 +00003412static void substExprList(SubstContext*, ExprList*);
3413static void substSelect(SubstContext*, Select*, int);
drh17435752007-08-16 04:30:38 +00003414
drh22827922000-06-06 17:27:05 +00003415/*
drh832508b2002-03-02 17:04:07 +00003416** Scan through the expression pExpr. Replace every reference to
drh6a3ea0e2003-05-02 14:32:12 +00003417** a column in table number iTable with a copy of the iColumn-th
drh84e59202002-03-14 14:33:31 +00003418** entry in pEList. (But leave references to the ROWID column
drh6a3ea0e2003-05-02 14:32:12 +00003419** unchanged.)
drh832508b2002-03-02 17:04:07 +00003420**
3421** This routine is part of the flattening procedure. A subquery
3422** whose result set is defined by pEList appears as entry in the
3423** FROM clause of a SELECT such that the VDBE cursor assigned to that
drhaca19e12017-04-07 19:41:31 +00003424** FORM clause entry is iTable. This routine makes the necessary
drh832508b2002-03-02 17:04:07 +00003425** changes to pExpr so that it refers directly to the source table
3426** of the subquery rather the result set of the subquery.
3427*/
drhb7916a72009-05-27 10:31:29 +00003428static Expr *substExpr(
drh46967de2017-04-14 12:39:37 +00003429 SubstContext *pSubst, /* Description of the substitution */
3430 Expr *pExpr /* Expr in which substitution occurs */
drh17435752007-08-16 04:30:38 +00003431){
drhb7916a72009-05-27 10:31:29 +00003432 if( pExpr==0 ) return 0;
drh3d240d22017-09-28 16:56:55 +00003433 if( ExprHasProperty(pExpr, EP_FromJoin)
3434 && pExpr->iRightJoinTable==pSubst->iTable
3435 ){
drh399c7e22017-04-14 17:18:45 +00003436 pExpr->iRightJoinTable = pSubst->iNewTable;
3437 }
drh46967de2017-04-14 12:39:37 +00003438 if( pExpr->op==TK_COLUMN && pExpr->iTable==pSubst->iTable ){
drh50350a12004-02-13 16:22:22 +00003439 if( pExpr->iColumn<0 ){
3440 pExpr->op = TK_NULL;
3441 }else{
3442 Expr *pNew;
drh46967de2017-04-14 12:39:37 +00003443 Expr *pCopy = pSubst->pEList->a[pExpr->iColumn].pExpr;
drh31d6fd52017-04-14 19:03:10 +00003444 Expr ifNullRow;
drh46967de2017-04-14 12:39:37 +00003445 assert( pSubst->pEList!=0 && pExpr->iColumn<pSubst->pEList->nExpr );
drh3d6bedf2018-09-19 14:54:38 +00003446 assert( pExpr->eX!=EX_Right );
dan44c56042016-12-07 15:38:37 +00003447 if( sqlite3ExprIsVector(pCopy) ){
drh46967de2017-04-14 12:39:37 +00003448 sqlite3VectorErrorMsg(pSubst->pParse, pCopy);
dan44c56042016-12-07 15:38:37 +00003449 }else{
drh46967de2017-04-14 12:39:37 +00003450 sqlite3 *db = pSubst->pParse->db;
drh31d6fd52017-04-14 19:03:10 +00003451 if( pSubst->isLeftJoin && pCopy->op!=TK_COLUMN ){
3452 memset(&ifNullRow, 0, sizeof(ifNullRow));
3453 ifNullRow.op = TK_IF_NULL_ROW;
3454 ifNullRow.pLeft = pCopy;
3455 ifNullRow.iTable = pSubst->iNewTable;
3456 pCopy = &ifNullRow;
3457 }
dan44c56042016-12-07 15:38:37 +00003458 pNew = sqlite3ExprDup(db, pCopy, 0);
danbd11a2a2017-06-20 17:43:26 +00003459 if( pNew && pSubst->isLeftJoin ){
3460 ExprSetProperty(pNew, EP_CanBeNull);
3461 }
3462 if( pNew && ExprHasProperty(pExpr,EP_FromJoin) ){
dan44c56042016-12-07 15:38:37 +00003463 pNew->iRightJoinTable = pExpr->iRightJoinTable;
danbd11a2a2017-06-20 17:43:26 +00003464 ExprSetProperty(pNew, EP_FromJoin);
dan44c56042016-12-07 15:38:37 +00003465 }
3466 sqlite3ExprDelete(db, pExpr);
3467 pExpr = pNew;
dan92ddb3b2016-12-01 19:38:05 +00003468 }
drh50350a12004-02-13 16:22:22 +00003469 }
drh832508b2002-03-02 17:04:07 +00003470 }else{
drh7c1544e2017-05-23 12:44:57 +00003471 if( pExpr->op==TK_IF_NULL_ROW && pExpr->iTable==pSubst->iTable ){
3472 pExpr->iTable = pSubst->iNewTable;
3473 }
drh46967de2017-04-14 12:39:37 +00003474 pExpr->pLeft = substExpr(pSubst, pExpr->pLeft);
drh3b3c86a2018-09-18 21:35:31 +00003475 switch( pExpr->eX ){
3476 case EX_Select: {
3477 substSelect(pSubst, pExpr->x.pSelect, 1);
3478 break;
3479 }
3480 case EX_List: {
3481 substExprList(pSubst, pExpr->x.pList);
3482 break;
3483 }
drh3d6bedf2018-09-19 14:54:38 +00003484 case EX_Right: {
3485 pExpr->x.pRight = substExpr(pSubst, pExpr->x.pRight);
3486 break;
3487 }
danielk19776ab3a2e2009-02-19 14:39:25 +00003488 }
drh832508b2002-03-02 17:04:07 +00003489 }
drhb7916a72009-05-27 10:31:29 +00003490 return pExpr;
drh832508b2002-03-02 17:04:07 +00003491}
drh17435752007-08-16 04:30:38 +00003492static void substExprList(
drh46967de2017-04-14 12:39:37 +00003493 SubstContext *pSubst, /* Description of the substitution */
3494 ExprList *pList /* List to scan and in which to make substitutes */
drh17435752007-08-16 04:30:38 +00003495){
drh832508b2002-03-02 17:04:07 +00003496 int i;
3497 if( pList==0 ) return;
3498 for(i=0; i<pList->nExpr; i++){
drh46967de2017-04-14 12:39:37 +00003499 pList->a[i].pExpr = substExpr(pSubst, pList->a[i].pExpr);
drh832508b2002-03-02 17:04:07 +00003500 }
3501}
drh17435752007-08-16 04:30:38 +00003502static void substSelect(
drh46967de2017-04-14 12:39:37 +00003503 SubstContext *pSubst, /* Description of the substitution */
3504 Select *p, /* SELECT statement in which to make substitutions */
3505 int doPrior /* Do substitutes on p->pPrior too */
drh17435752007-08-16 04:30:38 +00003506){
drh588a9a12008-09-01 15:52:10 +00003507 SrcList *pSrc;
3508 struct SrcList_item *pItem;
3509 int i;
danielk1977b3bce662005-01-29 08:32:43 +00003510 if( !p ) return;
drhd12b6362015-10-11 19:46:59 +00003511 do{
drh46967de2017-04-14 12:39:37 +00003512 substExprList(pSubst, p->pEList);
3513 substExprList(pSubst, p->pGroupBy);
3514 substExprList(pSubst, p->pOrderBy);
3515 p->pHaving = substExpr(pSubst, p->pHaving);
3516 p->pWhere = substExpr(pSubst, p->pWhere);
drhd12b6362015-10-11 19:46:59 +00003517 pSrc = p->pSrc;
drh29064902015-10-11 20:08:31 +00003518 assert( pSrc!=0 );
drh588a9a12008-09-01 15:52:10 +00003519 for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){
drh46967de2017-04-14 12:39:37 +00003520 substSelect(pSubst, pItem->pSelect, 1);
drh29064902015-10-11 20:08:31 +00003521 if( pItem->fg.isTabFunc ){
drh46967de2017-04-14 12:39:37 +00003522 substExprList(pSubst, pItem->u1.pFuncArg);
drhd12b6362015-10-11 19:46:59 +00003523 }
drh588a9a12008-09-01 15:52:10 +00003524 }
drhd12b6362015-10-11 19:46:59 +00003525 }while( doPrior && (p = p->pPrior)!=0 );
danielk1977b3bce662005-01-29 08:32:43 +00003526}
shane3514b6f2008-07-22 05:00:55 +00003527#endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
drh832508b2002-03-02 17:04:07 +00003528
shane3514b6f2008-07-22 05:00:55 +00003529#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
drh832508b2002-03-02 17:04:07 +00003530/*
drh630d2962011-12-11 21:51:04 +00003531** This routine attempts to flatten subqueries as a performance optimization.
3532** This routine returns 1 if it makes changes and 0 if no flattening occurs.
drh1350b032002-02-27 19:00:20 +00003533**
3534** To understand the concept of flattening, consider the following
3535** query:
3536**
3537** SELECT a FROM (SELECT x+y AS a FROM t1 WHERE z<100) WHERE a>5
3538**
3539** The default way of implementing this query is to execute the
3540** subquery first and store the results in a temporary table, then
3541** run the outer query on that temporary table. This requires two
3542** passes over the data. Furthermore, because the temporary table
3543** has no indices, the WHERE clause on the outer query cannot be
drh832508b2002-03-02 17:04:07 +00003544** optimized.
drh1350b032002-02-27 19:00:20 +00003545**
drh832508b2002-03-02 17:04:07 +00003546** This routine attempts to rewrite queries such as the above into
drh1350b032002-02-27 19:00:20 +00003547** a single flat select, like this:
3548**
3549** SELECT x+y AS a FROM t1 WHERE z<100 AND a>5
3550**
peter.d.reid60ec9142014-09-06 16:39:46 +00003551** The code generated for this simplification gives the same result
drh832508b2002-03-02 17:04:07 +00003552** but only has to scan the data once. And because indices might
3553** exist on the table t1, a complete scan of the data might be
3554** avoided.
drh1350b032002-02-27 19:00:20 +00003555**
drhd981e822017-09-29 16:07:56 +00003556** Flattening is subject to the following constraints:
drh1350b032002-02-27 19:00:20 +00003557**
drh25c221e2017-09-29 22:13:24 +00003558** (**) We no longer attempt to flatten aggregate subqueries. Was:
3559** The subquery and the outer query cannot both be aggregates.
drh1350b032002-02-27 19:00:20 +00003560**
drh25c221e2017-09-29 22:13:24 +00003561** (**) We no longer attempt to flatten aggregate subqueries. Was:
3562** (2) If the subquery is an aggregate then
drhd981e822017-09-29 16:07:56 +00003563** (2a) the outer query must not be a join and
3564** (2b) the outer query must not use subqueries
3565** other than the one FROM-clause subquery that is a candidate
3566** for flattening. (This is due to ticket [2f7170d73bf9abf80]
3567** from 2015-02-09.)
drh832508b2002-03-02 17:04:07 +00003568**
drhd981e822017-09-29 16:07:56 +00003569** (3) If the subquery is the right operand of a LEFT JOIN then
3570** (3a) the subquery may not be a join and
3571** (3b) the FROM clause of the subquery may not contain a virtual
3572** table and
3573** (3c) the outer query may not be an aggregate.
drh832508b2002-03-02 17:04:07 +00003574**
drhd981e822017-09-29 16:07:56 +00003575** (4) The subquery can not be DISTINCT.
drh832508b2002-03-02 17:04:07 +00003576**
dan49ad3302010-08-13 16:38:48 +00003577** (**) At one point restrictions (4) and (5) defined a subset of DISTINCT
3578** sub-queries that were excluded from this optimization. Restriction
3579** (4) has since been expanded to exclude all DISTINCT subqueries.
drh832508b2002-03-02 17:04:07 +00003580**
drh25c221e2017-09-29 22:13:24 +00003581** (**) We no longer attempt to flatten aggregate subqueries. Was:
3582** If the subquery is aggregate, the outer query may not be DISTINCT.
drh832508b2002-03-02 17:04:07 +00003583**
drhd981e822017-09-29 16:07:56 +00003584** (7) The subquery must have a FROM clause. TODO: For subqueries without
drh31d6fd52017-04-14 19:03:10 +00003585** A FROM clause, consider adding a FROM clause with the special
drh630d2962011-12-11 21:51:04 +00003586** table sqlite_once that consists of a single row containing a
3587** single NULL.
drh08192d52002-04-30 19:20:28 +00003588**
drhd981e822017-09-29 16:07:56 +00003589** (8) If the subquery uses LIMIT then the outer query may not be a join.
drhdf199a22002-06-14 22:38:41 +00003590**
drhd981e822017-09-29 16:07:56 +00003591** (9) If the subquery uses LIMIT then the outer query may not be aggregate.
drhdf199a22002-06-14 22:38:41 +00003592**
drh6092d2b2014-09-15 11:14:50 +00003593** (**) Restriction (10) was removed from the code on 2005-02-05 but we
3594** accidently carried the comment forward until 2014-09-15. Original
drhd981e822017-09-29 16:07:56 +00003595** constraint: "If the subquery is aggregate then the outer query
3596** may not use LIMIT."
drhdf199a22002-06-14 22:38:41 +00003597**
drhd981e822017-09-29 16:07:56 +00003598** (11) The subquery and the outer query may not both have ORDER BY clauses.
drh174b6192002-12-03 02:22:52 +00003599**
drh7b688ed2009-12-22 00:29:53 +00003600** (**) Not implemented. Subsumed into restriction (3). Was previously
drh2b300d52008-08-14 00:19:48 +00003601** a separate restriction deriving from ticket #350.
drh3fc673e2003-06-16 00:40:34 +00003602**
drhd981e822017-09-29 16:07:56 +00003603** (13) The subquery and outer query may not both use LIMIT.
drhac839632006-01-21 22:19:54 +00003604**
drhd981e822017-09-29 16:07:56 +00003605** (14) The subquery may not use OFFSET.
drhac839632006-01-21 22:19:54 +00003606**
drhd981e822017-09-29 16:07:56 +00003607** (15) If the outer query is part of a compound select, then the
3608** subquery may not use LIMIT.
drhf3913272010-04-15 23:24:29 +00003609** (See ticket #2339 and ticket [02a8e81d44]).
drhad91c6c2007-05-06 20:04:24 +00003610**
drhd981e822017-09-29 16:07:56 +00003611** (16) If the outer query is aggregate, then the subquery may not
3612** use ORDER BY. (Ticket #2942) This used to not matter
drhc52e3552008-02-15 14:33:03 +00003613** until we introduced the group_concat() function.
3614**
drhd981e822017-09-29 16:07:56 +00003615** (17) If the subquery is a compound select, then
3616** (17a) all compound operators must be a UNION ALL, and
3617** (17b) no terms within the subquery compound may be aggregate
drhe76acc62017-10-04 02:30:45 +00003618** or DISTINCT, and
drhd981e822017-09-29 16:07:56 +00003619** (17c) every term within the subquery compound must have a FROM clause
3620** (17d) the outer query may not be
3621** (17d1) aggregate, or
3622** (17d2) DISTINCT, or
3623** (17d3) a join.
danielk1977f23329a2008-07-01 14:09:13 +00003624**
danielk19774914cf92008-07-01 18:26:49 +00003625** The parent and sub-query may contain WHERE clauses. Subject to
3626** rules (11), (13) and (14), they may also contain ORDER BY,
drh630d2962011-12-11 21:51:04 +00003627** LIMIT and OFFSET clauses. The subquery cannot use any compound
3628** operator other than UNION ALL because all the other compound
3629** operators have an implied DISTINCT which is disallowed by
3630** restriction (4).
danielk1977f23329a2008-07-01 14:09:13 +00003631**
dan67c70142012-08-28 14:45:50 +00003632** Also, each component of the sub-query must return the same number
3633** of result columns. This is actually a requirement for any compound
3634** SELECT statement, but all the code here does is make sure that no
3635** such (illegal) sub-query is flattened. The caller will detect the
3636** syntax error and return a detailed message.
3637**
danielk197749fc1f62008-07-08 17:43:56 +00003638** (18) If the sub-query is a compound select, then all terms of the
drhd981e822017-09-29 16:07:56 +00003639** ORDER BY clause of the parent must be simple references to
danielk197749fc1f62008-07-08 17:43:56 +00003640** columns of the sub-query.
3641**
drhd981e822017-09-29 16:07:56 +00003642** (19) If the subquery uses LIMIT then the outer query may not
drh229cf702008-08-26 12:56:14 +00003643** have a WHERE clause.
3644**
drhfca23552017-10-28 20:51:54 +00003645** (20) If the sub-query is a compound select, then it must not use
3646** an ORDER BY clause. Ticket #3773. We could relax this constraint
3647** somewhat by saying that the terms of the ORDER BY clause must
3648** appear as unmodified result columns in the outer query. But we
3649** have other optimizations in mind to deal with that case.
drhe8902a72009-04-02 16:59:47 +00003650**
drhd981e822017-09-29 16:07:56 +00003651** (21) If the subquery uses LIMIT then the outer query may not be
shaneha91491e2011-02-11 20:52:20 +00003652** DISTINCT. (See ticket [752e1646fc]).
3653**
drhd981e822017-09-29 16:07:56 +00003654** (22) The subquery may not be a recursive CTE.
dan8290c2a2014-01-16 10:58:39 +00003655**
drhcdb2f602017-10-04 05:59:54 +00003656** (**) Subsumed into restriction (17d3). Was: If the outer query is
3657** a recursive CTE, then the sub-query may not be a compound query.
3658** This restriction is because transforming the
dan8290c2a2014-01-16 10:58:39 +00003659** parent to a compound query confuses the code that handles
3660** recursive queries in multiSelect().
3661**
drh508e2d02017-09-30 01:25:04 +00003662** (**) We no longer attempt to flatten aggregate subqueries. Was:
3663** The subquery may not be an aggregate that uses the built-in min() or
drh9588ad92014-09-15 14:46:02 +00003664** or max() functions. (Without this restriction, a query like:
3665** "SELECT x FROM (SELECT max(y), x FROM t1)" would not necessarily
3666** return the value X for which Y was maximal.)
3667**
dan9a947222018-06-14 19:06:36 +00003668** (25) If either the subquery or the parent query contains a window
3669** function in the select list or ORDER BY clause, flattening
3670** is not attempted.
3671**
dan8290c2a2014-01-16 10:58:39 +00003672**
drh832508b2002-03-02 17:04:07 +00003673** In this routine, the "p" parameter is a pointer to the outer query.
3674** The subquery is p->pSrc->a[iFrom]. isAgg is true if the outer query
drh25c221e2017-09-29 22:13:24 +00003675** uses aggregates.
drh832508b2002-03-02 17:04:07 +00003676**
drh665de472003-03-31 13:36:09 +00003677** If flattening is not attempted, this routine is a no-op and returns 0.
drh832508b2002-03-02 17:04:07 +00003678** If flattening is attempted this routine returns 1.
3679**
3680** All of the expression analysis must occur on both the outer query and
3681** the subquery before this routine runs.
drh1350b032002-02-27 19:00:20 +00003682*/
drh8c74a8c2002-08-25 19:20:40 +00003683static int flattenSubquery(
danielk1977524cc212008-07-02 13:13:51 +00003684 Parse *pParse, /* Parsing context */
drh8c74a8c2002-08-25 19:20:40 +00003685 Select *p, /* The parent or outer SELECT statement */
3686 int iFrom, /* Index in p->pSrc->a[] of the inner subquery */
drh25c221e2017-09-29 22:13:24 +00003687 int isAgg /* True if outer SELECT uses aggregate functions */
drh8c74a8c2002-08-25 19:20:40 +00003688){
danielk1977524cc212008-07-02 13:13:51 +00003689 const char *zSavedAuthContext = pParse->zAuthContext;
drhd12b6362015-10-11 19:46:59 +00003690 Select *pParent; /* Current UNION ALL term of the other query */
drh0bb28102002-05-08 11:54:14 +00003691 Select *pSub; /* The inner query or "subquery" */
danielk1977f23329a2008-07-01 14:09:13 +00003692 Select *pSub1; /* Pointer to the rightmost select in sub-query */
drhad3cab52002-05-24 02:04:32 +00003693 SrcList *pSrc; /* The FROM clause of the outer query */
3694 SrcList *pSubSrc; /* The FROM clause of the subquery */
drh6a3ea0e2003-05-02 14:32:12 +00003695 int iParent; /* VDBE cursor number of the pSub result set temp table */
drh399c7e22017-04-14 17:18:45 +00003696 int iNewParent = -1;/* Replacement table for iParent */
3697 int isLeftJoin = 0; /* True if pSub is the right side of a LEFT JOIN */
drh91bb0ee2004-09-01 03:06:34 +00003698 int i; /* Loop counter */
3699 Expr *pWhere; /* The WHERE clause */
3700 struct SrcList_item *pSubitem; /* The subquery */
danielk1977524cc212008-07-02 13:13:51 +00003701 sqlite3 *db = pParse->db;
drh1350b032002-02-27 19:00:20 +00003702
drh832508b2002-03-02 17:04:07 +00003703 /* Check to see if flattening is permitted. Return 0 if not.
3704 */
drha78c22c2008-11-11 18:28:58 +00003705 assert( p!=0 );
drhd981e822017-09-29 16:07:56 +00003706 assert( p->pPrior==0 );
drh7e5418e2012-09-27 15:05:54 +00003707 if( OptimizationDisabled(db, SQLITE_QueryFlattener) ) return 0;
drh832508b2002-03-02 17:04:07 +00003708 pSrc = p->pSrc;
drhad3cab52002-05-24 02:04:32 +00003709 assert( pSrc && iFrom>=0 && iFrom<pSrc->nSrc );
drh91bb0ee2004-09-01 03:06:34 +00003710 pSubitem = &pSrc->a[iFrom];
danielk197749fc1f62008-07-08 17:43:56 +00003711 iParent = pSubitem->iCursor;
drh91bb0ee2004-09-01 03:06:34 +00003712 pSub = pSubitem->pSelect;
drh832508b2002-03-02 17:04:07 +00003713 assert( pSub!=0 );
drh399c7e22017-04-14 17:18:45 +00003714
dan67a9b8e2018-06-22 20:51:35 +00003715#ifndef SQLITE_OMIT_WINDOWFUNC
dan9a947222018-06-14 19:06:36 +00003716 if( p->pWin || pSub->pWin ) return 0; /* Restriction (25) */
dan67a9b8e2018-06-22 20:51:35 +00003717#endif
dan86fb6e12018-05-16 20:58:07 +00003718
drh832508b2002-03-02 17:04:07 +00003719 pSubSrc = pSub->pSrc;
3720 assert( pSubSrc );
drhac839632006-01-21 22:19:54 +00003721 /* Prior to version 3.1.2, when LIMIT and OFFSET had to be simple constants,
peter.d.reid60ec9142014-09-06 16:39:46 +00003722 ** not arbitrary expressions, we allowed some combining of LIMIT and OFFSET
drhac839632006-01-21 22:19:54 +00003723 ** because they could be computed at compile-time. But when LIMIT and OFFSET
3724 ** became arbitrary expressions, we were forced to add restrictions (13)
3725 ** and (14). */
3726 if( pSub->pLimit && p->pLimit ) return 0; /* Restriction (13) */
drh3d6bedf2018-09-19 14:54:38 +00003727 if( pSub->pLimit && pSub->pLimit->eX==EX_Right ){
3728 return 0; /* Restriction (14) */
3729 }
drhd227a292014-02-09 18:02:09 +00003730 if( (p->selFlags & SF_Compound)!=0 && pSub->pLimit ){
drhad91c6c2007-05-06 20:04:24 +00003731 return 0; /* Restriction (15) */
3732 }
drhac839632006-01-21 22:19:54 +00003733 if( pSubSrc->nSrc==0 ) return 0; /* Restriction (7) */
drhd981e822017-09-29 16:07:56 +00003734 if( pSub->selFlags & SF_Distinct ) return 0; /* Restriction (4) */
dan49ad3302010-08-13 16:38:48 +00003735 if( pSub->pLimit && (pSrc->nSrc>1 || isAgg) ){
3736 return 0; /* Restrictions (8)(9) */
drhdf199a22002-06-14 22:38:41 +00003737 }
drh7d10d5a2008-08-20 16:35:10 +00003738 if( p->pOrderBy && pSub->pOrderBy ){
drhac839632006-01-21 22:19:54 +00003739 return 0; /* Restriction (11) */
3740 }
drhc52e3552008-02-15 14:33:03 +00003741 if( isAgg && pSub->pOrderBy ) return 0; /* Restriction (16) */
drh229cf702008-08-26 12:56:14 +00003742 if( pSub->pLimit && p->pWhere ) return 0; /* Restriction (19) */
shaneha91491e2011-02-11 20:52:20 +00003743 if( pSub->pLimit && (p->selFlags & SF_Distinct)!=0 ){
3744 return 0; /* Restriction (21) */
3745 }
drh508e2d02017-09-30 01:25:04 +00003746 if( pSub->selFlags & (SF_Recursive) ){
3747 return 0; /* Restrictions (22) */
drh9588ad92014-09-15 14:46:02 +00003748 }
drh832508b2002-03-02 17:04:07 +00003749
drh399c7e22017-04-14 17:18:45 +00003750 /*
3751 ** If the subquery is the right operand of a LEFT JOIN, then the
drhd981e822017-09-29 16:07:56 +00003752 ** subquery may not be a join itself (3a). Example of why this is not
3753 ** allowed:
drh8af4d3a2003-05-06 20:35:16 +00003754 **
3755 ** t1 LEFT OUTER JOIN (t2 JOIN t3)
3756 **
3757 ** If we flatten the above, we would get
3758 **
3759 ** (t1 LEFT OUTER JOIN t2) JOIN t3
3760 **
3761 ** which is not at all the same thing.
drh2b300d52008-08-14 00:19:48 +00003762 **
drh3c790f22017-05-23 15:33:41 +00003763 ** If the subquery is the right operand of a LEFT JOIN, then the outer
drhd981e822017-09-29 16:07:56 +00003764 ** query cannot be an aggregate. (3c) This is an artifact of the way
3765 ** aggregates are processed - there is no mechanism to determine if
3766 ** the LEFT JOIN table should be all-NULL.
drh3c790f22017-05-23 15:33:41 +00003767 **
drh31d6fd52017-04-14 19:03:10 +00003768 ** See also tickets #306, #350, and #3300.
drh3fc673e2003-06-16 00:40:34 +00003769 */
drh8a48b9c2015-08-19 15:20:00 +00003770 if( (pSubitem->fg.jointype & JT_OUTER)!=0 ){
drh399c7e22017-04-14 17:18:45 +00003771 isLeftJoin = 1;
dan46133d92017-07-18 17:34:41 +00003772 if( pSubSrc->nSrc>1 || isAgg || IsVirtual(pSubSrc->a[0].pTab) ){
drhd981e822017-09-29 16:07:56 +00003773 /* (3a) (3c) (3b) */
3774 return 0;
drh399c7e22017-04-14 17:18:45 +00003775 }
drh3fc673e2003-06-16 00:40:34 +00003776 }
drhdc6de472017-05-25 11:39:50 +00003777#ifdef SQLITE_EXTRA_IFNULLROW
3778 else if( iFrom>0 && !isAgg ){
3779 /* Setting isLeftJoin to -1 causes OP_IfNullRow opcodes to be generated for
drh3d240d22017-09-28 16:56:55 +00003780 ** every reference to any result column from subquery in a join, even
3781 ** though they are not necessary. This will stress-test the OP_IfNullRow
3782 ** opcode. */
drhdc6de472017-05-25 11:39:50 +00003783 isLeftJoin = -1;
3784 }
3785#endif
drh3fc673e2003-06-16 00:40:34 +00003786
drhd981e822017-09-29 16:07:56 +00003787 /* Restriction (17): If the sub-query is a compound SELECT, then it must
danielk1977f23329a2008-07-01 14:09:13 +00003788 ** use only the UNION ALL operator. And none of the simple select queries
3789 ** that make up the compound SELECT are allowed to be aggregate or distinct
3790 ** queries.
3791 */
3792 if( pSub->pPrior ){
drhfca23552017-10-28 20:51:54 +00003793 if( pSub->pOrderBy ){
3794 return 0; /* Restriction (20) */
3795 }
drhe2f02ba2009-01-09 01:12:27 +00003796 if( isAgg || (p->selFlags & SF_Distinct)!=0 || pSrc->nSrc!=1 ){
drhd981e822017-09-29 16:07:56 +00003797 return 0; /* (17d1), (17d2), or (17d3) */
danielk1977f23329a2008-07-01 14:09:13 +00003798 }
3799 for(pSub1=pSub; pSub1; pSub1=pSub1->pPrior){
drhccfcbce2009-05-18 15:46:07 +00003800 testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct );
3801 testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate );
drh4b3ac732011-12-10 23:18:32 +00003802 assert( pSub->pSrc!=0 );
drh2ec18a32015-06-23 23:31:52 +00003803 assert( pSub->pEList->nExpr==pSub1->pEList->nExpr );
drhd981e822017-09-29 16:07:56 +00003804 if( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))!=0 /* (17b) */
3805 || (pSub1->pPrior && pSub1->op!=TK_ALL) /* (17a) */
3806 || pSub1->pSrc->nSrc<1 /* (17c) */
danielk197780b3c542008-07-10 17:59:12 +00003807 ){
danielk1977f23329a2008-07-01 14:09:13 +00003808 return 0;
3809 }
drh4b3ac732011-12-10 23:18:32 +00003810 testcase( pSub1->pSrc->nSrc>1 );
danielk1977f23329a2008-07-01 14:09:13 +00003811 }
danielk197749fc1f62008-07-08 17:43:56 +00003812
drhd981e822017-09-29 16:07:56 +00003813 /* Restriction (18). */
danielk197749fc1f62008-07-08 17:43:56 +00003814 if( p->pOrderBy ){
3815 int ii;
3816 for(ii=0; ii<p->pOrderBy->nExpr; ii++){
drhc2acc4e2013-11-15 18:15:19 +00003817 if( p->pOrderBy->a[ii].u.x.iOrderByCol==0 ) return 0;
danielk197749fc1f62008-07-08 17:43:56 +00003818 }
3819 }
danielk1977f23329a2008-07-01 14:09:13 +00003820 }
3821
drhcdb2f602017-10-04 05:59:54 +00003822 /* Ex-restriction (23):
3823 ** The only way that the recursive part of a CTE can contain a compound
3824 ** subquery is for the subquery to be one term of a join. But if the
3825 ** subquery is a join, then the flattening has already been stopped by
3826 ** restriction (17d3)
3827 */
3828 assert( (p->selFlags & SF_Recursive)==0 || pSub->pPrior==0 );
3829
drh7d10d5a2008-08-20 16:35:10 +00003830 /***** If we reach this point, flattening is permitted. *****/
drhfef37762018-07-10 19:48:35 +00003831 SELECTTRACE(1,pParse,p,("flatten %u.%p from term %d\n",
3832 pSub->selId, pSub, iFrom));
drh7d10d5a2008-08-20 16:35:10 +00003833
3834 /* Authorize the subquery */
danielk1977524cc212008-07-02 13:13:51 +00003835 pParse->zAuthContext = pSubitem->zName;
drha2acb0d2012-04-11 23:22:37 +00003836 TESTONLY(i =) sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0);
3837 testcase( i==SQLITE_DENY );
danielk1977524cc212008-07-02 13:13:51 +00003838 pParse->zAuthContext = zSavedAuthContext;
3839
drh7d10d5a2008-08-20 16:35:10 +00003840 /* If the sub-query is a compound SELECT statement, then (by restrictions
3841 ** 17 and 18 above) it must be a UNION ALL and the parent query must
3842 ** be of the form:
danielk1977f23329a2008-07-01 14:09:13 +00003843 **
3844 ** SELECT <expr-list> FROM (<sub-query>) <where-clause>
3845 **
3846 ** followed by any ORDER BY, LIMIT and/or OFFSET clauses. This block
drha78c22c2008-11-11 18:28:58 +00003847 ** creates N-1 copies of the parent query without any ORDER BY, LIMIT or
danielk1977f23329a2008-07-01 14:09:13 +00003848 ** OFFSET clauses and joins them to the left-hand-side of the original
3849 ** using UNION ALL operators. In this case N is the number of simple
3850 ** select statements in the compound sub-query.
drha78c22c2008-11-11 18:28:58 +00003851 **
3852 ** Example:
3853 **
3854 ** SELECT a+1 FROM (
3855 ** SELECT x FROM tab
3856 ** UNION ALL
3857 ** SELECT y FROM tab
3858 ** UNION ALL
3859 ** SELECT abs(z*2) FROM tab2
3860 ** ) WHERE a!=5 ORDER BY 1
3861 **
3862 ** Transformed into:
3863 **
3864 ** SELECT x+1 FROM tab WHERE x+1!=5
3865 ** UNION ALL
3866 ** SELECT y+1 FROM tab WHERE y+1!=5
3867 ** UNION ALL
3868 ** SELECT abs(z*2)+1 FROM tab2 WHERE abs(z*2)+1!=5
3869 ** ORDER BY 1
3870 **
3871 ** We call this the "compound-subquery flattening".
danielk1977f23329a2008-07-01 14:09:13 +00003872 */
3873 for(pSub=pSub->pPrior; pSub; pSub=pSub->pPrior){
3874 Select *pNew;
3875 ExprList *pOrderBy = p->pOrderBy;
danielk19774b86ef12008-07-01 14:39:35 +00003876 Expr *pLimit = p->pLimit;
danielk1977f23329a2008-07-01 14:09:13 +00003877 Select *pPrior = p->pPrior;
3878 p->pOrderBy = 0;
3879 p->pSrc = 0;
3880 p->pPrior = 0;
danielk19774b86ef12008-07-01 14:39:35 +00003881 p->pLimit = 0;
danielk19776ab3a2e2009-02-19 14:39:25 +00003882 pNew = sqlite3SelectDup(db, p, 0);
danielk19774b86ef12008-07-01 14:39:35 +00003883 p->pLimit = pLimit;
drha78c22c2008-11-11 18:28:58 +00003884 p->pOrderBy = pOrderBy;
3885 p->pSrc = pSrc;
3886 p->op = TK_ALL;
drha78c22c2008-11-11 18:28:58 +00003887 if( pNew==0 ){
drhd227a292014-02-09 18:02:09 +00003888 p->pPrior = pPrior;
drha78c22c2008-11-11 18:28:58 +00003889 }else{
3890 pNew->pPrior = pPrior;
drhd227a292014-02-09 18:02:09 +00003891 if( pPrior ) pPrior->pNext = pNew;
3892 pNew->pNext = p;
3893 p->pPrior = pNew;
drhe2243d22018-04-23 17:18:03 +00003894 SELECTTRACE(2,pParse,p,("compound-subquery flattener"
drhfef37762018-07-10 19:48:35 +00003895 " creates %u as peer\n",pNew->selId));
drha78c22c2008-11-11 18:28:58 +00003896 }
drha78c22c2008-11-11 18:28:58 +00003897 if( db->mallocFailed ) return 1;
danielk1977f23329a2008-07-01 14:09:13 +00003898 }
3899
drh7d10d5a2008-08-20 16:35:10 +00003900 /* Begin flattening the iFrom-th entry of the FROM clause
3901 ** in the outer query.
drh832508b2002-03-02 17:04:07 +00003902 */
danielk1977f23329a2008-07-01 14:09:13 +00003903 pSub = pSub1 = pSubitem->pSelect;
drha78c22c2008-11-11 18:28:58 +00003904
3905 /* Delete the transient table structure associated with the
3906 ** subquery
3907 */
3908 sqlite3DbFree(db, pSubitem->zDatabase);
3909 sqlite3DbFree(db, pSubitem->zName);
3910 sqlite3DbFree(db, pSubitem->zAlias);
3911 pSubitem->zDatabase = 0;
3912 pSubitem->zName = 0;
3913 pSubitem->zAlias = 0;
3914 pSubitem->pSelect = 0;
3915
3916 /* Defer deleting the Table object associated with the
3917 ** subquery until code generation is
3918 ** complete, since there may still exist Expr.pTab entries that
3919 ** refer to the subquery even after flattening. Ticket #3346.
drhccfcbce2009-05-18 15:46:07 +00003920 **
3921 ** pSubitem->pTab is always non-NULL by test restrictions and tests above.
drha78c22c2008-11-11 18:28:58 +00003922 */
drhccfcbce2009-05-18 15:46:07 +00003923 if( ALWAYS(pSubitem->pTab!=0) ){
drha78c22c2008-11-11 18:28:58 +00003924 Table *pTabToDel = pSubitem->pTab;
drh79df7782016-12-14 14:07:35 +00003925 if( pTabToDel->nTabRef==1 ){
dan65a7cd12009-09-01 12:16:01 +00003926 Parse *pToplevel = sqlite3ParseToplevel(pParse);
3927 pTabToDel->pNextZombie = pToplevel->pZombieTab;
3928 pToplevel->pZombieTab = pTabToDel;
drha78c22c2008-11-11 18:28:58 +00003929 }else{
drh79df7782016-12-14 14:07:35 +00003930 pTabToDel->nTabRef--;
drha78c22c2008-11-11 18:28:58 +00003931 }
3932 pSubitem->pTab = 0;
3933 }
3934
3935 /* The following loop runs once for each term in a compound-subquery
3936 ** flattening (as described above). If we are doing a different kind
3937 ** of flattening - a flattening other than a compound-subquery flattening -
3938 ** then this loop only runs once.
3939 **
3940 ** This loop moves all of the FROM elements of the subquery into the
3941 ** the FROM clause of the outer query. Before doing this, remember
3942 ** the cursor number for the original outer query FROM element in
3943 ** iParent. The iParent cursor will never be used. Subsequent code
3944 ** will scan expressions looking for iParent references and replace
3945 ** those references with expressions that resolve to the subquery FROM
3946 ** elements we are now copying in.
3947 */
danielk1977f23329a2008-07-01 14:09:13 +00003948 for(pParent=p; pParent; pParent=pParent->pPrior, pSub=pSub->pPrior){
drha78c22c2008-11-11 18:28:58 +00003949 int nSubSrc;
drhea678832008-12-10 19:26:22 +00003950 u8 jointype = 0;
drha78c22c2008-11-11 18:28:58 +00003951 pSubSrc = pSub->pSrc; /* FROM clause of subquery */
3952 nSubSrc = pSubSrc->nSrc; /* Number of terms in subquery FROM clause */
3953 pSrc = pParent->pSrc; /* FROM clause of the outer query */
drhc31c2eb2003-05-02 16:04:17 +00003954
danielk1977f23329a2008-07-01 14:09:13 +00003955 if( pSrc ){
drha78c22c2008-11-11 18:28:58 +00003956 assert( pParent==p ); /* First time through the loop */
drh8a48b9c2015-08-19 15:20:00 +00003957 jointype = pSubitem->fg.jointype;
drha78c22c2008-11-11 18:28:58 +00003958 }else{
3959 assert( pParent!=p ); /* 2nd and subsequent times through the loop */
3960 pSrc = pParent->pSrc = sqlite3SrcListAppend(db, 0, 0, 0);
3961 if( pSrc==0 ){
3962 assert( db->mallocFailed );
3963 break;
3964 }
3965 }
drh588a9a12008-09-01 15:52:10 +00003966
drha78c22c2008-11-11 18:28:58 +00003967 /* The subquery uses a single slot of the FROM clause of the outer
3968 ** query. If the subquery has more than one element in its FROM clause,
3969 ** then expand the outer query to make space for it to hold all elements
3970 ** of the subquery.
3971 **
3972 ** Example:
3973 **
3974 ** SELECT * FROM tabA, (SELECT * FROM sub1, sub2), tabB;
3975 **
3976 ** The outer query has 3 slots in its FROM clause. One slot of the
3977 ** outer query (the middle slot) is used by the subquery. The next
drhd12b6362015-10-11 19:46:59 +00003978 ** block of code will expand the outer query FROM clause to 4 slots.
3979 ** The middle slot is expanded to two slots in order to make space
3980 ** for the two elements in the FROM clause of the subquery.
drha78c22c2008-11-11 18:28:58 +00003981 */
3982 if( nSubSrc>1 ){
3983 pParent->pSrc = pSrc = sqlite3SrcListEnlarge(db, pSrc, nSubSrc-1,iFrom+1);
3984 if( db->mallocFailed ){
3985 break;
drhc31c2eb2003-05-02 16:04:17 +00003986 }
3987 }
drha78c22c2008-11-11 18:28:58 +00003988
3989 /* Transfer the FROM clause terms from the subquery into the
3990 ** outer query.
3991 */
drhc31c2eb2003-05-02 16:04:17 +00003992 for(i=0; i<nSubSrc; i++){
drhc3a84022009-06-12 03:27:26 +00003993 sqlite3IdListDelete(db, pSrc->a[i+iFrom].pUsing);
drh20292312015-11-21 13:24:46 +00003994 assert( pSrc->a[i+iFrom].fg.isTabFunc==0 );
drhc31c2eb2003-05-02 16:04:17 +00003995 pSrc->a[i+iFrom] = pSubSrc->a[i];
drh399c7e22017-04-14 17:18:45 +00003996 iNewParent = pSubSrc->a[i].iCursor;
drhc31c2eb2003-05-02 16:04:17 +00003997 memset(&pSubSrc->a[i], 0, sizeof(pSubSrc->a[i]));
3998 }
drh8a48b9c2015-08-19 15:20:00 +00003999 pSrc->a[iFrom].fg.jointype = jointype;
danielk1977f23329a2008-07-01 14:09:13 +00004000
4001 /* Now begin substituting subquery result set expressions for
4002 ** references to the iParent in the outer query.
4003 **
4004 ** Example:
4005 **
4006 ** SELECT a+5, b*10 FROM (SELECT x*3 AS a, y+10 AS b FROM t1) WHERE a>b;
4007 ** \ \_____________ subquery __________/ /
4008 ** \_____________________ outer query ______________________________/
4009 **
4010 ** We look at every expression in the outer query and every place we see
4011 ** "a" we substitute "x*3" and every place we see "b" we substitute "y+10".
4012 */
danielk1977f23329a2008-07-01 14:09:13 +00004013 if( pSub->pOrderBy ){
dan7c0a4722014-09-20 20:38:48 +00004014 /* At this point, any non-zero iOrderByCol values indicate that the
4015 ** ORDER BY column expression is identical to the iOrderByCol'th
4016 ** expression returned by SELECT statement pSub. Since these values
4017 ** do not necessarily correspond to columns in SELECT statement pParent,
4018 ** zero them before transfering the ORDER BY clause.
4019 **
4020 ** Not doing this may cause an error if a subsequent call to this
4021 ** function attempts to flatten a compound sub-query into pParent
4022 ** (the only way this can happen is if the compound sub-query is
4023 ** currently part of pSub->pSrc). See ticket [d11a6e908f]. */
4024 ExprList *pOrderBy = pSub->pOrderBy;
4025 for(i=0; i<pOrderBy->nExpr; i++){
4026 pOrderBy->a[i].u.x.iOrderByCol = 0;
4027 }
danielk1977f23329a2008-07-01 14:09:13 +00004028 assert( pParent->pOrderBy==0 );
dan7c0a4722014-09-20 20:38:48 +00004029 pParent->pOrderBy = pOrderBy;
danielk1977f23329a2008-07-01 14:09:13 +00004030 pSub->pOrderBy = 0;
danielk1977f23329a2008-07-01 14:09:13 +00004031 }
drhd12b6362015-10-11 19:46:59 +00004032 pWhere = sqlite3ExprDup(db, pSub->pWhere, 0);
drhdc6de472017-05-25 11:39:50 +00004033 if( isLeftJoin>0 ){
drh399c7e22017-04-14 17:18:45 +00004034 setJoinExpr(pWhere, iNewParent);
4035 }
drh25c221e2017-09-29 22:13:24 +00004036 pParent->pWhere = sqlite3ExprAnd(db, pWhere, pParent->pWhere);
danc3becdd2017-03-13 14:30:40 +00004037 if( db->mallocFailed==0 ){
drh46967de2017-04-14 12:39:37 +00004038 SubstContext x;
4039 x.pParse = pParse;
4040 x.iTable = iParent;
drh399c7e22017-04-14 17:18:45 +00004041 x.iNewTable = iNewParent;
drh31d6fd52017-04-14 19:03:10 +00004042 x.isLeftJoin = isLeftJoin;
drh46967de2017-04-14 12:39:37 +00004043 x.pEList = pSub->pEList;
4044 substSelect(&x, pParent, 0);
danc3becdd2017-03-13 14:30:40 +00004045 }
danielk1977f23329a2008-07-01 14:09:13 +00004046
4047 /* The flattened query is distinct if either the inner or the
4048 ** outer query is distinct.
4049 */
drh7d10d5a2008-08-20 16:35:10 +00004050 pParent->selFlags |= pSub->selFlags & SF_Distinct;
danielk1977f23329a2008-07-01 14:09:13 +00004051
4052 /*
4053 ** SELECT ... FROM (SELECT ... LIMIT a OFFSET b) LIMIT x OFFSET y;
4054 **
4055 ** One is tempted to try to add a and b to combine the limits. But this
4056 ** does not work if either limit is negative.
4057 */
4058 if( pSub->pLimit ){
4059 pParent->pLimit = pSub->pLimit;
4060 pSub->pLimit = 0;
4061 }
drhdf199a22002-06-14 22:38:41 +00004062 }
drh8c74a8c2002-08-25 19:20:40 +00004063
drhc31c2eb2003-05-02 16:04:17 +00004064 /* Finially, delete what is left of the subquery and return
4065 ** success.
4066 */
drh633e6d52008-07-28 19:34:53 +00004067 sqlite3SelectDelete(db, pSub1);
danielk1977f23329a2008-07-01 14:09:13 +00004068
drhc90713d2014-09-30 13:46:49 +00004069#if SELECTTRACE_ENABLED
4070 if( sqlite3SelectTrace & 0x100 ){
drhbc8edba2015-06-05 20:27:26 +00004071 SELECTTRACE(0x100,pParse,p,("After flattening:\n"));
drhc90713d2014-09-30 13:46:49 +00004072 sqlite3TreeViewSelect(0, p, 0);
4073 }
4074#endif
4075
drh832508b2002-03-02 17:04:07 +00004076 return 1;
4077}
shane3514b6f2008-07-22 05:00:55 +00004078#endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
drh1350b032002-02-27 19:00:20 +00004079
drh660ee552018-07-26 21:16:53 +00004080/*
drhefad2e22018-07-27 16:57:11 +00004081** A structure to keep track of all of the column values that fixed to
4082** a known value due to WHERE clause constraints of the form COLUMN=VALUE.
drh660ee552018-07-26 21:16:53 +00004083*/
4084typedef struct WhereConst WhereConst;
4085struct WhereConst {
drhefad2e22018-07-27 16:57:11 +00004086 Parse *pParse; /* Parsing context */
drh660ee552018-07-26 21:16:53 +00004087 int nConst; /* Number for COLUMN=CONSTANT terms */
4088 int nChng; /* Number of times a constant is propagated */
drhefad2e22018-07-27 16:57:11 +00004089 Expr **apExpr; /* [i*2] is COLUMN and [i*2+1] is VALUE */
drh660ee552018-07-26 21:16:53 +00004090};
drh69b72d52015-06-01 20:28:03 +00004091
drh660ee552018-07-26 21:16:53 +00004092/*
4093** Add a new entry to the pConst object
4094*/
4095static void constInsert(
4096 WhereConst *pConst,
4097 Expr *pColumn,
4098 Expr *pValue
4099){
drh9cbf4f32018-07-27 20:01:00 +00004100
drh660ee552018-07-26 21:16:53 +00004101 pConst->nConst++;
drhefad2e22018-07-27 16:57:11 +00004102 pConst->apExpr = sqlite3DbReallocOrFree(pConst->pParse->db, pConst->apExpr,
drh660ee552018-07-26 21:16:53 +00004103 pConst->nConst*2*sizeof(Expr*));
4104 if( pConst->apExpr==0 ){
4105 pConst->nConst = 0;
4106 }else{
drhefad2e22018-07-27 16:57:11 +00004107 if( ExprHasProperty(pValue, EP_FixedCol) ) pValue = pValue->pLeft;
drh660ee552018-07-26 21:16:53 +00004108 pConst->apExpr[pConst->nConst*2-2] = pColumn;
4109 pConst->apExpr[pConst->nConst*2-1] = pValue;
4110 }
4111}
4112
4113/*
drhefad2e22018-07-27 16:57:11 +00004114** Find all terms of COLUMN=VALUE or VALUE=COLUMN in pExpr where VALUE
4115** is a constant expression and where the term must be true because it
4116** is part of the AND-connected terms of the expression. For each term
4117** found, add it to the pConst structure.
drh660ee552018-07-26 21:16:53 +00004118*/
4119static void findConstInWhere(WhereConst *pConst, Expr *pExpr){
drhefad2e22018-07-27 16:57:11 +00004120 Expr *pRight, *pLeft;
drh660ee552018-07-26 21:16:53 +00004121 if( pExpr==0 ) return;
4122 if( ExprHasProperty(pExpr, EP_FromJoin) ) return;
4123 if( pExpr->op==TK_AND ){
drh3d6bedf2018-09-19 14:54:38 +00004124 assert( pExpr->eX==EX_Right );
4125 findConstInWhere(pConst, pExpr->x.pRight);
drh660ee552018-07-26 21:16:53 +00004126 findConstInWhere(pConst, pExpr->pLeft);
4127 return;
4128 }
4129 if( pExpr->op!=TK_EQ ) return;
drh3d6bedf2018-09-19 14:54:38 +00004130 assert( pExpr->eX==EX_Right );
4131 pRight = pExpr->x.pRight;
drhefad2e22018-07-27 16:57:11 +00004132 pLeft = pExpr->pLeft;
4133 assert( pRight!=0 );
4134 assert( pLeft!=0 );
drhefad2e22018-07-27 16:57:11 +00004135 if( pRight->op==TK_COLUMN
4136 && !ExprHasProperty(pRight, EP_FixedCol)
4137 && sqlite3ExprIsConstant(pLeft)
drh3d6bedf2018-09-19 14:54:38 +00004138 && sqlite3IsBinary(sqlite3ComparisonCollSeq(pConst->pParse,pLeft,pRight))
drhefad2e22018-07-27 16:57:11 +00004139 ){
4140 constInsert(pConst, pRight, pLeft);
drh660ee552018-07-26 21:16:53 +00004141 }else
drhefad2e22018-07-27 16:57:11 +00004142 if( pLeft->op==TK_COLUMN
4143 && !ExprHasProperty(pLeft, EP_FixedCol)
drh9cbf4f32018-07-27 20:01:00 +00004144 && sqlite3ExprIsConstant(pRight)
drh3d6bedf2018-09-19 14:54:38 +00004145 && sqlite3IsBinary(sqlite3ComparisonCollSeq(pConst->pParse,pLeft,pRight))
drh9cbf4f32018-07-27 20:01:00 +00004146 ){
drhefad2e22018-07-27 16:57:11 +00004147 constInsert(pConst, pLeft, pRight);
drh660ee552018-07-26 21:16:53 +00004148 }
4149}
4150
4151/*
4152** This is a Walker expression callback. pExpr is a candidate expression
4153** to be replaced by a value. If pExpr is equivalent to one of the
4154** columns named in pWalker->u.pConst, then overwrite it with its
4155** corresponding value.
4156*/
4157static int propagateConstantExprRewrite(Walker *pWalker, Expr *pExpr){
4158 int i;
4159 WhereConst *pConst;
4160 if( pExpr->op!=TK_COLUMN ) return WRC_Continue;
drhefad2e22018-07-27 16:57:11 +00004161 if( ExprHasProperty(pExpr, EP_FixedCol) ) return WRC_Continue;
drh660ee552018-07-26 21:16:53 +00004162 pConst = pWalker->u.pConst;
4163 for(i=0; i<pConst->nConst; i++){
4164 Expr *pColumn = pConst->apExpr[i*2];
4165 if( pColumn==pExpr ) continue;
4166 if( pColumn->iTable!=pExpr->iTable ) continue;
4167 if( pColumn->iColumn!=pExpr->iColumn ) continue;
drhefad2e22018-07-27 16:57:11 +00004168 /* A match is found. Add the EP_FixedCol property */
drh660ee552018-07-26 21:16:53 +00004169 pConst->nChng++;
4170 ExprClearProperty(pExpr, EP_Leaf);
drhefad2e22018-07-27 16:57:11 +00004171 ExprSetProperty(pExpr, EP_FixedCol);
4172 assert( pExpr->pLeft==0 );
4173 pExpr->pLeft = sqlite3ExprDup(pConst->pParse->db, pConst->apExpr[i*2+1], 0);
drh660ee552018-07-26 21:16:53 +00004174 break;
4175 }
4176 return WRC_Prune;
4177}
4178
4179/*
4180** The WHERE-clause constant propagation optimization.
4181**
4182** If the WHERE clause contains terms of the form COLUMN=CONSTANT or
4183** CONSTANT=COLUMN that must be tree (in other words, if the terms top-level
4184** AND-connected terms that are not part of a ON clause from a LEFT JOIN)
4185** then throughout the query replace all other occurrences of COLUMN
drhefad2e22018-07-27 16:57:11 +00004186** with CONSTANT within the WHERE clause.
drh660ee552018-07-26 21:16:53 +00004187**
4188** For example, the query:
4189**
4190** SELECT * FROM t1, t2, t3 WHERE t1.a=39 AND t2.b=t1.a AND t3.c=t2.b
4191**
4192** Is transformed into
4193**
4194** SELECT * FROM t1, t2, t3 WHERE t1.a=39 AND t2.b=39 AND t3.c=39
4195**
4196** Return true if any transformations where made and false if not.
drhefad2e22018-07-27 16:57:11 +00004197**
4198** Implementation note: Constant propagation is tricky due to affinity
4199** and collating sequence interactions. Consider this example:
4200**
4201** CREATE TABLE t1(a INT,b TEXT);
4202** INSERT INTO t1 VALUES(123,'0123');
4203** SELECT * FROM t1 WHERE a=123 AND b=a;
4204** SELECT * FROM t1 WHERE a=123 AND b=123;
4205**
4206** The two SELECT statements above should return different answers. b=a
4207** is alway true because the comparison uses numeric affinity, but b=123
4208** is false because it uses text affinity and '0123' is not the same as '123'.
4209** To work around this, the expression tree is not actually changed from
4210** "b=a" to "b=123" but rather the "a" in "b=a" is tagged with EP_FixedCol
4211** and the "123" value is hung off of the pLeft pointer. Code generator
4212** routines know to generate the constant "123" instead of looking up the
4213** column value. Also, to avoid collation problems, this optimization is
4214** only attempted if the "a=123" term uses the default BINARY collation.
drh660ee552018-07-26 21:16:53 +00004215*/
4216static int propagateConstants(
4217 Parse *pParse, /* The parsing context */
4218 Select *p /* The query in which to propagate constants */
4219){
4220 WhereConst x;
4221 Walker w;
4222 int nChng = 0;
drhefad2e22018-07-27 16:57:11 +00004223 x.pParse = pParse;
drh660ee552018-07-26 21:16:53 +00004224 do{
4225 x.nConst = 0;
4226 x.nChng = 0;
4227 x.apExpr = 0;
4228 findConstInWhere(&x, p->pWhere);
4229 if( x.nConst ){
4230 memset(&w, 0, sizeof(w));
4231 w.pParse = pParse;
4232 w.xExprCallback = propagateConstantExprRewrite;
4233 w.xSelectCallback = sqlite3SelectWalkNoop;
4234 w.xSelectCallback2 = 0;
4235 w.walkerDepth = 0;
4236 w.u.pConst = &x;
drhefad2e22018-07-27 16:57:11 +00004237 sqlite3WalkExpr(&w, p->pWhere);
4238 sqlite3DbFree(x.pParse->db, x.apExpr);
drh660ee552018-07-26 21:16:53 +00004239 nChng += x.nChng;
4240 }
4241 }while( x.nChng );
4242 return nChng;
4243}
drh69b72d52015-06-01 20:28:03 +00004244
4245#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
4246/*
4247** Make copies of relevant WHERE clause terms of the outer query into
4248** the WHERE clause of subquery. Example:
4249**
4250** SELECT * FROM (SELECT a AS x, c-d AS y FROM t1) WHERE x=5 AND y=10;
4251**
4252** Transformed into:
4253**
4254** SELECT * FROM (SELECT a AS x, c-d AS y FROM t1 WHERE a=5 AND c-d=10)
4255** WHERE x=5 AND y=10;
4256**
4257** The hope is that the terms added to the inner query will make it more
4258** efficient.
4259**
4260** Do not attempt this optimization if:
4261**
drh25c221e2017-09-29 22:13:24 +00004262** (1) (** This restriction was removed on 2017-09-29. We used to
4263** disallow this optimization for aggregate subqueries, but now
drh67cc51a2017-09-30 11:47:06 +00004264** it is allowed by putting the extra terms on the HAVING clause.
4265** The added HAVING clause is pointless if the subquery lacks
4266** a GROUP BY clause. But such a HAVING clause is also harmless
4267** so there does not appear to be any reason to add extra logic
4268** to suppress it. **)
drh69b72d52015-06-01 20:28:03 +00004269**
4270** (2) The inner query is the recursive part of a common table expression.
4271**
4272** (3) The inner query has a LIMIT clause (since the changes to the WHERE
dance103732018-06-23 07:59:39 +00004273** clause would change the meaning of the LIMIT).
drh69b72d52015-06-01 20:28:03 +00004274**
drh6a9b9522018-03-27 15:13:43 +00004275** (4) The inner query is the right operand of a LEFT JOIN and the
4276** expression to be pushed down does not come from the ON clause
4277** on that LEFT JOIN.
drh69b72d52015-06-01 20:28:03 +00004278**
drh38978dd2015-08-22 01:32:29 +00004279** (5) The WHERE clause expression originates in the ON or USING clause
drh7fbb1012018-03-21 01:59:46 +00004280** of a LEFT JOIN where iCursor is not the right-hand table of that
4281** left join. An example:
4282**
4283** SELECT *
4284** FROM (SELECT 1 AS a1 UNION ALL SELECT 2) AS aa
4285** JOIN (SELECT 1 AS b2 UNION ALL SELECT 2) AS bb ON (a1=b2)
4286** LEFT JOIN (SELECT 8 AS c3 UNION ALL SELECT 9) AS cc ON (b2=2);
4287**
4288** The correct answer is three rows: (1,1,NULL),(2,2,8),(2,2,9).
4289** But if the (b2=2) term were to be pushed down into the bb subquery,
4290** then the (1,1,NULL) row would be suppressed.
drh38978dd2015-08-22 01:32:29 +00004291**
dance103732018-06-23 07:59:39 +00004292** (6) The inner query features one or more window-functions (since
4293** changes to the WHERE clause of the inner query could change the
4294** window over which window functions are calculated).
4295**
drh69b72d52015-06-01 20:28:03 +00004296** Return 0 if no changes are made and non-zero if one or more WHERE clause
4297** terms are duplicated into the subquery.
4298*/
4299static int pushDownWhereTerms(
dan44c56042016-12-07 15:38:37 +00004300 Parse *pParse, /* Parse context (for malloc() and error reporting) */
drh69b72d52015-06-01 20:28:03 +00004301 Select *pSubq, /* The subquery whose WHERE clause is to be augmented */
4302 Expr *pWhere, /* The WHERE clause of the outer query */
drh6a9b9522018-03-27 15:13:43 +00004303 int iCursor, /* Cursor number of the subquery */
4304 int isLeftJoin /* True if pSubq is the right term of a LEFT JOIN */
drh69b72d52015-06-01 20:28:03 +00004305){
4306 Expr *pNew;
4307 int nChng = 0;
4308 if( pWhere==0 ) return 0;
drh508e2d02017-09-30 01:25:04 +00004309 if( pSubq->selFlags & SF_Recursive ) return 0; /* restriction (2) */
4310
dance103732018-06-23 07:59:39 +00004311#ifndef SQLITE_OMIT_WINDOWFUNC
drh142066d2018-07-09 20:58:43 +00004312 if( pSubq->pWin ) return 0; /* restriction (6) */
dance103732018-06-23 07:59:39 +00004313#endif
4314
drh508e2d02017-09-30 01:25:04 +00004315#ifdef SQLITE_DEBUG
4316 /* Only the first term of a compound can have a WITH clause. But make
4317 ** sure no other terms are marked SF_Recursive in case something changes
4318 ** in the future.
4319 */
4320 {
4321 Select *pX;
4322 for(pX=pSubq; pX; pX=pX->pPrior){
4323 assert( (pX->selFlags & (SF_Recursive))==0 );
drhb1ec87a2016-04-25 02:20:10 +00004324 }
drh69b72d52015-06-01 20:28:03 +00004325 }
drh508e2d02017-09-30 01:25:04 +00004326#endif
4327
drh69b72d52015-06-01 20:28:03 +00004328 if( pSubq->pLimit!=0 ){
drhb1ec87a2016-04-25 02:20:10 +00004329 return 0; /* restriction (3) */
drh69b72d52015-06-01 20:28:03 +00004330 }
4331 while( pWhere->op==TK_AND ){
drh3d6bedf2018-09-19 14:54:38 +00004332 assert( pWhere->eX==EX_Right );
4333 nChng += pushDownWhereTerms(pParse, pSubq, pWhere->x.pRight,
drh6a9b9522018-03-27 15:13:43 +00004334 iCursor, isLeftJoin);
drh69b72d52015-06-01 20:28:03 +00004335 pWhere = pWhere->pLeft;
4336 }
drh6a9b9522018-03-27 15:13:43 +00004337 if( isLeftJoin
4338 && (ExprHasProperty(pWhere,EP_FromJoin)==0
4339 || pWhere->iRightJoinTable!=iCursor)
4340 ){
4341 return 0; /* restriction (4) */
4342 }
drh7fbb1012018-03-21 01:59:46 +00004343 if( ExprHasProperty(pWhere,EP_FromJoin) && pWhere->iRightJoinTable!=iCursor ){
4344 return 0; /* restriction (5) */
4345 }
drh69b72d52015-06-01 20:28:03 +00004346 if( sqlite3ExprIsTableConstant(pWhere, iCursor) ){
4347 nChng++;
4348 while( pSubq ){
drh46967de2017-04-14 12:39:37 +00004349 SubstContext x;
dan44c56042016-12-07 15:38:37 +00004350 pNew = sqlite3ExprDup(pParse->db, pWhere, 0);
drh7fbb1012018-03-21 01:59:46 +00004351 unsetJoinExpr(pNew, -1);
drh46967de2017-04-14 12:39:37 +00004352 x.pParse = pParse;
4353 x.iTable = iCursor;
drh399c7e22017-04-14 17:18:45 +00004354 x.iNewTable = iCursor;
drh31d6fd52017-04-14 19:03:10 +00004355 x.isLeftJoin = 0;
drh46967de2017-04-14 12:39:37 +00004356 x.pEList = pSubq->pEList;
4357 pNew = substExpr(&x, pNew);
drh25c221e2017-09-29 22:13:24 +00004358 if( pSubq->selFlags & SF_Aggregate ){
4359 pSubq->pHaving = sqlite3ExprAnd(pParse->db, pSubq->pHaving, pNew);
4360 }else{
4361 pSubq->pWhere = sqlite3ExprAnd(pParse->db, pSubq->pWhere, pNew);
4362 }
drh69b72d52015-06-01 20:28:03 +00004363 pSubq = pSubq->pPrior;
4364 }
4365 }
4366 return nChng;
4367}
4368#endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
4369
drh1350b032002-02-27 19:00:20 +00004370/*
drh47d9f832017-10-26 20:04:28 +00004371** The pFunc is the only aggregate function in the query. Check to see
4372** if the query is a candidate for the min/max optimization.
danielk1977a9d1ccb2008-01-05 17:39:29 +00004373**
drh47d9f832017-10-26 20:04:28 +00004374** If the query is a candidate for the min/max optimization, then set
4375** *ppMinMax to be an ORDER BY clause to be used for the optimization
4376** and return either WHERE_ORDERBY_MIN or WHERE_ORDERBY_MAX depending on
4377** whether pFunc is a min() or max() function.
danielk1977738bdcf2008-01-07 10:16:40 +00004378**
drh47d9f832017-10-26 20:04:28 +00004379** If the query is not a candidate for the min/max optimization, return
4380** WHERE_ORDERBY_NORMAL (which must be zero).
dan4ac391f2012-12-13 16:37:10 +00004381**
drh47d9f832017-10-26 20:04:28 +00004382** This routine must be called after aggregate functions have been
4383** located but before their arguments have been subjected to aggregate
4384** analysis.
danielk1977a9d1ccb2008-01-05 17:39:29 +00004385*/
drh47d9f832017-10-26 20:04:28 +00004386static u8 minMaxQuery(sqlite3 *db, Expr *pFunc, ExprList **ppMinMax){
4387 int eRet = WHERE_ORDERBY_NORMAL; /* Return value */
4388 ExprList *pEList = pFunc->x.pList; /* Arguments to agg function */
4389 const char *zFunc; /* Name of aggregate function pFunc */
4390 ExprList *pOrderBy;
4391 u8 sortOrder;
danielk1977a9d1ccb2008-01-05 17:39:29 +00004392
drh47d9f832017-10-26 20:04:28 +00004393 assert( *ppMinMax==0 );
4394 assert( pFunc->op==TK_AGG_FUNCTION );
4395 if( pEList==0 || pEList->nExpr!=1 ) return eRet;
4396 zFunc = pFunc->u.zToken;
4397 if( sqlite3StrICmp(zFunc, "min")==0 ){
4398 eRet = WHERE_ORDERBY_MIN;
4399 sortOrder = SQLITE_SO_ASC;
4400 }else if( sqlite3StrICmp(zFunc, "max")==0 ){
4401 eRet = WHERE_ORDERBY_MAX;
4402 sortOrder = SQLITE_SO_DESC;
4403 }else{
4404 return eRet;
danielk1977a9d1ccb2008-01-05 17:39:29 +00004405 }
drh47d9f832017-10-26 20:04:28 +00004406 *ppMinMax = pOrderBy = sqlite3ExprListDup(db, pEList, 0);
4407 assert( pOrderBy!=0 || db->mallocFailed );
4408 if( pOrderBy ) pOrderBy->a[0].sortOrder = sortOrder;
dan4ac391f2012-12-13 16:37:10 +00004409 return eRet;
danielk1977a9d1ccb2008-01-05 17:39:29 +00004410}
4411
4412/*
danielk1977a5533162009-02-24 10:01:51 +00004413** The select statement passed as the first argument is an aggregate query.
peter.d.reid60ec9142014-09-06 16:39:46 +00004414** The second argument is the associated aggregate-info object. This
danielk1977a5533162009-02-24 10:01:51 +00004415** function tests if the SELECT is of the form:
4416**
4417** SELECT count(*) FROM <tbl>
4418**
4419** where table is a database table, not a sub-select or view. If the query
4420** does match this pattern, then a pointer to the Table object representing
4421** <tbl> is returned. Otherwise, 0 is returned.
4422*/
4423static Table *isSimpleCount(Select *p, AggInfo *pAggInfo){
4424 Table *pTab;
4425 Expr *pExpr;
4426
4427 assert( !p->pGroupBy );
4428
danielk19777a895a82009-02-24 18:33:15 +00004429 if( p->pWhere || p->pEList->nExpr!=1
danielk1977a5533162009-02-24 10:01:51 +00004430 || p->pSrc->nSrc!=1 || p->pSrc->a[0].pSelect
4431 ){
4432 return 0;
4433 }
danielk1977a5533162009-02-24 10:01:51 +00004434 pTab = p->pSrc->a[0].pTab;
4435 pExpr = p->pEList->a[0].pExpr;
danielk197702f33722009-02-25 08:56:47 +00004436 assert( pTab && !pTab->pSelect && pExpr );
4437
4438 if( IsVirtual(pTab) ) return 0;
danielk1977a5533162009-02-24 10:01:51 +00004439 if( pExpr->op!=TK_AGG_FUNCTION ) return 0;
drhfb0a6082012-08-24 01:07:52 +00004440 if( NEVER(pAggInfo->nFunc==0) ) return 0;
drhd36e1042013-09-06 13:10:12 +00004441 if( (pAggInfo->aFunc[0].pFunc->funcFlags&SQLITE_FUNC_COUNT)==0 ) return 0;
danielk1977a5533162009-02-24 10:01:51 +00004442 if( pExpr->flags&EP_Distinct ) return 0;
4443
4444 return pTab;
4445}
4446
4447/*
danielk1977b1c685b2008-10-06 16:18:39 +00004448** If the source-list item passed as an argument was augmented with an
4449** INDEXED BY clause, then try to locate the specified index. If there
4450** was such a clause and the named index cannot be found, return
4451** SQLITE_ERROR and leave an error in pParse. Otherwise, populate
4452** pFrom->pIndex and return SQLITE_OK.
4453*/
4454int sqlite3IndexedByLookup(Parse *pParse, struct SrcList_item *pFrom){
drh8a48b9c2015-08-19 15:20:00 +00004455 if( pFrom->pTab && pFrom->fg.isIndexedBy ){
danielk1977b1c685b2008-10-06 16:18:39 +00004456 Table *pTab = pFrom->pTab;
drh8a48b9c2015-08-19 15:20:00 +00004457 char *zIndexedBy = pFrom->u1.zIndexedBy;
danielk1977b1c685b2008-10-06 16:18:39 +00004458 Index *pIdx;
4459 for(pIdx=pTab->pIndex;
drhd62fbb52015-06-04 12:08:53 +00004460 pIdx && sqlite3StrICmp(pIdx->zName, zIndexedBy);
danielk1977b1c685b2008-10-06 16:18:39 +00004461 pIdx=pIdx->pNext
4462 );
4463 if( !pIdx ){
drhd62fbb52015-06-04 12:08:53 +00004464 sqlite3ErrorMsg(pParse, "no such index: %s", zIndexedBy, 0);
dan1db95102010-06-28 10:15:19 +00004465 pParse->checkSchema = 1;
danielk1977b1c685b2008-10-06 16:18:39 +00004466 return SQLITE_ERROR;
4467 }
drh8a48b9c2015-08-19 15:20:00 +00004468 pFrom->pIBIndex = pIdx;
danielk1977b1c685b2008-10-06 16:18:39 +00004469 }
4470 return SQLITE_OK;
4471}
drhc01b7302013-05-07 17:49:08 +00004472/*
4473** Detect compound SELECT statements that use an ORDER BY clause with
4474** an alternative collating sequence.
4475**
4476** SELECT ... FROM t1 EXCEPT SELECT ... FROM t2 ORDER BY .. COLLATE ...
4477**
4478** These are rewritten as a subquery:
4479**
4480** SELECT * FROM (SELECT ... FROM t1 EXCEPT SELECT ... FROM t2)
4481** ORDER BY ... COLLATE ...
4482**
4483** This transformation is necessary because the multiSelectOrderBy() routine
4484** above that generates the code for a compound SELECT with an ORDER BY clause
4485** uses a merge algorithm that requires the same collating sequence on the
4486** result columns as on the ORDER BY clause. See ticket
4487** http://www.sqlite.org/src/info/6709574d2a
4488**
4489** This transformation is only needed for EXCEPT, INTERSECT, and UNION.
4490** The UNION ALL operator works fine with multiSelectOrderBy() even when
4491** there are COLLATE terms in the ORDER BY.
4492*/
4493static int convertCompoundSelectToSubquery(Walker *pWalker, Select *p){
4494 int i;
4495 Select *pNew;
4496 Select *pX;
4497 sqlite3 *db;
4498 struct ExprList_item *a;
4499 SrcList *pNewSrc;
4500 Parse *pParse;
4501 Token dummy;
4502
4503 if( p->pPrior==0 ) return WRC_Continue;
4504 if( p->pOrderBy==0 ) return WRC_Continue;
4505 for(pX=p; pX && (pX->op==TK_ALL || pX->op==TK_SELECT); pX=pX->pPrior){}
4506 if( pX==0 ) return WRC_Continue;
4507 a = p->pOrderBy->a;
4508 for(i=p->pOrderBy->nExpr-1; i>=0; i--){
4509 if( a[i].pExpr->flags & EP_Collate ) break;
4510 }
4511 if( i<0 ) return WRC_Continue;
4512
4513 /* If we reach this point, that means the transformation is required. */
4514
4515 pParse = pWalker->pParse;
4516 db = pParse->db;
4517 pNew = sqlite3DbMallocZero(db, sizeof(*pNew) );
4518 if( pNew==0 ) return WRC_Abort;
4519 memset(&dummy, 0, sizeof(dummy));
4520 pNewSrc = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&dummy,pNew,0,0);
4521 if( pNewSrc==0 ) return WRC_Abort;
4522 *pNew = *p;
4523 p->pSrc = pNewSrc;
drh1a1d3cd2015-11-19 16:33:31 +00004524 p->pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ASTERISK, 0));
drhc01b7302013-05-07 17:49:08 +00004525 p->op = TK_SELECT;
4526 p->pWhere = 0;
4527 pNew->pGroupBy = 0;
4528 pNew->pHaving = 0;
4529 pNew->pOrderBy = 0;
4530 p->pPrior = 0;
drh8af9ad92014-02-10 18:56:05 +00004531 p->pNext = 0;
drhf932f712015-04-12 17:35:27 +00004532 p->pWith = 0;
drh8af9ad92014-02-10 18:56:05 +00004533 p->selFlags &= ~SF_Compound;
danb33c50f2015-04-04 16:43:16 +00004534 assert( (p->selFlags & SF_Converted)==0 );
4535 p->selFlags |= SF_Converted;
drha6e3a8c2014-02-10 21:07:51 +00004536 assert( pNew->pPrior!=0 );
4537 pNew->pPrior->pNext = pNew;
drhc01b7302013-05-07 17:49:08 +00004538 pNew->pLimit = 0;
drhc01b7302013-05-07 17:49:08 +00004539 return WRC_Continue;
4540}
danielk1977b1c685b2008-10-06 16:18:39 +00004541
drh20292312015-11-21 13:24:46 +00004542/*
4543** Check to see if the FROM clause term pFrom has table-valued function
4544** arguments. If it does, leave an error message in pParse and return
4545** non-zero, since pFrom is not allowed to be a table-valued function.
4546*/
4547static int cannotBeFunction(Parse *pParse, struct SrcList_item *pFrom){
4548 if( pFrom->fg.isTabFunc ){
4549 sqlite3ErrorMsg(pParse, "'%s' is not a function", pFrom->zName);
4550 return 1;
4551 }
4552 return 0;
4553}
4554
daneede6a52014-01-15 19:42:23 +00004555#ifndef SQLITE_OMIT_CTE
4556/*
4557** Argument pWith (which may be NULL) points to a linked list of nested
4558** WITH contexts, from inner to outermost. If the table identified by
4559** FROM clause element pItem is really a common-table-expression (CTE)
4560** then return a pointer to the CTE definition for that table. Otherwise
4561** return NULL.
dan98f45e52014-01-17 17:40:46 +00004562**
4563** If a non-NULL value is returned, set *ppContext to point to the With
4564** object that the returned CTE belongs to.
drh60c1a2f2014-01-15 18:23:00 +00004565*/
dan98f45e52014-01-17 17:40:46 +00004566static struct Cte *searchWith(
drh2476a6f2015-11-07 15:19:59 +00004567 With *pWith, /* Current innermost WITH clause */
dan98f45e52014-01-17 17:40:46 +00004568 struct SrcList_item *pItem, /* FROM clause element to resolve */
4569 With **ppContext /* OUT: WITH clause return value belongs to */
4570){
drh7b19f252014-01-16 04:37:13 +00004571 const char *zName;
4572 if( pItem->zDatabase==0 && (zName = pItem->zName)!=0 ){
daneede6a52014-01-15 19:42:23 +00004573 With *p;
4574 for(p=pWith; p; p=p->pOuter){
dan4e9119d2014-01-13 15:12:23 +00004575 int i;
daneede6a52014-01-15 19:42:23 +00004576 for(i=0; i<p->nCte; i++){
4577 if( sqlite3StrICmp(zName, p->a[i].zName)==0 ){
dan98f45e52014-01-17 17:40:46 +00004578 *ppContext = p;
daneede6a52014-01-15 19:42:23 +00004579 return &p->a[i];
dan4e9119d2014-01-13 15:12:23 +00004580 }
4581 }
4582 }
4583 }
4584 return 0;
4585}
4586
drhc49832c2014-01-15 18:35:52 +00004587/* The code generator maintains a stack of active WITH clauses
4588** with the inner-most WITH clause being at the top of the stack.
4589**
danb290f112014-01-17 14:59:27 +00004590** This routine pushes the WITH clause passed as the second argument
4591** onto the top of the stack. If argument bFree is true, then this
4592** WITH clause will never be popped from the stack. In this case it
4593** should be freed along with the Parse object. In other cases, when
4594** bFree==0, the With object will be freed along with the SELECT
4595** statement with which it is associated.
drhc49832c2014-01-15 18:35:52 +00004596*/
danb290f112014-01-17 14:59:27 +00004597void sqlite3WithPush(Parse *pParse, With *pWith, u8 bFree){
drh6e772262015-11-07 17:48:21 +00004598 assert( bFree==0 || (pParse->pWith==0 && pParse->pWithToFree==0) );
dan4e9119d2014-01-13 15:12:23 +00004599 if( pWith ){
drh2476a6f2015-11-07 15:19:59 +00004600 assert( pParse->pWith!=pWith );
dan4e9119d2014-01-13 15:12:23 +00004601 pWith->pOuter = pParse->pWith;
4602 pParse->pWith = pWith;
drh6e772262015-11-07 17:48:21 +00004603 if( bFree ) pParse->pWithToFree = pWith;
dan4e9119d2014-01-13 15:12:23 +00004604 }
4605}
dan4e9119d2014-01-13 15:12:23 +00004606
daneede6a52014-01-15 19:42:23 +00004607/*
daneede6a52014-01-15 19:42:23 +00004608** This function checks if argument pFrom refers to a CTE declared by
4609** a WITH clause on the stack currently maintained by the parser. And,
4610** if currently processing a CTE expression, if it is a recursive
4611** reference to the current CTE.
4612**
4613** If pFrom falls into either of the two categories above, pFrom->pTab
4614** and other fields are populated accordingly. The caller should check
4615** (pFrom->pTab!=0) to determine whether or not a successful match
4616** was found.
4617**
4618** Whether or not a match is found, SQLITE_OK is returned if no error
4619** occurs. If an error does occur, an error message is stored in the
4620** parser and some error code other than SQLITE_OK returned.
4621*/
dan8ce71842014-01-14 20:14:09 +00004622static int withExpand(
4623 Walker *pWalker,
daneede6a52014-01-15 19:42:23 +00004624 struct SrcList_item *pFrom
dan8ce71842014-01-14 20:14:09 +00004625){
dan8ce71842014-01-14 20:14:09 +00004626 Parse *pParse = pWalker->pParse;
4627 sqlite3 *db = pParse->db;
dan98f45e52014-01-17 17:40:46 +00004628 struct Cte *pCte; /* Matched CTE (or NULL if no match) */
4629 With *pWith; /* WITH clause that pCte belongs to */
dan8ce71842014-01-14 20:14:09 +00004630
dan8ce71842014-01-14 20:14:09 +00004631 assert( pFrom->pTab==0 );
4632
dan98f45e52014-01-17 17:40:46 +00004633 pCte = searchWith(pParse->pWith, pFrom, &pWith);
daneae73fb2014-01-16 18:34:33 +00004634 if( pCte ){
dan98f45e52014-01-17 17:40:46 +00004635 Table *pTab;
dan8ce71842014-01-14 20:14:09 +00004636 ExprList *pEList;
4637 Select *pSel;
dan60e70682014-01-15 15:27:51 +00004638 Select *pLeft; /* Left-most SELECT statement */
danf2655fe2014-01-16 21:02:02 +00004639 int bMayRecursive; /* True if compound joined by UNION [ALL] */
dan98f45e52014-01-17 17:40:46 +00004640 With *pSavedWith; /* Initial value of pParse->pWith */
danf2655fe2014-01-16 21:02:02 +00004641
drh0576bc52015-08-26 11:40:11 +00004642 /* If pCte->zCteErr is non-NULL at this point, then this is an illegal
danf2655fe2014-01-16 21:02:02 +00004643 ** recursive reference to CTE pCte. Leave an error in pParse and return
drh0576bc52015-08-26 11:40:11 +00004644 ** early. If pCte->zCteErr is NULL, then this is not a recursive reference.
danf2655fe2014-01-16 21:02:02 +00004645 ** In this case, proceed. */
drh0576bc52015-08-26 11:40:11 +00004646 if( pCte->zCteErr ){
4647 sqlite3ErrorMsg(pParse, pCte->zCteErr, pCte->zName);
dan98f45e52014-01-17 17:40:46 +00004648 return SQLITE_ERROR;
danf2655fe2014-01-16 21:02:02 +00004649 }
drh20292312015-11-21 13:24:46 +00004650 if( cannotBeFunction(pParse, pFrom) ) return SQLITE_ERROR;
dan8ce71842014-01-14 20:14:09 +00004651
drhc25e2eb2014-01-20 14:58:55 +00004652 assert( pFrom->pTab==0 );
dan8ce71842014-01-14 20:14:09 +00004653 pFrom->pTab = pTab = sqlite3DbMallocZero(db, sizeof(Table));
4654 if( pTab==0 ) return WRC_Abort;
drh79df7782016-12-14 14:07:35 +00004655 pTab->nTabRef = 1;
dan2d4dc5f2014-01-17 11:48:24 +00004656 pTab->zName = sqlite3DbStrDup(db, pCte->zName);
dan8ce71842014-01-14 20:14:09 +00004657 pTab->iPKey = -1;
dancfc9df72014-04-25 15:01:01 +00004658 pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
drhfccda8a2015-05-27 13:06:55 +00004659 pTab->tabFlags |= TF_Ephemeral | TF_NoVisibleRowid;
dan8ce71842014-01-14 20:14:09 +00004660 pFrom->pSelect = sqlite3SelectDup(db, pCte->pSelect, 0);
mistachkinfad30392016-02-13 23:43:46 +00004661 if( db->mallocFailed ) return SQLITE_NOMEM_BKPT;
dan8ce71842014-01-14 20:14:09 +00004662 assert( pFrom->pSelect );
4663
daneae73fb2014-01-16 18:34:33 +00004664 /* Check if this is a recursive CTE. */
dan8ce71842014-01-14 20:14:09 +00004665 pSel = pFrom->pSelect;
danf2655fe2014-01-16 21:02:02 +00004666 bMayRecursive = ( pSel->op==TK_ALL || pSel->op==TK_UNION );
4667 if( bMayRecursive ){
daneae73fb2014-01-16 18:34:33 +00004668 int i;
4669 SrcList *pSrc = pFrom->pSelect->pSrc;
4670 for(i=0; i<pSrc->nSrc; i++){
4671 struct SrcList_item *pItem = &pSrc->a[i];
4672 if( pItem->zDatabase==0
4673 && pItem->zName!=0
4674 && 0==sqlite3StrICmp(pItem->zName, pCte->zName)
4675 ){
4676 pItem->pTab = pTab;
drh8a48b9c2015-08-19 15:20:00 +00004677 pItem->fg.isRecursive = 1;
drh79df7782016-12-14 14:07:35 +00004678 pTab->nTabRef++;
daneae73fb2014-01-16 18:34:33 +00004679 pSel->selFlags |= SF_Recursive;
4680 }
4681 }
dan8ce71842014-01-14 20:14:09 +00004682 }
4683
daneae73fb2014-01-16 18:34:33 +00004684 /* Only one recursive reference is permitted. */
drh79df7782016-12-14 14:07:35 +00004685 if( pTab->nTabRef>2 ){
daneae73fb2014-01-16 18:34:33 +00004686 sqlite3ErrorMsg(
drh727a99f2014-01-16 21:59:51 +00004687 pParse, "multiple references to recursive table: %s", pCte->zName
daneae73fb2014-01-16 18:34:33 +00004688 );
dan98f45e52014-01-17 17:40:46 +00004689 return SQLITE_ERROR;
daneae73fb2014-01-16 18:34:33 +00004690 }
drh3d240d22017-09-28 16:56:55 +00004691 assert( pTab->nTabRef==1 ||
4692 ((pSel->selFlags&SF_Recursive) && pTab->nTabRef==2 ));
daneae73fb2014-01-16 18:34:33 +00004693
drh0576bc52015-08-26 11:40:11 +00004694 pCte->zCteErr = "circular reference: %s";
dan98f45e52014-01-17 17:40:46 +00004695 pSavedWith = pParse->pWith;
4696 pParse->pWith = pWith;
dan067cd832017-02-03 19:16:39 +00004697 if( bMayRecursive ){
4698 Select *pPrior = pSel->pPrior;
4699 assert( pPrior->pWith==0 );
4700 pPrior->pWith = pSel->pWith;
4701 sqlite3WalkSelect(pWalker, pPrior);
4702 pPrior->pWith = 0;
4703 }else{
4704 sqlite3WalkSelect(pWalker, pSel);
4705 }
drh6e772262015-11-07 17:48:21 +00004706 pParse->pWith = pWith;
daneae73fb2014-01-16 18:34:33 +00004707
dan60e70682014-01-15 15:27:51 +00004708 for(pLeft=pSel; pLeft->pPrior; pLeft=pLeft->pPrior);
4709 pEList = pLeft->pEList;
dan8ce71842014-01-14 20:14:09 +00004710 if( pCte->pCols ){
drh8f9d0b22015-03-21 03:18:22 +00004711 if( pEList && pEList->nExpr!=pCte->pCols->nExpr ){
drh727a99f2014-01-16 21:59:51 +00004712 sqlite3ErrorMsg(pParse, "table %s has %d values for %d columns",
dan60e70682014-01-15 15:27:51 +00004713 pCte->zName, pEList->nExpr, pCte->pCols->nExpr
4714 );
dan98f45e52014-01-17 17:40:46 +00004715 pParse->pWith = pSavedWith;
4716 return SQLITE_ERROR;
dan60e70682014-01-15 15:27:51 +00004717 }
dan8ce71842014-01-14 20:14:09 +00004718 pEList = pCte->pCols;
dan8ce71842014-01-14 20:14:09 +00004719 }
dan8ce71842014-01-14 20:14:09 +00004720
drh8981b902015-08-24 17:42:49 +00004721 sqlite3ColumnsFromExprList(pParse, pEList, &pTab->nCol, &pTab->aCol);
danf2655fe2014-01-16 21:02:02 +00004722 if( bMayRecursive ){
4723 if( pSel->selFlags & SF_Recursive ){
drh0576bc52015-08-26 11:40:11 +00004724 pCte->zCteErr = "multiple recursive references: %s";
danf2655fe2014-01-16 21:02:02 +00004725 }else{
drh0576bc52015-08-26 11:40:11 +00004726 pCte->zCteErr = "recursive reference in a subquery: %s";
danf2655fe2014-01-16 21:02:02 +00004727 }
4728 sqlite3WalkSelect(pWalker, pSel);
4729 }
drh0576bc52015-08-26 11:40:11 +00004730 pCte->zCteErr = 0;
dan98f45e52014-01-17 17:40:46 +00004731 pParse->pWith = pSavedWith;
dan8ce71842014-01-14 20:14:09 +00004732 }
4733
4734 return SQLITE_OK;
4735}
daneede6a52014-01-15 19:42:23 +00004736#endif
dan4e9119d2014-01-13 15:12:23 +00004737
danb290f112014-01-17 14:59:27 +00004738#ifndef SQLITE_OMIT_CTE
dan71856942014-01-17 15:15:10 +00004739/*
4740** If the SELECT passed as the second argument has an associated WITH
4741** clause, pop it from the stack stored as part of the Parse object.
4742**
4743** This function is used as the xSelectCallback2() callback by
4744** sqlite3SelectExpand() when walking a SELECT tree to resolve table
4745** names and other FROM clause elements.
4746*/
danb290f112014-01-17 14:59:27 +00004747static void selectPopWith(Walker *pWalker, Select *p){
4748 Parse *pParse = pWalker->pParse;
drh2f65b2f2017-10-02 21:29:51 +00004749 if( OK_IF_ALWAYS_TRUE(pParse->pWith) && p->pPrior==0 ){
dan067cd832017-02-03 19:16:39 +00004750 With *pWith = findRightmost(p)->pWith;
4751 if( pWith!=0 ){
4752 assert( pParse->pWith==pWith );
4753 pParse->pWith = pWith->pOuter;
4754 }
danb290f112014-01-17 14:59:27 +00004755 }
danb290f112014-01-17 14:59:27 +00004756}
4757#else
4758#define selectPopWith 0
4759#endif
4760
dan9a947222018-06-14 19:06:36 +00004761/*
4762** The SrcList_item structure passed as the second argument represents a
4763** sub-query in the FROM clause of a SELECT statement. This function
4764** allocates and populates the SrcList_item.pTab object. If successful,
4765** SQLITE_OK is returned. Otherwise, if an OOM error is encountered,
4766** SQLITE_NOMEM.
4767*/
dandfa552f2018-06-02 21:04:28 +00004768int sqlite3ExpandSubquery(Parse *pParse, struct SrcList_item *pFrom){
dan86fb6e12018-05-16 20:58:07 +00004769 Select *pSel = pFrom->pSelect;
4770 Table *pTab;
4771
dan9a947222018-06-14 19:06:36 +00004772 assert( pSel );
dan86fb6e12018-05-16 20:58:07 +00004773 pFrom->pTab = pTab = sqlite3DbMallocZero(pParse->db, sizeof(Table));
dan9a947222018-06-14 19:06:36 +00004774 if( pTab==0 ) return SQLITE_NOMEM;
dan86fb6e12018-05-16 20:58:07 +00004775 pTab->nTabRef = 1;
4776 if( pFrom->zAlias ){
4777 pTab->zName = sqlite3DbStrDup(pParse->db, pFrom->zAlias);
4778 }else{
drhfef37762018-07-10 19:48:35 +00004779 pTab->zName = sqlite3MPrintf(pParse->db, "subquery_%u", pSel->selId);
dan86fb6e12018-05-16 20:58:07 +00004780 }
4781 while( pSel->pPrior ){ pSel = pSel->pPrior; }
4782 sqlite3ColumnsFromExprList(pParse, pSel->pEList,&pTab->nCol,&pTab->aCol);
4783 pTab->iPKey = -1;
4784 pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
4785 pTab->tabFlags |= TF_Ephemeral;
4786
dan9a947222018-06-14 19:06:36 +00004787 return SQLITE_OK;
dan86fb6e12018-05-16 20:58:07 +00004788}
4789
danielk1977b1c685b2008-10-06 16:18:39 +00004790/*
drh7d10d5a2008-08-20 16:35:10 +00004791** This routine is a Walker callback for "expanding" a SELECT statement.
4792** "Expanding" means to do the following:
4793**
4794** (1) Make sure VDBE cursor numbers have been assigned to every
4795** element of the FROM clause.
4796**
4797** (2) Fill in the pTabList->a[].pTab fields in the SrcList that
4798** defines FROM clause. When views appear in the FROM clause,
4799** fill pTabList->a[].pSelect with a copy of the SELECT statement
4800** that implements the view. A copy is made of the view's SELECT
4801** statement so that we can freely modify or delete that statement
peter.d.reid60ec9142014-09-06 16:39:46 +00004802** without worrying about messing up the persistent representation
drh7d10d5a2008-08-20 16:35:10 +00004803** of the view.
4804**
peter.d.reid60ec9142014-09-06 16:39:46 +00004805** (3) Add terms to the WHERE clause to accommodate the NATURAL keyword
drh7d10d5a2008-08-20 16:35:10 +00004806** on joins and the ON and USING clause of joins.
4807**
4808** (4) Scan the list of columns in the result set (pEList) looking
4809** for instances of the "*" operator or the TABLE.* operator.
4810** If found, expand each "*" to be every column in every table
4811** and TABLE.* to be every column in TABLE.
4812**
danielk1977b3bce662005-01-29 08:32:43 +00004813*/
drh7d10d5a2008-08-20 16:35:10 +00004814static int selectExpander(Walker *pWalker, Select *p){
4815 Parse *pParse = pWalker->pParse;
4816 int i, j, k;
4817 SrcList *pTabList;
4818 ExprList *pEList;
4819 struct SrcList_item *pFrom;
4820 sqlite3 *db = pParse->db;
drh3e3f1a52013-01-03 00:45:56 +00004821 Expr *pE, *pRight, *pExpr;
drh785097d2013-02-12 22:09:48 +00004822 u16 selFlags = p->selFlags;
drhfca23552017-10-28 20:51:54 +00004823 u32 elistFlags = 0;
danielk1977b3bce662005-01-29 08:32:43 +00004824
drh785097d2013-02-12 22:09:48 +00004825 p->selFlags |= SF_Expanded;
drh7d10d5a2008-08-20 16:35:10 +00004826 if( db->mallocFailed ){
4827 return WRC_Abort;
danielk1977b3bce662005-01-29 08:32:43 +00004828 }
drh9d9c41e2017-10-31 03:40:15 +00004829 assert( p->pSrc!=0 );
4830 if( (selFlags & SF_Expanded)!=0 ){
drh7d10d5a2008-08-20 16:35:10 +00004831 return WRC_Prune;
danielk1977b3bce662005-01-29 08:32:43 +00004832 }
drh7d10d5a2008-08-20 16:35:10 +00004833 pTabList = p->pSrc;
danielk1977b3bce662005-01-29 08:32:43 +00004834 pEList = p->pEList;
drha5746e02018-04-09 20:36:09 +00004835 sqlite3WithPush(pParse, p->pWith, 0);
drh7d10d5a2008-08-20 16:35:10 +00004836
4837 /* Make sure cursor numbers have been assigned to all entries in
4838 ** the FROM clause of the SELECT statement.
4839 */
4840 sqlite3SrcListAssignCursors(pParse, pTabList);
4841
4842 /* Look up every table named in the FROM clause of the select. If
4843 ** an entry of the FROM clause is a subquery instead of a table or view,
4844 ** then create a transient table structure to describe the subquery.
4845 */
4846 for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
4847 Table *pTab;
drhe2b7d7a2015-09-29 15:50:04 +00004848 assert( pFrom->fg.isRecursive==0 || pFrom->pTab!=0 );
drh8a48b9c2015-08-19 15:20:00 +00004849 if( pFrom->fg.isRecursive ) continue;
drhe2b7d7a2015-09-29 15:50:04 +00004850 assert( pFrom->pTab==0 );
dan4e9119d2014-01-13 15:12:23 +00004851#ifndef SQLITE_OMIT_CTE
daneede6a52014-01-15 19:42:23 +00004852 if( withExpand(pWalker, pFrom) ) return WRC_Abort;
4853 if( pFrom->pTab ) {} else
dan4e9119d2014-01-13 15:12:23 +00004854#endif
drh7d10d5a2008-08-20 16:35:10 +00004855 if( pFrom->zName==0 ){
4856#ifndef SQLITE_OMIT_SUBQUERY
4857 Select *pSel = pFrom->pSelect;
4858 /* A sub-query in the FROM clause of a SELECT */
4859 assert( pSel!=0 );
4860 assert( pFrom->pTab==0 );
drh2b8c5a02015-01-22 12:00:17 +00004861 if( sqlite3WalkSelect(pWalker, pSel) ) return WRC_Abort;
dandfa552f2018-06-02 21:04:28 +00004862 if( sqlite3ExpandSubquery(pParse, pFrom) ) return WRC_Abort;
dan86fb6e12018-05-16 20:58:07 +00004863#endif
drh7d10d5a2008-08-20 16:35:10 +00004864 }else{
4865 /* An ordinary table or view name in the FROM clause */
4866 assert( pFrom->pTab==0 );
dan41fb5cd2012-10-04 19:33:00 +00004867 pFrom->pTab = pTab = sqlite3LocateTableItem(pParse, 0, pFrom);
drh7d10d5a2008-08-20 16:35:10 +00004868 if( pTab==0 ) return WRC_Abort;
drh79df7782016-12-14 14:07:35 +00004869 if( pTab->nTabRef>=0xffff ){
drhd2a56232013-01-28 19:00:20 +00004870 sqlite3ErrorMsg(pParse, "too many references to \"%s\": max 65535",
4871 pTab->zName);
4872 pFrom->pTab = 0;
4873 return WRC_Abort;
4874 }
drh79df7782016-12-14 14:07:35 +00004875 pTab->nTabRef++;
drh20292312015-11-21 13:24:46 +00004876 if( !IsVirtual(pTab) && cannotBeFunction(pParse, pFrom) ){
4877 return WRC_Abort;
4878 }
drh7d10d5a2008-08-20 16:35:10 +00004879#if !defined(SQLITE_OMIT_VIEW) || !defined (SQLITE_OMIT_VIRTUALTABLE)
drh20292312015-11-21 13:24:46 +00004880 if( IsVirtual(pTab) || pTab->pSelect ){
drhbfad7be2015-10-11 20:39:46 +00004881 i16 nCol;
drh7d10d5a2008-08-20 16:35:10 +00004882 if( sqlite3ViewGetColumnNames(pParse, pTab) ) return WRC_Abort;
drh43152cf2009-05-19 19:04:58 +00004883 assert( pFrom->pSelect==0 );
4884 pFrom->pSelect = sqlite3SelectDup(db, pTab->pSelect, 0);
drhbfad7be2015-10-11 20:39:46 +00004885 nCol = pTab->nCol;
4886 pTab->nCol = -1;
drh43152cf2009-05-19 19:04:58 +00004887 sqlite3WalkSelect(pWalker, pFrom->pSelect);
drhbfad7be2015-10-11 20:39:46 +00004888 pTab->nCol = nCol;
drh7d10d5a2008-08-20 16:35:10 +00004889 }
4890#endif
danielk1977b3bce662005-01-29 08:32:43 +00004891 }
danielk197785574e32008-10-06 05:32:18 +00004892
4893 /* Locate the index named by the INDEXED BY clause, if any. */
danielk1977b1c685b2008-10-06 16:18:39 +00004894 if( sqlite3IndexedByLookup(pParse, pFrom) ){
4895 return WRC_Abort;
danielk197785574e32008-10-06 05:32:18 +00004896 }
danielk1977b3bce662005-01-29 08:32:43 +00004897 }
4898
drh7d10d5a2008-08-20 16:35:10 +00004899 /* Process NATURAL keywords, and ON and USING clauses of joins.
danielk1977b3bce662005-01-29 08:32:43 +00004900 */
drh7d10d5a2008-08-20 16:35:10 +00004901 if( db->mallocFailed || sqliteProcessJoin(pParse, p) ){
4902 return WRC_Abort;
danielk1977b3bce662005-01-29 08:32:43 +00004903 }
4904
drh7d10d5a2008-08-20 16:35:10 +00004905 /* For every "*" that occurs in the column list, insert the names of
4906 ** all columns in all tables. And for every TABLE.* insert the names
4907 ** of all columns in TABLE. The parser inserted a special expression
drh1a1d3cd2015-11-19 16:33:31 +00004908 ** with the TK_ASTERISK operator for each "*" that it found in the column
4909 ** list. The following code just has to locate the TK_ASTERISK
4910 ** expressions and expand each one to the list of all columns in
4911 ** all tables.
danielk1977b3bce662005-01-29 08:32:43 +00004912 **
drh7d10d5a2008-08-20 16:35:10 +00004913 ** The first loop just checks to see if there are any "*" operators
4914 ** that need expanding.
danielk1977b3bce662005-01-29 08:32:43 +00004915 */
drh7d10d5a2008-08-20 16:35:10 +00004916 for(k=0; k<pEList->nExpr; k++){
drh3e3f1a52013-01-03 00:45:56 +00004917 pE = pEList->a[k].pExpr;
drh1a1d3cd2015-11-19 16:33:31 +00004918 if( pE->op==TK_ASTERISK ) break;
drh3d6bedf2018-09-19 14:54:38 +00004919 assert( pE->op!=TK_DOT || pE->eX==EX_Right );
drh43152cf2009-05-19 19:04:58 +00004920 assert( pE->op!=TK_DOT || (pE->pLeft!=0 && pE->pLeft->op==TK_ID) );
drh3d6bedf2018-09-19 14:54:38 +00004921 if( pE->op==TK_DOT && pE->x.pRight->op==TK_ASTERISK ) break;
drhfca23552017-10-28 20:51:54 +00004922 elistFlags |= pE->flags;
danielk1977b3bce662005-01-29 08:32:43 +00004923 }
drh7d10d5a2008-08-20 16:35:10 +00004924 if( k<pEList->nExpr ){
4925 /*
4926 ** If we get here it means the result set contains one or more "*"
4927 ** operators that need to be expanded. Loop through each expression
4928 ** in the result set and expand them one by one.
4929 */
4930 struct ExprList_item *a = pEList->a;
4931 ExprList *pNew = 0;
4932 int flags = pParse->db->flags;
4933 int longNames = (flags & SQLITE_FullColNames)!=0
drh38b384a2013-01-03 17:34:28 +00004934 && (flags & SQLITE_ShortColNames)==0;
4935
drh7d10d5a2008-08-20 16:35:10 +00004936 for(k=0; k<pEList->nExpr; k++){
drh3e3f1a52013-01-03 00:45:56 +00004937 pE = a[k].pExpr;
drhfca23552017-10-28 20:51:54 +00004938 elistFlags |= pE->flags;
drh3d6bedf2018-09-19 14:54:38 +00004939 pRight = pE->eX==EX_Right ? pE->x.pRight : 0;
drh3e3f1a52013-01-03 00:45:56 +00004940 assert( pE->op!=TK_DOT || pRight!=0 );
drh1a1d3cd2015-11-19 16:33:31 +00004941 if( pE->op!=TK_ASTERISK
4942 && (pE->op!=TK_DOT || pRight->op!=TK_ASTERISK)
4943 ){
drh7d10d5a2008-08-20 16:35:10 +00004944 /* This particular expression does not need to be expanded.
4945 */
drhb7916a72009-05-27 10:31:29 +00004946 pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr);
drh7d10d5a2008-08-20 16:35:10 +00004947 if( pNew ){
4948 pNew->a[pNew->nExpr-1].zName = a[k].zName;
drhb7916a72009-05-27 10:31:29 +00004949 pNew->a[pNew->nExpr-1].zSpan = a[k].zSpan;
4950 a[k].zName = 0;
4951 a[k].zSpan = 0;
drh7d10d5a2008-08-20 16:35:10 +00004952 }
4953 a[k].pExpr = 0;
drh7d10d5a2008-08-20 16:35:10 +00004954 }else{
4955 /* This expression is a "*" or a "TABLE.*" and needs to be
4956 ** expanded. */
4957 int tableSeen = 0; /* Set to 1 when TABLE matches */
drh3e3f1a52013-01-03 00:45:56 +00004958 char *zTName = 0; /* text of name of TABLE */
drh43152cf2009-05-19 19:04:58 +00004959 if( pE->op==TK_DOT ){
4960 assert( pE->pLeft!=0 );
drh33e619f2009-05-28 01:00:55 +00004961 assert( !ExprHasProperty(pE->pLeft, EP_IntValue) );
4962 zTName = pE->pLeft->u.zToken;
drh7d10d5a2008-08-20 16:35:10 +00004963 }
4964 for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
4965 Table *pTab = pFrom->pTab;
drh3e3f1a52013-01-03 00:45:56 +00004966 Select *pSub = pFrom->pSelect;
drh7d10d5a2008-08-20 16:35:10 +00004967 char *zTabName = pFrom->zAlias;
drh3e3f1a52013-01-03 00:45:56 +00004968 const char *zSchemaName = 0;
drhc75e09c2013-01-03 16:54:20 +00004969 int iDb;
drh43152cf2009-05-19 19:04:58 +00004970 if( zTabName==0 ){
drh7d10d5a2008-08-20 16:35:10 +00004971 zTabName = pTab->zName;
4972 }
4973 if( db->mallocFailed ) break;
drh3e3f1a52013-01-03 00:45:56 +00004974 if( pSub==0 || (pSub->selFlags & SF_NestedFrom)==0 ){
drh3e3f1a52013-01-03 00:45:56 +00004975 pSub = 0;
4976 if( zTName && sqlite3StrICmp(zTName, zTabName)!=0 ){
4977 continue;
4978 }
4979 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
drh69c33822016-08-18 14:33:11 +00004980 zSchemaName = iDb>=0 ? db->aDb[iDb].zDbSName : "*";
drh7d10d5a2008-08-20 16:35:10 +00004981 }
drh7d10d5a2008-08-20 16:35:10 +00004982 for(j=0; j<pTab->nCol; j++){
drh7d10d5a2008-08-20 16:35:10 +00004983 char *zName = pTab->aCol[j].zName;
drhb7916a72009-05-27 10:31:29 +00004984 char *zColname; /* The computed column name */
4985 char *zToFree; /* Malloced string that needs to be freed */
4986 Token sColname; /* Computed column name as a token */
drh7d10d5a2008-08-20 16:35:10 +00004987
drhc75e09c2013-01-03 16:54:20 +00004988 assert( zName );
drh3e3f1a52013-01-03 00:45:56 +00004989 if( zTName && pSub
4990 && sqlite3MatchSpanName(pSub->pEList->a[j].zSpan, 0, zTName, 0)==0
4991 ){
4992 continue;
4993 }
4994
drh80090f92015-11-19 17:55:11 +00004995 /* If a column is marked as 'hidden', omit it from the expanded
4996 ** result-set list unless the SELECT has the SF_IncludeHidden
4997 ** bit set.
drh7d10d5a2008-08-20 16:35:10 +00004998 */
drh80090f92015-11-19 17:55:11 +00004999 if( (p->selFlags & SF_IncludeHidden)==0
5000 && IsHiddenColumn(&pTab->aCol[j])
5001 ){
drh7d10d5a2008-08-20 16:35:10 +00005002 continue;
5003 }
drh3e3f1a52013-01-03 00:45:56 +00005004 tableSeen = 1;
drh7d10d5a2008-08-20 16:35:10 +00005005
drhda55c482008-12-05 00:00:07 +00005006 if( i>0 && zTName==0 ){
drh8a48b9c2015-08-19 15:20:00 +00005007 if( (pFrom->fg.jointype & JT_NATURAL)!=0
drh2179b432009-12-09 17:36:39 +00005008 && tableAndColumnIndex(pTabList, i, zName, 0, 0)
5009 ){
drh7d10d5a2008-08-20 16:35:10 +00005010 /* In a NATURAL join, omit the join columns from the
drh2179b432009-12-09 17:36:39 +00005011 ** table to the right of the join */
drh7d10d5a2008-08-20 16:35:10 +00005012 continue;
5013 }
drh2179b432009-12-09 17:36:39 +00005014 if( sqlite3IdListIndex(pFrom->pUsing, zName)>=0 ){
drh7d10d5a2008-08-20 16:35:10 +00005015 /* In a join with a USING clause, omit columns in the
5016 ** using clause from the table on the right. */
5017 continue;
5018 }
5019 }
drhb7916a72009-05-27 10:31:29 +00005020 pRight = sqlite3Expr(db, TK_ID, zName);
5021 zColname = zName;
5022 zToFree = 0;
drh7d10d5a2008-08-20 16:35:10 +00005023 if( longNames || pTabList->nSrc>1 ){
drhb7916a72009-05-27 10:31:29 +00005024 Expr *pLeft;
5025 pLeft = sqlite3Expr(db, TK_ID, zTabName);
drhabfd35e2016-12-06 22:47:23 +00005026 pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight);
drh38b384a2013-01-03 17:34:28 +00005027 if( zSchemaName ){
drhc75e09c2013-01-03 16:54:20 +00005028 pLeft = sqlite3Expr(db, TK_ID, zSchemaName);
drhabfd35e2016-12-06 22:47:23 +00005029 pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pExpr);
drhc75e09c2013-01-03 16:54:20 +00005030 }
drhb7916a72009-05-27 10:31:29 +00005031 if( longNames ){
5032 zColname = sqlite3MPrintf(db, "%s.%s", zTabName, zName);
5033 zToFree = zColname;
5034 }
drh7d10d5a2008-08-20 16:35:10 +00005035 }else{
5036 pExpr = pRight;
drh7d10d5a2008-08-20 16:35:10 +00005037 }
drhb7916a72009-05-27 10:31:29 +00005038 pNew = sqlite3ExprListAppend(pParse, pNew, pExpr);
drh40aced52016-01-22 17:48:09 +00005039 sqlite3TokenInit(&sColname, zColname);
drhb7916a72009-05-27 10:31:29 +00005040 sqlite3ExprListSetName(pParse, pNew, &sColname, 0);
drh8f25d182012-12-19 02:36:45 +00005041 if( pNew && (p->selFlags & SF_NestedFrom)!=0 ){
drh3e3f1a52013-01-03 00:45:56 +00005042 struct ExprList_item *pX = &pNew->a[pNew->nExpr-1];
5043 if( pSub ){
5044 pX->zSpan = sqlite3DbStrDup(db, pSub->pEList->a[j].zSpan);
drhc75e09c2013-01-03 16:54:20 +00005045 testcase( pX->zSpan==0 );
drh3e3f1a52013-01-03 00:45:56 +00005046 }else{
5047 pX->zSpan = sqlite3MPrintf(db, "%s.%s.%s",
5048 zSchemaName, zTabName, zColname);
drhc75e09c2013-01-03 16:54:20 +00005049 testcase( pX->zSpan==0 );
drh3e3f1a52013-01-03 00:45:56 +00005050 }
5051 pX->bSpanIsTab = 1;
drh8f25d182012-12-19 02:36:45 +00005052 }
drhb7916a72009-05-27 10:31:29 +00005053 sqlite3DbFree(db, zToFree);
drh7d10d5a2008-08-20 16:35:10 +00005054 }
5055 }
5056 if( !tableSeen ){
5057 if( zTName ){
5058 sqlite3ErrorMsg(pParse, "no such table: %s", zTName);
5059 }else{
5060 sqlite3ErrorMsg(pParse, "no tables specified");
5061 }
5062 }
drh7d10d5a2008-08-20 16:35:10 +00005063 }
drh9a993342007-12-13 02:45:31 +00005064 }
drh7d10d5a2008-08-20 16:35:10 +00005065 sqlite3ExprListDelete(db, pEList);
5066 p->pEList = pNew;
drh4c774312007-12-08 21:10:20 +00005067 }
drhfca23552017-10-28 20:51:54 +00005068 if( p->pEList ){
5069 if( p->pEList->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
5070 sqlite3ErrorMsg(pParse, "too many columns in result set");
5071 return WRC_Abort;
5072 }
5073 if( (elistFlags & (EP_HasFunc|EP_Subquery))!=0 ){
5074 p->selFlags |= SF_ComplexResult;
5075 }
drh994c80a2007-04-12 21:25:01 +00005076 }
drh7d10d5a2008-08-20 16:35:10 +00005077 return WRC_Continue;
5078}
danielk1977b3bce662005-01-29 08:32:43 +00005079
drh7d10d5a2008-08-20 16:35:10 +00005080/*
5081** No-op routine for the parse-tree walker.
5082**
5083** When this routine is the Walker.xExprCallback then expression trees
5084** are walked without any actions being taken at each node. Presumably,
5085** when this routine is used for Walker.xExprCallback then
5086** Walker.xSelectCallback is set to do something useful for every
5087** subquery in the parser tree.
5088*/
drh5b88bc42013-12-07 23:35:21 +00005089int sqlite3ExprWalkNoop(Walker *NotUsed, Expr *NotUsed2){
danielk197762c14b32008-11-19 09:05:26 +00005090 UNUSED_PARAMETER2(NotUsed, NotUsed2);
drh7d10d5a2008-08-20 16:35:10 +00005091 return WRC_Continue;
5092}
danielk19779afe6892007-05-31 08:20:43 +00005093
drh7d10d5a2008-08-20 16:35:10 +00005094/*
drh979dd1b2017-05-29 14:26:07 +00005095** No-op routine for the parse-tree walker for SELECT statements.
5096** subquery in the parser tree.
5097*/
5098int sqlite3SelectWalkNoop(Walker *NotUsed, Select *NotUsed2){
5099 UNUSED_PARAMETER2(NotUsed, NotUsed2);
5100 return WRC_Continue;
5101}
5102
5103#if SQLITE_DEBUG
5104/*
5105** Always assert. This xSelectCallback2 implementation proves that the
5106** xSelectCallback2 is never invoked.
5107*/
5108void sqlite3SelectWalkAssert2(Walker *NotUsed, Select *NotUsed2){
5109 UNUSED_PARAMETER2(NotUsed, NotUsed2);
5110 assert( 0 );
5111}
5112#endif
5113/*
drh7d10d5a2008-08-20 16:35:10 +00005114** This routine "expands" a SELECT statement and all of its subqueries.
5115** For additional information on what it means to "expand" a SELECT
5116** statement, see the comment on the selectExpand worker callback above.
5117**
5118** Expanding a SELECT statement is the first step in processing a
5119** SELECT statement. The SELECT statement must be expanded before
5120** name resolution is performed.
5121**
5122** If anything goes wrong, an error message is written into pParse.
5123** The calling function can detect the problem by looking at pParse->nErr
5124** and/or pParse->db->mallocFailed.
5125*/
5126static void sqlite3SelectExpand(Parse *pParse, Select *pSelect){
5127 Walker w;
drh5b88bc42013-12-07 23:35:21 +00005128 w.xExprCallback = sqlite3ExprWalkNoop;
drh7d10d5a2008-08-20 16:35:10 +00005129 w.pParse = pParse;
drh878fcf92017-10-02 23:50:08 +00005130 if( OK_IF_ALWAYS_TRUE(pParse->hasCompound) ){
drhd58d3272013-08-05 22:05:02 +00005131 w.xSelectCallback = convertCompoundSelectToSubquery;
drh979dd1b2017-05-29 14:26:07 +00005132 w.xSelectCallback2 = 0;
drhd58d3272013-08-05 22:05:02 +00005133 sqlite3WalkSelect(&w, pSelect);
5134 }
drhc01b7302013-05-07 17:49:08 +00005135 w.xSelectCallback = selectExpander;
dan067cd832017-02-03 19:16:39 +00005136 w.xSelectCallback2 = selectPopWith;
drhc01b7302013-05-07 17:49:08 +00005137 sqlite3WalkSelect(&w, pSelect);
drh7d10d5a2008-08-20 16:35:10 +00005138}
5139
5140
5141#ifndef SQLITE_OMIT_SUBQUERY
5142/*
5143** This is a Walker.xSelectCallback callback for the sqlite3SelectTypeInfo()
5144** interface.
5145**
5146** For each FROM-clause subquery, add Column.zType and Column.zColl
5147** information to the Table structure that represents the result set
5148** of that subquery.
5149**
5150** The Table structure that represents the result set was constructed
5151** by selectExpander() but the type and collation information was omitted
5152** at that point because identifiers had not yet been resolved. This
5153** routine is called after identifier resolution.
5154*/
danb290f112014-01-17 14:59:27 +00005155static void selectAddSubqueryTypeInfo(Walker *pWalker, Select *p){
drh7d10d5a2008-08-20 16:35:10 +00005156 Parse *pParse;
5157 int i;
5158 SrcList *pTabList;
5159 struct SrcList_item *pFrom;
5160
drh9d8b3072008-08-22 16:29:51 +00005161 assert( p->selFlags & SF_Resolved );
dancc464412018-06-19 18:11:05 +00005162 if( p->selFlags & SF_HasTypeInfo ) return;
drhe2b7d7a2015-09-29 15:50:04 +00005163 p->selFlags |= SF_HasTypeInfo;
5164 pParse = pWalker->pParse;
5165 pTabList = p->pSrc;
5166 for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
5167 Table *pTab = pFrom->pTab;
5168 assert( pTab!=0 );
5169 if( (pTab->tabFlags & TF_Ephemeral)!=0 ){
5170 /* A sub-query in the FROM clause of a SELECT */
5171 Select *pSel = pFrom->pSelect;
5172 if( pSel ){
5173 while( pSel->pPrior ) pSel = pSel->pPrior;
drhed06a132016-04-05 20:59:12 +00005174 sqlite3SelectAddColumnTypeAndCollation(pParse, pTab, pSel);
drh5a29d9c2010-02-24 15:10:14 +00005175 }
drh13449892005-09-07 21:22:45 +00005176 }
5177 }
drh7d10d5a2008-08-20 16:35:10 +00005178}
5179#endif
drh13449892005-09-07 21:22:45 +00005180
drh7d10d5a2008-08-20 16:35:10 +00005181
5182/*
5183** This routine adds datatype and collating sequence information to
5184** the Table structures of all FROM-clause subqueries in a
5185** SELECT statement.
5186**
5187** Use this routine after name resolution.
5188*/
5189static void sqlite3SelectAddTypeInfo(Parse *pParse, Select *pSelect){
5190#ifndef SQLITE_OMIT_SUBQUERY
5191 Walker w;
drh979dd1b2017-05-29 14:26:07 +00005192 w.xSelectCallback = sqlite3SelectWalkNoop;
danb290f112014-01-17 14:59:27 +00005193 w.xSelectCallback2 = selectAddSubqueryTypeInfo;
drh5b88bc42013-12-07 23:35:21 +00005194 w.xExprCallback = sqlite3ExprWalkNoop;
drh7d10d5a2008-08-20 16:35:10 +00005195 w.pParse = pParse;
5196 sqlite3WalkSelect(&w, pSelect);
5197#endif
5198}
5199
5200
5201/*
drh030796d2012-08-23 16:18:10 +00005202** This routine sets up a SELECT statement for processing. The
drh7d10d5a2008-08-20 16:35:10 +00005203** following is accomplished:
5204**
5205** * VDBE Cursor numbers are assigned to all FROM-clause terms.
5206** * Ephemeral Table objects are created for all FROM-clause subqueries.
5207** * ON and USING clauses are shifted into WHERE statements
5208** * Wildcards "*" and "TABLE.*" in result sets are expanded.
5209** * Identifiers in expression are matched to tables.
5210**
5211** This routine acts recursively on all subqueries within the SELECT.
5212*/
5213void sqlite3SelectPrep(
5214 Parse *pParse, /* The parser context */
5215 Select *p, /* The SELECT statement being coded. */
5216 NameContext *pOuterNC /* Name context for container */
5217){
drhe2463392017-10-03 14:24:24 +00005218 assert( p!=0 || pParse->db->mallocFailed );
5219 if( pParse->db->mallocFailed ) return;
drh7d10d5a2008-08-20 16:35:10 +00005220 if( p->selFlags & SF_HasTypeInfo ) return;
drh7d10d5a2008-08-20 16:35:10 +00005221 sqlite3SelectExpand(pParse, p);
drhb7651e62017-10-02 23:30:45 +00005222 if( pParse->nErr || pParse->db->mallocFailed ) return;
drh7d10d5a2008-08-20 16:35:10 +00005223 sqlite3ResolveSelectNames(pParse, p, pOuterNC);
drhb7651e62017-10-02 23:30:45 +00005224 if( pParse->nErr || pParse->db->mallocFailed ) return;
drh7d10d5a2008-08-20 16:35:10 +00005225 sqlite3SelectAddTypeInfo(pParse, p);
danielk1977b3bce662005-01-29 08:32:43 +00005226}
5227
5228/*
drh13449892005-09-07 21:22:45 +00005229** Reset the aggregate accumulator.
5230**
5231** The aggregate accumulator is a set of memory cells that hold
5232** intermediate results while calculating an aggregate. This
drh030796d2012-08-23 16:18:10 +00005233** routine generates code that stores NULLs in all of those memory
5234** cells.
danielk1977b3bce662005-01-29 08:32:43 +00005235*/
drh13449892005-09-07 21:22:45 +00005236static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){
5237 Vdbe *v = pParse->pVdbe;
5238 int i;
drhc99130f2005-09-11 11:56:27 +00005239 struct AggInfo_func *pFunc;
drh7e61d182013-12-20 13:11:45 +00005240 int nReg = pAggInfo->nFunc + pAggInfo->nColumn;
5241 if( nReg==0 ) return;
5242#ifdef SQLITE_DEBUG
5243 /* Verify that all AggInfo registers are within the range specified by
5244 ** AggInfo.mnReg..AggInfo.mxReg */
5245 assert( nReg==pAggInfo->mxReg-pAggInfo->mnReg+1 );
drh13449892005-09-07 21:22:45 +00005246 for(i=0; i<pAggInfo->nColumn; i++){
drh7e61d182013-12-20 13:11:45 +00005247 assert( pAggInfo->aCol[i].iMem>=pAggInfo->mnReg
5248 && pAggInfo->aCol[i].iMem<=pAggInfo->mxReg );
drh13449892005-09-07 21:22:45 +00005249 }
drh7e61d182013-12-20 13:11:45 +00005250 for(i=0; i<pAggInfo->nFunc; i++){
5251 assert( pAggInfo->aFunc[i].iMem>=pAggInfo->mnReg
5252 && pAggInfo->aFunc[i].iMem<=pAggInfo->mxReg );
5253 }
5254#endif
5255 sqlite3VdbeAddOp3(v, OP_Null, 0, pAggInfo->mnReg, pAggInfo->mxReg);
drhc99130f2005-09-11 11:56:27 +00005256 for(pFunc=pAggInfo->aFunc, i=0; i<pAggInfo->nFunc; i++, pFunc++){
drhc99130f2005-09-11 11:56:27 +00005257 if( pFunc->iDistinct>=0 ){
5258 Expr *pE = pFunc->pExpr;
drh3b3c86a2018-09-18 21:35:31 +00005259 assert( pE->eX==EX_List || pE->eX==EX_None );
5260 if( pE->eX==EX_None || pE->x.pList->nExpr!=1 ){
drh0daa0022009-02-09 13:19:28 +00005261 sqlite3ErrorMsg(pParse, "DISTINCT aggregates must have exactly one "
5262 "argument");
drhc99130f2005-09-11 11:56:27 +00005263 pFunc->iDistinct = -1;
5264 }else{
danf9eae182018-05-21 19:45:11 +00005265 KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pE->x.pList,0,0);
drh66a51672008-01-03 00:01:23 +00005266 sqlite3VdbeAddOp4(v, OP_OpenEphemeral, pFunc->iDistinct, 0, 0,
drh2ec2fb22013-11-06 19:59:23 +00005267 (char*)pKeyInfo, P4_KEYINFO);
drhc99130f2005-09-11 11:56:27 +00005268 }
5269 }
drh13449892005-09-07 21:22:45 +00005270 }
danielk1977b3bce662005-01-29 08:32:43 +00005271}
5272
5273/*
drh13449892005-09-07 21:22:45 +00005274** Invoke the OP_AggFinalize opcode for every aggregate function
5275** in the AggInfo structure.
danielk1977b3bce662005-01-29 08:32:43 +00005276*/
drh13449892005-09-07 21:22:45 +00005277static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){
5278 Vdbe *v = pParse->pVdbe;
5279 int i;
5280 struct AggInfo_func *pF;
5281 for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
danielk19776ab3a2e2009-02-19 14:39:25 +00005282 ExprList *pList = pF->pExpr->x.pList;
drh3b3c86a2018-09-18 21:35:31 +00005283 assert( pF->pExpr->eX==EX_List || pF->pExpr->eX==EX_None );
5284 assert( pF->pExpr->eX==EX_List || pList==0 );
drh2700aca2016-12-08 01:38:24 +00005285 sqlite3VdbeAddOp2(v, OP_AggFinal, pF->iMem, pList ? pList->nExpr : 0);
5286 sqlite3VdbeAppendP4(v, pF->pFunc, P4_FUNCDEF);
drh13449892005-09-07 21:22:45 +00005287 }
danielk1977b3bce662005-01-29 08:32:43 +00005288}
drh13449892005-09-07 21:22:45 +00005289
dan280c8942018-06-05 20:04:28 +00005290
drh13449892005-09-07 21:22:45 +00005291/*
5292** Update the accumulator memory cells for an aggregate based on
5293** the current cursor position.
dan280c8942018-06-05 20:04:28 +00005294**
5295** If regAcc is non-zero and there are no min() or max() aggregates
5296** in pAggInfo, then only populate the pAggInfo->nAccumulator accumulator
5297** registers i register regAcc contains 0. The caller will take care
5298** of setting and clearing regAcc.
drh13449892005-09-07 21:22:45 +00005299*/
dan280c8942018-06-05 20:04:28 +00005300static void updateAccumulator(Parse *pParse, int regAcc, AggInfo *pAggInfo){
drh13449892005-09-07 21:22:45 +00005301 Vdbe *v = pParse->pVdbe;
5302 int i;
drh7a957892012-02-02 17:35:43 +00005303 int regHit = 0;
5304 int addrHitTest = 0;
drh13449892005-09-07 21:22:45 +00005305 struct AggInfo_func *pF;
5306 struct AggInfo_col *pC;
drh13449892005-09-07 21:22:45 +00005307
5308 pAggInfo->directMode = 1;
5309 for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
5310 int nArg;
drhc99130f2005-09-11 11:56:27 +00005311 int addrNext = 0;
drh98757152008-01-09 23:04:12 +00005312 int regAgg;
danielk19776ab3a2e2009-02-19 14:39:25 +00005313 ExprList *pList = pF->pExpr->x.pList;
drh3b3c86a2018-09-18 21:35:31 +00005314 assert( pF->pExpr->eX==EX_List || pF->pExpr->eX==EX_None );
drh13449892005-09-07 21:22:45 +00005315 if( pList ){
5316 nArg = pList->nExpr;
drh892d3172008-01-10 03:46:36 +00005317 regAgg = sqlite3GetTempRange(pParse, nArg);
drh5579d592015-08-26 14:01:41 +00005318 sqlite3ExprCodeExprList(pParse, pList, regAgg, 0, SQLITE_ECEL_DUP);
drh13449892005-09-07 21:22:45 +00005319 }else{
5320 nArg = 0;
drh98757152008-01-09 23:04:12 +00005321 regAgg = 0;
drh13449892005-09-07 21:22:45 +00005322 }
drhc99130f2005-09-11 11:56:27 +00005323 if( pF->iDistinct>=0 ){
5324 addrNext = sqlite3VdbeMakeLabel(v);
drh7c052da2015-04-21 15:16:48 +00005325 testcase( nArg==0 ); /* Error condition */
5326 testcase( nArg>1 ); /* Also an error */
drh2dcef112008-01-12 19:03:48 +00005327 codeDistinct(pParse, pF->iDistinct, addrNext, 1, regAgg);
drhc99130f2005-09-11 11:56:27 +00005328 }
drhd36e1042013-09-06 13:10:12 +00005329 if( pF->pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL ){
drh13449892005-09-07 21:22:45 +00005330 CollSeq *pColl = 0;
5331 struct ExprList_item *pItem;
5332 int j;
drhe82f5d02008-10-07 19:53:14 +00005333 assert( pList!=0 ); /* pList!=0 if pF->pFunc has NEEDCOLL */
drh43617e92006-03-06 20:55:46 +00005334 for(j=0, pItem=pList->a; !pColl && j<nArg; j++, pItem++){
drh13449892005-09-07 21:22:45 +00005335 pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
5336 }
5337 if( !pColl ){
5338 pColl = pParse->db->pDfltColl;
5339 }
drh7a957892012-02-02 17:35:43 +00005340 if( regHit==0 && pAggInfo->nAccumulator ) regHit = ++pParse->nMem;
5341 sqlite3VdbeAddOp4(v, OP_CollSeq, regHit, 0, 0, (char *)pColl, P4_COLLSEQ);
drh13449892005-09-07 21:22:45 +00005342 }
drh8f26da62018-07-05 21:22:57 +00005343 sqlite3VdbeAddOp3(v, OP_AggStep, 0, regAgg, pF->iMem);
drh2700aca2016-12-08 01:38:24 +00005344 sqlite3VdbeAppendP4(v, pF->pFunc, P4_FUNCDEF);
drhea678832008-12-10 19:26:22 +00005345 sqlite3VdbeChangeP5(v, (u8)nArg);
drhf49f3522009-12-30 14:12:38 +00005346 sqlite3ReleaseTempRange(pParse, regAgg, nArg);
drhc99130f2005-09-11 11:56:27 +00005347 if( addrNext ){
5348 sqlite3VdbeResolveLabel(v, addrNext);
5349 }
drh13449892005-09-07 21:22:45 +00005350 }
dan280c8942018-06-05 20:04:28 +00005351 if( regHit==0 && pAggInfo->nAccumulator ){
5352 regHit = regAcc;
5353 }
drh7a957892012-02-02 17:35:43 +00005354 if( regHit ){
drh688852a2014-02-17 22:40:43 +00005355 addrHitTest = sqlite3VdbeAddOp1(v, OP_If, regHit); VdbeCoverage(v);
drh7a957892012-02-02 17:35:43 +00005356 }
drh13449892005-09-07 21:22:45 +00005357 for(i=0, pC=pAggInfo->aCol; i<pAggInfo->nAccumulator; i++, pC++){
drh389a1ad2008-01-03 23:44:53 +00005358 sqlite3ExprCode(pParse, pC->pExpr, pC->iMem);
drh13449892005-09-07 21:22:45 +00005359 }
5360 pAggInfo->directMode = 0;
drh7a957892012-02-02 17:35:43 +00005361 if( addrHitTest ){
5362 sqlite3VdbeJumpHere(v, addrHitTest);
5363 }
drh13449892005-09-07 21:22:45 +00005364}
5365
danielk1977b3bce662005-01-29 08:32:43 +00005366/*
danef7075d2011-02-21 17:49:49 +00005367** Add a single OP_Explain instruction to the VDBE to explain a simple
5368** count(*) query ("SELECT count(*) FROM pTab").
5369*/
5370#ifndef SQLITE_OMIT_EXPLAIN
5371static void explainSimpleCount(
5372 Parse *pParse, /* Parse context */
5373 Table *pTab, /* Table being queried */
5374 Index *pIdx /* Index used to optimize scan, or NULL */
5375){
5376 if( pParse->explain==2 ){
drh48dd1d82014-05-27 18:18:58 +00005377 int bCover = (pIdx!=0 && (HasRowid(pTab) || !IsPrimaryKeyIndex(pIdx)));
drhe2ca99c2018-05-02 00:33:43 +00005378 sqlite3VdbeExplain(pParse, 0, "SCAN TABLE %s%s%s",
dane96f2df2014-05-23 17:17:06 +00005379 pTab->zName,
5380 bCover ? " USING COVERING INDEX " : "",
5381 bCover ? pIdx->zName : ""
danef7075d2011-02-21 17:49:49 +00005382 );
danef7075d2011-02-21 17:49:49 +00005383 }
5384}
5385#else
5386# define explainSimpleCount(a,b,c)
5387#endif
5388
5389/*
danab31a842017-04-29 20:53:09 +00005390** sqlite3WalkExpr() callback used by havingToWhere().
5391**
5392** If the node passed to the callback is a TK_AND node, return
5393** WRC_Continue to tell sqlite3WalkExpr() to iterate through child nodes.
5394**
5395** Otherwise, return WRC_Prune. In this case, also check if the
5396** sub-expression matches the criteria for being moved to the WHERE
5397** clause. If so, add it to the WHERE clause and replace the sub-expression
5398** within the HAVING expression with a constant "1".
5399*/
5400static int havingToWhereExprCb(Walker *pWalker, Expr *pExpr){
5401 if( pExpr->op!=TK_AND ){
drhcd0abc22018-03-20 18:08:33 +00005402 Select *pS = pWalker->u.pSelect;
5403 if( sqlite3ExprIsConstantOrGroupBy(pWalker->pParse, pExpr, pS->pGroupBy) ){
danab31a842017-04-29 20:53:09 +00005404 sqlite3 *db = pWalker->pParse->db;
5405 Expr *pNew = sqlite3ExprAlloc(db, TK_INTEGER, &sqlite3IntTokens[1], 0);
5406 if( pNew ){
drhcd0abc22018-03-20 18:08:33 +00005407 Expr *pWhere = pS->pWhere;
danab31a842017-04-29 20:53:09 +00005408 SWAP(Expr, *pNew, *pExpr);
drhc478c8d2017-05-01 19:53:12 +00005409 pNew = sqlite3ExprAnd(db, pWhere, pNew);
drhcd0abc22018-03-20 18:08:33 +00005410 pS->pWhere = pNew;
5411 pWalker->eCode = 1;
danab31a842017-04-29 20:53:09 +00005412 }
5413 }
5414 return WRC_Prune;
5415 }
5416 return WRC_Continue;
5417}
5418
5419/*
5420** Transfer eligible terms from the HAVING clause of a query, which is
5421** processed after grouping, to the WHERE clause, which is processed before
5422** grouping. For example, the query:
5423**
5424** SELECT * FROM <tables> WHERE a=? GROUP BY b HAVING b=? AND c=?
5425**
5426** can be rewritten as:
5427**
5428** SELECT * FROM <tables> WHERE a=? AND b=? GROUP BY b HAVING c=?
5429**
5430** A term of the HAVING expression is eligible for transfer if it consists
5431** entirely of constants and expressions that are also GROUP BY terms that
5432** use the "BINARY" collation sequence.
5433*/
drhcd0abc22018-03-20 18:08:33 +00005434static void havingToWhere(Parse *pParse, Select *p){
danab31a842017-04-29 20:53:09 +00005435 Walker sWalker;
danab31a842017-04-29 20:53:09 +00005436 memset(&sWalker, 0, sizeof(sWalker));
5437 sWalker.pParse = pParse;
5438 sWalker.xExprCallback = havingToWhereExprCb;
drhcd0abc22018-03-20 18:08:33 +00005439 sWalker.u.pSelect = p;
5440 sqlite3WalkExpr(&sWalker, p->pHaving);
5441#if SELECTTRACE_ENABLED
5442 if( sWalker.eCode && (sqlite3SelectTrace & 0x100)!=0 ){
5443 SELECTTRACE(0x100,pParse,p,("Move HAVING terms into WHERE:\n"));
5444 sqlite3TreeViewSelect(0, p, 0);
5445 }
5446#endif
danab31a842017-04-29 20:53:09 +00005447}
5448
5449/*
drhe08e8d62017-05-01 15:15:41 +00005450** Check to see if the pThis entry of pTabList is a self-join of a prior view.
5451** If it is, then return the SrcList_item for the prior view. If it is not,
5452** then return 0.
5453*/
5454static struct SrcList_item *isSelfJoinView(
5455 SrcList *pTabList, /* Search for self-joins in this FROM clause */
5456 struct SrcList_item *pThis /* Search for prior reference to this subquery */
5457){
5458 struct SrcList_item *pItem;
5459 for(pItem = pTabList->a; pItem<pThis; pItem++){
5460 if( pItem->pSelect==0 ) continue;
5461 if( pItem->fg.viaCoroutine ) continue;
drh33543c22017-05-01 16:37:20 +00005462 if( pItem->zName==0 ) continue;
5463 if( sqlite3_stricmp(pItem->zDatabase, pThis->zDatabase)!=0 ) continue;
drhed712982017-05-01 17:04:35 +00005464 if( sqlite3_stricmp(pItem->zName, pThis->zName)!=0 ) continue;
dan5aa550c2017-06-24 18:10:29 +00005465 if( sqlite3ExprCompare(0,
5466 pThis->pSelect->pWhere, pItem->pSelect->pWhere, -1)
5467 ){
drhed712982017-05-01 17:04:35 +00005468 /* The view was modified by some other optimization such as
5469 ** pushDownWhereTerms() */
5470 continue;
5471 }
5472 return pItem;
drhe08e8d62017-05-01 15:15:41 +00005473 }
5474 return 0;
5475}
5476
drh269ba802017-07-04 19:34:36 +00005477#ifdef SQLITE_COUNTOFVIEW_OPTIMIZATION
5478/*
5479** Attempt to transform a query of the form
5480**
5481** SELECT count(*) FROM (SELECT x FROM t1 UNION ALL SELECT y FROM t2)
5482**
5483** Into this:
5484**
5485** SELECT (SELECT count(*) FROM t1)+(SELECT count(*) FROM t2)
5486**
5487** The transformation only works if all of the following are true:
5488**
5489** * The subquery is a UNION ALL of two or more terms
dana4b5fb52018-08-03 20:19:52 +00005490** * The subquery does not have a LIMIT clause
drh269ba802017-07-04 19:34:36 +00005491** * There is no WHERE or GROUP BY or HAVING clauses on the subqueries
5492** * The outer query is a simple count(*)
5493**
5494** Return TRUE if the optimization is undertaken.
5495*/
5496static int countOfViewOptimization(Parse *pParse, Select *p){
5497 Select *pSub, *pPrior;
5498 Expr *pExpr;
5499 Expr *pCount;
5500 sqlite3 *db;
drh3d240d22017-09-28 16:56:55 +00005501 if( (p->selFlags & SF_Aggregate)==0 ) return 0; /* This is an aggregate */
drh269ba802017-07-04 19:34:36 +00005502 if( p->pEList->nExpr!=1 ) return 0; /* Single result column */
5503 pExpr = p->pEList->a[0].pExpr;
5504 if( pExpr->op!=TK_AGG_FUNCTION ) return 0; /* Result is an aggregate */
drh3d240d22017-09-28 16:56:55 +00005505 if( sqlite3_stricmp(pExpr->u.zToken,"count") ) return 0; /* Is count() */
drh269ba802017-07-04 19:34:36 +00005506 if( pExpr->x.pList!=0 ) return 0; /* Must be count(*) */
drh3d240d22017-09-28 16:56:55 +00005507 if( p->pSrc->nSrc!=1 ) return 0; /* One table in FROM */
drh269ba802017-07-04 19:34:36 +00005508 pSub = p->pSrc->a[0].pSelect;
5509 if( pSub==0 ) return 0; /* The FROM is a subquery */
drh3d240d22017-09-28 16:56:55 +00005510 if( pSub->pPrior==0 ) return 0; /* Must be a compound ry */
drh269ba802017-07-04 19:34:36 +00005511 do{
5512 if( pSub->op!=TK_ALL && pSub->pPrior ) return 0; /* Must be UNION ALL */
5513 if( pSub->pWhere ) return 0; /* No WHERE clause */
dana4b5fb52018-08-03 20:19:52 +00005514 if( pSub->pLimit ) return 0; /* No LIMIT clause */
drh269ba802017-07-04 19:34:36 +00005515 if( pSub->selFlags & SF_Aggregate ) return 0; /* Not an aggregate */
drh3d240d22017-09-28 16:56:55 +00005516 pSub = pSub->pPrior; /* Repeat over compound */
drh269ba802017-07-04 19:34:36 +00005517 }while( pSub );
5518
drh3d240d22017-09-28 16:56:55 +00005519 /* If we reach this point then it is OK to perform the transformation */
drh269ba802017-07-04 19:34:36 +00005520
5521 db = pParse->db;
5522 pCount = pExpr;
5523 pExpr = 0;
5524 pSub = p->pSrc->a[0].pSelect;
5525 p->pSrc->a[0].pSelect = 0;
5526 sqlite3SrcListDelete(db, p->pSrc);
5527 p->pSrc = sqlite3DbMallocZero(pParse->db, sizeof(*p->pSrc));
5528 while( pSub ){
5529 Expr *pTerm;
5530 pPrior = pSub->pPrior;
5531 pSub->pPrior = 0;
5532 pSub->pNext = 0;
5533 pSub->selFlags |= SF_Aggregate;
5534 pSub->selFlags &= ~SF_Compound;
5535 pSub->nSelectRow = 0;
5536 sqlite3ExprListDelete(db, pSub->pEList);
5537 pTerm = pPrior ? sqlite3ExprDup(db, pCount, 0) : pCount;
5538 pSub->pEList = sqlite3ExprListAppend(pParse, 0, pTerm);
5539 pTerm = sqlite3PExpr(pParse, TK_SELECT, 0, 0);
5540 sqlite3PExprAddSelect(pParse, pTerm, pSub);
5541 if( pExpr==0 ){
5542 pExpr = pTerm;
5543 }else{
5544 pExpr = sqlite3PExpr(pParse, TK_PLUS, pTerm, pExpr);
5545 }
5546 pSub = pPrior;
5547 }
5548 p->pEList->a[0].pExpr = pExpr;
5549 p->selFlags &= ~SF_Aggregate;
5550
5551#if SELECTTRACE_ENABLED
5552 if( sqlite3SelectTrace & 0x400 ){
5553 SELECTTRACE(0x400,pParse,p,("After count-of-view optimization:\n"));
5554 sqlite3TreeViewSelect(0, p, 0);
5555 }
5556#endif
5557 return 1;
5558}
5559#endif /* SQLITE_COUNTOFVIEW_OPTIMIZATION */
5560
drhe08e8d62017-05-01 15:15:41 +00005561/*
drh7d10d5a2008-08-20 16:35:10 +00005562** Generate code for the SELECT statement given in the p argument.
drh9bb61fe2000-06-05 16:01:39 +00005563**
drh340309f2014-01-22 00:23:49 +00005564** The results are returned according to the SelectDest structure.
5565** See comments in sqliteInt.h for further information.
drhe78e8282003-01-19 03:59:45 +00005566**
drh9bb61fe2000-06-05 16:01:39 +00005567** This routine returns the number of errors. If any errors are
5568** encountered, then an appropriate error message is left in
5569** pParse->zErrMsg.
5570**
5571** This routine does NOT free the Select structure passed in. The
5572** calling function needs to do that.
5573*/
danielk19774adee202004-05-08 08:23:19 +00005574int sqlite3Select(
drhcce7d172000-05-31 15:34:51 +00005575 Parse *pParse, /* The parser context */
drh9bb61fe2000-06-05 16:01:39 +00005576 Select *p, /* The SELECT statement being coded. */
drh7d10d5a2008-08-20 16:35:10 +00005577 SelectDest *pDest /* What to do with the query results */
drhcce7d172000-05-31 15:34:51 +00005578){
drh13449892005-09-07 21:22:45 +00005579 int i, j; /* Loop counters */
5580 WhereInfo *pWInfo; /* Return from sqlite3WhereBegin() */
5581 Vdbe *v; /* The virtual machine under construction */
danielk1977b3bce662005-01-29 08:32:43 +00005582 int isAgg; /* True for select lists like "count(*)" */
mistachkinc29cbb02015-07-02 16:52:01 +00005583 ExprList *pEList = 0; /* List of columns to extract. */
drhad3cab52002-05-24 02:04:32 +00005584 SrcList *pTabList; /* List of tables to select from */
drh9bb61fe2000-06-05 16:01:39 +00005585 Expr *pWhere; /* The WHERE clause. May be NULL */
drh22827922000-06-06 17:27:05 +00005586 ExprList *pGroupBy; /* The GROUP BY clause. May be NULL */
5587 Expr *pHaving; /* The HAVING clause. May be NULL */
drh1d83f052002-02-17 00:30:36 +00005588 int rc = 1; /* Value to return from this function */
drhe8e4af72012-09-21 00:04:28 +00005589 DistinctCtx sDistinct; /* Info on how to code the DISTINCT keyword */
drh079a3072014-03-19 14:10:55 +00005590 SortCtx sSort; /* Info on how to code the ORDER BY clause */
drh13449892005-09-07 21:22:45 +00005591 AggInfo sAggInfo; /* Information used by aggregate queries */
drhec7429a2005-10-06 16:53:14 +00005592 int iEnd; /* Address of the end of the query */
drh17435752007-08-16 04:30:38 +00005593 sqlite3 *db; /* The database connection */
drh47d9f832017-10-26 20:04:28 +00005594 ExprList *pMinMaxOrderBy = 0; /* Added ORDER BY for min/max queries */
5595 u8 minMaxFlag; /* Flag for min/max queries */
drh9bb61fe2000-06-05 16:01:39 +00005596
drh17435752007-08-16 04:30:38 +00005597 db = pParse->db;
drhe2ca99c2018-05-02 00:33:43 +00005598 v = sqlite3GetVdbe(pParse);
drh17435752007-08-16 04:30:38 +00005599 if( p==0 || db->mallocFailed || pParse->nErr ){
drh6f7adc82006-01-11 21:41:20 +00005600 return 1;
5601 }
danielk19774adee202004-05-08 08:23:19 +00005602 if( sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1;
drh13449892005-09-07 21:22:45 +00005603 memset(&sAggInfo, 0, sizeof(sAggInfo));
drhe2ca99c2018-05-02 00:33:43 +00005604#if SELECTTRACE_ENABLED
5605 SELECTTRACE(1,pParse,p, ("begin processing:\n", pParse->addrExplain));
drhc90713d2014-09-30 13:46:49 +00005606 if( sqlite3SelectTrace & 0x100 ){
5607 sqlite3TreeViewSelect(0, p, 0);
5608 }
drheb9b8842014-09-21 00:27:26 +00005609#endif
drhdaffd0e2001-04-11 14:28:42 +00005610
drh8e1ee882014-03-21 19:56:09 +00005611 assert( p->pOrderBy==0 || pDest->eDest!=SRT_DistFifo );
5612 assert( p->pOrderBy==0 || pDest->eDest!=SRT_Fifo );
dan9afccba2014-03-21 19:27:54 +00005613 assert( p->pOrderBy==0 || pDest->eDest!=SRT_DistQueue );
5614 assert( p->pOrderBy==0 || pDest->eDest!=SRT_Queue );
danielk19776c8c8ce2008-01-02 16:27:09 +00005615 if( IgnorableOrderby(pDest) ){
danielk19779ed1dfa2008-01-02 17:11:14 +00005616 assert(pDest->eDest==SRT_Exists || pDest->eDest==SRT_Union ||
dan9afccba2014-03-21 19:27:54 +00005617 pDest->eDest==SRT_Except || pDest->eDest==SRT_Discard ||
drh8e1ee882014-03-21 19:56:09 +00005618 pDest->eDest==SRT_Queue || pDest->eDest==SRT_DistFifo ||
5619 pDest->eDest==SRT_DistQueue || pDest->eDest==SRT_Fifo);
drhccfcbce2009-05-18 15:46:07 +00005620 /* If ORDER BY makes no difference in the output then neither does
5621 ** DISTINCT so it can be removed too. */
5622 sqlite3ExprListDelete(db, p->pOrderBy);
5623 p->pOrderBy = 0;
drh7d10d5a2008-08-20 16:35:10 +00005624 p->selFlags &= ~SF_Distinct;
drh9a993342007-12-13 02:45:31 +00005625 }
drh7d10d5a2008-08-20 16:35:10 +00005626 sqlite3SelectPrep(pParse, p, 0);
danielk1977956f4312008-11-21 09:43:20 +00005627 if( pParse->nErr || db->mallocFailed ){
drh9a993342007-12-13 02:45:31 +00005628 goto select_end;
5629 }
drhadc57f62015-06-06 00:18:01 +00005630 assert( p->pEList!=0 );
drh17645f52015-02-09 13:42:59 +00005631#if SELECTTRACE_ENABLED
drhe2243d22018-04-23 17:18:03 +00005632 if( sqlite3SelectTrace & 0x104 ){
5633 SELECTTRACE(0x104,pParse,p, ("after name resolution:\n"));
drh17645f52015-02-09 13:42:59 +00005634 sqlite3TreeViewSelect(0, p, 0);
5635 }
5636#endif
drhcce7d172000-05-31 15:34:51 +00005637
drhf35f2f92017-07-29 16:01:55 +00005638 if( pDest->eDest==SRT_Output ){
5639 generateColumnNames(pParse, p);
5640 }
5641
dan67a9b8e2018-06-22 20:51:35 +00005642#ifndef SQLITE_OMIT_WINDOWFUNC
5643 if( sqlite3WindowRewrite(pParse, p) ){
dan86fb6e12018-05-16 20:58:07 +00005644 goto select_end;
5645 }
dandfa552f2018-06-02 21:04:28 +00005646#if SELECTTRACE_ENABLED
5647 if( sqlite3SelectTrace & 0x108 ){
5648 SELECTTRACE(0x104,pParse,p, ("after window rewrite:\n"));
5649 sqlite3TreeViewSelect(0, p, 0);
5650 }
5651#endif
dan67a9b8e2018-06-22 20:51:35 +00005652#endif /* SQLITE_OMIT_WINDOWFUNC */
dan86fb6e12018-05-16 20:58:07 +00005653 pTabList = p->pSrc;
dan73925692018-06-12 18:40:17 +00005654 isAgg = (p->selFlags & SF_Aggregate)!=0;
danf02cdd32018-06-27 19:48:50 +00005655 memset(&sSort, 0, sizeof(sSort));
5656 sSort.pOrderBy = p->pOrderBy;
dan86fb6e12018-05-16 20:58:07 +00005657
drh25897872018-03-20 21:16:15 +00005658 /* Try to various optimizations (flattening subqueries, and strength
5659 ** reduction of join operators) in the FROM clause up into the main query
drhd820cb12002-02-18 03:21:45 +00005660 */
drh51522cd2005-01-20 13:36:19 +00005661#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
danielk1977f23329a2008-07-01 14:09:13 +00005662 for(i=0; !p->pPrior && i<pTabList->nSrc; i++){
drh13449892005-09-07 21:22:45 +00005663 struct SrcList_item *pItem = &pTabList->a[i];
danielk1977daf79ac2008-06-30 18:12:28 +00005664 Select *pSub = pItem->pSelect;
drh2679f142015-09-25 13:42:55 +00005665 Table *pTab = pItem->pTab;
drh25897872018-03-20 21:16:15 +00005666
5667 /* Convert LEFT JOIN into JOIN if there are terms of the right table
5668 ** of the LEFT JOIN used in the WHERE clause.
5669 */
5670 if( (pItem->fg.jointype & JT_LEFT)!=0
5671 && sqlite3ExprImpliesNonNullRow(p->pWhere, pItem->iCursor)
5672 && OptimizationEnabled(db, SQLITE_SimplifyJoin)
5673 ){
5674 SELECTTRACE(0x100,pParse,p,
5675 ("LEFT-JOIN simplifies to JOIN on term %d\n",i));
drhefce69d2018-03-20 22:52:27 +00005676 pItem->fg.jointype &= ~(JT_LEFT|JT_OUTER);
drh25897872018-03-20 21:16:15 +00005677 unsetJoinExpr(p->pWhere, pItem->iCursor);
5678 }
5679
5680 /* No futher action if this term of the FROM clause is no a subquery */
drh4490c402015-06-05 22:33:39 +00005681 if( pSub==0 ) continue;
drh2679f142015-09-25 13:42:55 +00005682
5683 /* Catch mismatch in the declared columns of a view and the number of
5684 ** columns in the SELECT on the RHS */
5685 if( pTab->nCol!=pSub->pEList->nExpr ){
5686 sqlite3ErrorMsg(pParse, "expected %d columns for '%s' but got %d",
5687 pTab->nCol, pTab->zName, pSub->pEList->nExpr);
5688 goto select_end;
5689 }
5690
drh25c221e2017-09-29 22:13:24 +00005691 /* Do not try to flatten an aggregate subquery.
5692 **
5693 ** Flattening an aggregate subquery is only possible if the outer query
5694 ** is not a join. But if the outer query is not a join, then the subquery
5695 ** will be implemented as a co-routine and there is no advantage to
5696 ** flattening in that case.
5697 */
5698 if( (pSub->selFlags & SF_Aggregate)!=0 ) continue;
5699 assert( pSub->pGroupBy==0 );
5700
drhfca23552017-10-28 20:51:54 +00005701 /* If the outer query contains a "complex" result set (that is,
5702 ** if the result set of the outer query uses functions or subqueries)
5703 ** and if the subquery contains an ORDER BY clause and if
drh648fe492017-09-28 20:06:53 +00005704 ** it will be implemented as a co-routine, then do not flatten. This
5705 ** restriction allows SQL constructs like this:
5706 **
5707 ** SELECT expensive_function(x)
5708 ** FROM (SELECT x FROM tab ORDER BY y LIMIT 10);
5709 **
5710 ** The expensive_function() is only computed on the 10 rows that
5711 ** are output, rather than every row of the table.
drhfca23552017-10-28 20:51:54 +00005712 **
5713 ** The requirement that the outer query have a complex result set
5714 ** means that flattening does occur on simpler SQL constraints without
5715 ** the expensive_function() like:
5716 **
5717 ** SELECT x FROM (SELECT x FROM tab ORDER BY y LIMIT 10);
drh648fe492017-09-28 20:06:53 +00005718 */
drh25c221e2017-09-29 22:13:24 +00005719 if( pSub->pOrderBy!=0
drh648fe492017-09-28 20:06:53 +00005720 && i==0
drhfca23552017-10-28 20:51:54 +00005721 && (p->selFlags & SF_ComplexResult)!=0
drh648fe492017-09-28 20:06:53 +00005722 && (pTabList->nSrc==1
5723 || (pTabList->a[1].fg.jointype&(JT_LEFT|JT_CROSS))!=0)
drh648fe492017-09-28 20:06:53 +00005724 ){
5725 continue;
5726 }
5727
drh25c221e2017-09-29 22:13:24 +00005728 if( flattenSubquery(pParse, p, i, isAgg) ){
drh4490c402015-06-05 22:33:39 +00005729 /* This subquery can be absorbed into its parent. */
drh4490c402015-06-05 22:33:39 +00005730 i = -1;
5731 }
5732 pTabList = p->pSrc;
5733 if( db->mallocFailed ) goto select_end;
5734 if( !IgnorableOrderby(pDest) ){
5735 sSort.pOrderBy = p->pOrderBy;
5736 }
5737 }
5738#endif
5739
drh4490c402015-06-05 22:33:39 +00005740#ifndef SQLITE_OMIT_COMPOUND_SELECT
5741 /* Handle compound SELECT statements using the separate multiSelect()
5742 ** procedure.
5743 */
5744 if( p->pPrior ){
5745 rc = multiSelect(pParse, p, pDest);
drh4490c402015-06-05 22:33:39 +00005746#if SELECTTRACE_ENABLED
drhf20609d2018-04-23 17:43:35 +00005747 SELECTTRACE(0x1,pParse,p,("end compound-select processing\n"));
drhe2ca99c2018-05-02 00:33:43 +00005748 if( (sqlite3SelectTrace & 0x2000)!=0 && ExplainQueryPlanParent(pParse)==0 ){
drhf20609d2018-04-23 17:43:35 +00005749 sqlite3TreeViewSelect(0, p, 0);
5750 }
drh4490c402015-06-05 22:33:39 +00005751#endif
drhc631ded2018-05-02 02:22:22 +00005752 if( p->pNext==0 ) ExplainQueryPlanPop(pParse);
drh4490c402015-06-05 22:33:39 +00005753 return rc;
5754 }
5755#endif
5756
drh7810ab62018-07-27 17:51:20 +00005757 /* Do the WHERE-clause constant propagation optimization if this is
5758 ** a join. No need to speed time on this operation for non-join queries
5759 ** as the equivalent optimization will be handled by query planner in
5760 ** sqlite3WhereBegin().
5761 */
5762 if( pTabList->nSrc>1
5763 && OptimizationEnabled(db, SQLITE_PropagateConst)
drh24e11162018-07-26 23:47:11 +00005764 && propagateConstants(pParse, p)
5765 ){
5766#if SELECTTRACE_ENABLED
5767 if( sqlite3SelectTrace & 0x100 ){
5768 SELECTTRACE(0x100,pParse,p,("After constant propagation:\n"));
5769 sqlite3TreeViewSelect(0, p, 0);
5770 }
5771#endif
5772 }else{
drh7810ab62018-07-27 17:51:20 +00005773 SELECTTRACE(0x100,pParse,p,("Constant propagation not helpful\n"));
drh24e11162018-07-26 23:47:11 +00005774 }
5775
dana4b5fb52018-08-03 20:19:52 +00005776#ifdef SQLITE_COUNTOFVIEW_OPTIMIZATION
5777 if( OptimizationEnabled(db, SQLITE_QueryFlattener|SQLITE_CountOfView)
5778 && countOfViewOptimization(pParse, p)
5779 ){
5780 if( db->mallocFailed ) goto select_end;
5781 pEList = p->pEList;
5782 pTabList = p->pSrc;
5783 }
5784#endif
5785
drh701caf12017-05-10 16:12:00 +00005786 /* For each term in the FROM clause, do two things:
5787 ** (1) Authorized unreferenced tables
5788 ** (2) Generate code for all sub-queries
drhd820cb12002-02-18 03:21:45 +00005789 */
drh4490c402015-06-05 22:33:39 +00005790 for(i=0; i<pTabList->nSrc; i++){
danielk1977742f9472004-06-16 12:02:43 +00005791 struct SrcList_item *pItem = &pTabList->a[i];
drhc31c2eb2003-05-02 16:04:17 +00005792 SelectDest dest;
drh701caf12017-05-10 16:12:00 +00005793 Select *pSub;
drh824d21a2017-09-29 12:44:52 +00005794#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
5795 const char *zSavedAuthContext;
5796#endif
drh701caf12017-05-10 16:12:00 +00005797
drh3d240d22017-09-28 16:56:55 +00005798 /* Issue SQLITE_READ authorizations with a fake column name for any
5799 ** tables that are referenced but from which no values are extracted.
5800 ** Examples of where these kinds of null SQLITE_READ authorizations
5801 ** would occur:
drh701caf12017-05-10 16:12:00 +00005802 **
drh2336c932017-05-11 12:05:23 +00005803 ** SELECT count(*) FROM t1; -- SQLITE_READ t1.""
5804 ** SELECT t1.* FROM t1, t2; -- SQLITE_READ t2.""
5805 **
5806 ** The fake column name is an empty string. It is possible for a table to
5807 ** have a column named by the empty string, in which case there is no way to
5808 ** distinguish between an unreferenced table and an actual reference to the
drh3d240d22017-09-28 16:56:55 +00005809 ** "" column. The original design was for the fake column name to be a NULL,
drh2336c932017-05-11 12:05:23 +00005810 ** which would be unambiguous. But legacy authorization callbacks might
drh3d240d22017-09-28 16:56:55 +00005811 ** assume the column name is non-NULL and segfault. The use of an empty
5812 ** string for the fake column name seems safer.
drh701caf12017-05-10 16:12:00 +00005813 */
5814 if( pItem->colUsed==0 ){
drh2336c932017-05-11 12:05:23 +00005815 sqlite3AuthCheck(pParse, SQLITE_READ, pItem->zName, "", pItem->zDatabase);
drh701caf12017-05-10 16:12:00 +00005816 }
5817
5818#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
5819 /* Generate code for all sub-queries in the FROM clause
5820 */
5821 pSub = pItem->pSelect;
drh5b6a9ed2011-09-15 23:58:14 +00005822 if( pSub==0 ) continue;
drh21172c42012-10-30 00:29:07 +00005823
5824 /* Sometimes the code for a subquery will be generated more than
5825 ** once, if the subquery is part of the WHERE clause in a LEFT JOIN,
5826 ** for example. In that case, do not regenerate the code to manifest
5827 ** a view or the co-routine to implement a view. The first instance
5828 ** is sufficient, though the subroutine to manifest the view does need
5829 ** to be invoked again. */
danccb9eb72018-04-24 18:59:18 +00005830 if( pItem->addrFillSub ){
drh8a48b9c2015-08-19 15:20:00 +00005831 if( pItem->fg.viaCoroutine==0 ){
drh75555812017-04-29 19:29:49 +00005832 /* The subroutine that manifests the view might be a one-time routine,
5833 ** or it might need to be rerun on each iteration because it
5834 ** encodes a correlated subquery. */
5835 testcase( sqlite3VdbeGetOp(v, pItem->addrFillSub)->opcode==OP_Once );
drh21172c42012-10-30 00:29:07 +00005836 sqlite3VdbeAddOp2(v, OP_Gosub, pItem->regReturn, pItem->addrFillSub);
5837 }
drh5b6a9ed2011-09-15 23:58:14 +00005838 continue;
5839 }
danielk1977daf79ac2008-06-30 18:12:28 +00005840
danielk1977fc976062007-05-10 10:46:56 +00005841 /* Increment Parse.nHeight by the height of the largest expression
drhf7b54962013-05-28 12:11:54 +00005842 ** tree referred to by this, the parent select. The child select
danielk1977fc976062007-05-10 10:46:56 +00005843 ** may contain expression trees of at most
5844 ** (SQLITE_MAX_EXPR_DEPTH-Parse.nHeight) height. This is a bit
5845 ** more conservative than necessary, but much easier than enforcing
5846 ** an exact limit.
5847 */
5848 pParse->nHeight += sqlite3SelectExprHeight(p);
danielk1977daf79ac2008-06-30 18:12:28 +00005849
drhadc57f62015-06-06 00:18:01 +00005850 /* Make copies of constant WHERE-clause terms in the outer query down
5851 ** inside the subquery. This can help the subquery to run more efficiently.
5852 */
drh7fbb1012018-03-21 01:59:46 +00005853 if( OptimizationEnabled(db, SQLITE_PushDown)
drh6a9b9522018-03-27 15:13:43 +00005854 && pushDownWhereTerms(pParse, pSub, p->pWhere, pItem->iCursor,
5855 (pItem->fg.jointype & JT_OUTER)!=0)
drh4490c402015-06-05 22:33:39 +00005856 ){
drh69b72d52015-06-01 20:28:03 +00005857#if SELECTTRACE_ENABLED
drh4490c402015-06-05 22:33:39 +00005858 if( sqlite3SelectTrace & 0x100 ){
drhd2a44012018-07-28 14:34:22 +00005859 SELECTTRACE(0x100,pParse,p,
5860 ("After WHERE-clause push-down into subquery %d:\n", pSub->selId));
drh4490c402015-06-05 22:33:39 +00005861 sqlite3TreeViewSelect(0, p, 0);
danielk1977daf79ac2008-06-30 18:12:28 +00005862 }
drh69b72d52015-06-01 20:28:03 +00005863#endif
drh2d277bb2018-03-20 11:24:30 +00005864 }else{
5865 SELECTTRACE(0x100,pParse,p,("Push-down not possible\n"));
drh4490c402015-06-05 22:33:39 +00005866 }
drhadc57f62015-06-06 00:18:01 +00005867
drh824d21a2017-09-29 12:44:52 +00005868 zSavedAuthContext = pParse->zAuthContext;
5869 pParse->zAuthContext = pItem->zName;
5870
drhadc57f62015-06-06 00:18:01 +00005871 /* Generate code to implement the subquery
drh0ff47e92016-03-15 17:52:12 +00005872 **
drh25c221e2017-09-29 22:13:24 +00005873 ** The subquery is implemented as a co-routine if the subquery is
5874 ** guaranteed to be the outer loop (so that it does not need to be
5875 ** computed more than once)
drh0ff47e92016-03-15 17:52:12 +00005876 **
5877 ** TODO: Are there other reasons beside (1) to use a co-routine
5878 ** implementation?
drhadc57f62015-06-06 00:18:01 +00005879 */
drh0ff47e92016-03-15 17:52:12 +00005880 if( i==0
5881 && (pTabList->nSrc==1
5882 || (pTabList->a[1].fg.jointype&(JT_LEFT|JT_CROSS))!=0) /* (1) */
drha5759672012-10-30 14:39:12 +00005883 ){
drh21172c42012-10-30 00:29:07 +00005884 /* Implement a co-routine that will return a single row of the result
5885 ** set on each invocation.
5886 */
drh4490c402015-06-05 22:33:39 +00005887 int addrTop = sqlite3VdbeCurrentAddr(v)+1;
drh824d21a2017-09-29 12:44:52 +00005888
drh21172c42012-10-30 00:29:07 +00005889 pItem->regReturn = ++pParse->nMem;
drh4490c402015-06-05 22:33:39 +00005890 sqlite3VdbeAddOp3(v, OP_InitCoroutine, pItem->regReturn, 0, addrTop);
5891 VdbeComment((v, "%s", pItem->pTab->zName));
drh21172c42012-10-30 00:29:07 +00005892 pItem->addrFillSub = addrTop;
drh21172c42012-10-30 00:29:07 +00005893 sqlite3SelectDestInit(&dest, SRT_Coroutine, pItem->regReturn);
drhfef37762018-07-10 19:48:35 +00005894 ExplainQueryPlan((pParse, 1, "CO-ROUTINE %u", pSub->selId));
drh21172c42012-10-30 00:29:07 +00005895 sqlite3Select(pParse, pSub, &dest);
drhc3489bb2016-02-25 16:04:59 +00005896 pItem->pTab->nRowLogEst = pSub->nSelectRow;
drh8a48b9c2015-08-19 15:20:00 +00005897 pItem->fg.viaCoroutine = 1;
drh4490c402015-06-05 22:33:39 +00005898 pItem->regResult = dest.iSdst;
drh2fade2f2016-02-09 02:12:20 +00005899 sqlite3VdbeEndCoroutine(v, pItem->regReturn);
drh21172c42012-10-30 00:29:07 +00005900 sqlite3VdbeJumpHere(v, addrTop-1);
5901 sqlite3ClearTempRegCache(pParse);
danielk1977daf79ac2008-06-30 18:12:28 +00005902 }else{
drh5b6a9ed2011-09-15 23:58:14 +00005903 /* Generate a subroutine that will fill an ephemeral table with
5904 ** the content of this subquery. pItem->addrFillSub will point
5905 ** to the address of the generated subroutine. pItem->regReturn
5906 ** is a register allocated to hold the subroutine return address
5907 */
drh7157e8e2011-09-16 16:00:51 +00005908 int topAddr;
drh48f2d3b2011-09-16 01:34:43 +00005909 int onceAddr = 0;
drh7157e8e2011-09-16 16:00:51 +00005910 int retAddr;
drhe08e8d62017-05-01 15:15:41 +00005911 struct SrcList_item *pPrior;
5912
drh5b6a9ed2011-09-15 23:58:14 +00005913 assert( pItem->addrFillSub==0 );
drh5b6a9ed2011-09-15 23:58:14 +00005914 pItem->regReturn = ++pParse->nMem;
drh7157e8e2011-09-16 16:00:51 +00005915 topAddr = sqlite3VdbeAddOp2(v, OP_Integer, 0, pItem->regReturn);
5916 pItem->addrFillSub = topAddr+1;
drh8a48b9c2015-08-19 15:20:00 +00005917 if( pItem->fg.isCorrelated==0 ){
drhed171672013-04-24 13:50:09 +00005918 /* If the subquery is not correlated and if we are not inside of
drh5b6a9ed2011-09-15 23:58:14 +00005919 ** a trigger, then we only need to compute the value of the subquery
5920 ** once. */
drh511f9e82016-09-22 18:53:13 +00005921 onceAddr = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
drh4490c402015-06-05 22:33:39 +00005922 VdbeComment((v, "materialize \"%s\"", pItem->pTab->zName));
drh69b72d52015-06-01 20:28:03 +00005923 }else{
drh4490c402015-06-05 22:33:39 +00005924 VdbeNoopComment((v, "materialize \"%s\"", pItem->pTab->zName));
drh5b6a9ed2011-09-15 23:58:14 +00005925 }
drhe08e8d62017-05-01 15:15:41 +00005926 pPrior = isSelfJoinView(pTabList, pItem);
5927 if( pPrior ){
5928 sqlite3VdbeAddOp2(v, OP_OpenDup, pItem->iCursor, pPrior->iCursor);
drheafc6df2017-06-11 19:51:36 +00005929 assert( pPrior->pSelect!=0 );
5930 pSub->nSelectRow = pPrior->pSelect->nSelectRow;
drhe08e8d62017-05-01 15:15:41 +00005931 }else{
5932 sqlite3SelectDestInit(&dest, SRT_EphemTab, pItem->iCursor);
drhfef37762018-07-10 19:48:35 +00005933 ExplainQueryPlan((pParse, 1, "MATERIALIZE %u", pSub->selId));
drhe08e8d62017-05-01 15:15:41 +00005934 sqlite3Select(pParse, pSub, &dest);
5935 }
drhc3489bb2016-02-25 16:04:59 +00005936 pItem->pTab->nRowLogEst = pSub->nSelectRow;
drh48f2d3b2011-09-16 01:34:43 +00005937 if( onceAddr ) sqlite3VdbeJumpHere(v, onceAddr);
drh7157e8e2011-09-16 16:00:51 +00005938 retAddr = sqlite3VdbeAddOp1(v, OP_Return, pItem->regReturn);
5939 VdbeComment((v, "end %s", pItem->pTab->zName));
5940 sqlite3VdbeChangeP1(v, topAddr, retAddr);
drhcdc69552011-12-06 13:24:59 +00005941 sqlite3ClearTempRegCache(pParse);
danielk1977daf79ac2008-06-30 18:12:28 +00005942 }
drhadc57f62015-06-06 00:18:01 +00005943 if( db->mallocFailed ) goto select_end;
danielk1977fc976062007-05-10 10:46:56 +00005944 pParse->nHeight -= sqlite3SelectExprHeight(p);
drh824d21a2017-09-29 12:44:52 +00005945 pParse->zAuthContext = zSavedAuthContext;
drh51522cd2005-01-20 13:36:19 +00005946#endif
drh701caf12017-05-10 16:12:00 +00005947 }
drhadc57f62015-06-06 00:18:01 +00005948
drh38b41492015-06-08 15:08:15 +00005949 /* Various elements of the SELECT copied into local variables for
5950 ** convenience */
drhadc57f62015-06-06 00:18:01 +00005951 pEList = p->pEList;
danielk1977daf79ac2008-06-30 18:12:28 +00005952 pWhere = p->pWhere;
5953 pGroupBy = p->pGroupBy;
5954 pHaving = p->pHaving;
drhe8e4af72012-09-21 00:04:28 +00005955 sDistinct.isTnct = (p->selFlags & SF_Distinct)!=0;
drh832508b2002-03-02 17:04:07 +00005956
drhbc8edba2015-06-05 20:27:26 +00005957#if SELECTTRACE_ENABLED
5958 if( sqlite3SelectTrace & 0x400 ){
5959 SELECTTRACE(0x400,pParse,p,("After all FROM-clause analysis:\n"));
5960 sqlite3TreeViewSelect(0, p, 0);
danielk1977f23329a2008-07-01 14:09:13 +00005961 }
5962#endif
5963
dan50118cd2011-07-01 14:21:38 +00005964 /* If the query is DISTINCT with an ORDER BY but is not an aggregate, and
5965 ** if the select-list is the same as the ORDER BY list, then this query
5966 ** can be rewritten as a GROUP BY. In other words, this:
5967 **
5968 ** SELECT DISTINCT xyz FROM ... ORDER BY xyz
5969 **
5970 ** is transformed to:
5971 **
drhdea7d702014-12-04 21:54:58 +00005972 ** SELECT xyz FROM ... GROUP BY xyz ORDER BY xyz
dan50118cd2011-07-01 14:21:38 +00005973 **
5974 ** The second form is preferred as a single index (or temp-table) may be
5975 ** used for both the ORDER BY and DISTINCT processing. As originally
5976 ** written the query must use a temp-table for at least one of the ORDER
5977 ** BY and DISTINCT, and an index or separate temp-table for the other.
5978 */
5979 if( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct
drhadc57f62015-06-06 00:18:01 +00005980 && sqlite3ExprListCompare(sSort.pOrderBy, pEList, -1)==0
dan50118cd2011-07-01 14:21:38 +00005981 ){
5982 p->selFlags &= ~SF_Distinct;
drhadc57f62015-06-06 00:18:01 +00005983 pGroupBy = p->pGroupBy = sqlite3ExprListDup(db, pEList, 0);
drhe8e4af72012-09-21 00:04:28 +00005984 /* Notice that even thought SF_Distinct has been cleared from p->selFlags,
5985 ** the sDistinct.isTnct is still set. Hence, isTnct represents the
5986 ** original setting of the SF_Distinct flag, not the current setting */
5987 assert( sDistinct.isTnct );
drh7512cb42016-04-14 13:06:49 +00005988
5989#if SELECTTRACE_ENABLED
5990 if( sqlite3SelectTrace & 0x400 ){
5991 SELECTTRACE(0x400,pParse,p,("Transform DISTINCT into GROUP BY:\n"));
5992 sqlite3TreeViewSelect(0, p, 0);
5993 }
5994#endif
dan50118cd2011-07-01 14:21:38 +00005995 }
5996
drhadc57f62015-06-06 00:18:01 +00005997 /* If there is an ORDER BY clause, then create an ephemeral index to
5998 ** do the sorting. But this sorting ephemeral index might end up
5999 ** being unused if the data can be extracted in pre-sorted order.
6000 ** If that is the case, then the OP_OpenEphemeral instruction will be
6001 ** changed to an OP_Noop once we figure out that the sorting index is
6002 ** not needed. The sSort.addrSortIndex variable is used to facilitate
6003 ** that change.
danielk19777cedc8d2004-06-10 10:50:08 +00006004 */
drh079a3072014-03-19 14:10:55 +00006005 if( sSort.pOrderBy ){
drh0342b1f2005-09-01 03:07:44 +00006006 KeyInfo *pKeyInfo;
danf9eae182018-05-21 19:45:11 +00006007 pKeyInfo = sqlite3KeyInfoFromExprList(
6008 pParse, sSort.pOrderBy, 0, pEList->nExpr);
drh079a3072014-03-19 14:10:55 +00006009 sSort.iECursor = pParse->nTab++;
6010 sSort.addrSortIndex =
drh66a51672008-01-03 00:01:23 +00006011 sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
drhf45f2322014-03-23 17:45:03 +00006012 sSort.iECursor, sSort.pOrderBy->nExpr+1+pEList->nExpr, 0,
6013 (char*)pKeyInfo, P4_KEYINFO
6014 );
drh9d2985c2005-09-08 01:58:42 +00006015 }else{
drh079a3072014-03-19 14:10:55 +00006016 sSort.addrSortIndex = -1;
danielk19777cedc8d2004-06-10 10:50:08 +00006017 }
6018
drh2d0794e2002-03-03 03:03:52 +00006019 /* If the output is destined for a temporary table, open that table.
6020 */
danielk19776c8c8ce2008-01-02 16:27:09 +00006021 if( pDest->eDest==SRT_EphemTab ){
drh2b596da2012-07-23 21:43:19 +00006022 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pDest->iSDParm, pEList->nExpr);
drh2d0794e2002-03-03 03:03:52 +00006023 }
6024
drhf42bacc2006-04-26 17:39:34 +00006025 /* Set the limiter.
6026 */
6027 iEnd = sqlite3VdbeMakeLabel(v);
dan69b93832016-12-16 15:05:40 +00006028 if( (p->selFlags & SF_FixedLimit)==0 ){
6029 p->nSelectRow = 320; /* 4 billion rows */
6030 }
drhf42bacc2006-04-26 17:39:34 +00006031 computeLimitRegisters(pParse, p, iEnd);
drh079a3072014-03-19 14:10:55 +00006032 if( p->iLimit==0 && sSort.addrSortIndex>=0 ){
drh0ff287f2015-09-02 18:40:33 +00006033 sqlite3VdbeChangeOpcode(v, sSort.addrSortIndex, OP_SorterOpen);
drh079a3072014-03-19 14:10:55 +00006034 sSort.sortFlags |= SORTFLAG_UseSorter;
drhc6aff302011-09-01 15:32:47 +00006035 }
drhf42bacc2006-04-26 17:39:34 +00006036
drhadc57f62015-06-06 00:18:01 +00006037 /* Open an ephemeral index to use for the distinct set.
drhefb72512000-05-31 20:00:52 +00006038 */
dan2ce22452010-11-08 19:01:16 +00006039 if( p->selFlags & SF_Distinct ){
drhe8e4af72012-09-21 00:04:28 +00006040 sDistinct.tabTnct = pParse->nTab++;
6041 sDistinct.addrTnct = sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
danf9eae182018-05-21 19:45:11 +00006042 sDistinct.tabTnct, 0, 0,
6043 (char*)sqlite3KeyInfoFromExprList(pParse, p->pEList,0,0),
6044 P4_KEYINFO);
drhd4187c72010-08-30 22:15:45 +00006045 sqlite3VdbeChangeP5(v, BTREE_UNORDERED);
drhe8e4af72012-09-21 00:04:28 +00006046 sDistinct.eTnctType = WHERE_DISTINCT_UNORDERED;
drh832508b2002-03-02 17:04:07 +00006047 }else{
drhe8e4af72012-09-21 00:04:28 +00006048 sDistinct.eTnctType = WHERE_DISTINCT_NOOP;
drhefb72512000-05-31 20:00:52 +00006049 }
drh832508b2002-03-02 17:04:07 +00006050
drh13449892005-09-07 21:22:45 +00006051 if( !isAgg && pGroupBy==0 ){
drhe8e4af72012-09-21 00:04:28 +00006052 /* No aggregate functions and no GROUP BY clause */
dan67a9b8e2018-06-22 20:51:35 +00006053 u16 wctrlFlags = (sDistinct.isTnct ? WHERE_WANT_DISTINCT : 0)
6054 | (p->selFlags & SF_FixedLimit);
6055#ifndef SQLITE_OMIT_WINDOWFUNC
6056 Window *pWin = p->pWin; /* Master window object (or NULL) */
danf9eae182018-05-21 19:45:11 +00006057 if( pWin ){
6058 sqlite3WindowCodeInit(pParse, pWin);
dan86fb6e12018-05-16 20:58:07 +00006059 }
dan67a9b8e2018-06-22 20:51:35 +00006060#endif
6061 assert( WHERE_USE_LIMIT==SF_FixedLimit );
6062
dan86fb6e12018-05-16 20:58:07 +00006063
dan38cc40c2011-06-30 20:17:15 +00006064 /* Begin the database scan. */
drhcfd74702018-03-19 22:28:34 +00006065 SELECTTRACE(1,pParse,p,("WhereBegin\n"));
drh079a3072014-03-19 14:10:55 +00006066 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, sSort.pOrderBy,
drhc3489bb2016-02-25 16:04:59 +00006067 p->pEList, wctrlFlags, p->nSelectRow);
drh13449892005-09-07 21:22:45 +00006068 if( pWInfo==0 ) goto select_end;
drh6f328482013-06-05 23:39:34 +00006069 if( sqlite3WhereOutputRowCount(pWInfo) < p->nSelectRow ){
6070 p->nSelectRow = sqlite3WhereOutputRowCount(pWInfo);
6071 }
drh6457a352013-06-21 00:35:37 +00006072 if( sDistinct.isTnct && sqlite3WhereIsDistinct(pWInfo) ){
drh6f328482013-06-05 23:39:34 +00006073 sDistinct.eTnctType = sqlite3WhereIsDistinct(pWInfo);
6074 }
drh079a3072014-03-19 14:10:55 +00006075 if( sSort.pOrderBy ){
6076 sSort.nOBSat = sqlite3WhereIsOrdered(pWInfo);
drh6ee5a7b2018-09-08 20:09:46 +00006077 sSort.labelOBLopt = sqlite3WhereOrderByLimitOptLabel(pWInfo);
drh079a3072014-03-19 14:10:55 +00006078 if( sSort.nOBSat==sSort.pOrderBy->nExpr ){
6079 sSort.pOrderBy = 0;
6080 }
6081 }
drhcce7d172000-05-31 15:34:51 +00006082
drhb9bb7c12006-06-11 23:41:55 +00006083 /* If sorting index that was created by a prior OP_OpenEphemeral
6084 ** instruction ended up not being needed, then change the OP_OpenEphemeral
drh9d2985c2005-09-08 01:58:42 +00006085 ** into an OP_Noop.
6086 */
drh079a3072014-03-19 14:10:55 +00006087 if( sSort.addrSortIndex>=0 && sSort.pOrderBy==0 ){
6088 sqlite3VdbeChangeToNoop(v, sSort.addrSortIndex);
drh9d2985c2005-09-08 01:58:42 +00006089 }
6090
drh2def2f72017-09-15 17:40:34 +00006091 assert( p->pEList==pEList );
dan67a9b8e2018-06-22 20:51:35 +00006092#ifndef SQLITE_OMIT_WINDOWFUNC
danf9eae182018-05-21 19:45:11 +00006093 if( pWin ){
6094 int addrGosub = sqlite3VdbeMakeLabel(v);
dandacf1de2018-06-08 16:11:55 +00006095 int iCont = sqlite3VdbeMakeLabel(v);
danefa3a3c2018-06-23 16:26:20 +00006096 int iBreak = sqlite3VdbeMakeLabel(v);
danf9eae182018-05-21 19:45:11 +00006097 int regGosub = ++pParse->nMem;
drhefb72512000-05-31 20:00:52 +00006098
dandacf1de2018-06-08 16:11:55 +00006099 sqlite3WindowCodeStep(pParse, p, pWInfo, regGosub, addrGosub);
dan86fb6e12018-05-16 20:58:07 +00006100
danefa3a3c2018-06-23 16:26:20 +00006101 sqlite3VdbeAddOp2(v, OP_Goto, 0, iBreak);
danf9eae182018-05-21 19:45:11 +00006102 sqlite3VdbeResolveLabel(v, addrGosub);
drhb0225bc2018-07-10 20:50:27 +00006103 VdbeNoopComment((v, "inner-loop subroutine"));
drhd4cb09e2018-09-17 15:19:13 +00006104 sSort.labelOBLopt = 0;
danefa3a3c2018-06-23 16:26:20 +00006105 selectInnerLoop(pParse, p, -1, &sSort, &sDistinct, pDest, iCont, iBreak);
dandacf1de2018-06-08 16:11:55 +00006106 sqlite3VdbeResolveLabel(v, iCont);
dan86fb6e12018-05-16 20:58:07 +00006107 sqlite3VdbeAddOp1(v, OP_Return, regGosub);
drh0b3b0dd2018-07-10 05:11:03 +00006108 VdbeComment((v, "end inner-loop subroutine"));
danefa3a3c2018-06-23 16:26:20 +00006109 sqlite3VdbeResolveLabel(v, iBreak);
dan67a9b8e2018-06-22 20:51:35 +00006110 }else
6111#endif /* SQLITE_OMIT_WINDOWFUNC */
6112 {
dan86fb6e12018-05-16 20:58:07 +00006113 /* Use the standard inner loop. */
6114 selectInnerLoop(pParse, p, -1, &sSort, &sDistinct, pDest,
6115 sqlite3WhereContinueLabel(pWInfo),
6116 sqlite3WhereBreakLabel(pWInfo));
6117
6118 /* End the database scan loop.
6119 */
6120 sqlite3WhereEnd(pWInfo);
6121 }
drh13449892005-09-07 21:22:45 +00006122 }else{
drhe8e4af72012-09-21 00:04:28 +00006123 /* This case when there exist aggregate functions or a GROUP BY clause
6124 ** or both */
drh13449892005-09-07 21:22:45 +00006125 NameContext sNC; /* Name context for processing aggregate information */
6126 int iAMem; /* First Mem address for storing current GROUP BY */
6127 int iBMem; /* First Mem address for previous GROUP BY */
6128 int iUseFlag; /* Mem address holding flag indicating that at least
6129 ** one row of the input to the aggregator has been
6130 ** processed */
6131 int iAbortFlag; /* Mem address which causes query abort if positive */
6132 int groupBySort; /* Rows come from source in GROUP BY order */
drhd1766112008-09-17 00:13:12 +00006133 int addrEnd; /* End of processing for this SELECT */
drh1c9d8352011-09-01 16:01:27 +00006134 int sortPTab = 0; /* Pseudotable used to decode sorting results */
6135 int sortOut = 0; /* Output register from the sorter */
dan374cd782014-04-21 13:21:56 +00006136 int orderByGrp = 0; /* True if the GROUP BY and ORDER BY are the same */
drhcce7d172000-05-31 15:34:51 +00006137
drhd1766112008-09-17 00:13:12 +00006138 /* Remove any and all aliases between the result set and the
6139 ** GROUP BY clause.
6140 */
6141 if( pGroupBy ){
drhdc5ea5c2008-12-10 17:19:59 +00006142 int k; /* Loop counter */
drhd1766112008-09-17 00:13:12 +00006143 struct ExprList_item *pItem; /* For looping over expression in a list */
drhcce7d172000-05-31 15:34:51 +00006144
drhdc5ea5c2008-12-10 17:19:59 +00006145 for(k=p->pEList->nExpr, pItem=p->pEList->a; k>0; k--, pItem++){
drhc2acc4e2013-11-15 18:15:19 +00006146 pItem->u.x.iAlias = 0;
drhd1766112008-09-17 00:13:12 +00006147 }
drhdc5ea5c2008-12-10 17:19:59 +00006148 for(k=pGroupBy->nExpr, pItem=pGroupBy->a; k>0; k--, pItem++){
drhc2acc4e2013-11-15 18:15:19 +00006149 pItem->u.x.iAlias = 0;
drhd1766112008-09-17 00:13:12 +00006150 }
drhc3489bb2016-02-25 16:04:59 +00006151 assert( 66==sqlite3LogEst(100) );
6152 if( p->nSelectRow>66 ) p->nSelectRow = 66;
drh95aa47b2010-11-16 02:49:15 +00006153 }else{
drhc3489bb2016-02-25 16:04:59 +00006154 assert( 0==sqlite3LogEst(1) );
6155 p->nSelectRow = 0;
drhd1766112008-09-17 00:13:12 +00006156 }
drh13449892005-09-07 21:22:45 +00006157
dan374cd782014-04-21 13:21:56 +00006158 /* If there is both a GROUP BY and an ORDER BY clause and they are
6159 ** identical, then it may be possible to disable the ORDER BY clause
6160 ** on the grounds that the GROUP BY will cause elements to come out
drhadc57f62015-06-06 00:18:01 +00006161 ** in the correct order. It also may not - the GROUP BY might use a
dan374cd782014-04-21 13:21:56 +00006162 ** database index that causes rows to be grouped together as required
6163 ** but not actually sorted. Either way, record the fact that the
6164 ** ORDER BY and GROUP BY clauses are the same by setting the orderByGrp
6165 ** variable. */
6166 if( sqlite3ExprListCompare(pGroupBy, sSort.pOrderBy, -1)==0 ){
6167 orderByGrp = 1;
6168 }
drhd1766112008-09-17 00:13:12 +00006169
6170 /* Create a label to jump to when we want to abort the query */
drh13449892005-09-07 21:22:45 +00006171 addrEnd = sqlite3VdbeMakeLabel(v);
6172
6173 /* Convert TK_COLUMN nodes into TK_AGG_COLUMN and make entries in
6174 ** sAggInfo for all TK_AGG_FUNCTION nodes in expressions of the
6175 ** SELECT statement.
6176 */
6177 memset(&sNC, 0, sizeof(sNC));
6178 sNC.pParse = pParse;
6179 sNC.pSrcList = pTabList;
drh25c3b8c2018-04-16 10:34:13 +00006180 sNC.uNC.pAggInfo = &sAggInfo;
6181 VVA_ONLY( sNC.ncFlags = NC_UAggInfo; )
drh7e61d182013-12-20 13:11:45 +00006182 sAggInfo.mnReg = pParse->nMem+1;
dandd23c6b2014-03-24 20:19:07 +00006183 sAggInfo.nSortingColumn = pGroupBy ? pGroupBy->nExpr : 0;
drh9d2985c2005-09-08 01:58:42 +00006184 sAggInfo.pGroupBy = pGroupBy;
drhd2b3e232008-01-23 14:51:49 +00006185 sqlite3ExprAnalyzeAggList(&sNC, pEList);
drh079a3072014-03-19 14:10:55 +00006186 sqlite3ExprAnalyzeAggList(&sNC, sSort.pOrderBy);
drhd2b3e232008-01-23 14:51:49 +00006187 if( pHaving ){
danab31a842017-04-29 20:53:09 +00006188 if( pGroupBy ){
6189 assert( pWhere==p->pWhere );
drhcd0abc22018-03-20 18:08:33 +00006190 assert( pHaving==p->pHaving );
6191 assert( pGroupBy==p->pGroupBy );
6192 havingToWhere(pParse, p);
danab31a842017-04-29 20:53:09 +00006193 pWhere = p->pWhere;
6194 }
drhd2b3e232008-01-23 14:51:49 +00006195 sqlite3ExprAnalyzeAggregates(&sNC, pHaving);
drh13449892005-09-07 21:22:45 +00006196 }
6197 sAggInfo.nAccumulator = sAggInfo.nColumn;
drh47d9f832017-10-26 20:04:28 +00006198 if( p->pGroupBy==0 && p->pHaving==0 && sAggInfo.nFunc==1 ){
6199 minMaxFlag = minMaxQuery(db, sAggInfo.aFunc[0].pExpr, &pMinMaxOrderBy);
6200 }else{
6201 minMaxFlag = WHERE_ORDERBY_NORMAL;
6202 }
drh13449892005-09-07 21:22:45 +00006203 for(i=0; i<sAggInfo.nFunc; i++){
drh3b3c86a2018-09-18 21:35:31 +00006204 if( sAggInfo.aFunc[i].pExpr->eX==EX_List ){
6205 sNC.ncFlags |= NC_InAggFunc;
6206 sqlite3ExprAnalyzeAggList(&sNC, sAggInfo.aFunc[i].pExpr->x.pList);
6207 sNC.ncFlags &= ~NC_InAggFunc;
6208 }
drh13449892005-09-07 21:22:45 +00006209 }
drh7e61d182013-12-20 13:11:45 +00006210 sAggInfo.mxReg = pParse->nMem;
drh17435752007-08-16 04:30:38 +00006211 if( db->mallocFailed ) goto select_end;
drh7ea11062017-10-26 18:43:19 +00006212#if SELECTTRACE_ENABLED
6213 if( sqlite3SelectTrace & 0x400 ){
6214 int ii;
6215 SELECTTRACE(0x400,pParse,p,("After aggregate analysis:\n"));
6216 sqlite3TreeViewSelect(0, p, 0);
6217 for(ii=0; ii<sAggInfo.nColumn; ii++){
6218 sqlite3DebugPrintf("agg-column[%d] iMem=%d\n",
6219 ii, sAggInfo.aCol[ii].iMem);
6220 sqlite3TreeViewExpr(0, sAggInfo.aCol[ii].pExpr, 0);
6221 }
6222 for(ii=0; ii<sAggInfo.nFunc; ii++){
6223 sqlite3DebugPrintf("agg-func[%d]: iMem=%d\n",
6224 ii, sAggInfo.aFunc[ii].iMem);
6225 sqlite3TreeViewExpr(0, sAggInfo.aFunc[ii].pExpr, 0);
6226 }
6227 }
6228#endif
6229
drh13449892005-09-07 21:22:45 +00006230
6231 /* Processing for aggregates with GROUP BY is very different and
danielk19773c4809a2007-11-12 15:29:18 +00006232 ** much more complex than aggregates without a GROUP BY.
drh13449892005-09-07 21:22:45 +00006233 */
6234 if( pGroupBy ){
6235 KeyInfo *pKeyInfo; /* Keying information for the group by clause */
drh728e0f92015-10-10 14:41:28 +00006236 int addr1; /* A-vs-B comparision jump */
drhd1766112008-09-17 00:13:12 +00006237 int addrOutputRow; /* Start of subroutine that outputs a result row */
6238 int regOutputRow; /* Return address register for output subroutine */
6239 int addrSetAbort; /* Set the abort flag and return */
6240 int addrTopOfLoop; /* Top of the input loop */
6241 int addrSortingIdx; /* The OP_OpenEphemeral for the sorting index */
6242 int addrReset; /* Subroutine for resetting the accumulator */
6243 int regReset; /* Return address register for reset subroutine */
drh13449892005-09-07 21:22:45 +00006244
6245 /* If there is a GROUP BY clause we might need a sorting index to
6246 ** implement it. Allocate that sorting index now. If it turns out
drh1c9d8352011-09-01 16:01:27 +00006247 ** that we do not need it after all, the OP_SorterOpen instruction
drh13449892005-09-07 21:22:45 +00006248 ** will be converted into a Noop.
6249 */
6250 sAggInfo.sortingIdx = pParse->nTab++;
danf9eae182018-05-21 19:45:11 +00006251 pKeyInfo = sqlite3KeyInfoFromExprList(pParse,pGroupBy,0,sAggInfo.nColumn);
drh1c9d8352011-09-01 16:01:27 +00006252 addrSortingIdx = sqlite3VdbeAddOp4(v, OP_SorterOpen,
danielk1977cd3e8f72008-03-25 09:47:35 +00006253 sAggInfo.sortingIdx, sAggInfo.nSortingColumn,
drh2ec2fb22013-11-06 19:59:23 +00006254 0, (char*)pKeyInfo, P4_KEYINFO);
drh13449892005-09-07 21:22:45 +00006255
6256 /* Initialize memory locations used by GROUP BY aggregate processing
6257 */
drh0a07c102008-01-03 18:03:08 +00006258 iUseFlag = ++pParse->nMem;
6259 iAbortFlag = ++pParse->nMem;
drhd1766112008-09-17 00:13:12 +00006260 regOutputRow = ++pParse->nMem;
6261 addrOutputRow = sqlite3VdbeMakeLabel(v);
6262 regReset = ++pParse->nMem;
6263 addrReset = sqlite3VdbeMakeLabel(v);
drh0a07c102008-01-03 18:03:08 +00006264 iAMem = pParse->nMem + 1;
drh13449892005-09-07 21:22:45 +00006265 pParse->nMem += pGroupBy->nExpr;
drh0a07c102008-01-03 18:03:08 +00006266 iBMem = pParse->nMem + 1;
drh13449892005-09-07 21:22:45 +00006267 pParse->nMem += pGroupBy->nExpr;
drh4c583122008-01-04 22:01:03 +00006268 sqlite3VdbeAddOp2(v, OP_Integer, 0, iAbortFlag);
drhd4e70eb2008-01-02 00:34:36 +00006269 VdbeComment((v, "clear abort flag"));
drhb8475df2011-12-09 16:21:19 +00006270 sqlite3VdbeAddOp3(v, OP_Null, 0, iAMem, iAMem+pGroupBy->nExpr-1);
drhe3133822005-09-20 13:11:59 +00006271
drh13449892005-09-07 21:22:45 +00006272 /* Begin a loop that will extract all source rows in GROUP BY order.
6273 ** This might involve two separate loops with an OP_Sort in between, or
6274 ** it might be a single loop that uses an index to extract information
6275 ** in the right order to begin with.
6276 */
drh2eb95372008-06-06 15:04:36 +00006277 sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset);
drhcfd74702018-03-19 22:28:34 +00006278 SELECTTRACE(1,pParse,p,("WhereBegin\n"));
drh079a3072014-03-19 14:10:55 +00006279 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pGroupBy, 0,
dan374cd782014-04-21 13:21:56 +00006280 WHERE_GROUPBY | (orderByGrp ? WHERE_SORTBYGROUP : 0), 0
6281 );
drh5360ad32005-09-08 00:13:27 +00006282 if( pWInfo==0 ) goto select_end;
drhddba0c22014-03-18 20:33:42 +00006283 if( sqlite3WhereIsOrdered(pWInfo)==pGroupBy->nExpr ){
drh13449892005-09-07 21:22:45 +00006284 /* The optimizer is able to deliver rows in group by order so
drhb9bb7c12006-06-11 23:41:55 +00006285 ** we do not have to sort. The OP_OpenEphemeral table will be
drh13449892005-09-07 21:22:45 +00006286 ** cancelled later because we still need to use the pKeyInfo
6287 */
drh13449892005-09-07 21:22:45 +00006288 groupBySort = 0;
6289 }else{
6290 /* Rows are coming out in undetermined order. We have to push
6291 ** each row into a sorting index, terminate the first loop,
6292 ** then loop over the sorting index in order to get the output
6293 ** in sorted order
6294 */
drh892d3172008-01-10 03:46:36 +00006295 int regBase;
6296 int regRecord;
6297 int nCol;
6298 int nGroupBy;
6299
dan2ce22452010-11-08 19:01:16 +00006300 explainTempTable(pParse,
drhe8e4af72012-09-21 00:04:28 +00006301 (sDistinct.isTnct && (p->selFlags&SF_Distinct)==0) ?
6302 "DISTINCT" : "GROUP BY");
dan2ce22452010-11-08 19:01:16 +00006303
drh13449892005-09-07 21:22:45 +00006304 groupBySort = 1;
drh892d3172008-01-10 03:46:36 +00006305 nGroupBy = pGroupBy->nExpr;
dandd23c6b2014-03-24 20:19:07 +00006306 nCol = nGroupBy;
6307 j = nGroupBy;
drh892d3172008-01-10 03:46:36 +00006308 for(i=0; i<sAggInfo.nColumn; i++){
6309 if( sAggInfo.aCol[i].iSorterColumn>=j ){
6310 nCol++;
6311 j++;
6312 }
6313 }
6314 regBase = sqlite3GetTempRange(pParse, nCol);
drh5579d592015-08-26 14:01:41 +00006315 sqlite3ExprCodeExprList(pParse, pGroupBy, regBase, 0, 0);
dandd23c6b2014-03-24 20:19:07 +00006316 j = nGroupBy;
drh13449892005-09-07 21:22:45 +00006317 for(i=0; i<sAggInfo.nColumn; i++){
6318 struct AggInfo_col *pCol = &sAggInfo.aCol[i];
drh892d3172008-01-10 03:46:36 +00006319 if( pCol->iSorterColumn>=j ){
drhe55cbd72008-03-31 23:48:03 +00006320 int r1 = j + regBase;
drh8c607192018-08-04 15:53:55 +00006321 sqlite3ExprCodeGetColumnOfTable(v,
6322 pCol->pTab, pCol->iTable, pCol->iColumn, r1);
drh6a012f02008-08-21 14:15:59 +00006323 j++;
drh892d3172008-01-10 03:46:36 +00006324 }
drh13449892005-09-07 21:22:45 +00006325 }
drh892d3172008-01-10 03:46:36 +00006326 regRecord = sqlite3GetTempReg(pParse);
drh1db639c2008-01-17 02:36:28 +00006327 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord);
drh1c9d8352011-09-01 16:01:27 +00006328 sqlite3VdbeAddOp2(v, OP_SorterInsert, sAggInfo.sortingIdx, regRecord);
drh892d3172008-01-10 03:46:36 +00006329 sqlite3ReleaseTempReg(pParse, regRecord);
6330 sqlite3ReleaseTempRange(pParse, regBase, nCol);
drh13449892005-09-07 21:22:45 +00006331 sqlite3WhereEnd(pWInfo);
dan5134d132011-09-02 10:31:11 +00006332 sAggInfo.sortingIdxPTab = sortPTab = pParse->nTab++;
drh1c9d8352011-09-01 16:01:27 +00006333 sortOut = sqlite3GetTempReg(pParse);
6334 sqlite3VdbeAddOp3(v, OP_OpenPseudo, sortPTab, sortOut, nCol);
6335 sqlite3VdbeAddOp2(v, OP_SorterSort, sAggInfo.sortingIdx, addrEnd);
drh688852a2014-02-17 22:40:43 +00006336 VdbeComment((v, "GROUP BY sort")); VdbeCoverage(v);
drh13449892005-09-07 21:22:45 +00006337 sAggInfo.useSortingIdx = 1;
dan374cd782014-04-21 13:21:56 +00006338 }
6339
6340 /* If the index or temporary table used by the GROUP BY sort
6341 ** will naturally deliver rows in the order required by the ORDER BY
6342 ** clause, cancel the ephemeral table open coded earlier.
6343 **
6344 ** This is an optimization - the correct answer should result regardless.
6345 ** Use the SQLITE_GroupByOrder flag with SQLITE_TESTCTRL_OPTIMIZER to
6346 ** disable this optimization for testing purposes. */
6347 if( orderByGrp && OptimizationEnabled(db, SQLITE_GroupByOrder)
6348 && (groupBySort || sqlite3WhereIsSorted(pWInfo))
6349 ){
6350 sSort.pOrderBy = 0;
6351 sqlite3VdbeChangeToNoop(v, sSort.addrSortIndex);
drh13449892005-09-07 21:22:45 +00006352 }
6353
6354 /* Evaluate the current GROUP BY terms and store in b0, b1, b2...
6355 ** (b0 is memory location iBMem+0, b1 is iBMem+1, and so forth)
6356 ** Then compare the current GROUP BY terms against the GROUP BY terms
6357 ** from the previous row currently stored in a0, a1, a2...
6358 */
6359 addrTopOfLoop = sqlite3VdbeCurrentAddr(v);
drh1c9d8352011-09-01 16:01:27 +00006360 if( groupBySort ){
drh38b41492015-06-08 15:08:15 +00006361 sqlite3VdbeAddOp3(v, OP_SorterData, sAggInfo.sortingIdx,
6362 sortOut, sortPTab);
drh1c9d8352011-09-01 16:01:27 +00006363 }
drh13449892005-09-07 21:22:45 +00006364 for(j=0; j<pGroupBy->nExpr; j++){
6365 if( groupBySort ){
drh1c9d8352011-09-01 16:01:27 +00006366 sqlite3VdbeAddOp3(v, OP_Column, sortPTab, j, iBMem+j);
drh13449892005-09-07 21:22:45 +00006367 }else{
6368 sAggInfo.directMode = 1;
drh2dcef112008-01-12 19:03:48 +00006369 sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr, iBMem+j);
drh13449892005-09-07 21:22:45 +00006370 }
drh13449892005-09-07 21:22:45 +00006371 }
drh16ee60f2008-06-20 18:13:25 +00006372 sqlite3VdbeAddOp4(v, OP_Compare, iAMem, iBMem, pGroupBy->nExpr,
drh2ec2fb22013-11-06 19:59:23 +00006373 (char*)sqlite3KeyInfoRef(pKeyInfo), P4_KEYINFO);
drh728e0f92015-10-10 14:41:28 +00006374 addr1 = sqlite3VdbeCurrentAddr(v);
6375 sqlite3VdbeAddOp3(v, OP_Jump, addr1+1, 0, addr1+1); VdbeCoverage(v);
drh13449892005-09-07 21:22:45 +00006376
6377 /* Generate code that runs whenever the GROUP BY changes.
drhe00ee6e2008-06-20 15:24:01 +00006378 ** Changes in the GROUP BY are detected by the previous code
drh13449892005-09-07 21:22:45 +00006379 ** block. If there were no changes, this block is skipped.
6380 **
6381 ** This code copies current group by terms in b0,b1,b2,...
6382 ** over to a0,a1,a2. It then calls the output subroutine
6383 ** and resets the aggregate accumulator registers in preparation
6384 ** for the next GROUP BY batch.
6385 */
drhb21e7c72008-06-22 12:37:57 +00006386 sqlite3ExprCodeMove(pParse, iBMem, iAMem, pGroupBy->nExpr);
drh2eb95372008-06-06 15:04:36 +00006387 sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow);
drhd4e70eb2008-01-02 00:34:36 +00006388 VdbeComment((v, "output one row"));
drh688852a2014-02-17 22:40:43 +00006389 sqlite3VdbeAddOp2(v, OP_IfPos, iAbortFlag, addrEnd); VdbeCoverage(v);
drhd4e70eb2008-01-02 00:34:36 +00006390 VdbeComment((v, "check abort flag"));
drh2eb95372008-06-06 15:04:36 +00006391 sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset);
drhd4e70eb2008-01-02 00:34:36 +00006392 VdbeComment((v, "reset accumulator"));
drh13449892005-09-07 21:22:45 +00006393
6394 /* Update the aggregate accumulators based on the content of
6395 ** the current row
6396 */
drh728e0f92015-10-10 14:41:28 +00006397 sqlite3VdbeJumpHere(v, addr1);
dan280c8942018-06-05 20:04:28 +00006398 updateAccumulator(pParse, iUseFlag, &sAggInfo);
drh4c583122008-01-04 22:01:03 +00006399 sqlite3VdbeAddOp2(v, OP_Integer, 1, iUseFlag);
drhd4e70eb2008-01-02 00:34:36 +00006400 VdbeComment((v, "indicate data in accumulator"));
drh13449892005-09-07 21:22:45 +00006401
6402 /* End of the loop
6403 */
6404 if( groupBySort ){
drh1c9d8352011-09-01 16:01:27 +00006405 sqlite3VdbeAddOp2(v, OP_SorterNext, sAggInfo.sortingIdx, addrTopOfLoop);
drh688852a2014-02-17 22:40:43 +00006406 VdbeCoverage(v);
drh13449892005-09-07 21:22:45 +00006407 }else{
6408 sqlite3WhereEnd(pWInfo);
drh48f2d3b2011-09-16 01:34:43 +00006409 sqlite3VdbeChangeToNoop(v, addrSortingIdx);
drh13449892005-09-07 21:22:45 +00006410 }
6411
6412 /* Output the final row of result
6413 */
drh2eb95372008-06-06 15:04:36 +00006414 sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow);
drhd4e70eb2008-01-02 00:34:36 +00006415 VdbeComment((v, "output final row"));
drhd1766112008-09-17 00:13:12 +00006416
6417 /* Jump over the subroutines
6418 */
drh076e85f2015-09-03 13:46:12 +00006419 sqlite3VdbeGoto(v, addrEnd);
drhd1766112008-09-17 00:13:12 +00006420
6421 /* Generate a subroutine that outputs a single row of the result
6422 ** set. This subroutine first looks at the iUseFlag. If iUseFlag
6423 ** is less than or equal to zero, the subroutine is a no-op. If
6424 ** the processing calls for the query to abort, this subroutine
6425 ** increments the iAbortFlag memory location before returning in
6426 ** order to signal the caller to abort.
6427 */
6428 addrSetAbort = sqlite3VdbeCurrentAddr(v);
6429 sqlite3VdbeAddOp2(v, OP_Integer, 1, iAbortFlag);
6430 VdbeComment((v, "set abort flag"));
6431 sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);
6432 sqlite3VdbeResolveLabel(v, addrOutputRow);
6433 addrOutputRow = sqlite3VdbeCurrentAddr(v);
6434 sqlite3VdbeAddOp2(v, OP_IfPos, iUseFlag, addrOutputRow+2);
drh38b41492015-06-08 15:08:15 +00006435 VdbeCoverage(v);
drhd1766112008-09-17 00:13:12 +00006436 VdbeComment((v, "Groupby result generator entry point"));
6437 sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);
6438 finalizeAggFunctions(pParse, &sAggInfo);
drh33cd4902009-05-30 20:49:20 +00006439 sqlite3ExprIfFalse(pParse, pHaving, addrOutputRow+1, SQLITE_JUMPIFNULL);
drh2def2f72017-09-15 17:40:34 +00006440 selectInnerLoop(pParse, p, -1, &sSort,
drhe8e4af72012-09-21 00:04:28 +00006441 &sDistinct, pDest,
drhd1766112008-09-17 00:13:12 +00006442 addrOutputRow+1, addrSetAbort);
6443 sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);
6444 VdbeComment((v, "end groupby result generator"));
6445
6446 /* Generate a subroutine that will reset the group-by accumulator
6447 */
6448 sqlite3VdbeResolveLabel(v, addrReset);
6449 resetAccumulator(pParse, &sAggInfo);
dan280c8942018-06-05 20:04:28 +00006450 sqlite3VdbeAddOp2(v, OP_Integer, 0, iUseFlag);
6451 VdbeComment((v, "indicate accumulator empty"));
drhd1766112008-09-17 00:13:12 +00006452 sqlite3VdbeAddOp1(v, OP_Return, regReset);
6453
drh43152cf2009-05-19 19:04:58 +00006454 } /* endif pGroupBy. Begin aggregate queries without GROUP BY: */
drh13449892005-09-07 21:22:45 +00006455 else {
danielk1977a5533162009-02-24 10:01:51 +00006456#ifndef SQLITE_OMIT_BTREECOUNT
6457 Table *pTab;
6458 if( (pTab = isSimpleCount(p, &sAggInfo))!=0 ){
6459 /* If isSimpleCount() returns a pointer to a Table structure, then
6460 ** the SQL statement is of the form:
6461 **
6462 ** SELECT count(*) FROM <tbl>
6463 **
6464 ** where the Table structure returned represents table <tbl>.
6465 **
6466 ** This statement is so common that it is optimized specially. The
6467 ** OP_Count instruction is executed either on the intkey table that
6468 ** contains the data for table <tbl> or on one of its indexes. It
6469 ** is better to execute the op on an index, as indexes are almost
6470 ** always spread across less pages than their corresponding tables.
6471 */
6472 const int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
6473 const int iCsr = pParse->nTab++; /* Cursor to scan b-tree */
6474 Index *pIdx; /* Iterator variable */
6475 KeyInfo *pKeyInfo = 0; /* Keyinfo for scanned index */
6476 Index *pBest = 0; /* Best index found so far */
6477 int iRoot = pTab->tnum; /* Root page of scanned b-tree */
danielk1977a9d1ccb2008-01-05 17:39:29 +00006478
danielk1977a5533162009-02-24 10:01:51 +00006479 sqlite3CodeVerifySchema(pParse, iDb);
6480 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
6481
drhd9e3cad2013-10-04 02:36:19 +00006482 /* Search for the index that has the lowest scan cost.
danielk1977a5533162009-02-24 10:01:51 +00006483 **
drh3e9548b2011-04-15 14:46:27 +00006484 ** (2011-04-15) Do not do a full scan of an unordered index.
6485 **
drhabcc1942013-11-12 14:55:40 +00006486 ** (2013-10-03) Do not count the entries in a partial index.
drh5f33f372013-10-04 00:00:12 +00006487 **
danielk1977a5533162009-02-24 10:01:51 +00006488 ** In practice the KeyInfo structure will not be used. It is only
6489 ** passed to keep OP_OpenRead happy.
6490 */
drh5c7917e2013-11-12 15:33:40 +00006491 if( !HasRowid(pTab) ) pBest = sqlite3PrimaryKeyIndex(pTab);
danielk1977a5533162009-02-24 10:01:51 +00006492 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
drhd9e3cad2013-10-04 02:36:19 +00006493 if( pIdx->bUnordered==0
drhe13e9f52013-10-05 19:18:00 +00006494 && pIdx->szIdxRow<pTab->szTabRow
drhd3037a42013-10-04 18:29:25 +00006495 && pIdx->pPartIdxWhere==0
drhe13e9f52013-10-05 19:18:00 +00006496 && (!pBest || pIdx->szIdxRow<pBest->szIdxRow)
drhd9e3cad2013-10-04 02:36:19 +00006497 ){
danielk1977a5533162009-02-24 10:01:51 +00006498 pBest = pIdx;
6499 }
6500 }
drhd9e3cad2013-10-04 02:36:19 +00006501 if( pBest ){
danielk1977a5533162009-02-24 10:01:51 +00006502 iRoot = pBest->tnum;
drh2ec2fb22013-11-06 19:59:23 +00006503 pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pBest);
danielk1977a5533162009-02-24 10:01:51 +00006504 }
6505
6506 /* Open a read-only cursor, execute the OP_Count, close the cursor. */
drh261c02d2013-10-25 14:46:15 +00006507 sqlite3VdbeAddOp4Int(v, OP_OpenRead, iCsr, iRoot, iDb, 1);
danielk1977a5533162009-02-24 10:01:51 +00006508 if( pKeyInfo ){
drh2ec2fb22013-11-06 19:59:23 +00006509 sqlite3VdbeChangeP4(v, -1, (char *)pKeyInfo, P4_KEYINFO);
danielk1977a5533162009-02-24 10:01:51 +00006510 }
6511 sqlite3VdbeAddOp2(v, OP_Count, iCsr, sAggInfo.aFunc[0].iMem);
6512 sqlite3VdbeAddOp1(v, OP_Close, iCsr);
danef7075d2011-02-21 17:49:49 +00006513 explainSimpleCount(pParse, pTab, pBest);
danielk1977a5533162009-02-24 10:01:51 +00006514 }else
6515#endif /* SQLITE_OMIT_BTREECOUNT */
6516 {
dan280c8942018-06-05 20:04:28 +00006517 int regAcc = 0; /* "populate accumulators" flag */
6518
6519 /* If there are accumulator registers but no min() or max() functions,
6520 ** allocate register regAcc. Register regAcc will contain 0 the first
6521 ** time the inner loop runs, and 1 thereafter. The code generated
6522 ** by updateAccumulator() only updates the accumulator registers if
6523 ** regAcc contains 0. */
6524 if( sAggInfo.nAccumulator ){
6525 for(i=0; i<sAggInfo.nFunc; i++){
6526 if( sAggInfo.aFunc[i].pFunc->funcFlags&SQLITE_FUNC_NEEDCOLL ) break;
6527 }
6528 if( i==sAggInfo.nFunc ){
6529 regAcc = ++pParse->nMem;
6530 sqlite3VdbeAddOp2(v, OP_Integer, 0, regAcc);
6531 }
6532 }
6533
danielk1977a5533162009-02-24 10:01:51 +00006534 /* This case runs if the aggregate has no GROUP BY clause. The
6535 ** processing is much simpler since there is only a single row
6536 ** of output.
6537 */
drh47d9f832017-10-26 20:04:28 +00006538 assert( p->pGroupBy==0 );
danielk1977a5533162009-02-24 10:01:51 +00006539 resetAccumulator(pParse, &sAggInfo);
drh47d9f832017-10-26 20:04:28 +00006540
6541 /* If this query is a candidate for the min/max optimization, then
6542 ** minMaxFlag will have been previously set to either
6543 ** WHERE_ORDERBY_MIN or WHERE_ORDERBY_MAX and pMinMaxOrderBy will
6544 ** be an appropriate ORDER BY expression for the optimization.
6545 */
6546 assert( minMaxFlag==WHERE_ORDERBY_NORMAL || pMinMaxOrderBy!=0 );
6547 assert( pMinMaxOrderBy==0 || pMinMaxOrderBy->nExpr==1 );
6548
drhcfd74702018-03-19 22:28:34 +00006549 SELECTTRACE(1,pParse,p,("WhereBegin\n"));
drh47d9f832017-10-26 20:04:28 +00006550 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pMinMaxOrderBy,
6551 0, minMaxFlag, 0);
danielk1977a5533162009-02-24 10:01:51 +00006552 if( pWInfo==0 ){
danielk1977a5533162009-02-24 10:01:51 +00006553 goto select_end;
6554 }
dan280c8942018-06-05 20:04:28 +00006555 updateAccumulator(pParse, regAcc, &sAggInfo);
6556 if( regAcc ) sqlite3VdbeAddOp2(v, OP_Integer, 1, regAcc);
drhddba0c22014-03-18 20:33:42 +00006557 if( sqlite3WhereIsOrdered(pWInfo)>0 ){
drh076e85f2015-09-03 13:46:12 +00006558 sqlite3VdbeGoto(v, sqlite3WhereBreakLabel(pWInfo));
danielk1977a5533162009-02-24 10:01:51 +00006559 VdbeComment((v, "%s() by index",
drh47d9f832017-10-26 20:04:28 +00006560 (minMaxFlag==WHERE_ORDERBY_MIN?"min":"max")));
danielk1977a5533162009-02-24 10:01:51 +00006561 }
6562 sqlite3WhereEnd(pWInfo);
6563 finalizeAggFunctions(pParse, &sAggInfo);
danielk1977a9d1ccb2008-01-05 17:39:29 +00006564 }
6565
drh079a3072014-03-19 14:10:55 +00006566 sSort.pOrderBy = 0;
drh33cd4902009-05-30 20:49:20 +00006567 sqlite3ExprIfFalse(pParse, pHaving, addrEnd, SQLITE_JUMPIFNULL);
drh2def2f72017-09-15 17:40:34 +00006568 selectInnerLoop(pParse, p, -1, 0, 0,
drha9671a22008-07-08 23:40:20 +00006569 pDest, addrEnd, addrEnd);
drh13449892005-09-07 21:22:45 +00006570 }
6571 sqlite3VdbeResolveLabel(v, addrEnd);
6572
6573 } /* endif aggregate query */
drh22827922000-06-06 17:27:05 +00006574
drhe8e4af72012-09-21 00:04:28 +00006575 if( sDistinct.eTnctType==WHERE_DISTINCT_UNORDERED ){
dan2ce22452010-11-08 19:01:16 +00006576 explainTempTable(pParse, "DISTINCT");
6577 }
6578
drhcce7d172000-05-31 15:34:51 +00006579 /* If there is an ORDER BY clause, then we need to sort the results
6580 ** and send them to the callback one by one.
6581 */
drh079a3072014-03-19 14:10:55 +00006582 if( sSort.pOrderBy ){
drh38b41492015-06-08 15:08:15 +00006583 explainTempTable(pParse,
6584 sSort.nOBSat>0 ? "RIGHT PART OF ORDER BY":"ORDER BY");
dan24e25d32018-04-14 18:46:20 +00006585 assert( p->pEList==pEList );
drh079a3072014-03-19 14:10:55 +00006586 generateSortTail(pParse, p, &sSort, pEList->nExpr, pDest);
drhcce7d172000-05-31 15:34:51 +00006587 }
drh6a535342001-10-19 16:44:56 +00006588
drhec7429a2005-10-06 16:53:14 +00006589 /* Jump here to skip this query
6590 */
6591 sqlite3VdbeResolveLabel(v, iEnd);
6592
dan5b1c07e2015-04-16 07:19:23 +00006593 /* The SELECT has been coded. If there is an error in the Parse structure,
6594 ** set the return code to 1. Otherwise 0. */
6595 rc = (pParse->nErr>0);
drh1d83f052002-02-17 00:30:36 +00006596
6597 /* Control jumps to here if an error is encountered above, or upon
6598 ** successful coding of the SELECT.
6599 */
6600select_end:
drh47d9f832017-10-26 20:04:28 +00006601 sqlite3ExprListDelete(db, pMinMaxOrderBy);
drh633e6d52008-07-28 19:34:53 +00006602 sqlite3DbFree(db, sAggInfo.aCol);
6603 sqlite3DbFree(db, sAggInfo.aFunc);
drheb9b8842014-09-21 00:27:26 +00006604#if SELECTTRACE_ENABLED
drhf20609d2018-04-23 17:43:35 +00006605 SELECTTRACE(0x1,pParse,p,("end processing\n"));
drhe2ca99c2018-05-02 00:33:43 +00006606 if( (sqlite3SelectTrace & 0x2000)!=0 && ExplainQueryPlanParent(pParse)==0 ){
drhf20609d2018-04-23 17:43:35 +00006607 sqlite3TreeViewSelect(0, p, 0);
6608 }
drheb9b8842014-09-21 00:27:26 +00006609#endif
drhe2ca99c2018-05-02 00:33:43 +00006610 ExplainQueryPlanPop(pParse);
drh1d83f052002-02-17 00:30:36 +00006611 return rc;
drhcce7d172000-05-31 15:34:51 +00006612}