blob: 3da69943f7ba7b89af27d92f75fda195465081c9 [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/*
18** An instance of the following object is used to record information about
19** how to process the DISTINCT keyword, to simplify passing that information
20** into the selectInnerLoop() routine.
drheda639e2006-01-22 00:42:09 +000021*/
drh079a3072014-03-19 14:10:55 +000022typedef struct DistinctCtx DistinctCtx;
23struct DistinctCtx {
24 u8 isTnct; /* True if the DISTINCT keyword is present */
25 u8 eTnctType; /* One of the WHERE_DISTINCT_* operators */
26 int tabTnct; /* Ephemeral table used for DISTINCT processing */
27 int addrTnct; /* Address of OP_OpenEphemeral opcode for tabTnct */
28};
29
30/*
31** An instance of the following object is used to record information about
32** the ORDER BY (or GROUP BY) clause of query is being coded.
dan24e25d32018-04-14 18:46:20 +000033**
34** The aDefer[] array is used by the sorter-references optimization. For
35** example, assuming there is no index that can be used for the ORDER BY,
36** for the query:
37**
38** SELECT a, bigblob FROM t1 ORDER BY a LIMIT 10;
39**
40** it may be more efficient to add just the "a" values to the sorter, and
41** retrieve the associated "bigblob" values directly from table t1 as the
42** 10 smallest "a" values are extracted from the sorter.
43**
44** When the sorter-reference optimization is used, there is one entry in the
45** aDefer[] array for each database table that may be read as values are
46** extracted from the sorter.
drh079a3072014-03-19 14:10:55 +000047*/
48typedef struct SortCtx SortCtx;
49struct SortCtx {
50 ExprList *pOrderBy; /* The ORDER BY (or GROUP BY clause) */
51 int nOBSat; /* Number of ORDER BY terms satisfied by indices */
52 int iECursor; /* Cursor number for the sorter */
53 int regReturn; /* Register holding block-output return address */
54 int labelBkOut; /* Start label for the block-output subroutine */
55 int addrSortIndex; /* Address of the OP_SorterOpen or OP_OpenEphemeral */
drha04a8be2016-01-13 17:50:10 +000056 int labelDone; /* Jump here when done, ex: LIMIT reached */
drh6ee5a7b2018-09-08 20:09:46 +000057 int labelOBLopt; /* Jump here when sorter is full */
drh079a3072014-03-19 14:10:55 +000058 u8 sortFlags; /* Zero or more SORTFLAG_* bits */
dan24e25d32018-04-14 18:46:20 +000059#ifdef SQLITE_ENABLE_SORTER_REFERENCES
60 u8 nDefer; /* Number of valid entries in aDefer[] */
61 struct DeferredCsr {
62 Table *pTab; /* Table definition */
63 int iCsr; /* Cursor number for table */
64 int nKey; /* Number of PK columns for table pTab (>=1) */
65 } aDefer[4];
66#endif
drhbbd4ae52018-04-30 19:32:49 +000067 struct RowLoadInfo *pDeferredRowLoad; /* Deferred row loading info or NULL */
drh079a3072014-03-19 14:10:55 +000068};
69#define SORTFLAG_UseSorter 0x01 /* Use SorterOpen instead of OpenEphemeral */
drh315555c2002-10-20 15:53:03 +000070
drhcce7d172000-05-31 15:34:51 +000071/*
drhb87fbed2015-01-05 15:48:45 +000072** Delete all the content of a Select structure. Deallocate the structure
drha9ebfe22019-12-25 23:54:21 +000073** itself depending on the value of bFree
74**
75** If bFree==1, call sqlite3DbFree() on the p object.
76** If bFree==0, Leave the first Select object unfreed
drheda639e2006-01-22 00:42:09 +000077*/
drhb87fbed2015-01-05 15:48:45 +000078static void clearSelect(sqlite3 *db, Select *p, int bFree){
79 while( p ){
80 Select *pPrior = p->pPrior;
81 sqlite3ExprListDelete(db, p->pEList);
82 sqlite3SrcListDelete(db, p->pSrc);
83 sqlite3ExprDelete(db, p->pWhere);
84 sqlite3ExprListDelete(db, p->pGroupBy);
85 sqlite3ExprDelete(db, p->pHaving);
86 sqlite3ExprListDelete(db, p->pOrderBy);
87 sqlite3ExprDelete(db, p->pLimit);
dan67a9b8e2018-06-22 20:51:35 +000088#ifndef SQLITE_OMIT_WINDOWFUNC
dane3bf6322018-06-08 20:58:27 +000089 if( OK_IF_ALWAYS_TRUE(p->pWinDefn) ){
90 sqlite3WindowListDelete(db, p->pWinDefn);
91 }
dan67a9b8e2018-06-22 20:51:35 +000092#endif
drh8906a4b2017-10-03 17:29:40 +000093 if( OK_IF_ALWAYS_TRUE(p->pWith) ) sqlite3WithDelete(db, p->pWith);
drhdbd6a7d2017-04-05 12:39:49 +000094 if( bFree ) sqlite3DbFreeNN(db, p);
drhb87fbed2015-01-05 15:48:45 +000095 p = pPrior;
96 bFree = 1;
97 }
drheda639e2006-01-22 00:42:09 +000098}
99
drh1013c932008-01-06 00:25:21 +0000100/*
101** Initialize a SelectDest structure.
102*/
103void sqlite3SelectDestInit(SelectDest *pDest, int eDest, int iParm){
drhea678832008-12-10 19:26:22 +0000104 pDest->eDest = (u8)eDest;
drh2b596da2012-07-23 21:43:19 +0000105 pDest->iSDParm = iParm;
dan9ed322d2020-04-29 17:41:29 +0000106 pDest->iSDParm2 = 0;
dan71c57db2016-07-09 20:23:55 +0000107 pDest->zAffSdst = 0;
drh2b596da2012-07-23 21:43:19 +0000108 pDest->iSdst = 0;
109 pDest->nSdst = 0;
drh1013c932008-01-06 00:25:21 +0000110}
111
drheda639e2006-01-22 00:42:09 +0000112
113/*
drh9bb61fe2000-06-05 16:01:39 +0000114** Allocate a new Select structure and return a pointer to that
115** structure.
drhcce7d172000-05-31 15:34:51 +0000116*/
danielk19774adee202004-05-08 08:23:19 +0000117Select *sqlite3SelectNew(
drh17435752007-08-16 04:30:38 +0000118 Parse *pParse, /* Parsing context */
drhdaffd0e2001-04-11 14:28:42 +0000119 ExprList *pEList, /* which columns to include in the result */
drhad3cab52002-05-24 02:04:32 +0000120 SrcList *pSrc, /* the FROM clause -- which tables to scan */
drhdaffd0e2001-04-11 14:28:42 +0000121 Expr *pWhere, /* the WHERE clause */
122 ExprList *pGroupBy, /* the GROUP BY clause */
123 Expr *pHaving, /* the HAVING clause */
124 ExprList *pOrderBy, /* the ORDER BY clause */
drhc3489bb2016-02-25 16:04:59 +0000125 u32 selFlags, /* Flag parameters, such as SF_Distinct */
drh8c0833f2017-11-14 23:48:23 +0000126 Expr *pLimit /* LIMIT value. NULL means not used */
drh9bb61fe2000-06-05 16:01:39 +0000127){
drhd3bf7662020-05-25 01:31:09 +0000128 Select *pNew, *pAllocated;
drheda639e2006-01-22 00:42:09 +0000129 Select standin;
drhd3bf7662020-05-25 01:31:09 +0000130 pAllocated = pNew = sqlite3DbMallocRawNN(pParse->db, sizeof(*pNew) );
drhdaffd0e2001-04-11 14:28:42 +0000131 if( pNew==0 ){
drhef90a6b2017-04-11 16:44:39 +0000132 assert( pParse->db->mallocFailed );
drheda639e2006-01-22 00:42:09 +0000133 pNew = &standin;
drheda639e2006-01-22 00:42:09 +0000134 }
135 if( pEList==0 ){
drh3d240d22017-09-28 16:56:55 +0000136 pEList = sqlite3ExprListAppend(pParse, 0,
137 sqlite3Expr(pParse->db,TK_ASTERISK,0));
drheda639e2006-01-22 00:42:09 +0000138 }
139 pNew->pEList = pEList;
drhca3862d2016-01-08 12:46:39 +0000140 pNew->op = TK_SELECT;
141 pNew->selFlags = selFlags;
142 pNew->iLimit = 0;
143 pNew->iOffset = 0;
drhfef37762018-07-10 19:48:35 +0000144 pNew->selId = ++pParse->nSelect;
drhca3862d2016-01-08 12:46:39 +0000145 pNew->addrOpenEphm[0] = -1;
146 pNew->addrOpenEphm[1] = -1;
147 pNew->nSelectRow = 0;
drhef90a6b2017-04-11 16:44:39 +0000148 if( pSrc==0 ) pSrc = sqlite3DbMallocZero(pParse->db, sizeof(*pSrc));
drheda639e2006-01-22 00:42:09 +0000149 pNew->pSrc = pSrc;
150 pNew->pWhere = pWhere;
151 pNew->pGroupBy = pGroupBy;
152 pNew->pHaving = pHaving;
153 pNew->pOrderBy = pOrderBy;
drhca3862d2016-01-08 12:46:39 +0000154 pNew->pPrior = 0;
155 pNew->pNext = 0;
drheda639e2006-01-22 00:42:09 +0000156 pNew->pLimit = pLimit;
drhca3862d2016-01-08 12:46:39 +0000157 pNew->pWith = 0;
dan67a9b8e2018-06-22 20:51:35 +0000158#ifndef SQLITE_OMIT_WINDOWFUNC
dan86fb6e12018-05-16 20:58:07 +0000159 pNew->pWin = 0;
dane3bf6322018-06-08 20:58:27 +0000160 pNew->pWinDefn = 0;
dan67a9b8e2018-06-22 20:51:35 +0000161#endif
drhef90a6b2017-04-11 16:44:39 +0000162 if( pParse->db->mallocFailed ) {
163 clearSelect(pParse->db, pNew, pNew!=&standin);
drhd3bf7662020-05-25 01:31:09 +0000164 pAllocated = 0;
drha464c232011-09-16 19:04:03 +0000165 }else{
166 assert( pNew->pSrc!=0 || pParse->nErr>0 );
drhdaffd0e2001-04-11 14:28:42 +0000167 }
drhd3bf7662020-05-25 01:31:09 +0000168 return pAllocated;
drh9bb61fe2000-06-05 16:01:39 +0000169}
170
drheb9b8842014-09-21 00:27:26 +0000171
drh9bb61fe2000-06-05 16:01:39 +0000172/*
drheda639e2006-01-22 00:42:09 +0000173** Delete the given Select structure and all of its substructures.
174*/
drh633e6d52008-07-28 19:34:53 +0000175void sqlite3SelectDelete(sqlite3 *db, Select *p){
drh8906a4b2017-10-03 17:29:40 +0000176 if( OK_IF_ALWAYS_TRUE(p) ) clearSelect(db, p, 1);
drheda639e2006-01-22 00:42:09 +0000177}
178
179/*
drhd227a292014-02-09 18:02:09 +0000180** Return a pointer to the right-most SELECT statement in a compound.
181*/
182static Select *findRightmost(Select *p){
183 while( p->pNext ) p = p->pNext;
184 return p;
drh9bb61fe2000-06-05 16:01:39 +0000185}
186
187/*
drhf7b54962013-05-28 12:11:54 +0000188** Given 1 to 3 identifiers preceding the JOIN keyword, determine the
drh01f3f252002-05-24 16:14:15 +0000189** type of join. Return an integer constant that expresses that type
190** in terms of the following bit values:
191**
192** JT_INNER
drh3dec2232005-09-10 15:28:09 +0000193** JT_CROSS
drh01f3f252002-05-24 16:14:15 +0000194** JT_OUTER
195** JT_NATURAL
196** JT_LEFT
197** JT_RIGHT
198**
199** A full outer join is the combination of JT_LEFT and JT_RIGHT.
200**
201** If an illegal or unsupported join type is seen, then still return
202** a join type, but put an error in the pParse structure.
203*/
danielk19774adee202004-05-08 08:23:19 +0000204int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){
drh01f3f252002-05-24 16:14:15 +0000205 int jointype = 0;
206 Token *apAll[3];
207 Token *p;
drh373cc2d2009-05-17 02:06:14 +0000208 /* 0123456789 123456789 123456789 123 */
209 static const char zKeyText[] = "naturaleftouterightfullinnercross";
drh57196282004-10-06 15:41:16 +0000210 static const struct {
drh373cc2d2009-05-17 02:06:14 +0000211 u8 i; /* Beginning of keyword text in zKeyText[] */
212 u8 nChar; /* Length of the keyword in characters */
213 u8 code; /* Join type mask */
214 } aKeyword[] = {
215 /* natural */ { 0, 7, JT_NATURAL },
216 /* left */ { 6, 4, JT_LEFT|JT_OUTER },
217 /* outer */ { 10, 5, JT_OUTER },
218 /* right */ { 14, 5, JT_RIGHT|JT_OUTER },
219 /* full */ { 19, 4, JT_LEFT|JT_RIGHT|JT_OUTER },
220 /* inner */ { 23, 5, JT_INNER },
221 /* cross */ { 28, 5, JT_INNER|JT_CROSS },
drh01f3f252002-05-24 16:14:15 +0000222 };
223 int i, j;
224 apAll[0] = pA;
225 apAll[1] = pB;
226 apAll[2] = pC;
drh195e6962002-05-25 00:18:20 +0000227 for(i=0; i<3 && apAll[i]; i++){
drh01f3f252002-05-24 16:14:15 +0000228 p = apAll[i];
drh373cc2d2009-05-17 02:06:14 +0000229 for(j=0; j<ArraySize(aKeyword); j++){
230 if( p->n==aKeyword[j].nChar
231 && sqlite3StrNICmp((char*)p->z, &zKeyText[aKeyword[j].i], p->n)==0 ){
232 jointype |= aKeyword[j].code;
drh01f3f252002-05-24 16:14:15 +0000233 break;
234 }
235 }
drh373cc2d2009-05-17 02:06:14 +0000236 testcase( j==0 || j==1 || j==2 || j==3 || j==4 || j==5 || j==6 );
237 if( j>=ArraySize(aKeyword) ){
drh01f3f252002-05-24 16:14:15 +0000238 jointype |= JT_ERROR;
239 break;
240 }
241 }
drhad2d8302002-05-24 20:31:36 +0000242 if(
243 (jointype & (JT_INNER|JT_OUTER))==(JT_INNER|JT_OUTER) ||
drh195e6962002-05-25 00:18:20 +0000244 (jointype & JT_ERROR)!=0
drhad2d8302002-05-24 20:31:36 +0000245 ){
drha9671a22008-07-08 23:40:20 +0000246 const char *zSp = " ";
247 assert( pB!=0 );
248 if( pC==0 ){ zSp++; }
drhae29ffb2004-09-25 14:39:18 +0000249 sqlite3ErrorMsg(pParse, "unknown or unsupported join type: "
drha9671a22008-07-08 23:40:20 +0000250 "%T %T%s%T", pA, pB, zSp, pC);
drh01f3f252002-05-24 16:14:15 +0000251 jointype = JT_INNER;
drh373cc2d2009-05-17 02:06:14 +0000252 }else if( (jointype & JT_OUTER)!=0
253 && (jointype & (JT_LEFT|JT_RIGHT))!=JT_LEFT ){
danielk19774adee202004-05-08 08:23:19 +0000254 sqlite3ErrorMsg(pParse,
drhda93d232003-03-31 02:12:46 +0000255 "RIGHT and FULL OUTER JOINs are not currently supported");
drh195e6962002-05-25 00:18:20 +0000256 jointype = JT_INNER;
drh01f3f252002-05-24 16:14:15 +0000257 }
258 return jointype;
259}
260
261/*
drhad2d8302002-05-24 20:31:36 +0000262** Return the index of a column in a table. Return -1 if the column
263** is not contained in the table.
264*/
dan6e6d9832021-02-16 20:43:36 +0000265int sqlite3ColumnIndex(Table *pTab, const char *zCol){
drhad2d8302002-05-24 20:31:36 +0000266 int i;
drha1928072020-07-20 13:11:19 +0000267 u8 h = sqlite3StrIHash(zCol);
268 Column *pCol;
269 for(pCol=pTab->aCol, i=0; i<pTab->nCol; pCol++, i++){
270 if( pCol->hName==h && sqlite3StrICmp(pCol->zName, zCol)==0 ) return i;
drhad2d8302002-05-24 20:31:36 +0000271 }
272 return -1;
273}
274
275/*
drh2179b432009-12-09 17:36:39 +0000276** Search the first N tables in pSrc, from left to right, looking for a
277** table that has a column named zCol.
278**
279** When found, set *piTab and *piCol to the table index and column index
280** of the matching column and return TRUE.
281**
282** If not found, return FALSE.
283*/
284static int tableAndColumnIndex(
285 SrcList *pSrc, /* Array of tables to search */
286 int N, /* Number of tables in pSrc->a[] to search */
287 const char *zCol, /* Name of the column we are looking for */
288 int *piTab, /* Write index of pSrc->a[] here */
dan9d41af22019-12-30 14:32:27 +0000289 int *piCol, /* Write index of pSrc->a[*piTab].pTab->aCol[] here */
290 int bIgnoreHidden /* True to ignore hidden columns */
drh2179b432009-12-09 17:36:39 +0000291){
292 int i; /* For looping over tables in pSrc */
293 int iCol; /* Index of column matching zCol */
294
295 assert( (piTab==0)==(piCol==0) ); /* Both or neither are NULL */
296 for(i=0; i<N; i++){
dan6e6d9832021-02-16 20:43:36 +0000297 iCol = sqlite3ColumnIndex(pSrc->a[i].pTab, zCol);
dan9d41af22019-12-30 14:32:27 +0000298 if( iCol>=0
299 && (bIgnoreHidden==0 || IsHiddenColumn(&pSrc->a[i].pTab->aCol[iCol])==0)
300 ){
drh2179b432009-12-09 17:36:39 +0000301 if( piTab ){
302 *piTab = i;
303 *piCol = iCol;
304 }
305 return 1;
306 }
307 }
308 return 0;
309}
310
311/*
danf7b0b0a2009-10-19 15:52:32 +0000312** This function is used to add terms implied by JOIN syntax to the
313** WHERE clause expression of a SELECT statement. The new term, which
314** is ANDed with the existing WHERE clause, is of the form:
315**
316** (tab1.col1 = tab2.col2)
317**
318** where tab1 is the iSrc'th table in SrcList pSrc and tab2 is the
319** (iSrc+1)'th. Column col1 is column iColLeft of tab1, and col2 is
320** column iColRight of tab2.
drhad2d8302002-05-24 20:31:36 +0000321*/
322static void addWhereTerm(
danf7b0b0a2009-10-19 15:52:32 +0000323 Parse *pParse, /* Parsing context */
324 SrcList *pSrc, /* List of tables in FROM clause */
drh2179b432009-12-09 17:36:39 +0000325 int iLeft, /* Index of first table to join in pSrc */
danf7b0b0a2009-10-19 15:52:32 +0000326 int iColLeft, /* Index of column in first table */
drh2179b432009-12-09 17:36:39 +0000327 int iRight, /* Index of second table in pSrc */
danf7b0b0a2009-10-19 15:52:32 +0000328 int iColRight, /* Index of column in second table */
329 int isOuterJoin, /* True if this is an OUTER join */
330 Expr **ppWhere /* IN/OUT: The WHERE clause to add to */
drhad2d8302002-05-24 20:31:36 +0000331){
danf7b0b0a2009-10-19 15:52:32 +0000332 sqlite3 *db = pParse->db;
333 Expr *pE1;
334 Expr *pE2;
335 Expr *pEq;
drhad2d8302002-05-24 20:31:36 +0000336
drh2179b432009-12-09 17:36:39 +0000337 assert( iLeft<iRight );
338 assert( pSrc->nSrc>iRight );
339 assert( pSrc->a[iLeft].pTab );
340 assert( pSrc->a[iRight].pTab );
danf7b0b0a2009-10-19 15:52:32 +0000341
drh2179b432009-12-09 17:36:39 +0000342 pE1 = sqlite3CreateColumnExpr(db, pSrc, iLeft, iColLeft);
343 pE2 = sqlite3CreateColumnExpr(db, pSrc, iRight, iColRight);
danf7b0b0a2009-10-19 15:52:32 +0000344
drhabfd35e2016-12-06 22:47:23 +0000345 pEq = sqlite3PExpr(pParse, TK_EQ, pE1, pE2);
danf7b0b0a2009-10-19 15:52:32 +0000346 if( pEq && isOuterJoin ){
347 ExprSetProperty(pEq, EP_FromJoin);
drhc5cd1242013-09-12 16:50:49 +0000348 assert( !ExprHasProperty(pEq, EP_TokenOnly|EP_Reduced) );
drhebb6a652013-09-12 23:42:22 +0000349 ExprSetVVAProperty(pEq, EP_NoReduce);
dan961a7262020-12-21 19:50:10 +0000350 pEq->iRightJoinTable = pE2->iTable;
drh030530d2005-01-18 17:40:04 +0000351 }
drhd5c851c2019-04-19 13:38:34 +0000352 *ppWhere = sqlite3ExprAnd(pParse, *ppWhere, pEq);
drhad2d8302002-05-24 20:31:36 +0000353}
354
355/*
drh1f162302002-10-27 19:35:33 +0000356** Set the EP_FromJoin property on all terms of the given expression.
drh22d6a532005-09-19 21:05:48 +0000357** And set the Expr.iRightJoinTable to iTable for every term in the
358** expression.
drh1cc093c2002-06-24 22:01:57 +0000359**
drhe78e8282003-01-19 03:59:45 +0000360** The EP_FromJoin property is used on terms of an expression to tell
drh1cc093c2002-06-24 22:01:57 +0000361** the LEFT OUTER JOIN processing logic that this term is part of the
drh1f162302002-10-27 19:35:33 +0000362** join restriction specified in the ON or USING clause and not a part
363** of the more general WHERE clause. These terms are moved over to the
364** WHERE clause during join processing but we need to remember that they
365** originated in the ON or USING clause.
drh22d6a532005-09-19 21:05:48 +0000366**
367** The Expr.iRightJoinTable tells the WHERE clause processing that the
368** expression depends on table iRightJoinTable even if that table is not
369** explicitly mentioned in the expression. That information is needed
370** for cases like this:
371**
372** SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.b AND t1.x=5
373**
374** The where clause needs to defer the handling of the t1.x=5
375** term until after the t2 loop of the join. In that way, a
376** NULL t2 row will be inserted whenever t1.x!=5. If we do not
377** defer the handling of t1.x=5, it will be processed immediately
378** after the t1 loop and rows with t1.x!=5 will never appear in
379** the output, which is incorrect.
drh1cc093c2002-06-24 22:01:57 +0000380*/
drh8103a032019-11-15 00:52:13 +0000381void sqlite3SetJoinExpr(Expr *p, int iTable){
drh1cc093c2002-06-24 22:01:57 +0000382 while( p ){
drh1f162302002-10-27 19:35:33 +0000383 ExprSetProperty(p, EP_FromJoin);
drhc5cd1242013-09-12 16:50:49 +0000384 assert( !ExprHasProperty(p, EP_TokenOnly|EP_Reduced) );
drhebb6a652013-09-12 23:42:22 +0000385 ExprSetVVAProperty(p, EP_NoReduce);
dan961a7262020-12-21 19:50:10 +0000386 p->iRightJoinTable = iTable;
drh606f2342015-06-18 14:32:51 +0000387 if( p->op==TK_FUNCTION && p->x.pList ){
388 int i;
389 for(i=0; i<p->x.pList->nExpr; i++){
drh8103a032019-11-15 00:52:13 +0000390 sqlite3SetJoinExpr(p->x.pList->a[i].pExpr, iTable);
drh606f2342015-06-18 14:32:51 +0000391 }
392 }
drh8103a032019-11-15 00:52:13 +0000393 sqlite3SetJoinExpr(p->pLeft, iTable);
drh1cc093c2002-06-24 22:01:57 +0000394 p = p->pRight;
395 }
396}
397
drh8103a032019-11-15 00:52:13 +0000398/* Undo the work of sqlite3SetJoinExpr(). In the expression p, convert every
drh25897872018-03-20 21:16:15 +0000399** term that is marked with EP_FromJoin and iRightJoinTable==iTable into
400** an ordinary term that omits the EP_FromJoin mark.
401**
402** This happens when a LEFT JOIN is simplified into an ordinary JOIN.
403*/
404static void unsetJoinExpr(Expr *p, int iTable){
405 while( p ){
drh7fbb1012018-03-21 01:59:46 +0000406 if( ExprHasProperty(p, EP_FromJoin)
407 && (iTable<0 || p->iRightJoinTable==iTable) ){
drh25897872018-03-20 21:16:15 +0000408 ExprClearProperty(p, EP_FromJoin);
409 }
410 if( p->op==TK_FUNCTION && p->x.pList ){
411 int i;
412 for(i=0; i<p->x.pList->nExpr; i++){
413 unsetJoinExpr(p->x.pList->a[i].pExpr, iTable);
414 }
415 }
416 unsetJoinExpr(p->pLeft, iTable);
417 p = p->pRight;
418 }
419}
420
drh1cc093c2002-06-24 22:01:57 +0000421/*
drhad2d8302002-05-24 20:31:36 +0000422** This routine processes the join information for a SELECT statement.
423** ON and USING clauses are converted into extra terms of the WHERE clause.
424** NATURAL joins also create extra WHERE clause terms.
425**
drh91bb0ee2004-09-01 03:06:34 +0000426** The terms of a FROM clause are contained in the Select.pSrc structure.
427** The left most table is the first entry in Select.pSrc. The right-most
428** table is the last entry. The join operator is held in the entry to
429** the left. Thus entry 0 contains the join operator for the join between
430** entries 0 and 1. Any ON or USING clauses associated with the join are
431** also attached to the left entry.
432**
drhad2d8302002-05-24 20:31:36 +0000433** This routine returns the number of errors encountered.
434*/
435static int sqliteProcessJoin(Parse *pParse, Select *p){
drh91bb0ee2004-09-01 03:06:34 +0000436 SrcList *pSrc; /* All tables in the FROM clause */
437 int i, j; /* Loop counters */
drh76012942021-02-21 21:04:54 +0000438 SrcItem *pLeft; /* Left table being joined */
439 SrcItem *pRight; /* Right table being joined */
drhad2d8302002-05-24 20:31:36 +0000440
drh91bb0ee2004-09-01 03:06:34 +0000441 pSrc = p->pSrc;
442 pLeft = &pSrc->a[0];
443 pRight = &pLeft[1];
444 for(i=0; i<pSrc->nSrc-1; i++, pRight++, pLeft++){
drh91bb0ee2004-09-01 03:06:34 +0000445 Table *pRightTab = pRight->pTab;
drhad27e762008-03-26 12:46:23 +0000446 int isOuter;
drh91bb0ee2004-09-01 03:06:34 +0000447
drhce2c4822017-10-03 17:17:34 +0000448 if( NEVER(pLeft->pTab==0 || pRightTab==0) ) continue;
drh8a48b9c2015-08-19 15:20:00 +0000449 isOuter = (pRight->fg.jointype & JT_OUTER)!=0;
drhad2d8302002-05-24 20:31:36 +0000450
451 /* When the NATURAL keyword is present, add WHERE clause terms for
452 ** every column that the two tables have in common.
453 */
drh8a48b9c2015-08-19 15:20:00 +0000454 if( pRight->fg.jointype & JT_NATURAL ){
drh61dfc312006-12-16 16:25:15 +0000455 if( pRight->pOn || pRight->pUsing ){
danielk19774adee202004-05-08 08:23:19 +0000456 sqlite3ErrorMsg(pParse, "a NATURAL join may not have "
drhad2d8302002-05-24 20:31:36 +0000457 "an ON or USING clause", 0);
drhad2d8302002-05-24 20:31:36 +0000458 return 1;
459 }
drh2179b432009-12-09 17:36:39 +0000460 for(j=0; j<pRightTab->nCol; j++){
461 char *zName; /* Name of column in the right table */
462 int iLeft; /* Matching left table */
463 int iLeftCol; /* Matching column in the left table */
464
dan9d41af22019-12-30 14:32:27 +0000465 if( IsHiddenColumn(&pRightTab->aCol[j]) ) continue;
drh2179b432009-12-09 17:36:39 +0000466 zName = pRightTab->aCol[j].zName;
dan9d41af22019-12-30 14:32:27 +0000467 if( tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol, 1) ){
drh2179b432009-12-09 17:36:39 +0000468 addWhereTerm(pParse, pSrc, iLeft, iLeftCol, i+1, j,
dan9d41af22019-12-30 14:32:27 +0000469 isOuter, &p->pWhere);
drhad2d8302002-05-24 20:31:36 +0000470 }
471 }
472 }
473
474 /* Disallow both ON and USING clauses in the same join
475 */
drh61dfc312006-12-16 16:25:15 +0000476 if( pRight->pOn && pRight->pUsing ){
danielk19774adee202004-05-08 08:23:19 +0000477 sqlite3ErrorMsg(pParse, "cannot have both ON and USING "
drhda93d232003-03-31 02:12:46 +0000478 "clauses in the same join");
drhad2d8302002-05-24 20:31:36 +0000479 return 1;
480 }
481
482 /* Add the ON clause to the end of the WHERE clause, connected by
drh91bb0ee2004-09-01 03:06:34 +0000483 ** an AND operator.
drhad2d8302002-05-24 20:31:36 +0000484 */
drh61dfc312006-12-16 16:25:15 +0000485 if( pRight->pOn ){
drh8103a032019-11-15 00:52:13 +0000486 if( isOuter ) sqlite3SetJoinExpr(pRight->pOn, pRight->iCursor);
drhd5c851c2019-04-19 13:38:34 +0000487 p->pWhere = sqlite3ExprAnd(pParse, p->pWhere, pRight->pOn);
drh61dfc312006-12-16 16:25:15 +0000488 pRight->pOn = 0;
drhad2d8302002-05-24 20:31:36 +0000489 }
490
491 /* Create extra terms on the WHERE clause for each column named
492 ** in the USING clause. Example: If the two tables to be joined are
493 ** A and B and the USING clause names X, Y, and Z, then add this
494 ** to the WHERE clause: A.X=B.X AND A.Y=B.Y AND A.Z=B.Z
495 ** Report an error if any column mentioned in the USING clause is
496 ** not contained in both tables to be joined.
497 */
drh61dfc312006-12-16 16:25:15 +0000498 if( pRight->pUsing ){
499 IdList *pList = pRight->pUsing;
drhad2d8302002-05-24 20:31:36 +0000500 for(j=0; j<pList->nId; j++){
drh2179b432009-12-09 17:36:39 +0000501 char *zName; /* Name of the term in the USING clause */
502 int iLeft; /* Table on the left with matching column name */
503 int iLeftCol; /* Column number of matching column on the left */
504 int iRightCol; /* Column number of matching column on the right */
505
506 zName = pList->a[j].zName;
dan6e6d9832021-02-16 20:43:36 +0000507 iRightCol = sqlite3ColumnIndex(pRightTab, zName);
drh2179b432009-12-09 17:36:39 +0000508 if( iRightCol<0
dan9d41af22019-12-30 14:32:27 +0000509 || !tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol, 0)
drh2179b432009-12-09 17:36:39 +0000510 ){
danielk19774adee202004-05-08 08:23:19 +0000511 sqlite3ErrorMsg(pParse, "cannot join using column %s - column "
drh91bb0ee2004-09-01 03:06:34 +0000512 "not present in both tables", zName);
drhad2d8302002-05-24 20:31:36 +0000513 return 1;
514 }
drh2179b432009-12-09 17:36:39 +0000515 addWhereTerm(pParse, pSrc, iLeft, iLeftCol, i+1, iRightCol,
516 isOuter, &p->pWhere);
drhad2d8302002-05-24 20:31:36 +0000517 }
518 }
519 }
520 return 0;
521}
522
523/*
drhbbd4ae52018-04-30 19:32:49 +0000524** An instance of this object holds information (beyond pParse and pSelect)
525** needed to load the next result row that is to be added to the sorter.
526*/
527typedef struct RowLoadInfo RowLoadInfo;
528struct RowLoadInfo {
529 int regResult; /* Store results in array of registers here */
530 u8 ecelFlags; /* Flag argument to ExprCodeExprList() */
531#ifdef SQLITE_ENABLE_SORTER_REFERENCES
532 ExprList *pExtra; /* Extra columns needed by sorter refs */
533 int regExtraResult; /* Where to load the extra columns */
534#endif
535};
536
537/*
538** This routine does the work of loading query data into an array of
539** registers so that it can be added to the sorter.
540*/
541static void innerLoopLoadRow(
542 Parse *pParse, /* Statement under construction */
543 Select *pSelect, /* The query being coded */
544 RowLoadInfo *pInfo /* Info needed to complete the row load */
545){
546 sqlite3ExprCodeExprList(pParse, pSelect->pEList, pInfo->regResult,
547 0, pInfo->ecelFlags);
548#ifdef SQLITE_ENABLE_SORTER_REFERENCES
549 if( pInfo->pExtra ){
550 sqlite3ExprCodeExprList(pParse, pInfo->pExtra, pInfo->regExtraResult, 0, 0);
551 sqlite3ExprListDelete(pParse->db, pInfo->pExtra);
552 }
553#endif
554}
555
556/*
557** Code the OP_MakeRecord instruction that generates the entry to be
558** added into the sorter.
559**
560** Return the register in which the result is stored.
561*/
562static int makeSorterRecord(
563 Parse *pParse,
564 SortCtx *pSort,
565 Select *pSelect,
566 int regBase,
567 int nBase
568){
569 int nOBSat = pSort->nOBSat;
570 Vdbe *v = pParse->pVdbe;
571 int regOut = ++pParse->nMem;
572 if( pSort->pDeferredRowLoad ){
573 innerLoopLoadRow(pParse, pSelect, pSort->pDeferredRowLoad);
574 }
575 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase+nOBSat, nBase-nOBSat, regOut);
576 return regOut;
577}
578
579/*
drhf45f2322014-03-23 17:45:03 +0000580** Generate code that will push the record in registers regData
581** through regData+nData-1 onto the sorter.
drhc926afb2002-06-20 03:38:26 +0000582*/
drhd59ba6c2006-01-08 05:02:54 +0000583static void pushOntoSorter(
584 Parse *pParse, /* Parser context */
drh079a3072014-03-19 14:10:55 +0000585 SortCtx *pSort, /* Information about the ORDER BY clause */
drhb7654112008-01-12 12:48:07 +0000586 Select *pSelect, /* The whole SELECT statement */
drhf45f2322014-03-23 17:45:03 +0000587 int regData, /* First register holding data to be sorted */
drh5579d592015-08-26 14:01:41 +0000588 int regOrigData, /* First register holding data before packing */
drhbbd4ae52018-04-30 19:32:49 +0000589 int nData, /* Number of elements in the regData data array */
drhfd0a2f92014-03-24 18:08:15 +0000590 int nPrefixReg /* No. of reg prior to regData available for use */
drhd59ba6c2006-01-08 05:02:54 +0000591){
drhf45f2322014-03-23 17:45:03 +0000592 Vdbe *v = pParse->pVdbe; /* Stmt under construction */
dan78d58432014-03-25 15:04:07 +0000593 int bSeq = ((pSort->sortFlags & SORTFLAG_UseSorter)==0);
drhf45f2322014-03-23 17:45:03 +0000594 int nExpr = pSort->pOrderBy->nExpr; /* No. of ORDER BY terms */
dan78d58432014-03-25 15:04:07 +0000595 int nBase = nExpr + bSeq + nData; /* Fields in sorter record */
drhfd0a2f92014-03-24 18:08:15 +0000596 int regBase; /* Regs for sorter record */
drhbbd4ae52018-04-30 19:32:49 +0000597 int regRecord = 0; /* Assembled sorter record */
dan78d58432014-03-25 15:04:07 +0000598 int nOBSat = pSort->nOBSat; /* ORDER BY terms to skip */
599 int op; /* Opcode to add sorter record to sorter */
drha04a8be2016-01-13 17:50:10 +0000600 int iLimit; /* LIMIT counter */
drhbbd4ae52018-04-30 19:32:49 +0000601 int iSkip = 0; /* End of the sorter insert loop */
drhf45f2322014-03-23 17:45:03 +0000602
dan78d58432014-03-25 15:04:07 +0000603 assert( bSeq==0 || bSeq==1 );
drhbbd4ae52018-04-30 19:32:49 +0000604
605 /* Three cases:
606 ** (1) The data to be sorted has already been packed into a Record
607 ** by a prior OP_MakeRecord. In this case nData==1 and regData
608 ** will be completely unrelated to regOrigData.
609 ** (2) All output columns are included in the sort record. In that
610 ** case regData==regOrigData.
611 ** (3) Some output columns are omitted from the sort record due to
612 ** the SQLITE_ENABLE_SORTER_REFERENCE optimization, or due to the
drhc6f36fa2018-05-05 16:50:35 +0000613 ** SQLITE_ECEL_OMITREF optimization, or due to the
614 ** SortCtx.pDeferredRowLoad optimiation. In any of these cases
615 ** regOrigData is 0 to prevent this routine from trying to copy
616 ** values that might not yet exist.
drhbbd4ae52018-04-30 19:32:49 +0000617 */
dan9af90b72016-11-11 18:08:59 +0000618 assert( nData==1 || regData==regOrigData || regOrigData==0 );
drhbbd4ae52018-04-30 19:32:49 +0000619
drhfd0a2f92014-03-24 18:08:15 +0000620 if( nPrefixReg ){
dan78d58432014-03-25 15:04:07 +0000621 assert( nPrefixReg==nExpr+bSeq );
drhbbd4ae52018-04-30 19:32:49 +0000622 regBase = regData - nPrefixReg;
drhfd0a2f92014-03-24 18:08:15 +0000623 }else{
drhfb0d6e52014-05-02 13:09:06 +0000624 regBase = pParse->nMem + 1;
625 pParse->nMem += nBase;
drhfd0a2f92014-03-24 18:08:15 +0000626 }
drha04a8be2016-01-13 17:50:10 +0000627 assert( pSelect->iOffset==0 || pSelect->iLimit!=0 );
628 iLimit = pSelect->iOffset ? pSelect->iOffset+1 : pSelect->iLimit;
drhec4ccdb2018-12-29 02:26:59 +0000629 pSort->labelDone = sqlite3VdbeMakeLabel(pParse);
drh5579d592015-08-26 14:01:41 +0000630 sqlite3ExprCodeExprList(pParse, pSort->pOrderBy, regBase, regOrigData,
dan9af90b72016-11-11 18:08:59 +0000631 SQLITE_ECEL_DUP | (regOrigData? SQLITE_ECEL_REF : 0));
dan78d58432014-03-25 15:04:07 +0000632 if( bSeq ){
633 sqlite3VdbeAddOp2(v, OP_Sequence, pSort->iECursor, regBase+nExpr);
drhfd0a2f92014-03-24 18:08:15 +0000634 }
dan257c13f2016-11-10 20:14:06 +0000635 if( nPrefixReg==0 && nData>0 ){
drh236241a2014-09-12 17:41:30 +0000636 sqlite3ExprCodeMove(pParse, regData, regBase+nExpr+bSeq, nData);
dan78d58432014-03-25 15:04:07 +0000637 }
drh079a3072014-03-19 14:10:55 +0000638 if( nOBSat>0 ){
639 int regPrevKey; /* The first nOBSat columns of the previous row */
640 int addrFirst; /* Address of the OP_IfNot opcode */
641 int addrJmp; /* Address of the OP_Jump opcode */
642 VdbeOp *pOp; /* Opcode that opens the sorter */
643 int nKey; /* Number of sorting key columns, including OP_Sequence */
drhdbfca2b2014-03-22 02:19:53 +0000644 KeyInfo *pKI; /* Original KeyInfo on the sorter table */
drh079a3072014-03-19 14:10:55 +0000645
drhbbd4ae52018-04-30 19:32:49 +0000646 regRecord = makeSorterRecord(pParse, pSort, pSelect, regBase, nBase);
drh26d7e7c2014-03-19 16:56:58 +0000647 regPrevKey = pParse->nMem+1;
648 pParse->nMem += pSort->nOBSat;
dan78d58432014-03-25 15:04:07 +0000649 nKey = nExpr - pSort->nOBSat + bSeq;
650 if( bSeq ){
651 addrFirst = sqlite3VdbeAddOp1(v, OP_IfNot, regBase+nExpr);
652 }else{
653 addrFirst = sqlite3VdbeAddOp1(v, OP_SequenceTest, pSort->iECursor);
654 }
655 VdbeCoverage(v);
drh26d7e7c2014-03-19 16:56:58 +0000656 sqlite3VdbeAddOp3(v, OP_Compare, regPrevKey, regBase, pSort->nOBSat);
drh079a3072014-03-19 14:10:55 +0000657 pOp = sqlite3VdbeGetOp(v, pSort->addrSortIndex);
drh59b8f2e2014-03-22 00:27:14 +0000658 if( pParse->db->mallocFailed ) return;
drhfb0d6e52014-05-02 13:09:06 +0000659 pOp->p2 = nKey + nData;
drhdbfca2b2014-03-22 02:19:53 +0000660 pKI = pOp->p4.pKeyInfo;
dan6e118922019-08-12 16:36:38 +0000661 memset(pKI->aSortFlags, 0, pKI->nKeyField); /* Makes OP_Jump testable */
drhdbfca2b2014-03-22 02:19:53 +0000662 sqlite3VdbeChangeP4(v, -1, (char*)pKI, P4_KEYINFO);
drha485ad12017-08-02 22:43:14 +0000663 testcase( pKI->nAllField > pKI->nKeyField+2 );
danf9eae182018-05-21 19:45:11 +0000664 pOp->p4.pKeyInfo = sqlite3KeyInfoFromExprList(pParse,pSort->pOrderBy,nOBSat,
drha485ad12017-08-02 22:43:14 +0000665 pKI->nAllField-pKI->nKeyField-1);
drh166bc382019-10-26 15:40:17 +0000666 pOp = 0; /* Ensure pOp not used after sqltie3VdbeAddOp3() */
drh079a3072014-03-19 14:10:55 +0000667 addrJmp = sqlite3VdbeCurrentAddr(v);
668 sqlite3VdbeAddOp3(v, OP_Jump, addrJmp+1, 0, addrJmp+1); VdbeCoverage(v);
drhec4ccdb2018-12-29 02:26:59 +0000669 pSort->labelBkOut = sqlite3VdbeMakeLabel(pParse);
drh079a3072014-03-19 14:10:55 +0000670 pSort->regReturn = ++pParse->nMem;
671 sqlite3VdbeAddOp2(v, OP_Gosub, pSort->regReturn, pSort->labelBkOut);
drh65ea12c2014-03-19 17:41:36 +0000672 sqlite3VdbeAddOp1(v, OP_ResetSorter, pSort->iECursor);
drha04a8be2016-01-13 17:50:10 +0000673 if( iLimit ){
674 sqlite3VdbeAddOp2(v, OP_IfNot, iLimit, pSort->labelDone);
675 VdbeCoverage(v);
676 }
drh079a3072014-03-19 14:10:55 +0000677 sqlite3VdbeJumpHere(v, addrFirst);
drh236241a2014-09-12 17:41:30 +0000678 sqlite3ExprCodeMove(pParse, regBase, regPrevKey, pSort->nOBSat);
drh079a3072014-03-19 14:10:55 +0000679 sqlite3VdbeJumpHere(v, addrJmp);
680 }
danf226f032018-04-26 16:13:47 +0000681 if( iLimit ){
682 /* At this point the values for the new sorter entry are stored
683 ** in an array of registers. They need to be composed into a record
684 ** and inserted into the sorter if either (a) there are currently
685 ** less than LIMIT+OFFSET items or (b) the new record is smaller than
686 ** the largest record currently in the sorter. If (b) is true and there
687 ** are already LIMIT+OFFSET items in the sorter, delete the largest
688 ** entry before inserting the new one. This way there are never more
689 ** than LIMIT+OFFSET items in the sorter.
690 **
691 ** If the new record does not need to be inserted into the sorter,
drh6ee5a7b2018-09-08 20:09:46 +0000692 ** jump to the next iteration of the loop. If the pSort->labelOBLopt
693 ** value is not zero, then it is a label of where to jump. Otherwise,
694 ** just bypass the row insert logic. See the header comment on the
695 ** sqlite3WhereOrderByLimitOptLabel() function for additional info.
danf226f032018-04-26 16:13:47 +0000696 */
697 int iCsr = pSort->iECursor;
danf226f032018-04-26 16:13:47 +0000698 sqlite3VdbeAddOp2(v, OP_IfNotZero, iLimit, sqlite3VdbeCurrentAddr(v)+4);
699 VdbeCoverage(v);
700 sqlite3VdbeAddOp2(v, OP_Last, iCsr, 0);
drhbbd4ae52018-04-30 19:32:49 +0000701 iSkip = sqlite3VdbeAddOp4Int(v, OP_IdxLE,
702 iCsr, 0, regBase+nOBSat, nExpr-nOBSat);
danf226f032018-04-26 16:13:47 +0000703 VdbeCoverage(v);
704 sqlite3VdbeAddOp1(v, OP_Delete, iCsr);
705 }
drhbbd4ae52018-04-30 19:32:49 +0000706 if( regRecord==0 ){
707 regRecord = makeSorterRecord(pParse, pSort, pSelect, regBase, nBase);
danf226f032018-04-26 16:13:47 +0000708 }
drh079a3072014-03-19 14:10:55 +0000709 if( pSort->sortFlags & SORTFLAG_UseSorter ){
drhc6aff302011-09-01 15:32:47 +0000710 op = OP_SorterInsert;
711 }else{
712 op = OP_IdxInsert;
713 }
drh4a8b0132016-11-09 01:38:56 +0000714 sqlite3VdbeAddOp4Int(v, op, pSort->iECursor, regRecord,
715 regBase+nOBSat, nBase-nOBSat);
drhbbd4ae52018-04-30 19:32:49 +0000716 if( iSkip ){
drhbbd4ae52018-04-30 19:32:49 +0000717 sqlite3VdbeChangeP2(v, iSkip,
drh6ee5a7b2018-09-08 20:09:46 +0000718 pSort->labelOBLopt ? pSort->labelOBLopt : sqlite3VdbeCurrentAddr(v));
drhbbd4ae52018-04-30 19:32:49 +0000719 }
drhc926afb2002-06-20 03:38:26 +0000720}
721
722/*
drhec7429a2005-10-06 16:53:14 +0000723** Add code to implement the OFFSET
drhea48eb22004-07-19 23:16:38 +0000724*/
drhec7429a2005-10-06 16:53:14 +0000725static void codeOffset(
drhbab39e12004-07-19 23:38:11 +0000726 Vdbe *v, /* Generate code into this VM */
drhaa9ce702014-01-22 18:07:04 +0000727 int iOffset, /* Register holding the offset counter */
drhb7654112008-01-12 12:48:07 +0000728 int iContinue /* Jump here to skip the current record */
drhea48eb22004-07-19 23:16:38 +0000729){
drha22a75e2014-03-21 18:16:23 +0000730 if( iOffset>0 ){
drh8b0cf382015-10-06 21:07:06 +0000731 sqlite3VdbeAddOp3(v, OP_IfPos, iOffset, iContinue, 1); VdbeCoverage(v);
732 VdbeComment((v, "OFFSET"));
drhea48eb22004-07-19 23:16:38 +0000733 }
drhea48eb22004-07-19 23:16:38 +0000734}
735
736/*
drh98757152008-01-09 23:04:12 +0000737** Add code that will check to make sure the N registers starting at iMem
738** form a distinct entry. iTab is a sorting index that holds previously
drha2a49dc2008-01-02 14:28:13 +0000739** seen combinations of the N values. A new entry is made in iTab
740** if the current N values are new.
741**
742** A jump to addrRepeat is made and the N+1 values are popped from the
743** stack if the top N elements are not distinct.
744*/
745static void codeDistinct(
drh2dcef112008-01-12 19:03:48 +0000746 Parse *pParse, /* Parsing and code generating context */
drha2a49dc2008-01-02 14:28:13 +0000747 int iTab, /* A sorting index used to test for distinctness */
748 int addrRepeat, /* Jump to here if not distinct */
drh477df4b2008-01-05 18:48:24 +0000749 int N, /* Number of elements */
drha2a49dc2008-01-02 14:28:13 +0000750 int iMem /* First element */
751){
drh2dcef112008-01-12 19:03:48 +0000752 Vdbe *v;
753 int r1;
754
755 v = pParse->pVdbe;
756 r1 = sqlite3GetTempReg(pParse);
drh688852a2014-02-17 22:40:43 +0000757 sqlite3VdbeAddOp4Int(v, OP_Found, iTab, addrRepeat, iMem, N); VdbeCoverage(v);
drh1db639c2008-01-17 02:36:28 +0000758 sqlite3VdbeAddOp3(v, OP_MakeRecord, iMem, N, r1);
drh9b4eaeb2016-11-09 00:10:33 +0000759 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iTab, r1, iMem, N);
drha67b5cb2017-01-07 00:56:01 +0000760 sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
drh2dcef112008-01-12 19:03:48 +0000761 sqlite3ReleaseTempReg(pParse, r1);
drha2a49dc2008-01-02 14:28:13 +0000762}
763
dan24e25d32018-04-14 18:46:20 +0000764#ifdef SQLITE_ENABLE_SORTER_REFERENCES
765/*
766** This function is called as part of inner-loop generation for a SELECT
767** statement with an ORDER BY that is not optimized by an index. It
768** determines the expressions, if any, that the sorter-reference
769** optimization should be used for. The sorter-reference optimization
770** is used for SELECT queries like:
771**
772** SELECT a, bigblob FROM t1 ORDER BY a LIMIT 10
773**
774** If the optimization is used for expression "bigblob", then instead of
775** storing values read from that column in the sorter records, the PK of
776** the row from table t1 is stored instead. Then, as records are extracted from
777** the sorter to return to the user, the required value of bigblob is
778** retrieved directly from table t1. If the values are very large, this
779** can be more efficient than storing them directly in the sorter records.
780**
781** The ExprList_item.bSorterRef flag is set for each expression in pEList
782** for which the sorter-reference optimization should be enabled.
783** Additionally, the pSort->aDefer[] array is populated with entries
784** for all cursors required to evaluate all selected expressions. Finally.
785** output variable (*ppExtra) is set to an expression list containing
786** expressions for all extra PK values that should be stored in the
787** sorter records.
788*/
789static void selectExprDefer(
790 Parse *pParse, /* Leave any error here */
791 SortCtx *pSort, /* Sorter context */
792 ExprList *pEList, /* Expressions destined for sorter */
793 ExprList **ppExtra /* Expressions to append to sorter record */
794){
795 int i;
796 int nDefer = 0;
797 ExprList *pExtra = 0;
798 for(i=0; i<pEList->nExpr; i++){
799 struct ExprList_item *pItem = &pEList->a[i];
800 if( pItem->u.x.iOrderByCol==0 ){
801 Expr *pExpr = pItem->pExpr;
drheda079c2018-09-20 19:02:15 +0000802 Table *pTab = pExpr->y.pTab;
dan0f86c9d2018-06-01 13:30:45 +0000803 if( pExpr->op==TK_COLUMN && pExpr->iColumn>=0 && pTab && !IsVirtual(pTab)
dan2e3a5a82018-04-16 21:12:42 +0000804 && (pTab->aCol[pExpr->iColumn].colFlags & COLFLAG_SORTERREF)
dan24e25d32018-04-14 18:46:20 +0000805 ){
806 int j;
807 for(j=0; j<nDefer; j++){
808 if( pSort->aDefer[j].iCsr==pExpr->iTable ) break;
809 }
810 if( j==nDefer ){
811 if( nDefer==ArraySize(pSort->aDefer) ){
812 continue;
813 }else{
814 int nKey = 1;
815 int k;
816 Index *pPk = 0;
817 if( !HasRowid(pTab) ){
818 pPk = sqlite3PrimaryKeyIndex(pTab);
819 nKey = pPk->nKeyCol;
820 }
821 for(k=0; k<nKey; k++){
822 Expr *pNew = sqlite3PExpr(pParse, TK_COLUMN, 0, 0);
823 if( pNew ){
824 pNew->iTable = pExpr->iTable;
drheda079c2018-09-20 19:02:15 +0000825 pNew->y.pTab = pExpr->y.pTab;
dan24e25d32018-04-14 18:46:20 +0000826 pNew->iColumn = pPk ? pPk->aiColumn[k] : -1;
827 pExtra = sqlite3ExprListAppend(pParse, pExtra, pNew);
828 }
829 }
drheda079c2018-09-20 19:02:15 +0000830 pSort->aDefer[nDefer].pTab = pExpr->y.pTab;
dan24e25d32018-04-14 18:46:20 +0000831 pSort->aDefer[nDefer].iCsr = pExpr->iTable;
832 pSort->aDefer[nDefer].nKey = nKey;
833 nDefer++;
834 }
835 }
836 pItem->bSorterRef = 1;
837 }
838 }
839 }
840 pSort->nDefer = (u8)nDefer;
841 *ppExtra = pExtra;
842}
843#endif
844
drhc99130f2005-09-11 11:56:27 +0000845/*
drh22827922000-06-06 17:27:05 +0000846** This routine generates the code for the inside of the inner loop
847** of a SELECT.
drh82c3d632000-06-06 21:56:07 +0000848**
drh2def2f72017-09-15 17:40:34 +0000849** If srcTab is negative, then the p->pEList expressions
drh340309f2014-01-22 00:23:49 +0000850** are evaluated in order to get the data for this row. If srcTab is
drh2def2f72017-09-15 17:40:34 +0000851** zero or more, then data is pulled from srcTab and p->pEList is used only
dan257c13f2016-11-10 20:14:06 +0000852** to get the number of columns and the collation sequence for each column.
drh22827922000-06-06 17:27:05 +0000853*/
drhd2b3e232008-01-23 14:51:49 +0000854static void selectInnerLoop(
drh22827922000-06-06 17:27:05 +0000855 Parse *pParse, /* The parser context */
drhdf199a22002-06-14 22:38:41 +0000856 Select *p, /* The complete select statement being coded */
drh2def2f72017-09-15 17:40:34 +0000857 int srcTab, /* Pull data from this table if non-negative */
drh079a3072014-03-19 14:10:55 +0000858 SortCtx *pSort, /* If not NULL, info on how to process ORDER BY */
drhe8e4af72012-09-21 00:04:28 +0000859 DistinctCtx *pDistinct, /* If not NULL, info on how to process DISTINCT */
danielk19776c8c8ce2008-01-02 16:27:09 +0000860 SelectDest *pDest, /* How to dispose of the results */
drh22827922000-06-06 17:27:05 +0000861 int iContinue, /* Jump here to continue with next row */
drha9671a22008-07-08 23:40:20 +0000862 int iBreak /* Jump here to break out of the inner loop */
drh22827922000-06-06 17:27:05 +0000863){
864 Vdbe *v = pParse->pVdbe;
drhd847eaa2008-01-17 17:15:56 +0000865 int i;
dan9af90b72016-11-11 18:08:59 +0000866 int hasDistinct; /* True if the DISTINCT keyword is present */
drhd847eaa2008-01-17 17:15:56 +0000867 int eDest = pDest->eDest; /* How to dispose of results */
drh2b596da2012-07-23 21:43:19 +0000868 int iParm = pDest->iSDParm; /* First argument to disposal method */
drhd847eaa2008-01-17 17:15:56 +0000869 int nResultCol; /* Number of result columns */
drhfd0a2f92014-03-24 18:08:15 +0000870 int nPrefixReg = 0; /* Number of extra registers before regResult */
drhbbd4ae52018-04-30 19:32:49 +0000871 RowLoadInfo sRowLoadInfo; /* Info for deferred row loading */
drh38640e12002-07-05 21:42:36 +0000872
dan9af90b72016-11-11 18:08:59 +0000873 /* Usually, regResult is the first cell in an array of memory cells
874 ** containing the current result row. In this case regOrig is set to the
875 ** same value. However, if the results are being sent to the sorter, the
876 ** values for any expressions that are also part of the sort-key are omitted
877 ** from this array. In this case regOrig is set to zero. */
878 int regResult; /* Start of memory holding current results */
879 int regOrig; /* Start of memory holding full result (or 0) */
880
drh1c767f02009-01-09 02:49:31 +0000881 assert( v );
drh2def2f72017-09-15 17:40:34 +0000882 assert( p->pEList!=0 );
drhe8e4af72012-09-21 00:04:28 +0000883 hasDistinct = pDistinct ? pDistinct->eTnctType : WHERE_DISTINCT_NOOP;
drh079a3072014-03-19 14:10:55 +0000884 if( pSort && pSort->pOrderBy==0 ) pSort = 0;
885 if( pSort==0 && !hasDistinct ){
drha22a75e2014-03-21 18:16:23 +0000886 assert( iContinue!=0 );
drhaa9ce702014-01-22 18:07:04 +0000887 codeOffset(v, p->iOffset, iContinue);
drhdf199a22002-06-14 22:38:41 +0000888 }
889
drh967e8b72000-06-21 13:59:10 +0000890 /* Pull the requested columns.
drh22827922000-06-06 17:27:05 +0000891 */
drh2def2f72017-09-15 17:40:34 +0000892 nResultCol = p->pEList->nExpr;
drh05a86c52014-02-16 01:55:49 +0000893
drh2b596da2012-07-23 21:43:19 +0000894 if( pDest->iSdst==0 ){
drhfd0a2f92014-03-24 18:08:15 +0000895 if( pSort ){
dan78d58432014-03-25 15:04:07 +0000896 nPrefixReg = pSort->pOrderBy->nExpr;
897 if( !(pSort->sortFlags & SORTFLAG_UseSorter) ) nPrefixReg++;
drhfd0a2f92014-03-24 18:08:15 +0000898 pParse->nMem += nPrefixReg;
899 }
drh2b596da2012-07-23 21:43:19 +0000900 pDest->iSdst = pParse->nMem+1;
drh0acb7e42008-06-25 00:12:41 +0000901 pParse->nMem += nResultCol;
drh05a86c52014-02-16 01:55:49 +0000902 }else if( pDest->iSdst+nResultCol > pParse->nMem ){
903 /* This is an error condition that can result, for example, when a SELECT
904 ** on the right-hand side of an INSERT contains more result columns than
905 ** there are columns in the table on the left. The error will be caught
906 ** and reported later. But we need to make sure enough memory is allocated
907 ** to avoid other spurious errors in the meantime. */
908 pParse->nMem += nResultCol;
drh1013c932008-01-06 00:25:21 +0000909 }
drh05a86c52014-02-16 01:55:49 +0000910 pDest->nSdst = nResultCol;
dan9af90b72016-11-11 18:08:59 +0000911 regOrig = regResult = pDest->iSdst;
drh340309f2014-01-22 00:23:49 +0000912 if( srcTab>=0 ){
913 for(i=0; i<nResultCol; i++){
drhd847eaa2008-01-17 17:15:56 +0000914 sqlite3VdbeAddOp3(v, OP_Column, srcTab, i, regResult+i);
drh41cee662019-12-12 20:22:34 +0000915 VdbeComment((v, "%s", p->pEList->a[i].zEName));
drh82c3d632000-06-06 21:56:07 +0000916 }
danielk19779ed1dfa2008-01-02 17:11:14 +0000917 }else if( eDest!=SRT_Exists ){
dan24e25d32018-04-14 18:46:20 +0000918#ifdef SQLITE_ENABLE_SORTER_REFERENCES
919 ExprList *pExtra = 0;
920#endif
danielk19779ed1dfa2008-01-02 17:11:14 +0000921 /* If the destination is an EXISTS(...) expression, the actual
922 ** values returned by the SELECT are not required.
923 */
drhbbd4ae52018-04-30 19:32:49 +0000924 u8 ecelFlags; /* "ecel" is an abbreviation of "ExprCodeExprList" */
925 ExprList *pEList;
drhdf553652015-05-18 04:24:27 +0000926 if( eDest==SRT_Mem || eDest==SRT_Output || eDest==SRT_Coroutine ){
927 ecelFlags = SQLITE_ECEL_DUP;
928 }else{
929 ecelFlags = 0;
930 }
danac56ab72017-01-05 17:23:11 +0000931 if( pSort && hasDistinct==0 && eDest!=SRT_EphemTab && eDest!=SRT_Table ){
drh2def2f72017-09-15 17:40:34 +0000932 /* For each expression in p->pEList that is a copy of an expression in
dan257c13f2016-11-10 20:14:06 +0000933 ** the ORDER BY clause (pSort->pOrderBy), set the associated
934 ** iOrderByCol value to one more than the index of the ORDER BY
935 ** expression within the sort-key that pushOntoSorter() will generate.
drh2def2f72017-09-15 17:40:34 +0000936 ** This allows the p->pEList field to be omitted from the sorted record,
dan257c13f2016-11-10 20:14:06 +0000937 ** saving space and CPU cycles. */
938 ecelFlags |= (SQLITE_ECEL_OMITREF|SQLITE_ECEL_REF);
drhbbd4ae52018-04-30 19:32:49 +0000939
dan257c13f2016-11-10 20:14:06 +0000940 for(i=pSort->nOBSat; i<pSort->pOrderBy->nExpr; i++){
941 int j;
942 if( (j = pSort->pOrderBy->a[i].u.x.iOrderByCol)>0 ){
drh2def2f72017-09-15 17:40:34 +0000943 p->pEList->a[j-1].u.x.iOrderByCol = i+1-pSort->nOBSat;
dan257c13f2016-11-10 20:14:06 +0000944 }
945 }
dan24e25d32018-04-14 18:46:20 +0000946#ifdef SQLITE_ENABLE_SORTER_REFERENCES
947 selectExprDefer(pParse, pSort, p->pEList, &pExtra);
drh5a2e65e2018-04-18 19:08:44 +0000948 if( pExtra && pParse->db->mallocFailed==0 ){
dan24e25d32018-04-14 18:46:20 +0000949 /* If there are any extra PK columns to add to the sorter records,
950 ** allocate extra memory cells and adjust the OpenEphemeral
951 ** instruction to account for the larger records. This is only
952 ** required if there are one or more WITHOUT ROWID tables with
953 ** composite primary keys in the SortCtx.aDefer[] array. */
954 VdbeOp *pOp = sqlite3VdbeGetOp(v, pSort->addrSortIndex);
955 pOp->p2 += (pExtra->nExpr - pSort->nDefer);
956 pOp->p4.pKeyInfo->nAllField += (pExtra->nExpr - pSort->nDefer);
957 pParse->nMem += pExtra->nExpr;
958 }
959#endif
drhbbd4ae52018-04-30 19:32:49 +0000960
961 /* Adjust nResultCol to account for columns that are omitted
962 ** from the sorter by the optimizations in this branch */
963 pEList = p->pEList;
964 for(i=0; i<pEList->nExpr; i++){
965 if( pEList->a[i].u.x.iOrderByCol>0
966#ifdef SQLITE_ENABLE_SORTER_REFERENCES
967 || pEList->a[i].bSorterRef
968#endif
969 ){
970 nResultCol--;
971 regOrig = 0;
972 }
973 }
974
975 testcase( regOrig );
976 testcase( eDest==SRT_Set );
977 testcase( eDest==SRT_Mem );
978 testcase( eDest==SRT_Coroutine );
979 testcase( eDest==SRT_Output );
dan257c13f2016-11-10 20:14:06 +0000980 assert( eDest==SRT_Set || eDest==SRT_Mem
danf2972b62020-04-29 20:11:01 +0000981 || eDest==SRT_Coroutine || eDest==SRT_Output
982 || eDest==SRT_Upfrom );
dan257c13f2016-11-10 20:14:06 +0000983 }
drhbbd4ae52018-04-30 19:32:49 +0000984 sRowLoadInfo.regResult = regResult;
985 sRowLoadInfo.ecelFlags = ecelFlags;
dan24e25d32018-04-14 18:46:20 +0000986#ifdef SQLITE_ENABLE_SORTER_REFERENCES
drhbbd4ae52018-04-30 19:32:49 +0000987 sRowLoadInfo.pExtra = pExtra;
988 sRowLoadInfo.regExtraResult = regResult + nResultCol;
989 if( pExtra ) nResultCol += pExtra->nExpr;
dan24e25d32018-04-14 18:46:20 +0000990#endif
drhbbd4ae52018-04-30 19:32:49 +0000991 if( p->iLimit
992 && (ecelFlags & SQLITE_ECEL_OMITREF)!=0
993 && nPrefixReg>0
994 ){
995 assert( pSort!=0 );
996 assert( hasDistinct==0 );
997 pSort->pDeferredRowLoad = &sRowLoadInfo;
drhc6f36fa2018-05-05 16:50:35 +0000998 regOrig = 0;
drhbbd4ae52018-04-30 19:32:49 +0000999 }else{
1000 innerLoopLoadRow(pParse, p, &sRowLoadInfo);
1001 }
drh22827922000-06-06 17:27:05 +00001002 }
1003
drhdaffd0e2001-04-11 14:28:42 +00001004 /* If the DISTINCT keyword was present on the SELECT statement
1005 ** and this row has been seen before, then do not make this row
1006 ** part of the result.
drh22827922000-06-06 17:27:05 +00001007 */
drhea48eb22004-07-19 23:16:38 +00001008 if( hasDistinct ){
drhe8e4af72012-09-21 00:04:28 +00001009 switch( pDistinct->eTnctType ){
1010 case WHERE_DISTINCT_ORDERED: {
1011 VdbeOp *pOp; /* No longer required OpenEphemeral instr. */
1012 int iJump; /* Jump destination */
1013 int regPrev; /* Previous row content */
1014
1015 /* Allocate space for the previous row */
1016 regPrev = pParse->nMem+1;
drh340309f2014-01-22 00:23:49 +00001017 pParse->nMem += nResultCol;
drhe8e4af72012-09-21 00:04:28 +00001018
1019 /* Change the OP_OpenEphemeral coded earlier to an OP_Null
1020 ** sets the MEM_Cleared bit on the first register of the
1021 ** previous value. This will cause the OP_Ne below to always
1022 ** fail on the first iteration of the loop even if the first
1023 ** row is all NULLs.
1024 */
1025 sqlite3VdbeChangeToNoop(v, pDistinct->addrTnct);
1026 pOp = sqlite3VdbeGetOp(v, pDistinct->addrTnct);
1027 pOp->opcode = OP_Null;
1028 pOp->p1 = 1;
1029 pOp->p2 = regPrev;
drh166bc382019-10-26 15:40:17 +00001030 pOp = 0; /* Ensure pOp is not used after sqlite3VdbeAddOp() */
drhe8e4af72012-09-21 00:04:28 +00001031
drh340309f2014-01-22 00:23:49 +00001032 iJump = sqlite3VdbeCurrentAddr(v) + nResultCol;
1033 for(i=0; i<nResultCol; i++){
drh2def2f72017-09-15 17:40:34 +00001034 CollSeq *pColl = sqlite3ExprCollSeq(pParse, p->pEList->a[i].pExpr);
drh340309f2014-01-22 00:23:49 +00001035 if( i<nResultCol-1 ){
drhe8e4af72012-09-21 00:04:28 +00001036 sqlite3VdbeAddOp3(v, OP_Ne, regResult+i, iJump, regPrev+i);
drh688852a2014-02-17 22:40:43 +00001037 VdbeCoverage(v);
drhe8e4af72012-09-21 00:04:28 +00001038 }else{
1039 sqlite3VdbeAddOp3(v, OP_Eq, regResult+i, iContinue, regPrev+i);
drh688852a2014-02-17 22:40:43 +00001040 VdbeCoverage(v);
1041 }
drhe8e4af72012-09-21 00:04:28 +00001042 sqlite3VdbeChangeP4(v, -1, (const char *)pColl, P4_COLLSEQ);
1043 sqlite3VdbeChangeP5(v, SQLITE_NULLEQ);
1044 }
drhfcf2a772014-08-12 01:23:07 +00001045 assert( sqlite3VdbeCurrentAddr(v)==iJump || pParse->db->mallocFailed );
drh340309f2014-01-22 00:23:49 +00001046 sqlite3VdbeAddOp3(v, OP_Copy, regResult, regPrev, nResultCol-1);
drhe8e4af72012-09-21 00:04:28 +00001047 break;
1048 }
1049
1050 case WHERE_DISTINCT_UNIQUE: {
1051 sqlite3VdbeChangeToNoop(v, pDistinct->addrTnct);
1052 break;
1053 }
1054
1055 default: {
1056 assert( pDistinct->eTnctType==WHERE_DISTINCT_UNORDERED );
drh38b41492015-06-08 15:08:15 +00001057 codeDistinct(pParse, pDistinct->tabTnct, iContinue, nResultCol,
1058 regResult);
drhe8e4af72012-09-21 00:04:28 +00001059 break;
1060 }
1061 }
drh079a3072014-03-19 14:10:55 +00001062 if( pSort==0 ){
drhaa9ce702014-01-22 18:07:04 +00001063 codeOffset(v, p->iOffset, iContinue);
drhea48eb22004-07-19 23:16:38 +00001064 }
drh22827922000-06-06 17:27:05 +00001065 }
drh82c3d632000-06-06 21:56:07 +00001066
drhc926afb2002-06-20 03:38:26 +00001067 switch( eDest ){
1068 /* In this mode, write each query result to the key of the temporary
1069 ** table iParm.
1070 */
drh13449892005-09-07 21:22:45 +00001071#ifndef SQLITE_OMIT_COMPOUND_SELECT
drhc926afb2002-06-20 03:38:26 +00001072 case SRT_Union: {
drh9cbf3422008-01-17 16:22:13 +00001073 int r1;
1074 r1 = sqlite3GetTempReg(pParse);
drh340309f2014-01-22 00:23:49 +00001075 sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r1);
drh9b4eaeb2016-11-09 00:10:33 +00001076 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regResult, nResultCol);
drh9cbf3422008-01-17 16:22:13 +00001077 sqlite3ReleaseTempReg(pParse, r1);
drhc926afb2002-06-20 03:38:26 +00001078 break;
drh22827922000-06-06 17:27:05 +00001079 }
drh22827922000-06-06 17:27:05 +00001080
drhc926afb2002-06-20 03:38:26 +00001081 /* Construct a record from the query result, but instead of
1082 ** saving that record, use it as a key to delete elements from
1083 ** the temporary table iParm.
1084 */
1085 case SRT_Except: {
drh340309f2014-01-22 00:23:49 +00001086 sqlite3VdbeAddOp3(v, OP_IdxDelete, iParm, regResult, nResultCol);
drhc926afb2002-06-20 03:38:26 +00001087 break;
1088 }
drh781def22014-01-22 13:35:53 +00001089#endif /* SQLITE_OMIT_COMPOUND_SELECT */
danielk19775338a5f2005-01-20 13:03:10 +00001090
1091 /* Store the result as data using a unique key.
1092 */
drh8e1ee882014-03-21 19:56:09 +00001093 case SRT_Fifo:
1094 case SRT_DistFifo:
danielk19775338a5f2005-01-20 13:03:10 +00001095 case SRT_Table:
drhb9bb7c12006-06-11 23:41:55 +00001096 case SRT_EphemTab: {
drhfd0a2f92014-03-24 18:08:15 +00001097 int r1 = sqlite3GetTempRange(pParse, nPrefixReg+1);
drh373cc2d2009-05-17 02:06:14 +00001098 testcase( eDest==SRT_Table );
1099 testcase( eDest==SRT_EphemTab );
drhe2248cf2015-05-22 17:29:27 +00001100 testcase( eDest==SRT_Fifo );
1101 testcase( eDest==SRT_DistFifo );
drhfd0a2f92014-03-24 18:08:15 +00001102 sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r1+nPrefixReg);
dan8ce71842014-01-14 20:14:09 +00001103#ifndef SQLITE_OMIT_CTE
drh8e1ee882014-03-21 19:56:09 +00001104 if( eDest==SRT_DistFifo ){
1105 /* If the destination is DistFifo, then cursor (iParm+1) is open
dan8ce71842014-01-14 20:14:09 +00001106 ** on an ephemeral index. If the current row is already present
1107 ** in the index, do not write it to the output. If not, add the
1108 ** current row to the index and proceed with writing it to the
1109 ** output table as well. */
1110 int addr = sqlite3VdbeCurrentAddr(v) + 4;
drh38b41492015-06-08 15:08:15 +00001111 sqlite3VdbeAddOp4Int(v, OP_Found, iParm+1, addr, r1, 0);
1112 VdbeCoverage(v);
drh9b4eaeb2016-11-09 00:10:33 +00001113 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm+1, r1,regResult,nResultCol);
drh079a3072014-03-19 14:10:55 +00001114 assert( pSort==0 );
dan8ce71842014-01-14 20:14:09 +00001115 }
1116#endif
drh079a3072014-03-19 14:10:55 +00001117 if( pSort ){
drhbbd4ae52018-04-30 19:32:49 +00001118 assert( regResult==regOrig );
1119 pushOntoSorter(pParse, pSort, p, r1+nPrefixReg, regOrig, 1, nPrefixReg);
danielk19775338a5f2005-01-20 13:03:10 +00001120 }else{
drhb7654112008-01-12 12:48:07 +00001121 int r2 = sqlite3GetTempReg(pParse);
1122 sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, r2);
1123 sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, r2);
1124 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
1125 sqlite3ReleaseTempReg(pParse, r2);
danielk19775338a5f2005-01-20 13:03:10 +00001126 }
drhfd0a2f92014-03-24 18:08:15 +00001127 sqlite3ReleaseTempRange(pParse, r1, nPrefixReg+1);
danielk19775338a5f2005-01-20 13:03:10 +00001128 break;
1129 }
drh5974a302000-06-07 14:42:26 +00001130
dan9ed322d2020-04-29 17:41:29 +00001131 case SRT_Upfrom: {
danf2972b62020-04-29 20:11:01 +00001132 if( pSort ){
1133 pushOntoSorter(
1134 pParse, pSort, p, regResult, regOrig, nResultCol, nPrefixReg);
drh2add24c2020-07-23 14:12:47 +00001135 }else{
danf2972b62020-04-29 20:11:01 +00001136 int i2 = pDest->iSDParm2;
1137 int r1 = sqlite3GetTempReg(pParse);
drh09cf5692020-07-20 18:07:35 +00001138
1139 /* If the UPDATE FROM join is an aggregate that matches no rows, it
1140 ** might still be trying to return one row, because that is what
1141 ** aggregates do. Don't record that empty row in the output table. */
1142 sqlite3VdbeAddOp2(v, OP_IsNull, regResult, iBreak); VdbeCoverage(v);
1143
1144 sqlite3VdbeAddOp3(v, OP_MakeRecord,
1145 regResult+(i2<0), nResultCol-(i2<0), r1);
danf2972b62020-04-29 20:11:01 +00001146 if( i2<0 ){
1147 sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, regResult);
1148 }else{
1149 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regResult, i2);
1150 }
dan9ed322d2020-04-29 17:41:29 +00001151 }
1152 break;
1153 }
1154
1155#ifndef SQLITE_OMIT_SUBQUERY
drhc926afb2002-06-20 03:38:26 +00001156 /* If we are creating a set for an "expr IN (SELECT ...)" construct,
1157 ** then there should be a single item on the stack. Write this
1158 ** item into the set table with bogus data.
1159 */
1160 case SRT_Set: {
drh079a3072014-03-19 14:10:55 +00001161 if( pSort ){
drhde941c62005-08-28 01:34:21 +00001162 /* At first glance you would think we could optimize out the
1163 ** ORDER BY in this case since the order of entries in the set
1164 ** does not matter. But there might be a LIMIT clause, in which
1165 ** case the order does matter */
dan51d82d12016-08-02 18:50:15 +00001166 pushOntoSorter(
dan9af90b72016-11-11 18:08:59 +00001167 pParse, pSort, p, regResult, regOrig, nResultCol, nPrefixReg);
drhc926afb2002-06-20 03:38:26 +00001168 }else{
drhb7654112008-01-12 12:48:07 +00001169 int r1 = sqlite3GetTempReg(pParse);
dan9ed322d2020-04-29 17:41:29 +00001170 assert( sqlite3Strlen30(pDest->zAffSdst)==nResultCol );
1171 sqlite3VdbeAddOp4(v, OP_MakeRecord, regResult, nResultCol,
1172 r1, pDest->zAffSdst, nResultCol);
1173 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regResult, nResultCol);
drhb7654112008-01-12 12:48:07 +00001174 sqlite3ReleaseTempReg(pParse, r1);
drhc926afb2002-06-20 03:38:26 +00001175 }
1176 break;
1177 }
drh22827922000-06-06 17:27:05 +00001178
dan9ed322d2020-04-29 17:41:29 +00001179
drh504b6982006-01-22 21:52:56 +00001180 /* If any row exist in the result set, record that fact and abort.
drhec7429a2005-10-06 16:53:14 +00001181 */
1182 case SRT_Exists: {
drh4c583122008-01-04 22:01:03 +00001183 sqlite3VdbeAddOp2(v, OP_Integer, 1, iParm);
drhec7429a2005-10-06 16:53:14 +00001184 /* The LIMIT clause will terminate the loop for us */
1185 break;
1186 }
1187
drhc926afb2002-06-20 03:38:26 +00001188 /* If this is a scalar select that is part of an expression, then
dan870a0702016-08-01 16:37:43 +00001189 ** store the results in the appropriate memory cell or array of
1190 ** memory cells and break out of the scan loop.
drhc926afb2002-06-20 03:38:26 +00001191 */
1192 case SRT_Mem: {
drh079a3072014-03-19 14:10:55 +00001193 if( pSort ){
dan257c13f2016-11-10 20:14:06 +00001194 assert( nResultCol<=pDest->nSdst );
dan870a0702016-08-01 16:37:43 +00001195 pushOntoSorter(
dan9af90b72016-11-11 18:08:59 +00001196 pParse, pSort, p, regResult, regOrig, nResultCol, nPrefixReg);
drhc926afb2002-06-20 03:38:26 +00001197 }else{
dan257c13f2016-11-10 20:14:06 +00001198 assert( nResultCol==pDest->nSdst );
drh53932ce2014-08-29 12:29:39 +00001199 assert( regResult==iParm );
drhec7429a2005-10-06 16:53:14 +00001200 /* The LIMIT clause will jump out of the loop for us */
drhc926afb2002-06-20 03:38:26 +00001201 }
1202 break;
1203 }
danielk197793758c82005-01-21 08:13:14 +00001204#endif /* #ifndef SQLITE_OMIT_SUBQUERY */
drh22827922000-06-06 17:27:05 +00001205
drh81cf13e2014-02-07 18:27:53 +00001206 case SRT_Coroutine: /* Send data to a co-routine */
1207 case SRT_Output: { /* Return the results */
drh373cc2d2009-05-17 02:06:14 +00001208 testcase( eDest==SRT_Coroutine );
1209 testcase( eDest==SRT_Output );
drh079a3072014-03-19 14:10:55 +00001210 if( pSort ){
dan9af90b72016-11-11 18:08:59 +00001211 pushOntoSorter(pParse, pSort, p, regResult, regOrig, nResultCol,
drh5579d592015-08-26 14:01:41 +00001212 nPrefixReg);
drhe00ee6e2008-06-20 15:24:01 +00001213 }else if( eDest==SRT_Coroutine ){
drh2b596da2012-07-23 21:43:19 +00001214 sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm);
drhc182d162005-08-14 20:47:16 +00001215 }else{
drh340309f2014-01-22 00:23:49 +00001216 sqlite3VdbeAddOp2(v, OP_ResultRow, regResult, nResultCol);
drhac82fcf2002-09-08 17:23:41 +00001217 }
drh142e30d2002-08-28 03:00:58 +00001218 break;
1219 }
1220
drhfe1c6bb2014-01-22 17:28:35 +00001221#ifndef SQLITE_OMIT_CTE
1222 /* Write the results into a priority queue that is order according to
1223 ** pDest->pOrderBy (in pSO). pDest->iSDParm (in iParm) is the cursor for an
1224 ** index with pSO->nExpr+2 columns. Build a key using pSO for the first
1225 ** pSO->nExpr columns, then make sure all keys are unique by adding a
1226 ** final OP_Sequence column. The last column is the record as a blob.
1227 */
1228 case SRT_DistQueue:
1229 case SRT_Queue: {
1230 int nKey;
1231 int r1, r2, r3;
1232 int addrTest = 0;
1233 ExprList *pSO;
1234 pSO = pDest->pOrderBy;
1235 assert( pSO );
1236 nKey = pSO->nExpr;
1237 r1 = sqlite3GetTempReg(pParse);
1238 r2 = sqlite3GetTempRange(pParse, nKey+2);
1239 r3 = r2+nKey+1;
drhfe1c6bb2014-01-22 17:28:35 +00001240 if( eDest==SRT_DistQueue ){
1241 /* If the destination is DistQueue, then cursor (iParm+1) is open
1242 ** on a second ephemeral index that holds all values every previously
drh7e4efae2014-02-26 21:35:31 +00001243 ** added to the queue. */
1244 addrTest = sqlite3VdbeAddOp4Int(v, OP_Found, iParm+1, 0,
1245 regResult, nResultCol);
drh688852a2014-02-17 22:40:43 +00001246 VdbeCoverage(v);
drh7e4efae2014-02-26 21:35:31 +00001247 }
1248 sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r3);
1249 if( eDest==SRT_DistQueue ){
drhfe1c6bb2014-01-22 17:28:35 +00001250 sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm+1, r3);
dancfe24582014-01-22 19:23:30 +00001251 sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
drhfe1c6bb2014-01-22 17:28:35 +00001252 }
1253 for(i=0; i<nKey; i++){
1254 sqlite3VdbeAddOp2(v, OP_SCopy,
1255 regResult + pSO->a[i].u.x.iOrderByCol - 1,
1256 r2+i);
1257 }
1258 sqlite3VdbeAddOp2(v, OP_Sequence, iParm, r2+nKey);
1259 sqlite3VdbeAddOp3(v, OP_MakeRecord, r2, nKey+2, r1);
drh9b4eaeb2016-11-09 00:10:33 +00001260 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, r2, nKey+2);
drhfe1c6bb2014-01-22 17:28:35 +00001261 if( addrTest ) sqlite3VdbeJumpHere(v, addrTest);
1262 sqlite3ReleaseTempReg(pParse, r1);
1263 sqlite3ReleaseTempRange(pParse, r2, nKey+2);
1264 break;
1265 }
1266#endif /* SQLITE_OMIT_CTE */
1267
1268
1269
danielk19776a67fe82005-02-04 04:07:16 +00001270#if !defined(SQLITE_OMIT_TRIGGER)
drhc926afb2002-06-20 03:38:26 +00001271 /* Discard the results. This is used for SELECT statements inside
1272 ** the body of a TRIGGER. The purpose of such selects is to call
1273 ** user-defined functions that have side effects. We do not care
1274 ** about the actual results of the select.
1275 */
drhc926afb2002-06-20 03:38:26 +00001276 default: {
drhf46f9052002-06-22 02:33:38 +00001277 assert( eDest==SRT_Discard );
drhc926afb2002-06-20 03:38:26 +00001278 break;
1279 }
danielk197793758c82005-01-21 08:13:14 +00001280#endif
drh82c3d632000-06-06 21:56:07 +00001281 }
drhec7429a2005-10-06 16:53:14 +00001282
drh5e87be82010-10-06 18:55:37 +00001283 /* Jump to the end of the loop if the LIMIT is reached. Except, if
1284 ** there is a sorter, in which case the sorter has already limited
1285 ** the output for us.
drhec7429a2005-10-06 16:53:14 +00001286 */
drh079a3072014-03-19 14:10:55 +00001287 if( pSort==0 && p->iLimit ){
drh16897072015-03-07 00:57:37 +00001288 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak); VdbeCoverage(v);
drhec7429a2005-10-06 16:53:14 +00001289 }
drh82c3d632000-06-06 21:56:07 +00001290}
1291
1292/*
drhad124322013-10-23 13:30:58 +00001293** Allocate a KeyInfo object sufficient for an index of N key columns and
1294** X extra columns.
drh323df792013-08-05 19:11:29 +00001295*/
drhad124322013-10-23 13:30:58 +00001296KeyInfo *sqlite3KeyInfoAlloc(sqlite3 *db, int N, int X){
drhd4ab0032017-05-31 13:45:59 +00001297 int nExtra = (N+X)*(sizeof(CollSeq*)+1) - sizeof(CollSeq*);
drhd8e4b132016-10-01 19:21:56 +00001298 KeyInfo *p = sqlite3DbMallocRawNN(db, sizeof(KeyInfo) + nExtra);
drh323df792013-08-05 19:11:29 +00001299 if( p ){
dan6e118922019-08-12 16:36:38 +00001300 p->aSortFlags = (u8*)&p->aColl[N+X];
drha485ad12017-08-02 22:43:14 +00001301 p->nKeyField = (u16)N;
1302 p->nAllField = (u16)(N+X);
drh323df792013-08-05 19:11:29 +00001303 p->enc = ENC(db);
1304 p->db = db;
drh2ec2fb22013-11-06 19:59:23 +00001305 p->nRef = 1;
drhc263f7c2016-01-18 13:18:54 +00001306 memset(&p[1], 0, nExtra);
drh2ec2fb22013-11-06 19:59:23 +00001307 }else{
drh4a642b62016-02-05 01:55:27 +00001308 sqlite3OomFault(db);
drh323df792013-08-05 19:11:29 +00001309 }
1310 return p;
1311}
1312
1313/*
drh2ec2fb22013-11-06 19:59:23 +00001314** Deallocate a KeyInfo object
1315*/
1316void sqlite3KeyInfoUnref(KeyInfo *p){
1317 if( p ){
1318 assert( p->nRef>0 );
drh2ec2fb22013-11-06 19:59:23 +00001319 p->nRef--;
drhdbd6a7d2017-04-05 12:39:49 +00001320 if( p->nRef==0 ) sqlite3DbFreeNN(p->db, p);
drh2ec2fb22013-11-06 19:59:23 +00001321 }
1322}
1323
1324/*
1325** Make a new pointer to a KeyInfo object
1326*/
1327KeyInfo *sqlite3KeyInfoRef(KeyInfo *p){
1328 if( p ){
1329 assert( p->nRef>0 );
1330 p->nRef++;
1331 }
1332 return p;
1333}
1334
1335#ifdef SQLITE_DEBUG
1336/*
1337** Return TRUE if a KeyInfo object can be change. The KeyInfo object
1338** can only be changed if this is just a single reference to the object.
1339**
1340** This routine is used only inside of assert() statements.
1341*/
1342int sqlite3KeyInfoIsWriteable(KeyInfo *p){ return p->nRef==1; }
1343#endif /* SQLITE_DEBUG */
1344
1345/*
drhdece1a82005-08-31 18:20:00 +00001346** Given an expression list, generate a KeyInfo structure that records
1347** the collating sequence for each expression in that expression list.
1348**
drh0342b1f2005-09-01 03:07:44 +00001349** If the ExprList is an ORDER BY or GROUP BY clause then the resulting
1350** KeyInfo structure is appropriate for initializing a virtual index to
1351** implement that clause. If the ExprList is the result set of a SELECT
1352** then the KeyInfo structure is appropriate for initializing a virtual
1353** index to implement a DISTINCT test.
1354**
peter.d.reid60ec9142014-09-06 16:39:46 +00001355** Space to hold the KeyInfo structure is obtained from malloc. The calling
drhdece1a82005-08-31 18:20:00 +00001356** function is responsible for seeing that this structure is eventually
drh2ec2fb22013-11-06 19:59:23 +00001357** freed.
drhdece1a82005-08-31 18:20:00 +00001358*/
danf9eae182018-05-21 19:45:11 +00001359KeyInfo *sqlite3KeyInfoFromExprList(
drh079a3072014-03-19 14:10:55 +00001360 Parse *pParse, /* Parsing context */
1361 ExprList *pList, /* Form the KeyInfo object from this ExprList */
1362 int iStart, /* Begin with this column of pList */
1363 int nExtra /* Add this many extra columns to the end */
1364){
drhdece1a82005-08-31 18:20:00 +00001365 int nExpr;
1366 KeyInfo *pInfo;
1367 struct ExprList_item *pItem;
drh323df792013-08-05 19:11:29 +00001368 sqlite3 *db = pParse->db;
drhdece1a82005-08-31 18:20:00 +00001369 int i;
1370
1371 nExpr = pList->nExpr;
drh3f39bcf2015-01-19 20:59:34 +00001372 pInfo = sqlite3KeyInfoAlloc(db, nExpr-iStart, nExtra+1);
drhdece1a82005-08-31 18:20:00 +00001373 if( pInfo ){
drh2ec2fb22013-11-06 19:59:23 +00001374 assert( sqlite3KeyInfoIsWriteable(pInfo) );
drh6284db92014-03-19 23:24:49 +00001375 for(i=iStart, pItem=pList->a+iStart; i<nExpr; i++, pItem++){
drh70efa842017-09-28 01:58:23 +00001376 pInfo->aColl[i-iStart] = sqlite3ExprNNCollSeq(pParse, pItem->pExpr);
dan6e118922019-08-12 16:36:38 +00001377 pInfo->aSortFlags[i-iStart] = pItem->sortFlags;
drhdece1a82005-08-31 18:20:00 +00001378 }
1379 }
1380 return pInfo;
1381}
1382
dan7f61e922010-11-11 16:46:40 +00001383/*
1384** Name of the connection operator, used for error messages.
1385*/
1386static const char *selectOpName(int id){
1387 char *z;
1388 switch( id ){
1389 case TK_ALL: z = "UNION ALL"; break;
1390 case TK_INTERSECT: z = "INTERSECT"; break;
1391 case TK_EXCEPT: z = "EXCEPT"; break;
1392 default: z = "UNION"; break;
1393 }
1394 return z;
1395}
dan7f61e922010-11-11 16:46:40 +00001396
dan2ce22452010-11-08 19:01:16 +00001397#ifndef SQLITE_OMIT_EXPLAIN
dan17c0bc02010-11-09 17:35:19 +00001398/*
1399** Unless an "EXPLAIN QUERY PLAN" command is being processed, this function
1400** is a no-op. Otherwise, it adds a single row of output to the EQP result,
1401** where the caption is of the form:
1402**
1403** "USE TEMP B-TREE FOR xxx"
1404**
1405** where xxx is one of "DISTINCT", "ORDER BY" or "GROUP BY". Exactly which
1406** is determined by the zUsage argument.
1407*/
dan2ce22452010-11-08 19:01:16 +00001408static void explainTempTable(Parse *pParse, const char *zUsage){
drhe2ca99c2018-05-02 00:33:43 +00001409 ExplainQueryPlan((pParse, 0, "USE TEMP B-TREE FOR %s", zUsage));
dan2ce22452010-11-08 19:01:16 +00001410}
dan17c0bc02010-11-09 17:35:19 +00001411
1412/*
danbb2b4412011-04-06 17:54:31 +00001413** Assign expression b to lvalue a. A second, no-op, version of this macro
1414** is provided when SQLITE_OMIT_EXPLAIN is defined. This allows the code
1415** in sqlite3Select() to assign values to structure member variables that
1416** only exist if SQLITE_OMIT_EXPLAIN is not defined without polluting the
1417** code with #ifndef directives.
1418*/
1419# define explainSetInteger(a, b) a = b
1420
1421#else
1422/* No-op versions of the explainXXX() functions and macros. */
1423# define explainTempTable(y,z)
1424# define explainSetInteger(y,z)
1425#endif
1426
drhdece1a82005-08-31 18:20:00 +00001427
1428/*
drhd8bc7082000-06-07 23:51:50 +00001429** If the inner loop was generated using a non-null pOrderBy argument,
1430** then the results were placed in a sorter. After the loop is terminated
1431** we need to run the sorter and output the results. The following
1432** routine generates the code needed to do that.
1433*/
drhc926afb2002-06-20 03:38:26 +00001434static void generateSortTail(
danielk19776c8c8ce2008-01-02 16:27:09 +00001435 Parse *pParse, /* Parsing context */
1436 Select *p, /* The SELECT statement */
drh079a3072014-03-19 14:10:55 +00001437 SortCtx *pSort, /* Information on the ORDER BY clause */
danielk19776c8c8ce2008-01-02 16:27:09 +00001438 int nColumn, /* Number of columns of data */
1439 SelectDest *pDest /* Write the sorted results here */
drhc926afb2002-06-20 03:38:26 +00001440){
drhddba0c22014-03-18 20:33:42 +00001441 Vdbe *v = pParse->pVdbe; /* The prepared statement */
drha04a8be2016-01-13 17:50:10 +00001442 int addrBreak = pSort->labelDone; /* Jump here to exit loop */
drhec4ccdb2018-12-29 02:26:59 +00001443 int addrContinue = sqlite3VdbeMakeLabel(pParse);/* Jump here for next cycle */
dan24e25d32018-04-14 18:46:20 +00001444 int addr; /* Top of output loop. Jump for Next. */
drh079a3072014-03-19 14:10:55 +00001445 int addrOnce = 0;
drh0342b1f2005-09-01 03:07:44 +00001446 int iTab;
drh079a3072014-03-19 14:10:55 +00001447 ExprList *pOrderBy = pSort->pOrderBy;
danielk19776c8c8ce2008-01-02 16:27:09 +00001448 int eDest = pDest->eDest;
drh2b596da2012-07-23 21:43:19 +00001449 int iParm = pDest->iSDParm;
drh2d401ab2008-01-10 23:50:11 +00001450 int regRow;
1451 int regRowid;
dan257c13f2016-11-10 20:14:06 +00001452 int iCol;
dan24e25d32018-04-14 18:46:20 +00001453 int nKey; /* Number of key columns in sorter record */
drhf45f2322014-03-23 17:45:03 +00001454 int iSortTab; /* Sorter cursor to read from */
drhf45f2322014-03-23 17:45:03 +00001455 int i;
dan78d58432014-03-25 15:04:07 +00001456 int bSeq; /* True if sorter record includes seq. no. */
dan24e25d32018-04-14 18:46:20 +00001457 int nRefKey = 0;
drh70f624c2014-03-24 01:43:50 +00001458 struct ExprList_item *aOutEx = p->pEList->a;
drh2d401ab2008-01-10 23:50:11 +00001459
drha04a8be2016-01-13 17:50:10 +00001460 assert( addrBreak<0 );
drh079a3072014-03-19 14:10:55 +00001461 if( pSort->labelBkOut ){
1462 sqlite3VdbeAddOp2(v, OP_Gosub, pSort->regReturn, pSort->labelBkOut);
drh076e85f2015-09-03 13:46:12 +00001463 sqlite3VdbeGoto(v, addrBreak);
drh079a3072014-03-19 14:10:55 +00001464 sqlite3VdbeResolveLabel(v, pSort->labelBkOut);
drh079a3072014-03-19 14:10:55 +00001465 }
dan24e25d32018-04-14 18:46:20 +00001466
1467#ifdef SQLITE_ENABLE_SORTER_REFERENCES
1468 /* Open any cursors needed for sorter-reference expressions */
1469 for(i=0; i<pSort->nDefer; i++){
1470 Table *pTab = pSort->aDefer[i].pTab;
1471 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
1472 sqlite3OpenTable(pParse, pSort->aDefer[i].iCsr, iDb, pTab, OP_OpenRead);
1473 nRefKey = MAX(nRefKey, pSort->aDefer[i].nKey);
1474 }
1475#endif
1476
drh079a3072014-03-19 14:10:55 +00001477 iTab = pSort->iECursor;
dan71c57db2016-07-09 20:23:55 +00001478 if( eDest==SRT_Output || eDest==SRT_Coroutine || eDest==SRT_Mem ){
drh3e9ca092009-09-08 01:14:48 +00001479 regRowid = 0;
drhf45f2322014-03-23 17:45:03 +00001480 regRow = pDest->iSdst;
drhed24da42016-09-06 14:37:05 +00001481 }else{
dan51d82d12016-08-02 18:50:15 +00001482 regRowid = sqlite3GetTempReg(pParse);
drh375afb82019-01-16 19:26:31 +00001483 if( eDest==SRT_EphemTab || eDest==SRT_Table ){
1484 regRow = sqlite3GetTempReg(pParse);
1485 nColumn = 0;
1486 }else{
1487 regRow = sqlite3GetTempRange(pParse, nColumn);
1488 }
drhcdd536f2006-03-17 00:04:03 +00001489 }
drh079a3072014-03-19 14:10:55 +00001490 nKey = pOrderBy->nExpr - pSort->nOBSat;
1491 if( pSort->sortFlags & SORTFLAG_UseSorter ){
drhc2bb3282011-09-04 01:11:46 +00001492 int regSortOut = ++pParse->nMem;
drhf45f2322014-03-23 17:45:03 +00001493 iSortTab = pParse->nTab++;
drh83553ee2014-03-24 02:20:53 +00001494 if( pSort->labelBkOut ){
drh511f9e82016-09-22 18:53:13 +00001495 addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
drh83553ee2014-03-24 02:20:53 +00001496 }
dan24e25d32018-04-14 18:46:20 +00001497 sqlite3VdbeAddOp3(v, OP_OpenPseudo, iSortTab, regSortOut,
1498 nKey+1+nColumn+nRefKey);
drh079a3072014-03-19 14:10:55 +00001499 if( addrOnce ) sqlite3VdbeJumpHere(v, addrOnce);
drhc6aff302011-09-01 15:32:47 +00001500 addr = 1 + sqlite3VdbeAddOp2(v, OP_SorterSort, iTab, addrBreak);
drh688852a2014-02-17 22:40:43 +00001501 VdbeCoverage(v);
drhaa9ce702014-01-22 18:07:04 +00001502 codeOffset(v, p->iOffset, addrContinue);
drh6cf4a7d2014-10-13 13:00:58 +00001503 sqlite3VdbeAddOp3(v, OP_SorterData, iTab, regSortOut, iSortTab);
dan78d58432014-03-25 15:04:07 +00001504 bSeq = 0;
drhc6aff302011-09-01 15:32:47 +00001505 }else{
drh688852a2014-02-17 22:40:43 +00001506 addr = 1 + sqlite3VdbeAddOp2(v, OP_Sort, iTab, addrBreak); VdbeCoverage(v);
drhaa9ce702014-01-22 18:07:04 +00001507 codeOffset(v, p->iOffset, addrContinue);
drhf45f2322014-03-23 17:45:03 +00001508 iSortTab = iTab;
dan78d58432014-03-25 15:04:07 +00001509 bSeq = 1;
drhf45f2322014-03-23 17:45:03 +00001510 }
dand6189ea2018-04-11 14:11:53 +00001511 for(i=0, iCol=nKey+bSeq-1; i<nColumn; i++){
dan24e25d32018-04-14 18:46:20 +00001512#ifdef SQLITE_ENABLE_SORTER_REFERENCES
1513 if( aOutEx[i].bSorterRef ) continue;
1514#endif
drh9f895232018-01-24 20:42:42 +00001515 if( aOutEx[i].u.x.iOrderByCol==0 ) iCol++;
1516 }
dan24e25d32018-04-14 18:46:20 +00001517#ifdef SQLITE_ENABLE_SORTER_REFERENCES
1518 if( pSort->nDefer ){
1519 int iKey = iCol+1;
1520 int regKey = sqlite3GetTempRange(pParse, nRefKey);
1521
1522 for(i=0; i<pSort->nDefer; i++){
1523 int iCsr = pSort->aDefer[i].iCsr;
1524 Table *pTab = pSort->aDefer[i].pTab;
1525 int nKey = pSort->aDefer[i].nKey;
1526
1527 sqlite3VdbeAddOp1(v, OP_NullRow, iCsr);
1528 if( HasRowid(pTab) ){
1529 sqlite3VdbeAddOp3(v, OP_Column, iSortTab, iKey++, regKey);
1530 sqlite3VdbeAddOp3(v, OP_SeekRowid, iCsr,
1531 sqlite3VdbeCurrentAddr(v)+1, regKey);
1532 }else{
dan24e25d32018-04-14 18:46:20 +00001533 int k;
1534 int iJmp;
drh7590d092018-04-18 14:04:19 +00001535 assert( sqlite3PrimaryKeyIndex(pTab)->nKeyCol==nKey );
dan24e25d32018-04-14 18:46:20 +00001536 for(k=0; k<nKey; k++){
1537 sqlite3VdbeAddOp3(v, OP_Column, iSortTab, iKey++, regKey+k);
1538 }
1539 iJmp = sqlite3VdbeCurrentAddr(v);
1540 sqlite3VdbeAddOp4Int(v, OP_SeekGE, iCsr, iJmp+2, regKey, nKey);
1541 sqlite3VdbeAddOp4Int(v, OP_IdxLE, iCsr, iJmp+3, regKey, nKey);
1542 sqlite3VdbeAddOp1(v, OP_NullRow, iCsr);
1543 }
dan257c13f2016-11-10 20:14:06 +00001544 }
dan24e25d32018-04-14 18:46:20 +00001545 sqlite3ReleaseTempRange(pParse, regKey, nRefKey);
1546 }
1547#endif
1548 for(i=nColumn-1; i>=0; i--){
1549#ifdef SQLITE_ENABLE_SORTER_REFERENCES
1550 if( aOutEx[i].bSorterRef ){
1551 sqlite3ExprCode(pParse, aOutEx[i].pExpr, regRow+i);
1552 }else
1553#endif
1554 {
1555 int iRead;
1556 if( aOutEx[i].u.x.iOrderByCol ){
1557 iRead = aOutEx[i].u.x.iOrderByCol-1;
1558 }else{
1559 iRead = iCol--;
1560 }
1561 sqlite3VdbeAddOp3(v, OP_Column, iSortTab, iRead, regRow+i);
drhcbb9da32019-12-12 22:11:33 +00001562 VdbeComment((v, "%s", aOutEx[i].zEName));
dan24e25d32018-04-14 18:46:20 +00001563 }
drhc6aff302011-09-01 15:32:47 +00001564 }
drhc926afb2002-06-20 03:38:26 +00001565 switch( eDest ){
danac56ab72017-01-05 17:23:11 +00001566 case SRT_Table:
drhb9bb7c12006-06-11 23:41:55 +00001567 case SRT_EphemTab: {
drh375afb82019-01-16 19:26:31 +00001568 sqlite3VdbeAddOp3(v, OP_Column, iSortTab, nKey+bSeq, regRow);
drh2d401ab2008-01-10 23:50:11 +00001569 sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, regRowid);
1570 sqlite3VdbeAddOp3(v, OP_Insert, iParm, regRow, regRowid);
1571 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
drhc926afb2002-06-20 03:38:26 +00001572 break;
1573 }
danielk197793758c82005-01-21 08:13:14 +00001574#ifndef SQLITE_OMIT_SUBQUERY
drhc926afb2002-06-20 03:38:26 +00001575 case SRT_Set: {
dan71c57db2016-07-09 20:23:55 +00001576 assert( nColumn==sqlite3Strlen30(pDest->zAffSdst) );
1577 sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, nColumn, regRowid,
dan553168c2016-08-01 20:14:31 +00001578 pDest->zAffSdst, nColumn);
drh9b4eaeb2016-11-09 00:10:33 +00001579 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, regRowid, regRow, nColumn);
drhc926afb2002-06-20 03:38:26 +00001580 break;
1581 }
1582 case SRT_Mem: {
drhec7429a2005-10-06 16:53:14 +00001583 /* The LIMIT clause will terminate the loop for us */
drhc926afb2002-06-20 03:38:26 +00001584 break;
1585 }
danielk197793758c82005-01-21 08:13:14 +00001586#endif
danf2972b62020-04-29 20:11:01 +00001587 case SRT_Upfrom: {
1588 int i2 = pDest->iSDParm2;
1589 int r1 = sqlite3GetTempReg(pParse);
1590 sqlite3VdbeAddOp3(v, OP_MakeRecord,regRow+(i2<0),nColumn-(i2<0),r1);
1591 if( i2<0 ){
1592 sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, regRow);
1593 }else{
1594 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regRow, i2);
1595 }
1596 break;
1597 }
drh373cc2d2009-05-17 02:06:14 +00001598 default: {
drh373cc2d2009-05-17 02:06:14 +00001599 assert( eDest==SRT_Output || eDest==SRT_Coroutine );
drh1c767f02009-01-09 02:49:31 +00001600 testcase( eDest==SRT_Output );
1601 testcase( eDest==SRT_Coroutine );
drh7d10d5a2008-08-20 16:35:10 +00001602 if( eDest==SRT_Output ){
drh2b596da2012-07-23 21:43:19 +00001603 sqlite3VdbeAddOp2(v, OP_ResultRow, pDest->iSdst, nColumn);
drha9671a22008-07-08 23:40:20 +00001604 }else{
drh2b596da2012-07-23 21:43:19 +00001605 sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm);
drhce665cf2004-05-21 03:01:58 +00001606 }
drhac82fcf2002-09-08 17:23:41 +00001607 break;
1608 }
drhc926afb2002-06-20 03:38:26 +00001609 }
drhf45f2322014-03-23 17:45:03 +00001610 if( regRowid ){
dan51d82d12016-08-02 18:50:15 +00001611 if( eDest==SRT_Set ){
1612 sqlite3ReleaseTempRange(pParse, regRow, nColumn);
1613 }else{
1614 sqlite3ReleaseTempReg(pParse, regRow);
1615 }
drhf45f2322014-03-23 17:45:03 +00001616 sqlite3ReleaseTempReg(pParse, regRowid);
1617 }
drhec7429a2005-10-06 16:53:14 +00001618 /* The bottom of the loop
1619 */
drhdc5ea5c2008-12-10 17:19:59 +00001620 sqlite3VdbeResolveLabel(v, addrContinue);
drh079a3072014-03-19 14:10:55 +00001621 if( pSort->sortFlags & SORTFLAG_UseSorter ){
drh688852a2014-02-17 22:40:43 +00001622 sqlite3VdbeAddOp2(v, OP_SorterNext, iTab, addr); VdbeCoverage(v);
drhc6aff302011-09-01 15:32:47 +00001623 }else{
drh688852a2014-02-17 22:40:43 +00001624 sqlite3VdbeAddOp2(v, OP_Next, iTab, addr); VdbeCoverage(v);
drhc6aff302011-09-01 15:32:47 +00001625 }
drh079a3072014-03-19 14:10:55 +00001626 if( pSort->regReturn ) sqlite3VdbeAddOp1(v, OP_Return, pSort->regReturn);
drhdc5ea5c2008-12-10 17:19:59 +00001627 sqlite3VdbeResolveLabel(v, addrBreak);
drhd8bc7082000-06-07 23:51:50 +00001628}
1629
1630/*
danielk1977517eb642004-06-07 10:00:31 +00001631** Return a pointer to a string containing the 'declaration type' of the
1632** expression pExpr. The string may be treated as static by the caller.
drhe78e8282003-01-19 03:59:45 +00001633**
drh5f3e5e72013-10-08 20:01:35 +00001634** Also try to estimate the size of the returned value and return that
1635** result in *pEstWidth.
1636**
danielk1977955de522006-02-10 02:27:42 +00001637** The declaration type is the exact datatype definition extracted from the
1638** original CREATE TABLE statement if the expression is a column. The
1639** declaration type for a ROWID field is INTEGER. Exactly when an expression
1640** is considered a column can be complex in the presence of subqueries. The
1641** result-set expression in all of the following SELECT statements is
1642** considered a column by this function.
1643**
1644** SELECT col FROM tbl;
1645** SELECT (SELECT col FROM tbl;
1646** SELECT (SELECT col FROM tbl);
1647** SELECT abc FROM (SELECT col AS abc FROM tbl);
danielk1977517eb642004-06-07 10:00:31 +00001648**
danielk1977955de522006-02-10 02:27:42 +00001649** The declaration type for any expression other than a column is NULL.
drh5f3e5e72013-10-08 20:01:35 +00001650**
1651** This routine has either 3 or 6 parameters depending on whether or not
1652** the SQLITE_ENABLE_COLUMN_METADATA compile-time option is used.
danielk1977517eb642004-06-07 10:00:31 +00001653*/
drh5f3e5e72013-10-08 20:01:35 +00001654#ifdef SQLITE_ENABLE_COLUMN_METADATA
drhcafc2f72017-10-03 03:01:09 +00001655# define columnType(A,B,C,D,E) columnTypeImpl(A,B,C,D,E)
drhb121dd12015-06-06 18:30:17 +00001656#else /* if !defined(SQLITE_ENABLE_COLUMN_METADATA) */
drhcafc2f72017-10-03 03:01:09 +00001657# define columnType(A,B,C,D,E) columnTypeImpl(A,B)
drhb121dd12015-06-06 18:30:17 +00001658#endif
drh5f3e5e72013-10-08 20:01:35 +00001659static const char *columnTypeImpl(
danielk1977955de522006-02-10 02:27:42 +00001660 NameContext *pNC,
drhcafc2f72017-10-03 03:01:09 +00001661#ifndef SQLITE_ENABLE_COLUMN_METADATA
1662 Expr *pExpr
1663#else
danielk1977955de522006-02-10 02:27:42 +00001664 Expr *pExpr,
drh5f3e5e72013-10-08 20:01:35 +00001665 const char **pzOrigDb,
1666 const char **pzOrigTab,
drhcafc2f72017-10-03 03:01:09 +00001667 const char **pzOrigCol
drhb121dd12015-06-06 18:30:17 +00001668#endif
danielk1977955de522006-02-10 02:27:42 +00001669){
1670 char const *zType = 0;
danielk1977517eb642004-06-07 10:00:31 +00001671 int j;
drhb121dd12015-06-06 18:30:17 +00001672#ifdef SQLITE_ENABLE_COLUMN_METADATA
1673 char const *zOrigDb = 0;
1674 char const *zOrigTab = 0;
1675 char const *zOrigCol = 0;
1676#endif
danielk19775338a5f2005-01-20 13:03:10 +00001677
drhf7ce4292015-12-02 19:46:12 +00001678 assert( pExpr!=0 );
1679 assert( pNC->pSrcList!=0 );
danielk197700e279d2004-06-21 07:36:32 +00001680 switch( pExpr->op ){
1681 case TK_COLUMN: {
danielk1977955de522006-02-10 02:27:42 +00001682 /* The expression is a column. Locate the table the column is being
1683 ** extracted from in NameContext.pSrcList. This table may be real
1684 ** database table or a subquery.
1685 */
1686 Table *pTab = 0; /* Table structure column is extracted from */
1687 Select *pS = 0; /* Select the column is extracted from */
1688 int iCol = pExpr->iColumn; /* Index of column in pTab */
dan43bc88b2009-09-10 10:15:59 +00001689 while( pNC && !pTab ){
danielk1977b3bce662005-01-29 08:32:43 +00001690 SrcList *pTabList = pNC->pSrcList;
1691 for(j=0;j<pTabList->nSrc && pTabList->a[j].iCursor!=pExpr->iTable;j++);
1692 if( j<pTabList->nSrc ){
1693 pTab = pTabList->a[j].pTab;
danielk1977955de522006-02-10 02:27:42 +00001694 pS = pTabList->a[j].pSelect;
danielk1977b3bce662005-01-29 08:32:43 +00001695 }else{
1696 pNC = pNC->pNext;
1697 }
1698 }
danielk1977955de522006-02-10 02:27:42 +00001699
dan43bc88b2009-09-10 10:15:59 +00001700 if( pTab==0 ){
drh417168a2009-09-07 18:14:02 +00001701 /* At one time, code such as "SELECT new.x" within a trigger would
1702 ** cause this condition to run. Since then, we have restructured how
1703 ** trigger code is generated and so this condition is no longer
dan43bc88b2009-09-10 10:15:59 +00001704 ** possible. However, it can still be true for statements like
1705 ** the following:
1706 **
1707 ** CREATE TABLE t1(col INTEGER);
1708 ** SELECT (SELECT t1.col) FROM FROM t1;
1709 **
1710 ** when columnType() is called on the expression "t1.col" in the
1711 ** sub-select. In this case, set the column type to NULL, even
1712 ** though it should really be "INTEGER".
1713 **
1714 ** This is not a problem, as the column type of "t1.col" is never
1715 ** used. When columnType() is called on the expression
1716 ** "(SELECT t1.col)", the correct type is returned (see the TK_SELECT
1717 ** branch below. */
drh7e627792005-04-29 02:10:00 +00001718 break;
1719 }
danielk1977955de522006-02-10 02:27:42 +00001720
drheda079c2018-09-20 19:02:15 +00001721 assert( pTab && pExpr->y.pTab==pTab );
danielk1977955de522006-02-10 02:27:42 +00001722 if( pS ){
1723 /* The "table" is actually a sub-select or a view in the FROM clause
1724 ** of the SELECT statement. Return the declaration type and origin
1725 ** data for the result-set column of the sub-select.
1726 */
drhf35f2f92017-07-29 16:01:55 +00001727 if( iCol>=0 && iCol<pS->pEList->nExpr ){
danielk1977955de522006-02-10 02:27:42 +00001728 /* If iCol is less than zero, then the expression requests the
1729 ** rowid of the sub-select or view. This expression is legal (see
1730 ** test case misc2.2.2) - it always evaluates to NULL.
1731 */
1732 NameContext sNC;
1733 Expr *p = pS->pEList->a[iCol].pExpr;
1734 sNC.pSrcList = pS->pSrc;
dan43bc88b2009-09-10 10:15:59 +00001735 sNC.pNext = pNC;
danielk1977955de522006-02-10 02:27:42 +00001736 sNC.pParse = pNC->pParse;
drhcafc2f72017-10-03 03:01:09 +00001737 zType = columnType(&sNC, p,&zOrigDb,&zOrigTab,&zOrigCol);
danielk1977955de522006-02-10 02:27:42 +00001738 }
drha78d7572017-10-03 16:57:33 +00001739 }else{
1740 /* A real table or a CTE table */
danielk1977955de522006-02-10 02:27:42 +00001741 assert( !pS );
drh5f3e5e72013-10-08 20:01:35 +00001742#ifdef SQLITE_ENABLE_COLUMN_METADATA
drha78d7572017-10-03 16:57:33 +00001743 if( iCol<0 ) iCol = pTab->iPKey;
1744 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
danielk1977955de522006-02-10 02:27:42 +00001745 if( iCol<0 ){
1746 zType = "INTEGER";
drh5f3e5e72013-10-08 20:01:35 +00001747 zOrigCol = "rowid";
danielk1977955de522006-02-10 02:27:42 +00001748 }else{
drh5f3e5e72013-10-08 20:01:35 +00001749 zOrigCol = pTab->aCol[iCol].zName;
drhd7564862016-03-22 20:05:09 +00001750 zType = sqlite3ColumnType(&pTab->aCol[iCol],0);
danielk1977955de522006-02-10 02:27:42 +00001751 }
drh5f3e5e72013-10-08 20:01:35 +00001752 zOrigTab = pTab->zName;
drha78d7572017-10-03 16:57:33 +00001753 if( pNC->pParse && pTab->pSchema ){
danielk1977955de522006-02-10 02:27:42 +00001754 int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema);
drhe59be012016-08-18 20:56:39 +00001755 zOrigDb = pNC->pParse->db->aDb[iDb].zDbSName;
danielk1977955de522006-02-10 02:27:42 +00001756 }
drh5f3e5e72013-10-08 20:01:35 +00001757#else
drha78d7572017-10-03 16:57:33 +00001758 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
drh5f3e5e72013-10-08 20:01:35 +00001759 if( iCol<0 ){
1760 zType = "INTEGER";
1761 }else{
drhd7564862016-03-22 20:05:09 +00001762 zType = sqlite3ColumnType(&pTab->aCol[iCol],0);
drh5f3e5e72013-10-08 20:01:35 +00001763 }
1764#endif
danielk197700e279d2004-06-21 07:36:32 +00001765 }
1766 break;
danielk1977517eb642004-06-07 10:00:31 +00001767 }
danielk197793758c82005-01-21 08:13:14 +00001768#ifndef SQLITE_OMIT_SUBQUERY
danielk197700e279d2004-06-21 07:36:32 +00001769 case TK_SELECT: {
danielk1977955de522006-02-10 02:27:42 +00001770 /* The expression is a sub-select. Return the declaration type and
1771 ** origin info for the single column in the result set of the SELECT
1772 ** statement.
1773 */
danielk1977b3bce662005-01-29 08:32:43 +00001774 NameContext sNC;
danielk19776ab3a2e2009-02-19 14:39:25 +00001775 Select *pS = pExpr->x.pSelect;
danielk1977955de522006-02-10 02:27:42 +00001776 Expr *p = pS->pEList->a[0].pExpr;
danielk19776ab3a2e2009-02-19 14:39:25 +00001777 assert( ExprHasProperty(pExpr, EP_xIsSelect) );
danielk1977955de522006-02-10 02:27:42 +00001778 sNC.pSrcList = pS->pSrc;
danielk1977b3bce662005-01-29 08:32:43 +00001779 sNC.pNext = pNC;
danielk1977955de522006-02-10 02:27:42 +00001780 sNC.pParse = pNC->pParse;
drhcafc2f72017-10-03 03:01:09 +00001781 zType = columnType(&sNC, p, &zOrigDb, &zOrigTab, &zOrigCol);
danielk197700e279d2004-06-21 07:36:32 +00001782 break;
danielk1977517eb642004-06-07 10:00:31 +00001783 }
danielk197793758c82005-01-21 08:13:14 +00001784#endif
danielk1977517eb642004-06-07 10:00:31 +00001785 }
drh5f3e5e72013-10-08 20:01:35 +00001786
1787#ifdef SQLITE_ENABLE_COLUMN_METADATA
1788 if( pzOrigDb ){
1789 assert( pzOrigTab && pzOrigCol );
1790 *pzOrigDb = zOrigDb;
1791 *pzOrigTab = zOrigTab;
1792 *pzOrigCol = zOrigCol;
danielk1977955de522006-02-10 02:27:42 +00001793 }
drh5f3e5e72013-10-08 20:01:35 +00001794#endif
danielk1977517eb642004-06-07 10:00:31 +00001795 return zType;
1796}
1797
1798/*
1799** Generate code that will tell the VDBE the declaration types of columns
1800** in the result set.
drhfcb78a42003-01-18 20:11:05 +00001801*/
1802static void generateColumnTypes(
1803 Parse *pParse, /* Parser context */
drhfcb78a42003-01-18 20:11:05 +00001804 SrcList *pTabList, /* List of tables */
1805 ExprList *pEList /* Expressions defining the result set */
1806){
drh3f913572008-03-22 01:07:17 +00001807#ifndef SQLITE_OMIT_DECLTYPE
drhfcb78a42003-01-18 20:11:05 +00001808 Vdbe *v = pParse->pVdbe;
danielk1977517eb642004-06-07 10:00:31 +00001809 int i;
danielk1977b3bce662005-01-29 08:32:43 +00001810 NameContext sNC;
1811 sNC.pSrcList = pTabList;
danielk1977955de522006-02-10 02:27:42 +00001812 sNC.pParse = pParse;
drheac5fc02017-04-11 01:01:27 +00001813 sNC.pNext = 0;
drhfcb78a42003-01-18 20:11:05 +00001814 for(i=0; i<pEList->nExpr; i++){
1815 Expr *p = pEList->a[i].pExpr;
drh3f913572008-03-22 01:07:17 +00001816 const char *zType;
1817#ifdef SQLITE_ENABLE_COLUMN_METADATA
danielk1977955de522006-02-10 02:27:42 +00001818 const char *zOrigDb = 0;
1819 const char *zOrigTab = 0;
1820 const char *zOrigCol = 0;
drhcafc2f72017-10-03 03:01:09 +00001821 zType = columnType(&sNC, p, &zOrigDb, &zOrigTab, &zOrigCol);
danielk1977955de522006-02-10 02:27:42 +00001822
drh85b623f2007-12-13 21:54:09 +00001823 /* The vdbe must make its own copy of the column-type and other
danielk19774b1ae992006-02-10 03:06:10 +00001824 ** column specific strings, in case the schema is reset before this
1825 ** virtual machine is deleted.
danielk1977fbcd5852004-06-15 02:44:18 +00001826 */
danielk197710fb7492008-10-31 10:53:22 +00001827 sqlite3VdbeSetColName(v, i, COLNAME_DATABASE, zOrigDb, SQLITE_TRANSIENT);
1828 sqlite3VdbeSetColName(v, i, COLNAME_TABLE, zOrigTab, SQLITE_TRANSIENT);
1829 sqlite3VdbeSetColName(v, i, COLNAME_COLUMN, zOrigCol, SQLITE_TRANSIENT);
drh3f913572008-03-22 01:07:17 +00001830#else
drhcafc2f72017-10-03 03:01:09 +00001831 zType = columnType(&sNC, p, 0, 0, 0);
drh3f913572008-03-22 01:07:17 +00001832#endif
danielk197710fb7492008-10-31 10:53:22 +00001833 sqlite3VdbeSetColName(v, i, COLNAME_DECLTYPE, zType, SQLITE_TRANSIENT);
drhfcb78a42003-01-18 20:11:05 +00001834 }
drh5f3e5e72013-10-08 20:01:35 +00001835#endif /* !defined(SQLITE_OMIT_DECLTYPE) */
drhfcb78a42003-01-18 20:11:05 +00001836}
1837
drheac5fc02017-04-11 01:01:27 +00001838
1839/*
drhec360a82017-07-12 14:10:19 +00001840** Compute the column names for a SELECT statement.
1841**
1842** The only guarantee that SQLite makes about column names is that if the
1843** column has an AS clause assigning it a name, that will be the name used.
1844** That is the only documented guarantee. However, countless applications
1845** developed over the years have made baseless assumptions about column names
1846** and will break if those assumptions changes. Hence, use extreme caution
1847** when modifying this routine to avoid breaking legacy.
1848**
1849** See Also: sqlite3ColumnsFromExprList()
1850**
1851** The PRAGMA short_column_names and PRAGMA full_column_names settings are
1852** deprecated. The default setting is short=ON, full=OFF. 99.9% of all
1853** applications should operate this way. Nevertheless, we need to support the
1854** other modes for legacy:
1855**
1856** short=OFF, full=OFF: Column name is the text of the expression has it
1857** originally appears in the SELECT statement. In
1858** other words, the zSpan of the result expression.
1859**
1860** short=ON, full=OFF: (This is the default setting). If the result
drh3d240d22017-09-28 16:56:55 +00001861** refers directly to a table column, then the
1862** result column name is just the table column
1863** name: COLUMN. Otherwise use zSpan.
drhec360a82017-07-12 14:10:19 +00001864**
1865** full=ON, short=ANY: If the result refers directly to a table column,
1866** then the result column name with the table name
1867** prefix, ex: TABLE.COLUMN. Otherwise use zSpan.
drh82c3d632000-06-06 21:56:07 +00001868*/
drh832508b2002-03-02 17:04:07 +00001869static void generateColumnNames(
1870 Parse *pParse, /* Parser context */
drhf35f2f92017-07-29 16:01:55 +00001871 Select *pSelect /* Generate column names for this SELECT statement */
drh832508b2002-03-02 17:04:07 +00001872){
drhd8bc7082000-06-07 23:51:50 +00001873 Vdbe *v = pParse->pVdbe;
drheac5fc02017-04-11 01:01:27 +00001874 int i;
1875 Table *pTab;
drhf35f2f92017-07-29 16:01:55 +00001876 SrcList *pTabList;
1877 ExprList *pEList;
drh9bb575f2004-09-06 17:24:11 +00001878 sqlite3 *db = pParse->db;
drhf35f2f92017-07-29 16:01:55 +00001879 int fullName; /* TABLE.COLUMN if no AS clause and is a direct table ref */
1880 int srcName; /* COLUMN or TABLE.COLUMN if no AS clause and is direct */
drhfcabd462004-02-20 14:50:58 +00001881
drhfe2093d2005-01-20 22:48:47 +00001882#ifndef SQLITE_OMIT_EXPLAIN
danielk19773cf86062004-05-26 10:11:05 +00001883 /* If this is an EXPLAIN, skip this step */
1884 if( pParse->explain ){
danielk197761de0d12004-05-27 23:56:16 +00001885 return;
danielk19773cf86062004-05-26 10:11:05 +00001886 }
danielk19775338a5f2005-01-20 13:03:10 +00001887#endif
danielk19773cf86062004-05-26 10:11:05 +00001888
drh5e8b9852018-05-03 22:52:56 +00001889 if( pParse->colNamesSet ) return;
drhf35f2f92017-07-29 16:01:55 +00001890 /* Column names are determined by the left-most term of a compound select */
1891 while( pSelect->pPrior ) pSelect = pSelect->pPrior;
drh07859482017-12-23 11:51:40 +00001892 SELECTTRACE(1,pParse,pSelect,("generating column names\n"));
drhf35f2f92017-07-29 16:01:55 +00001893 pTabList = pSelect->pSrc;
1894 pEList = pSelect->pEList;
drh98029472015-12-03 21:47:30 +00001895 assert( v!=0 );
drhf7ce4292015-12-02 19:46:12 +00001896 assert( pTabList!=0 );
drhd8bc7082000-06-07 23:51:50 +00001897 pParse->colNamesSet = 1;
drhec360a82017-07-12 14:10:19 +00001898 fullName = (db->flags & SQLITE_FullColNames)!=0;
1899 srcName = (db->flags & SQLITE_ShortColNames)!=0 || fullName;
danielk197722322fd2004-05-25 23:35:17 +00001900 sqlite3VdbeSetNumCols(v, pEList->nExpr);
drh82c3d632000-06-06 21:56:07 +00001901 for(i=0; i<pEList->nExpr; i++){
drhec360a82017-07-12 14:10:19 +00001902 Expr *p = pEList->a[i].pExpr;
1903
1904 assert( p!=0 );
drh4dd89d52017-08-14 14:53:24 +00001905 assert( p->op!=TK_AGG_COLUMN ); /* Agg processing has not run yet */
drheda079c2018-09-20 19:02:15 +00001906 assert( p->op!=TK_COLUMN || p->y.pTab!=0 ); /* Covering idx not yet coded */
drhcbb9da32019-12-12 22:11:33 +00001907 if( pEList->a[i].zEName && pEList->a[i].eEName==ENAME_NAME ){
drhec360a82017-07-12 14:10:19 +00001908 /* An AS clause always takes first priority */
drh41cee662019-12-12 20:22:34 +00001909 char *zName = pEList->a[i].zEName;
danielk197710fb7492008-10-31 10:53:22 +00001910 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_TRANSIENT);
drhf35f2f92017-07-29 16:01:55 +00001911 }else if( srcName && p->op==TK_COLUMN ){
drh97665872002-02-13 23:22:53 +00001912 char *zCol;
drh8aff1012001-12-22 14:49:24 +00001913 int iCol = p->iColumn;
drheda079c2018-09-20 19:02:15 +00001914 pTab = p->y.pTab;
drhf35f2f92017-07-29 16:01:55 +00001915 assert( pTab!=0 );
drh8aff1012001-12-22 14:49:24 +00001916 if( iCol<0 ) iCol = pTab->iPKey;
drh97665872002-02-13 23:22:53 +00001917 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
drhb1363202002-06-26 02:45:03 +00001918 if( iCol<0 ){
drh47a6db22005-01-18 16:02:40 +00001919 zCol = "rowid";
drhb1363202002-06-26 02:45:03 +00001920 }else{
1921 zCol = pTab->aCol[iCol].zName;
drhb1363202002-06-26 02:45:03 +00001922 }
drhec360a82017-07-12 14:10:19 +00001923 if( fullName ){
drh82c3d632000-06-06 21:56:07 +00001924 char *zName = 0;
drh1c767f02009-01-09 02:49:31 +00001925 zName = sqlite3MPrintf(db, "%s.%s", pTab->zName, zCol);
danielk197710fb7492008-10-31 10:53:22 +00001926 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_DYNAMIC);
drh82c3d632000-06-06 21:56:07 +00001927 }else{
danielk197710fb7492008-10-31 10:53:22 +00001928 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zCol, SQLITE_TRANSIENT);
drh82c3d632000-06-06 21:56:07 +00001929 }
drh1bee3d72001-10-15 00:44:35 +00001930 }else{
drhcbb9da32019-12-12 22:11:33 +00001931 const char *z = pEList->a[i].zEName;
drh859bc542014-01-13 20:32:18 +00001932 z = z==0 ? sqlite3MPrintf(db, "column%d", i+1) : sqlite3DbStrDup(db, z);
1933 sqlite3VdbeSetColName(v, i, COLNAME_NAME, z, SQLITE_DYNAMIC);
drh82c3d632000-06-06 21:56:07 +00001934 }
1935 }
danielk197776d505b2004-05-28 13:13:02 +00001936 generateColumnTypes(pParse, pTabList, pEList);
drh82c3d632000-06-06 21:56:07 +00001937}
1938
drhd8bc7082000-06-07 23:51:50 +00001939/*
peter.d.reid60ec9142014-09-06 16:39:46 +00001940** Given an expression list (which is really the list of expressions
drh7d10d5a2008-08-20 16:35:10 +00001941** that form the result set of a SELECT statement) compute appropriate
1942** column names for a table that would hold the expression list.
1943**
1944** All column names will be unique.
1945**
1946** Only the column names are computed. Column.zType, Column.zColl,
1947** and other fields of Column are zeroed.
1948**
1949** Return SQLITE_OK on success. If a memory allocation error occurs,
1950** store NULL in *paCol and 0 in *pnCol and return SQLITE_NOMEM.
drhec360a82017-07-12 14:10:19 +00001951**
1952** The only guarantee that SQLite makes about column names is that if the
1953** column has an AS clause assigning it a name, that will be the name used.
1954** That is the only documented guarantee. However, countless applications
1955** developed over the years have made baseless assumptions about column names
1956** and will break if those assumptions changes. Hence, use extreme caution
1957** when modifying this routine to avoid breaking legacy.
1958**
1959** See Also: generateColumnNames()
drh315555c2002-10-20 15:53:03 +00001960*/
drh8981b902015-08-24 17:42:49 +00001961int sqlite3ColumnsFromExprList(
drh7d10d5a2008-08-20 16:35:10 +00001962 Parse *pParse, /* Parsing context */
1963 ExprList *pEList, /* Expr list from which to derive column names */
drhd815f172012-09-13 14:42:43 +00001964 i16 *pnCol, /* Write the number of columns here */
drh7d10d5a2008-08-20 16:35:10 +00001965 Column **paCol /* Write the new column list here */
1966){
drhdc5ea5c2008-12-10 17:19:59 +00001967 sqlite3 *db = pParse->db; /* Database connection */
1968 int i, j; /* Loop counters */
drhebed3fa2015-11-14 16:47:23 +00001969 u32 cnt; /* Index added to make the name unique */
drhdc5ea5c2008-12-10 17:19:59 +00001970 Column *aCol, *pCol; /* For looping over result columns */
1971 int nCol; /* Number of columns in the result set */
drhdc5ea5c2008-12-10 17:19:59 +00001972 char *zName; /* Column name */
1973 int nName; /* Size of name in zName[] */
drh0315e3c2015-11-14 20:52:43 +00001974 Hash ht; /* Hash table of column names */
drh6d5ab2a2020-11-02 00:40:05 +00001975 Table *pTab;
drh22f70c32002-02-18 01:17:00 +00001976
drh0315e3c2015-11-14 20:52:43 +00001977 sqlite3HashInit(&ht);
dan8c2e0f02012-03-31 15:08:56 +00001978 if( pEList ){
1979 nCol = pEList->nExpr;
1980 aCol = sqlite3DbMallocZero(db, sizeof(aCol[0])*nCol);
1981 testcase( aCol==0 );
drh6fe37332017-10-21 14:17:31 +00001982 if( nCol>32767 ) nCol = 32767;
dan8c2e0f02012-03-31 15:08:56 +00001983 }else{
1984 nCol = 0;
1985 aCol = 0;
1986 }
dan8836cbb2015-11-21 19:43:29 +00001987 assert( nCol==(i16)nCol );
dan8c2e0f02012-03-31 15:08:56 +00001988 *pnCol = nCol;
1989 *paCol = aCol;
1990
drh0315e3c2015-11-14 20:52:43 +00001991 for(i=0, pCol=aCol; i<nCol && !db->mallocFailed; i++, pCol++){
drh79d5f632005-01-18 17:20:10 +00001992 /* Get an appropriate name for the column
1993 */
drhcbb9da32019-12-12 22:11:33 +00001994 if( (zName = pEList->a[i].zEName)!=0 && pEList->a[i].eEName==ENAME_NAME ){
drh79d5f632005-01-18 17:20:10 +00001995 /* If the column contains an "AS <name>" phrase, use <name> as the name */
drh93a960a2008-07-10 00:32:42 +00001996 }else{
drh0d950af2019-08-22 16:38:42 +00001997 Expr *pColExpr = sqlite3ExprSkipCollateAndLikely(pEList->a[i].pExpr);
drh235667a2020-11-08 20:44:30 +00001998 while( ALWAYS(pColExpr!=0) && pColExpr->op==TK_DOT ){
drhb07028f2011-10-14 21:49:18 +00001999 pColExpr = pColExpr->pRight;
2000 assert( pColExpr!=0 );
2001 }
drh6d5ab2a2020-11-02 00:40:05 +00002002 if( pColExpr->op==TK_COLUMN && (pTab = pColExpr->y.pTab)!=0 ){
drh7d10d5a2008-08-20 16:35:10 +00002003 /* For columns use the column name name */
drhdc5ea5c2008-12-10 17:19:59 +00002004 int iCol = pColExpr->iColumn;
drhf0209f72008-08-21 14:54:28 +00002005 if( iCol<0 ) iCol = pTab->iPKey;
drh96ceaf82015-11-14 22:04:22 +00002006 zName = iCol>=0 ? pTab->aCol[iCol].zName : "rowid";
drhb7916a72009-05-27 10:31:29 +00002007 }else if( pColExpr->op==TK_ID ){
drh33e619f2009-05-28 01:00:55 +00002008 assert( !ExprHasProperty(pColExpr, EP_IntValue) );
drh96ceaf82015-11-14 22:04:22 +00002009 zName = pColExpr->u.zToken;
drh7d10d5a2008-08-20 16:35:10 +00002010 }else{
2011 /* Use the original text of the column expression as its name */
drhcbb9da32019-12-12 22:11:33 +00002012 zName = pEList->a[i].zEName;
drh7d10d5a2008-08-20 16:35:10 +00002013 }
drh22f70c32002-02-18 01:17:00 +00002014 }
drh0cbec592020-01-03 02:20:37 +00002015 if( zName && !sqlite3IsTrueOrFalse(zName) ){
drhd7ca6002017-07-09 00:30:58 +00002016 zName = sqlite3DbStrDup(db, zName);
2017 }else{
drh155507b2017-07-09 18:55:29 +00002018 zName = sqlite3MPrintf(db,"column%d",i+1);
drhd7ca6002017-07-09 00:30:58 +00002019 }
drh79d5f632005-01-18 17:20:10 +00002020
2021 /* Make sure the column name is unique. If the name is not unique,
peter.d.reid60ec9142014-09-06 16:39:46 +00002022 ** append an integer to the name so that it becomes unique.
drh79d5f632005-01-18 17:20:10 +00002023 */
drh0315e3c2015-11-14 20:52:43 +00002024 cnt = 0;
2025 while( zName && sqlite3HashFind(&ht, zName)!=0 ){
drh0315e3c2015-11-14 20:52:43 +00002026 nName = sqlite3Strlen30(zName);
drhf7ee8962015-11-15 11:13:49 +00002027 if( nName>0 ){
2028 for(j=nName-1; j>0 && sqlite3Isdigit(zName[j]); j--){}
2029 if( zName[j]==':' ) nName = j;
2030 }
drh96ceaf82015-11-14 22:04:22 +00002031 zName = sqlite3MPrintf(db, "%.*z:%u", nName, zName, ++cnt);
drh0315e3c2015-11-14 20:52:43 +00002032 if( cnt>3 ) sqlite3_randomness(sizeof(cnt), &cnt);
drh79d5f632005-01-18 17:20:10 +00002033 }
drh91bb0ee2004-09-01 03:06:34 +00002034 pCol->zName = zName;
drhd44390c2020-04-06 18:16:31 +00002035 pCol->hName = sqlite3StrIHash(zName);
danba68f8f2015-11-19 16:46:46 +00002036 sqlite3ColumnPropertiesFromName(0, pCol);
drh03d69a62015-11-19 13:53:57 +00002037 if( zName && sqlite3HashInsert(&ht, zName, pCol)==pCol ){
drh4a642b62016-02-05 01:55:27 +00002038 sqlite3OomFault(db);
drh0315e3c2015-11-14 20:52:43 +00002039 }
drh7d10d5a2008-08-20 16:35:10 +00002040 }
drh0315e3c2015-11-14 20:52:43 +00002041 sqlite3HashClear(&ht);
drh7d10d5a2008-08-20 16:35:10 +00002042 if( db->mallocFailed ){
drh7d10d5a2008-08-20 16:35:10 +00002043 for(j=0; j<i; j++){
2044 sqlite3DbFree(db, aCol[j].zName);
2045 }
2046 sqlite3DbFree(db, aCol);
2047 *paCol = 0;
2048 *pnCol = 0;
mistachkinfad30392016-02-13 23:43:46 +00002049 return SQLITE_NOMEM_BKPT;
drh7d10d5a2008-08-20 16:35:10 +00002050 }
2051 return SQLITE_OK;
2052}
danielk1977517eb642004-06-07 10:00:31 +00002053
drh7d10d5a2008-08-20 16:35:10 +00002054/*
2055** Add type and collation information to a column list based on
2056** a SELECT statement.
2057**
2058** The column list presumably came from selectColumnNamesFromExprList().
2059** The column list has only names, not types or collations. This
2060** routine goes through and adds the types and collations.
2061**
shaneb08a67a2009-03-31 03:41:56 +00002062** This routine requires that all identifiers in the SELECT
drh7d10d5a2008-08-20 16:35:10 +00002063** statement be resolved.
2064*/
drhed06a132016-04-05 20:59:12 +00002065void sqlite3SelectAddColumnTypeAndCollation(
drh7d10d5a2008-08-20 16:35:10 +00002066 Parse *pParse, /* Parsing contexts */
drh186ad8c2013-10-08 18:40:37 +00002067 Table *pTab, /* Add column type information to this table */
drh81506b82019-08-05 19:32:06 +00002068 Select *pSelect, /* SELECT used to determine types and collations */
2069 char aff /* Default affinity for columns */
drh7d10d5a2008-08-20 16:35:10 +00002070){
2071 sqlite3 *db = pParse->db;
2072 NameContext sNC;
2073 Column *pCol;
2074 CollSeq *pColl;
2075 int i;
2076 Expr *p;
2077 struct ExprList_item *a;
2078
2079 assert( pSelect!=0 );
2080 assert( (pSelect->selFlags & SF_Resolved)!=0 );
drh186ad8c2013-10-08 18:40:37 +00002081 assert( pTab->nCol==pSelect->pEList->nExpr || db->mallocFailed );
drh7d10d5a2008-08-20 16:35:10 +00002082 if( db->mallocFailed ) return;
2083 memset(&sNC, 0, sizeof(sNC));
2084 sNC.pSrcList = pSelect->pSrc;
2085 a = pSelect->pEList->a;
drh186ad8c2013-10-08 18:40:37 +00002086 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
drhed06a132016-04-05 20:59:12 +00002087 const char *zType;
2088 int n, m;
drh6f6e60d2021-02-18 15:45:34 +00002089 pTab->tabFlags |= (pCol->colFlags & COLFLAG_NOINSERT);
drh7d10d5a2008-08-20 16:35:10 +00002090 p = a[i].pExpr;
drhcafc2f72017-10-03 03:01:09 +00002091 zType = columnType(&sNC, p, 0, 0, 0);
2092 /* pCol->szEst = ... // Column size est for SELECT tables never used */
danielk1977c60e9b82005-01-31 12:42:29 +00002093 pCol->affinity = sqlite3ExprAffinity(p);
drh0c4db032017-10-03 19:53:12 +00002094 if( zType ){
2095 m = sqlite3Strlen30(zType);
drhed06a132016-04-05 20:59:12 +00002096 n = sqlite3Strlen30(pCol->zName);
2097 pCol->zName = sqlite3DbReallocOrFree(db, pCol->zName, n+m+2);
2098 if( pCol->zName ){
2099 memcpy(&pCol->zName[n+1], zType, m+1);
2100 pCol->colFlags |= COLFLAG_HASTYPE;
2101 }
2102 }
drh96fb16e2019-08-06 14:37:24 +00002103 if( pCol->affinity<=SQLITE_AFF_NONE ) pCol->affinity = aff;
danielk1977b3bf5562006-01-10 17:58:23 +00002104 pColl = sqlite3ExprCollSeq(pParse, p);
drh1cb50c82015-04-21 17:17:47 +00002105 if( pColl && pCol->zColl==0 ){
drh17435752007-08-16 04:30:38 +00002106 pCol->zColl = sqlite3DbStrDup(db, pColl->zName);
danielk19770202b292004-06-09 09:55:16 +00002107 }
drh22f70c32002-02-18 01:17:00 +00002108 }
drhcafc2f72017-10-03 03:01:09 +00002109 pTab->szTabRow = 1; /* Any non-zero value works */
drh7d10d5a2008-08-20 16:35:10 +00002110}
2111
2112/*
2113** Given a SELECT statement, generate a Table structure that describes
2114** the result set of that SELECT.
2115*/
drh81506b82019-08-05 19:32:06 +00002116Table *sqlite3ResultSetOfSelect(Parse *pParse, Select *pSelect, char aff){
drh7d10d5a2008-08-20 16:35:10 +00002117 Table *pTab;
2118 sqlite3 *db = pParse->db;
drh70d5dfb2018-12-06 16:50:55 +00002119 u64 savedFlags;
drh7d10d5a2008-08-20 16:35:10 +00002120
2121 savedFlags = db->flags;
drhd5b44d62018-12-06 17:06:02 +00002122 db->flags &= ~(u64)SQLITE_FullColNames;
drh7d10d5a2008-08-20 16:35:10 +00002123 db->flags |= SQLITE_ShortColNames;
2124 sqlite3SelectPrep(pParse, pSelect, 0);
drh491b6d82019-01-24 15:51:03 +00002125 db->flags = savedFlags;
drh7d10d5a2008-08-20 16:35:10 +00002126 if( pParse->nErr ) return 0;
2127 while( pSelect->pPrior ) pSelect = pSelect->pPrior;
drh7d10d5a2008-08-20 16:35:10 +00002128 pTab = sqlite3DbMallocZero(db, sizeof(Table) );
2129 if( pTab==0 ){
2130 return 0;
2131 }
drh79df7782016-12-14 14:07:35 +00002132 pTab->nTabRef = 1;
drh7d10d5a2008-08-20 16:35:10 +00002133 pTab->zName = 0;
dancfc9df72014-04-25 15:01:01 +00002134 pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
drh8981b902015-08-24 17:42:49 +00002135 sqlite3ColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
drh81506b82019-08-05 19:32:06 +00002136 sqlite3SelectAddColumnTypeAndCollation(pParse, pTab, pSelect, aff);
drh22f70c32002-02-18 01:17:00 +00002137 pTab->iPKey = -1;
drh7ce72f62008-07-24 15:50:41 +00002138 if( db->mallocFailed ){
dan1feeaed2010-07-23 15:41:47 +00002139 sqlite3DeleteTable(db, pTab);
drh7ce72f62008-07-24 15:50:41 +00002140 return 0;
2141 }
drh22f70c32002-02-18 01:17:00 +00002142 return pTab;
2143}
2144
2145/*
drhd8bc7082000-06-07 23:51:50 +00002146** Get a VDBE for the given parser context. Create a new one if necessary.
2147** If an error occurs, return NULL and leave a message in pParse.
2148*/
drh55965612017-09-16 20:58:41 +00002149Vdbe *sqlite3GetVdbe(Parse *pParse){
2150 if( pParse->pVdbe ){
2151 return pParse->pVdbe;
2152 }
drh6f077342016-04-12 00:26:59 +00002153 if( pParse->pToplevel==0
2154 && OptimizationEnabled(pParse->db,SQLITE_FactorOutConst)
2155 ){
2156 pParse->okConstFactor = 1;
drhd8bc7082000-06-07 23:51:50 +00002157 }
drh55965612017-09-16 20:58:41 +00002158 return sqlite3VdbeCreate(pParse);
drh6f077342016-04-12 00:26:59 +00002159}
drhfcb78a42003-01-18 20:11:05 +00002160
drh15007a92006-01-08 18:10:17 +00002161
drhd8bc7082000-06-07 23:51:50 +00002162/*
drh7b58dae2003-07-20 01:16:46 +00002163** Compute the iLimit and iOffset fields of the SELECT based on the
drh8c0833f2017-11-14 23:48:23 +00002164** pLimit expressions. pLimit->pLeft and pLimit->pRight hold the expressions
drh7b58dae2003-07-20 01:16:46 +00002165** that appear in the original SQL statement after the LIMIT and OFFSET
danielk1977a2dc3b12005-02-05 12:48:48 +00002166** keywords. Or NULL if those keywords are omitted. iLimit and iOffset
2167** are the integer memory register numbers for counters used to compute
2168** the limit and offset. If there is no limit and/or offset, then
2169** iLimit and iOffset are negative.
drh7b58dae2003-07-20 01:16:46 +00002170**
drhd59ba6c2006-01-08 05:02:54 +00002171** This routine changes the values of iLimit and iOffset only if
drh8c0833f2017-11-14 23:48:23 +00002172** a limit or offset is defined by pLimit->pLeft and pLimit->pRight. iLimit
2173** and iOffset should have been preset to appropriate default values (zero)
drhaa9ce702014-01-22 18:07:04 +00002174** prior to calling this routine.
2175**
2176** The iOffset register (if it exists) is initialized to the value
2177** of the OFFSET. The iLimit register is initialized to LIMIT. Register
2178** iOffset+1 is initialized to LIMIT+OFFSET.
2179**
drh8c0833f2017-11-14 23:48:23 +00002180** Only if pLimit->pLeft!=0 do the limit registers get
drh7b58dae2003-07-20 01:16:46 +00002181** redefined. The UNION ALL operator uses this property to force
2182** the reuse of the same limit and offset registers across multiple
2183** SELECT statements.
2184*/
drhec7429a2005-10-06 16:53:14 +00002185static void computeLimitRegisters(Parse *pParse, Select *p, int iBreak){
drh02afc862006-01-20 18:10:57 +00002186 Vdbe *v = 0;
2187 int iLimit = 0;
drh15007a92006-01-08 18:10:17 +00002188 int iOffset;
drh8b0cf382015-10-06 21:07:06 +00002189 int n;
drh8c0833f2017-11-14 23:48:23 +00002190 Expr *pLimit = p->pLimit;
2191
drh0acb7e42008-06-25 00:12:41 +00002192 if( p->iLimit ) return;
drh15007a92006-01-08 18:10:17 +00002193
drh7b58dae2003-07-20 01:16:46 +00002194 /*
drh7b58dae2003-07-20 01:16:46 +00002195 ** "LIMIT -1" always shows all rows. There is some
drhf7b54962013-05-28 12:11:54 +00002196 ** controversy about what the correct behavior should be.
drh7b58dae2003-07-20 01:16:46 +00002197 ** The current implementation interprets "LIMIT 0" to mean
2198 ** no rows.
2199 */
drh8c0833f2017-11-14 23:48:23 +00002200 if( pLimit ){
2201 assert( pLimit->op==TK_LIMIT );
2202 assert( pLimit->pLeft!=0 );
drh0a07c102008-01-03 18:03:08 +00002203 p->iLimit = iLimit = ++pParse->nMem;
drh15007a92006-01-08 18:10:17 +00002204 v = sqlite3GetVdbe(pParse);
drhaa9ce702014-01-22 18:07:04 +00002205 assert( v!=0 );
drh8c0833f2017-11-14 23:48:23 +00002206 if( sqlite3ExprIsInteger(pLimit->pLeft, &n) ){
drh456e4e42009-11-20 16:13:15 +00002207 sqlite3VdbeAddOp2(v, OP_Integer, n, iLimit);
2208 VdbeComment((v, "LIMIT counter"));
drh9b918ed2009-11-12 03:13:26 +00002209 if( n==0 ){
drh076e85f2015-09-03 13:46:12 +00002210 sqlite3VdbeGoto(v, iBreak);
drhc3489bb2016-02-25 16:04:59 +00002211 }else if( n>=0 && p->nSelectRow>sqlite3LogEst((u64)n) ){
2212 p->nSelectRow = sqlite3LogEst((u64)n);
2213 p->selFlags |= SF_FixedLimit;
drh9b918ed2009-11-12 03:13:26 +00002214 }
2215 }else{
drh8c0833f2017-11-14 23:48:23 +00002216 sqlite3ExprCode(pParse, pLimit->pLeft, iLimit);
drh688852a2014-02-17 22:40:43 +00002217 sqlite3VdbeAddOp1(v, OP_MustBeInt, iLimit); VdbeCoverage(v);
drh9b918ed2009-11-12 03:13:26 +00002218 VdbeComment((v, "LIMIT counter"));
drh16897072015-03-07 00:57:37 +00002219 sqlite3VdbeAddOp2(v, OP_IfNot, iLimit, iBreak); VdbeCoverage(v);
drh9b918ed2009-11-12 03:13:26 +00002220 }
drh8c0833f2017-11-14 23:48:23 +00002221 if( pLimit->pRight ){
drh373cc2d2009-05-17 02:06:14 +00002222 p->iOffset = iOffset = ++pParse->nMem;
drhb7654112008-01-12 12:48:07 +00002223 pParse->nMem++; /* Allocate an extra register for limit+offset */
drh8c0833f2017-11-14 23:48:23 +00002224 sqlite3ExprCode(pParse, pLimit->pRight, iOffset);
drh688852a2014-02-17 22:40:43 +00002225 sqlite3VdbeAddOp1(v, OP_MustBeInt, iOffset); VdbeCoverage(v);
drh373cc2d2009-05-17 02:06:14 +00002226 VdbeComment((v, "OFFSET counter"));
drhcc2fa4c2016-01-25 15:57:29 +00002227 sqlite3VdbeAddOp3(v, OP_OffsetLimit, iLimit, iOffset+1, iOffset);
drhb7654112008-01-12 12:48:07 +00002228 VdbeComment((v, "LIMIT+OFFSET"));
drhd59ba6c2006-01-08 05:02:54 +00002229 }
drh7b58dae2003-07-20 01:16:46 +00002230 }
2231}
2232
drhb7f91642004-10-31 02:22:47 +00002233#ifndef SQLITE_OMIT_COMPOUND_SELECT
drhfbc4ee72004-08-29 01:31:05 +00002234/*
drhfbc4ee72004-08-29 01:31:05 +00002235** Return the appropriate collating sequence for the iCol-th column of
2236** the result set for the compound-select statement "p". Return NULL if
2237** the column has no default collating sequence.
2238**
2239** The collating sequence for the compound select is taken from the
2240** left-most term of the select that has a collating sequence.
2241*/
danielk1977dc1bdc42004-06-11 10:51:27 +00002242static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){
drhfbc4ee72004-08-29 01:31:05 +00002243 CollSeq *pRet;
danielk1977dc1bdc42004-06-11 10:51:27 +00002244 if( p->pPrior ){
2245 pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
drhfbc4ee72004-08-29 01:31:05 +00002246 }else{
2247 pRet = 0;
danielk1977dc1bdc42004-06-11 10:51:27 +00002248 }
drh10c081a2009-04-16 00:24:23 +00002249 assert( iCol>=0 );
drh2ec18a32015-06-23 23:31:52 +00002250 /* iCol must be less than p->pEList->nExpr. Otherwise an error would
2251 ** have been thrown during name resolution and we would not have gotten
2252 ** this far */
2253 if( pRet==0 && ALWAYS(iCol<p->pEList->nExpr) ){
danielk1977dc1bdc42004-06-11 10:51:27 +00002254 pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
2255 }
2256 return pRet;
drhd3d39e92004-05-20 22:16:29 +00002257}
2258
dan53bed452014-01-24 20:37:18 +00002259/*
2260** The select statement passed as the second parameter is a compound SELECT
2261** with an ORDER BY clause. This function allocates and returns a KeyInfo
2262** structure suitable for implementing the ORDER BY.
2263**
2264** Space to hold the KeyInfo structure is obtained from malloc. The calling
2265** function is responsible for ensuring that this structure is eventually
2266** freed.
2267*/
2268static KeyInfo *multiSelectOrderByKeyInfo(Parse *pParse, Select *p, int nExtra){
2269 ExprList *pOrderBy = p->pOrderBy;
2270 int nOrderBy = p->pOrderBy->nExpr;
2271 sqlite3 *db = pParse->db;
2272 KeyInfo *pRet = sqlite3KeyInfoAlloc(db, nOrderBy+nExtra, 1);
2273 if( pRet ){
2274 int i;
2275 for(i=0; i<nOrderBy; i++){
2276 struct ExprList_item *pItem = &pOrderBy->a[i];
2277 Expr *pTerm = pItem->pExpr;
2278 CollSeq *pColl;
2279
2280 if( pTerm->flags & EP_Collate ){
2281 pColl = sqlite3ExprCollSeq(pParse, pTerm);
2282 }else{
2283 pColl = multiSelectCollSeq(pParse, p, pItem->u.x.iOrderByCol-1);
2284 if( pColl==0 ) pColl = db->pDfltColl;
2285 pOrderBy->a[i].pExpr =
2286 sqlite3ExprAddCollateString(pParse, pTerm, pColl->zName);
2287 }
2288 assert( sqlite3KeyInfoIsWriteable(pRet) );
2289 pRet->aColl[i] = pColl;
dan6e118922019-08-12 16:36:38 +00002290 pRet->aSortFlags[i] = pOrderBy->a[i].sortFlags;
dan53bed452014-01-24 20:37:18 +00002291 }
2292 }
2293
2294 return pRet;
2295}
drhd3d39e92004-05-20 22:16:29 +00002296
drh781def22014-01-22 13:35:53 +00002297#ifndef SQLITE_OMIT_CTE
2298/*
2299** This routine generates VDBE code to compute the content of a WITH RECURSIVE
2300** query of the form:
2301**
2302** <recursive-table> AS (<setup-query> UNION [ALL] <recursive-query>)
2303** \___________/ \_______________/
2304** p->pPrior p
2305**
2306**
2307** There is exactly one reference to the recursive-table in the FROM clause
drh8a48b9c2015-08-19 15:20:00 +00002308** of recursive-query, marked with the SrcList->a[].fg.isRecursive flag.
drh781def22014-01-22 13:35:53 +00002309**
2310** The setup-query runs once to generate an initial set of rows that go
2311** into a Queue table. Rows are extracted from the Queue table one by
drhfe1c6bb2014-01-22 17:28:35 +00002312** one. Each row extracted from Queue is output to pDest. Then the single
2313** extracted row (now in the iCurrent table) becomes the content of the
2314** recursive-table for a recursive-query run. The output of the recursive-query
drh781def22014-01-22 13:35:53 +00002315** is added back into the Queue table. Then another row is extracted from Queue
2316** and the iteration continues until the Queue table is empty.
2317**
2318** If the compound query operator is UNION then no duplicate rows are ever
2319** inserted into the Queue table. The iDistinct table keeps a copy of all rows
2320** that have ever been inserted into Queue and causes duplicates to be
2321** discarded. If the operator is UNION ALL, then duplicates are allowed.
2322**
2323** If the query has an ORDER BY, then entries in the Queue table are kept in
2324** ORDER BY order and the first entry is extracted for each cycle. Without
2325** an ORDER BY, the Queue table is just a FIFO.
2326**
2327** If a LIMIT clause is provided, then the iteration stops after LIMIT rows
2328** have been output to pDest. A LIMIT of zero means to output no rows and a
2329** negative LIMIT means to output all rows. If there is also an OFFSET clause
2330** with a positive value, then the first OFFSET outputs are discarded rather
2331** than being sent to pDest. The LIMIT count does not begin until after OFFSET
2332** rows have been skipped.
2333*/
2334static void generateWithRecursiveQuery(
2335 Parse *pParse, /* Parsing context */
2336 Select *p, /* The recursive SELECT to be coded */
2337 SelectDest *pDest /* What to do with query results */
2338){
2339 SrcList *pSrc = p->pSrc; /* The FROM clause of the recursive query */
2340 int nCol = p->pEList->nExpr; /* Number of columns in the recursive table */
2341 Vdbe *v = pParse->pVdbe; /* The prepared statement under construction */
2342 Select *pSetup = p->pPrior; /* The setup query */
drh34055852020-10-19 01:23:48 +00002343 Select *pFirstRec; /* Left-most recursive term */
drh781def22014-01-22 13:35:53 +00002344 int addrTop; /* Top of the loop */
2345 int addrCont, addrBreak; /* CONTINUE and BREAK addresses */
drhedf83d12014-01-22 18:31:27 +00002346 int iCurrent = 0; /* The Current table */
drh781def22014-01-22 13:35:53 +00002347 int regCurrent; /* Register holding Current table */
2348 int iQueue; /* The Queue table */
2349 int iDistinct = 0; /* To ensure unique results if UNION */
drh8e1ee882014-03-21 19:56:09 +00002350 int eDest = SRT_Fifo; /* How to write to Queue */
drh781def22014-01-22 13:35:53 +00002351 SelectDest destQueue; /* SelectDest targetting the Queue table */
2352 int i; /* Loop counter */
2353 int rc; /* Result code */
drhfe1c6bb2014-01-22 17:28:35 +00002354 ExprList *pOrderBy; /* The ORDER BY clause */
drh8c0833f2017-11-14 23:48:23 +00002355 Expr *pLimit; /* Saved LIMIT and OFFSET */
drhaa9ce702014-01-22 18:07:04 +00002356 int regLimit, regOffset; /* Registers used by LIMIT and OFFSET */
drh781def22014-01-22 13:35:53 +00002357
dan6afa35c2018-09-27 12:14:15 +00002358#ifndef SQLITE_OMIT_WINDOWFUNC
2359 if( p->pWin ){
2360 sqlite3ErrorMsg(pParse, "cannot use window functions in recursive queries");
2361 return;
2362 }
2363#endif
2364
drh781def22014-01-22 13:35:53 +00002365 /* Obtain authorization to do a recursive query */
2366 if( sqlite3AuthCheck(pParse, SQLITE_RECURSIVE, 0, 0, 0) ) return;
drh781def22014-01-22 13:35:53 +00002367
drhaa9ce702014-01-22 18:07:04 +00002368 /* Process the LIMIT and OFFSET clauses, if they exist */
drhec4ccdb2018-12-29 02:26:59 +00002369 addrBreak = sqlite3VdbeMakeLabel(pParse);
dan69b93832016-12-16 15:05:40 +00002370 p->nSelectRow = 320; /* 4 billion rows */
drhaa9ce702014-01-22 18:07:04 +00002371 computeLimitRegisters(pParse, p, addrBreak);
2372 pLimit = p->pLimit;
drhaa9ce702014-01-22 18:07:04 +00002373 regLimit = p->iLimit;
2374 regOffset = p->iOffset;
drh8c0833f2017-11-14 23:48:23 +00002375 p->pLimit = 0;
drhaa9ce702014-01-22 18:07:04 +00002376 p->iLimit = p->iOffset = 0;
dan53bed452014-01-24 20:37:18 +00002377 pOrderBy = p->pOrderBy;
drh781def22014-01-22 13:35:53 +00002378
2379 /* Locate the cursor number of the Current table */
2380 for(i=0; ALWAYS(i<pSrc->nSrc); i++){
drh8a48b9c2015-08-19 15:20:00 +00002381 if( pSrc->a[i].fg.isRecursive ){
drh781def22014-01-22 13:35:53 +00002382 iCurrent = pSrc->a[i].iCursor;
2383 break;
2384 }
2385 }
2386
drhfe1c6bb2014-01-22 17:28:35 +00002387 /* Allocate cursors numbers for Queue and Distinct. The cursor number for
drh781def22014-01-22 13:35:53 +00002388 ** the Distinct table must be exactly one greater than Queue in order
drh8e1ee882014-03-21 19:56:09 +00002389 ** for the SRT_DistFifo and SRT_DistQueue destinations to work. */
drh781def22014-01-22 13:35:53 +00002390 iQueue = pParse->nTab++;
2391 if( p->op==TK_UNION ){
drh8e1ee882014-03-21 19:56:09 +00002392 eDest = pOrderBy ? SRT_DistQueue : SRT_DistFifo;
drh781def22014-01-22 13:35:53 +00002393 iDistinct = pParse->nTab++;
drhfe1c6bb2014-01-22 17:28:35 +00002394 }else{
drh8e1ee882014-03-21 19:56:09 +00002395 eDest = pOrderBy ? SRT_Queue : SRT_Fifo;
drh781def22014-01-22 13:35:53 +00002396 }
2397 sqlite3SelectDestInit(&destQueue, eDest, iQueue);
2398
2399 /* Allocate cursors for Current, Queue, and Distinct. */
2400 regCurrent = ++pParse->nMem;
2401 sqlite3VdbeAddOp3(v, OP_OpenPseudo, iCurrent, regCurrent, nCol);
drhfe1c6bb2014-01-22 17:28:35 +00002402 if( pOrderBy ){
dan53bed452014-01-24 20:37:18 +00002403 KeyInfo *pKeyInfo = multiSelectOrderByKeyInfo(pParse, p, 1);
drhfe1c6bb2014-01-22 17:28:35 +00002404 sqlite3VdbeAddOp4(v, OP_OpenEphemeral, iQueue, pOrderBy->nExpr+2, 0,
2405 (char*)pKeyInfo, P4_KEYINFO);
2406 destQueue.pOrderBy = pOrderBy;
2407 }else{
2408 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iQueue, nCol);
2409 }
2410 VdbeComment((v, "Queue table"));
drh781def22014-01-22 13:35:53 +00002411 if( iDistinct ){
2412 p->addrOpenEphm[0] = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iDistinct, 0);
2413 p->selFlags |= SF_UsesEphemeral;
2414 }
2415
dan53bed452014-01-24 20:37:18 +00002416 /* Detach the ORDER BY clause from the compound SELECT */
2417 p->pOrderBy = 0;
2418
drh34055852020-10-19 01:23:48 +00002419 /* Figure out how many elements of the compound SELECT are part of the
2420 ** recursive query. Make sure no recursive elements use aggregate
2421 ** functions. Mark the recursive elements as UNION ALL even if they
2422 ** are really UNION because the distinctness will be enforced by the
2423 ** iDistinct table. pFirstRec is left pointing to the left-most
2424 ** recursive term of the CTE.
2425 */
2426 pFirstRec = p;
2427 for(pFirstRec=p; ALWAYS(pFirstRec!=0); pFirstRec=pFirstRec->pPrior){
2428 if( pFirstRec->selFlags & SF_Aggregate ){
2429 sqlite3ErrorMsg(pParse, "recursive aggregate queries not supported");
2430 goto end_of_recursive_query;
2431 }
2432 pFirstRec->op = TK_ALL;
2433 if( (pFirstRec->pPrior->selFlags & SF_Recursive)==0 ) break;
2434 }
2435
drh781def22014-01-22 13:35:53 +00002436 /* Store the results of the setup-query in Queue. */
drh34055852020-10-19 01:23:48 +00002437 pSetup = pFirstRec->pPrior;
drhd227a292014-02-09 18:02:09 +00002438 pSetup->pNext = 0;
drh84a01de2018-05-02 16:13:48 +00002439 ExplainQueryPlan((pParse, 1, "SETUP"));
drh781def22014-01-22 13:35:53 +00002440 rc = sqlite3Select(pParse, pSetup, &destQueue);
drhd227a292014-02-09 18:02:09 +00002441 pSetup->pNext = p;
drhfe1c6bb2014-01-22 17:28:35 +00002442 if( rc ) goto end_of_recursive_query;
drh781def22014-01-22 13:35:53 +00002443
2444 /* Find the next row in the Queue and output that row */
drh688852a2014-02-17 22:40:43 +00002445 addrTop = sqlite3VdbeAddOp2(v, OP_Rewind, iQueue, addrBreak); VdbeCoverage(v);
drh781def22014-01-22 13:35:53 +00002446
2447 /* Transfer the next row in Queue over to Current */
2448 sqlite3VdbeAddOp1(v, OP_NullRow, iCurrent); /* To reset column cache */
drhfe1c6bb2014-01-22 17:28:35 +00002449 if( pOrderBy ){
2450 sqlite3VdbeAddOp3(v, OP_Column, iQueue, pOrderBy->nExpr+1, regCurrent);
2451 }else{
2452 sqlite3VdbeAddOp2(v, OP_RowData, iQueue, regCurrent);
2453 }
drh781def22014-01-22 13:35:53 +00002454 sqlite3VdbeAddOp1(v, OP_Delete, iQueue);
2455
drhfe1c6bb2014-01-22 17:28:35 +00002456 /* Output the single row in Current */
drhec4ccdb2018-12-29 02:26:59 +00002457 addrCont = sqlite3VdbeMakeLabel(pParse);
drhaa9ce702014-01-22 18:07:04 +00002458 codeOffset(v, regOffset, addrCont);
drh2def2f72017-09-15 17:40:34 +00002459 selectInnerLoop(pParse, p, iCurrent,
drh079a3072014-03-19 14:10:55 +00002460 0, 0, pDest, addrCont, addrBreak);
drh688852a2014-02-17 22:40:43 +00002461 if( regLimit ){
drh16897072015-03-07 00:57:37 +00002462 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, regLimit, addrBreak);
drh688852a2014-02-17 22:40:43 +00002463 VdbeCoverage(v);
2464 }
drhfe1c6bb2014-01-22 17:28:35 +00002465 sqlite3VdbeResolveLabel(v, addrCont);
2466
drh781def22014-01-22 13:35:53 +00002467 /* Execute the recursive SELECT taking the single row in Current as
2468 ** the value for the recursive-table. Store the results in the Queue.
2469 */
drh34055852020-10-19 01:23:48 +00002470 pFirstRec->pPrior = 0;
2471 ExplainQueryPlan((pParse, 1, "RECURSIVE STEP"));
2472 sqlite3Select(pParse, p, &destQueue);
2473 assert( pFirstRec->pPrior==0 );
2474 pFirstRec->pPrior = pSetup;
drh781def22014-01-22 13:35:53 +00002475
2476 /* Keep running the loop until the Queue is empty */
drh076e85f2015-09-03 13:46:12 +00002477 sqlite3VdbeGoto(v, addrTop);
drh781def22014-01-22 13:35:53 +00002478 sqlite3VdbeResolveLabel(v, addrBreak);
drhfe1c6bb2014-01-22 17:28:35 +00002479
2480end_of_recursive_query:
dan9afccba2014-03-21 19:27:54 +00002481 sqlite3ExprListDelete(pParse->db, p->pOrderBy);
drhfe1c6bb2014-01-22 17:28:35 +00002482 p->pOrderBy = pOrderBy;
drhaa9ce702014-01-22 18:07:04 +00002483 p->pLimit = pLimit;
drhfe1c6bb2014-01-22 17:28:35 +00002484 return;
drh781def22014-01-22 13:35:53 +00002485}
danb68b9772014-01-25 12:16:53 +00002486#endif /* SQLITE_OMIT_CTE */
drh781def22014-01-22 13:35:53 +00002487
2488/* Forward references */
drhb21e7c72008-06-22 12:37:57 +00002489static int multiSelectOrderBy(
2490 Parse *pParse, /* Parsing context */
2491 Select *p, /* The right-most of SELECTs to be coded */
drha9671a22008-07-08 23:40:20 +00002492 SelectDest *pDest /* What to do with query results */
drhb21e7c72008-06-22 12:37:57 +00002493);
2494
drh45f54a52015-01-05 19:16:42 +00002495/*
drh45f54a52015-01-05 19:16:42 +00002496** Handle the special case of a compound-select that originates from a
2497** VALUES clause. By handling this as a special case, we avoid deep
2498** recursion, and thus do not need to enforce the SQLITE_LIMIT_COMPOUND_SELECT
2499** on a VALUES clause.
2500**
2501** Because the Select object originates from a VALUES clause:
drhb058d052018-01-14 20:12:23 +00002502** (1) There is no LIMIT or OFFSET or else there is a LIMIT of exactly 1
drh45f54a52015-01-05 19:16:42 +00002503** (2) All terms are UNION ALL
2504** (3) There is no ORDER BY clause
drhb058d052018-01-14 20:12:23 +00002505**
2506** The "LIMIT of exactly 1" case of condition (1) comes about when a VALUES
2507** clause occurs within scalar expression (ex: "SELECT (VALUES(1),(2),(3))").
2508** The sqlite3CodeSubselect will have added the LIMIT 1 clause in tht case.
2509** Since the limit is exactly 1, we only need to evalutes the left-most VALUES.
drh45f54a52015-01-05 19:16:42 +00002510*/
2511static int multiSelectValues(
2512 Parse *pParse, /* Parsing context */
2513 Select *p, /* The right-most of SELECTs to be coded */
2514 SelectDest *pDest /* What to do with query results */
2515){
drh45f54a52015-01-05 19:16:42 +00002516 int nRow = 1;
2517 int rc = 0;
drhfa16f5d2018-05-03 01:37:13 +00002518 int bShowAll = p->pLimit==0;
drh772460f2015-04-16 14:13:12 +00002519 assert( p->selFlags & SF_MultiValue );
drh45f54a52015-01-05 19:16:42 +00002520 do{
2521 assert( p->selFlags & SF_Values );
2522 assert( p->op==TK_ALL || (p->op==TK_SELECT && p->pPrior==0) );
dan923cadb2015-06-23 12:19:55 +00002523 assert( p->pNext==0 || p->pEList->nExpr==p->pNext->pEList->nExpr );
drhef9f7192020-01-17 19:14:08 +00002524#ifndef SQLITE_OMIT_WINDOWFUNC
drh29cdbad2019-12-07 13:42:47 +00002525 if( p->pWin ) return -1;
drhef9f7192020-01-17 19:14:08 +00002526#endif
drh45f54a52015-01-05 19:16:42 +00002527 if( p->pPrior==0 ) break;
2528 assert( p->pPrior->pNext==p );
2529 p = p->pPrior;
drhfa16f5d2018-05-03 01:37:13 +00002530 nRow += bShowAll;
drh45f54a52015-01-05 19:16:42 +00002531 }while(1);
drhfa16f5d2018-05-03 01:37:13 +00002532 ExplainQueryPlan((pParse, 0, "SCAN %d CONSTANT ROW%s", nRow,
2533 nRow==1 ? "" : "S"));
drh45f54a52015-01-05 19:16:42 +00002534 while( p ){
drhfa16f5d2018-05-03 01:37:13 +00002535 selectInnerLoop(pParse, p, -1, 0, 0, pDest, 1, 1);
2536 if( !bShowAll ) break;
drh45f54a52015-01-05 19:16:42 +00002537 p->nSelectRow = nRow;
2538 p = p->pNext;
2539 }
2540 return rc;
2541}
drhb21e7c72008-06-22 12:37:57 +00002542
drhd3d39e92004-05-20 22:16:29 +00002543/*
drh34055852020-10-19 01:23:48 +00002544** Return true if the SELECT statement which is known to be the recursive
2545** part of a recursive CTE still has its anchor terms attached. If the
2546** anchor terms have already been removed, then return false.
2547*/
2548static int hasAnchor(Select *p){
2549 while( p && (p->selFlags & SF_Recursive)!=0 ){ p = p->pPrior; }
2550 return p!=0;
2551}
2552
2553/*
drh16ee60f2008-06-20 18:13:25 +00002554** This routine is called to process a compound query form from
2555** two or more separate queries using UNION, UNION ALL, EXCEPT, or
2556** INTERSECT
drhc926afb2002-06-20 03:38:26 +00002557**
drhe78e8282003-01-19 03:59:45 +00002558** "p" points to the right-most of the two queries. the query on the
2559** left is p->pPrior. The left query could also be a compound query
2560** in which case this routine will be called recursively.
2561**
2562** The results of the total query are to be written into a destination
2563** of type eDest with parameter iParm.
2564**
2565** Example 1: Consider a three-way compound SQL statement.
2566**
2567** SELECT a FROM t1 UNION SELECT b FROM t2 UNION SELECT c FROM t3
2568**
2569** This statement is parsed up as follows:
2570**
2571** SELECT c FROM t3
2572** |
2573** `-----> SELECT b FROM t2
2574** |
jplyon4b11c6d2004-01-19 04:57:53 +00002575** `------> SELECT a FROM t1
drhe78e8282003-01-19 03:59:45 +00002576**
2577** The arrows in the diagram above represent the Select.pPrior pointer.
2578** So if this routine is called with p equal to the t3 query, then
2579** pPrior will be the t2 query. p->op will be TK_UNION in this case.
2580**
2581** Notice that because of the way SQLite parses compound SELECTs, the
2582** individual selects always group from left to right.
drh82c3d632000-06-06 21:56:07 +00002583*/
danielk197784ac9d02004-05-18 09:58:06 +00002584static int multiSelect(
drhfbc4ee72004-08-29 01:31:05 +00002585 Parse *pParse, /* Parsing context */
2586 Select *p, /* The right-most of SELECTs to be coded */
drha9671a22008-07-08 23:40:20 +00002587 SelectDest *pDest /* What to do with query results */
danielk197784ac9d02004-05-18 09:58:06 +00002588){
drhfbc4ee72004-08-29 01:31:05 +00002589 int rc = SQLITE_OK; /* Success code from a subroutine */
2590 Select *pPrior; /* Another SELECT immediately to our left */
2591 Vdbe *v; /* Generate code to this VDBE */
drh1013c932008-01-06 00:25:21 +00002592 SelectDest dest; /* Alternative data destination */
danielk1977eca7e012008-07-01 16:05:25 +00002593 Select *pDelete = 0; /* Chain of simple selects to delete */
drh633e6d52008-07-28 19:34:53 +00002594 sqlite3 *db; /* Database connection */
drh82c3d632000-06-06 21:56:07 +00002595
drh7b58dae2003-07-20 01:16:46 +00002596 /* Make sure there is no ORDER BY or LIMIT clause on prior SELECTs. Only
drhfbc4ee72004-08-29 01:31:05 +00002597 ** the last (right-most) SELECT in the series may have an ORDER BY or LIMIT.
drh82c3d632000-06-06 21:56:07 +00002598 */
drh701bb3b2008-08-02 03:50:39 +00002599 assert( p && p->pPrior ); /* Calling function guarantees this much */
daneae73fb2014-01-16 18:34:33 +00002600 assert( (p->selFlags & SF_Recursive)==0 || p->op==TK_ALL || p->op==TK_UNION );
drhb0968b62019-05-29 18:33:59 +00002601 assert( p->selFlags & SF_Compound );
drh633e6d52008-07-28 19:34:53 +00002602 db = pParse->db;
drhd8bc7082000-06-07 23:51:50 +00002603 pPrior = p->pPrior;
drhbc103772008-08-08 18:06:25 +00002604 dest = *pDest;
drh63347e72017-09-18 13:16:10 +00002605 if( pPrior->pOrderBy || pPrior->pLimit ){
2606 sqlite3ErrorMsg(pParse,"%s clause should come after %s not before",
2607 pPrior->pOrderBy!=0 ? "ORDER BY" : "LIMIT", selectOpName(p->op));
danielk197784ac9d02004-05-18 09:58:06 +00002608 rc = 1;
2609 goto multi_select_end;
drh7b58dae2003-07-20 01:16:46 +00002610 }
drh82c3d632000-06-06 21:56:07 +00002611
danielk19774adee202004-05-08 08:23:19 +00002612 v = sqlite3GetVdbe(pParse);
drh701bb3b2008-08-02 03:50:39 +00002613 assert( v!=0 ); /* The VDBE already created by calling function */
drhd8bc7082000-06-07 23:51:50 +00002614
drh1cc3d752002-03-23 00:31:29 +00002615 /* Create the destination temporary table if necessary
2616 */
danielk19776c8c8ce2008-01-02 16:27:09 +00002617 if( dest.eDest==SRT_EphemTab ){
danielk1977b4964b72004-05-18 01:23:38 +00002618 assert( p->pEList );
drh2b596da2012-07-23 21:43:19 +00002619 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, dest.iSDParm, p->pEList->nExpr);
danielk19776c8c8ce2008-01-02 16:27:09 +00002620 dest.eDest = SRT_Table;
drh1cc3d752002-03-23 00:31:29 +00002621 }
2622
drh45f54a52015-01-05 19:16:42 +00002623 /* Special handling for a compound-select that originates as a VALUES clause.
2624 */
drh772460f2015-04-16 14:13:12 +00002625 if( p->selFlags & SF_MultiValue ){
drh45f54a52015-01-05 19:16:42 +00002626 rc = multiSelectValues(pParse, p, &dest);
drh29cdbad2019-12-07 13:42:47 +00002627 if( rc>=0 ) goto multi_select_end;
2628 rc = SQLITE_OK;
drh45f54a52015-01-05 19:16:42 +00002629 }
2630
drhf6e369a2008-06-24 12:46:30 +00002631 /* Make sure all SELECTs in the statement have the same number of elements
2632 ** in their result sets.
2633 */
2634 assert( p->pEList && pPrior->pEList );
dan923cadb2015-06-23 12:19:55 +00002635 assert( p->pEList->nExpr==pPrior->pEList->nExpr );
drhf6e369a2008-06-24 12:46:30 +00002636
daneede6a52014-01-15 19:42:23 +00002637#ifndef SQLITE_OMIT_CTE
drh34055852020-10-19 01:23:48 +00002638 if( (p->selFlags & SF_Recursive)!=0 && hasAnchor(p) ){
drh781def22014-01-22 13:35:53 +00002639 generateWithRecursiveQuery(pParse, p, &dest);
dan8ce71842014-01-14 20:14:09 +00002640 }else
2641#endif
drhf6e369a2008-06-24 12:46:30 +00002642
drha9671a22008-07-08 23:40:20 +00002643 /* Compound SELECTs that have an ORDER BY clause are handled separately.
2644 */
drhf6e369a2008-06-24 12:46:30 +00002645 if( p->pOrderBy ){
drha9671a22008-07-08 23:40:20 +00002646 return multiSelectOrderBy(pParse, p, pDest);
drh03c39052018-05-02 14:24:34 +00002647 }else{
drhf6e369a2008-06-24 12:46:30 +00002648
drhc631ded2018-05-02 02:22:22 +00002649#ifndef SQLITE_OMIT_EXPLAIN
drh03c39052018-05-02 14:24:34 +00002650 if( pPrior->pPrior==0 ){
drh4d799832018-05-03 19:47:14 +00002651 ExplainQueryPlan((pParse, 1, "COMPOUND QUERY"));
drh03c39052018-05-02 14:24:34 +00002652 ExplainQueryPlan((pParse, 1, "LEFT-MOST SUBQUERY"));
drh03c39052018-05-02 14:24:34 +00002653 }
drhc631ded2018-05-02 02:22:22 +00002654#endif
2655
drh03c39052018-05-02 14:24:34 +00002656 /* Generate code for the left and right SELECT statements.
2657 */
2658 switch( p->op ){
2659 case TK_ALL: {
2660 int addr = 0;
2661 int nLimit;
2662 assert( !pPrior->pLimit );
2663 pPrior->iLimit = p->iLimit;
2664 pPrior->iOffset = p->iOffset;
2665 pPrior->pLimit = p->pLimit;
2666 rc = sqlite3Select(pParse, pPrior, &dest);
2667 p->pLimit = 0;
2668 if( rc ){
2669 goto multi_select_end;
drh9f1ef452015-10-06 17:27:18 +00002670 }
drh03c39052018-05-02 14:24:34 +00002671 p->pPrior = 0;
2672 p->iLimit = pPrior->iLimit;
2673 p->iOffset = pPrior->iOffset;
2674 if( p->iLimit ){
2675 addr = sqlite3VdbeAddOp1(v, OP_IfNot, p->iLimit); VdbeCoverage(v);
2676 VdbeComment((v, "Jump ahead if LIMIT reached"));
2677 if( p->iOffset ){
2678 sqlite3VdbeAddOp3(v, OP_OffsetLimit,
2679 p->iLimit, p->iOffset+1, p->iOffset);
2680 }
2681 }
2682 ExplainQueryPlan((pParse, 1, "UNION ALL"));
drh03c39052018-05-02 14:24:34 +00002683 rc = sqlite3Select(pParse, p, &dest);
2684 testcase( rc!=SQLITE_OK );
2685 pDelete = p->pPrior;
2686 p->pPrior = pPrior;
2687 p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow);
2688 if( pPrior->pLimit
2689 && sqlite3ExprIsInteger(pPrior->pLimit->pLeft, &nLimit)
2690 && nLimit>0 && p->nSelectRow > sqlite3LogEst((u64)nLimit)
2691 ){
2692 p->nSelectRow = sqlite3LogEst((u64)nLimit);
2693 }
2694 if( addr ){
2695 sqlite3VdbeJumpHere(v, addr);
2696 }
2697 break;
drha9671a22008-07-08 23:40:20 +00002698 }
drh03c39052018-05-02 14:24:34 +00002699 case TK_EXCEPT:
2700 case TK_UNION: {
2701 int unionTab; /* Cursor number of the temp table holding result */
2702 u8 op = 0; /* One of the SRT_ operations to apply to self */
2703 int priorOp; /* The SRT_ operation to apply to prior selects */
2704 Expr *pLimit; /* Saved values of p->nLimit */
2705 int addr;
2706 SelectDest uniondest;
2707
2708 testcase( p->op==TK_EXCEPT );
2709 testcase( p->op==TK_UNION );
2710 priorOp = SRT_Union;
2711 if( dest.eDest==priorOp ){
2712 /* We can reuse a temporary table generated by a SELECT to our
2713 ** right.
2714 */
2715 assert( p->pLimit==0 ); /* Not allowed on leftward elements */
2716 unionTab = dest.iSDParm;
2717 }else{
2718 /* We will need to create our own temporary table to hold the
2719 ** intermediate results.
2720 */
2721 unionTab = pParse->nTab++;
2722 assert( p->pOrderBy==0 );
2723 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, unionTab, 0);
2724 assert( p->addrOpenEphm[0] == -1 );
2725 p->addrOpenEphm[0] = addr;
2726 findRightmost(p)->selFlags |= SF_UsesEphemeral;
2727 assert( p->pEList );
2728 }
drh34055852020-10-19 01:23:48 +00002729
drh03c39052018-05-02 14:24:34 +00002730
2731 /* Code the SELECT statements to our left
drhd8bc7082000-06-07 23:51:50 +00002732 */
drh03c39052018-05-02 14:24:34 +00002733 assert( !pPrior->pOrderBy );
2734 sqlite3SelectDestInit(&uniondest, priorOp, unionTab);
2735 rc = sqlite3Select(pParse, pPrior, &uniondest);
2736 if( rc ){
2737 goto multi_select_end;
2738 }
2739
2740 /* Code the current SELECT statement
drhd8bc7082000-06-07 23:51:50 +00002741 */
drh03c39052018-05-02 14:24:34 +00002742 if( p->op==TK_EXCEPT ){
2743 op = SRT_Except;
2744 }else{
2745 assert( p->op==TK_UNION );
2746 op = SRT_Union;
2747 }
2748 p->pPrior = 0;
2749 pLimit = p->pLimit;
2750 p->pLimit = 0;
2751 uniondest.eDest = op;
2752 ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE",
2753 selectOpName(p->op)));
drh03c39052018-05-02 14:24:34 +00002754 rc = sqlite3Select(pParse, p, &uniondest);
2755 testcase( rc!=SQLITE_OK );
drhb7cbf5c2020-06-15 13:51:34 +00002756 assert( p->pOrderBy==0 );
drh03c39052018-05-02 14:24:34 +00002757 pDelete = p->pPrior;
2758 p->pPrior = pPrior;
2759 p->pOrderBy = 0;
2760 if( p->op==TK_UNION ){
2761 p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow);
2762 }
2763 sqlite3ExprDelete(db, p->pLimit);
2764 p->pLimit = pLimit;
2765 p->iLimit = 0;
2766 p->iOffset = 0;
2767
2768 /* Convert the data in the temporary table into whatever form
2769 ** it is that we currently need.
2770 */
2771 assert( unionTab==dest.iSDParm || dest.eDest!=priorOp );
drha9ebfe22019-12-25 23:54:21 +00002772 assert( p->pEList || db->mallocFailed );
2773 if( dest.eDest!=priorOp && db->mallocFailed==0 ){
drh03c39052018-05-02 14:24:34 +00002774 int iCont, iBreak, iStart;
drhec4ccdb2018-12-29 02:26:59 +00002775 iBreak = sqlite3VdbeMakeLabel(pParse);
2776 iCont = sqlite3VdbeMakeLabel(pParse);
drh03c39052018-05-02 14:24:34 +00002777 computeLimitRegisters(pParse, p, iBreak);
2778 sqlite3VdbeAddOp2(v, OP_Rewind, unionTab, iBreak); VdbeCoverage(v);
2779 iStart = sqlite3VdbeCurrentAddr(v);
2780 selectInnerLoop(pParse, p, unionTab,
2781 0, 0, &dest, iCont, iBreak);
2782 sqlite3VdbeResolveLabel(v, iCont);
2783 sqlite3VdbeAddOp2(v, OP_Next, unionTab, iStart); VdbeCoverage(v);
2784 sqlite3VdbeResolveLabel(v, iBreak);
2785 sqlite3VdbeAddOp2(v, OP_Close, unionTab, 0);
2786 }
2787 break;
2788 }
2789 default: assert( p->op==TK_INTERSECT ); {
2790 int tab1, tab2;
2791 int iCont, iBreak, iStart;
2792 Expr *pLimit;
2793 int addr;
2794 SelectDest intersectdest;
2795 int r1;
2796
2797 /* INTERSECT is different from the others since it requires
2798 ** two temporary tables. Hence it has its own case. Begin
2799 ** by allocating the tables we will need.
2800 */
2801 tab1 = pParse->nTab++;
2802 tab2 = pParse->nTab++;
drh93a960a2008-07-10 00:32:42 +00002803 assert( p->pOrderBy==0 );
drh03c39052018-05-02 14:24:34 +00002804
2805 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab1, 0);
drh93a960a2008-07-10 00:32:42 +00002806 assert( p->addrOpenEphm[0] == -1 );
2807 p->addrOpenEphm[0] = addr;
drhd227a292014-02-09 18:02:09 +00002808 findRightmost(p)->selFlags |= SF_UsesEphemeral;
danielk197784ac9d02004-05-18 09:58:06 +00002809 assert( p->pEList );
drh03c39052018-05-02 14:24:34 +00002810
2811 /* Code the SELECTs to our left into temporary table "tab1".
2812 */
2813 sqlite3SelectDestInit(&intersectdest, SRT_Union, tab1);
2814 rc = sqlite3Select(pParse, pPrior, &intersectdest);
2815 if( rc ){
2816 goto multi_select_end;
2817 }
2818
2819 /* Code the current SELECT into temporary table "tab2"
2820 */
2821 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab2, 0);
2822 assert( p->addrOpenEphm[1] == -1 );
2823 p->addrOpenEphm[1] = addr;
2824 p->pPrior = 0;
2825 pLimit = p->pLimit;
2826 p->pLimit = 0;
2827 intersectdest.iSDParm = tab2;
2828 ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE",
2829 selectOpName(p->op)));
drh03c39052018-05-02 14:24:34 +00002830 rc = sqlite3Select(pParse, p, &intersectdest);
2831 testcase( rc!=SQLITE_OK );
2832 pDelete = p->pPrior;
2833 p->pPrior = pPrior;
2834 if( p->nSelectRow>pPrior->nSelectRow ){
2835 p->nSelectRow = pPrior->nSelectRow;
2836 }
2837 sqlite3ExprDelete(db, p->pLimit);
2838 p->pLimit = pLimit;
2839
2840 /* Generate code to take the intersection of the two temporary
2841 ** tables.
2842 */
drh5f695122020-02-20 14:08:51 +00002843 if( rc ) break;
drh82c3d632000-06-06 21:56:07 +00002844 assert( p->pEList );
drhec4ccdb2018-12-29 02:26:59 +00002845 iBreak = sqlite3VdbeMakeLabel(pParse);
2846 iCont = sqlite3VdbeMakeLabel(pParse);
drhec7429a2005-10-06 16:53:14 +00002847 computeLimitRegisters(pParse, p, iBreak);
drh03c39052018-05-02 14:24:34 +00002848 sqlite3VdbeAddOp2(v, OP_Rewind, tab1, iBreak); VdbeCoverage(v);
2849 r1 = sqlite3GetTempReg(pParse);
2850 iStart = sqlite3VdbeAddOp2(v, OP_RowData, tab1, r1);
2851 sqlite3VdbeAddOp4Int(v, OP_NotFound, tab2, iCont, r1, 0);
2852 VdbeCoverage(v);
2853 sqlite3ReleaseTempReg(pParse, r1);
2854 selectInnerLoop(pParse, p, tab1,
drhe8e4af72012-09-21 00:04:28 +00002855 0, 0, &dest, iCont, iBreak);
danielk19774adee202004-05-08 08:23:19 +00002856 sqlite3VdbeResolveLabel(v, iCont);
drh03c39052018-05-02 14:24:34 +00002857 sqlite3VdbeAddOp2(v, OP_Next, tab1, iStart); VdbeCoverage(v);
danielk19774adee202004-05-08 08:23:19 +00002858 sqlite3VdbeResolveLabel(v, iBreak);
drh03c39052018-05-02 14:24:34 +00002859 sqlite3VdbeAddOp2(v, OP_Close, tab2, 0);
2860 sqlite3VdbeAddOp2(v, OP_Close, tab1, 0);
2861 break;
drh82c3d632000-06-06 21:56:07 +00002862 }
drh82c3d632000-06-06 21:56:07 +00002863 }
drh03c39052018-05-02 14:24:34 +00002864
2865 #ifndef SQLITE_OMIT_EXPLAIN
2866 if( p->pNext==0 ){
2867 ExplainQueryPlanPop(pParse);
drh82c3d632000-06-06 21:56:07 +00002868 }
drh03c39052018-05-02 14:24:34 +00002869 #endif
drh82c3d632000-06-06 21:56:07 +00002870 }
drh8428b3b2019-12-19 22:08:19 +00002871 if( pParse->nErr ) goto multi_select_end;
drh03c39052018-05-02 14:24:34 +00002872
drha9671a22008-07-08 23:40:20 +00002873 /* Compute collating sequences used by
2874 ** temporary tables needed to implement the compound select.
2875 ** Attach the KeyInfo structure to all temporary tables.
drh8cdbf832004-08-29 16:25:03 +00002876 **
2877 ** This section is run by the right-most SELECT statement only.
2878 ** SELECT statements to the left always skip this part. The right-most
2879 ** SELECT might also skip this part if it has no ORDER BY clause and
2880 ** no temp tables are required.
drhfbc4ee72004-08-29 01:31:05 +00002881 */
drh7d10d5a2008-08-20 16:35:10 +00002882 if( p->selFlags & SF_UsesEphemeral ){
drhfbc4ee72004-08-29 01:31:05 +00002883 int i; /* Loop counter */
2884 KeyInfo *pKeyInfo; /* Collating sequence for the result set */
drh0342b1f2005-09-01 03:07:44 +00002885 Select *pLoop; /* For looping through SELECT statements */
drhf68d7d12007-05-03 13:02:26 +00002886 CollSeq **apColl; /* For looping through pKeyInfo->aColl[] */
drh93a960a2008-07-10 00:32:42 +00002887 int nCol; /* Number of columns in result set */
drhfbc4ee72004-08-29 01:31:05 +00002888
drhd227a292014-02-09 18:02:09 +00002889 assert( p->pNext==0 );
drh93a960a2008-07-10 00:32:42 +00002890 nCol = p->pEList->nExpr;
drhad124322013-10-23 13:30:58 +00002891 pKeyInfo = sqlite3KeyInfoAlloc(db, nCol, 1);
danielk1977dc1bdc42004-06-11 10:51:27 +00002892 if( !pKeyInfo ){
mistachkinfad30392016-02-13 23:43:46 +00002893 rc = SQLITE_NOMEM_BKPT;
danielk1977dc1bdc42004-06-11 10:51:27 +00002894 goto multi_select_end;
2895 }
drh0342b1f2005-09-01 03:07:44 +00002896 for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
2897 *apColl = multiSelectCollSeq(pParse, p, i);
2898 if( 0==*apColl ){
drh633e6d52008-07-28 19:34:53 +00002899 *apColl = db->pDfltColl;
danielk1977dc1bdc42004-06-11 10:51:27 +00002900 }
2901 }
2902
drh0342b1f2005-09-01 03:07:44 +00002903 for(pLoop=p; pLoop; pLoop=pLoop->pPrior){
2904 for(i=0; i<2; i++){
drhb9bb7c12006-06-11 23:41:55 +00002905 int addr = pLoop->addrOpenEphm[i];
drh0342b1f2005-09-01 03:07:44 +00002906 if( addr<0 ){
2907 /* If [0] is unused then [1] is also unused. So we can
2908 ** always safely abort as soon as the first unused slot is found */
drhb9bb7c12006-06-11 23:41:55 +00002909 assert( pLoop->addrOpenEphm[1]<0 );
drh0342b1f2005-09-01 03:07:44 +00002910 break;
2911 }
2912 sqlite3VdbeChangeP2(v, addr, nCol);
drh2ec2fb22013-11-06 19:59:23 +00002913 sqlite3VdbeChangeP4(v, addr, (char*)sqlite3KeyInfoRef(pKeyInfo),
2914 P4_KEYINFO);
drh0ee5a1e2007-01-26 19:04:00 +00002915 pLoop->addrOpenEphm[i] = -1;
drh0342b1f2005-09-01 03:07:44 +00002916 }
danielk1977dc1bdc42004-06-11 10:51:27 +00002917 }
drh2ec2fb22013-11-06 19:59:23 +00002918 sqlite3KeyInfoUnref(pKeyInfo);
danielk197784ac9d02004-05-18 09:58:06 +00002919 }
danielk1977dc1bdc42004-06-11 10:51:27 +00002920
2921multi_select_end:
drh2b596da2012-07-23 21:43:19 +00002922 pDest->iSdst = dest.iSdst;
2923 pDest->nSdst = dest.nSdst;
drh633e6d52008-07-28 19:34:53 +00002924 sqlite3SelectDelete(db, pDelete);
danielk197784ac9d02004-05-18 09:58:06 +00002925 return rc;
drh22827922000-06-06 17:27:05 +00002926}
drhb7f91642004-10-31 02:22:47 +00002927#endif /* SQLITE_OMIT_COMPOUND_SELECT */
drh22827922000-06-06 17:27:05 +00002928
drhb21e7c72008-06-22 12:37:57 +00002929/*
mistachkin89b31d72015-07-16 17:29:27 +00002930** Error message for when two or more terms of a compound select have different
2931** size result sets.
2932*/
2933void sqlite3SelectWrongNumTermsError(Parse *pParse, Select *p){
2934 if( p->selFlags & SF_Values ){
2935 sqlite3ErrorMsg(pParse, "all VALUES must have the same number of terms");
2936 }else{
2937 sqlite3ErrorMsg(pParse, "SELECTs to the left and right of %s"
2938 " do not have the same number of result columns", selectOpName(p->op));
2939 }
2940}
2941
2942/*
drhb21e7c72008-06-22 12:37:57 +00002943** Code an output subroutine for a coroutine implementation of a
2944** SELECT statment.
drh0acb7e42008-06-25 00:12:41 +00002945**
drh2b596da2012-07-23 21:43:19 +00002946** The data to be output is contained in pIn->iSdst. There are
2947** pIn->nSdst columns to be output. pDest is where the output should
drh0acb7e42008-06-25 00:12:41 +00002948** be sent.
2949**
2950** regReturn is the number of the register holding the subroutine
2951** return address.
2952**
drhf053d5b2010-08-09 14:26:32 +00002953** If regPrev>0 then it is the first register in a vector that
drh0acb7e42008-06-25 00:12:41 +00002954** records the previous output. mem[regPrev] is a flag that is false
2955** if there has been no previous output. If regPrev>0 then code is
2956** generated to suppress duplicates. pKeyInfo is used for comparing
2957** keys.
2958**
2959** If the LIMIT found in p->iLimit is reached, jump immediately to
2960** iBreak.
drhb21e7c72008-06-22 12:37:57 +00002961*/
drh0acb7e42008-06-25 00:12:41 +00002962static int generateOutputSubroutine(
drh92b01d52008-06-24 00:32:35 +00002963 Parse *pParse, /* Parsing context */
2964 Select *p, /* The SELECT statement */
2965 SelectDest *pIn, /* Coroutine supplying data */
2966 SelectDest *pDest, /* Where to send the data */
2967 int regReturn, /* The return address register */
drh0acb7e42008-06-25 00:12:41 +00002968 int regPrev, /* Previous result register. No uniqueness if 0 */
2969 KeyInfo *pKeyInfo, /* For comparing with previous entry */
drh92b01d52008-06-24 00:32:35 +00002970 int iBreak /* Jump here if we hit the LIMIT */
drhb21e7c72008-06-22 12:37:57 +00002971){
2972 Vdbe *v = pParse->pVdbe;
drh92b01d52008-06-24 00:32:35 +00002973 int iContinue;
2974 int addr;
drhb21e7c72008-06-22 12:37:57 +00002975
drh92b01d52008-06-24 00:32:35 +00002976 addr = sqlite3VdbeCurrentAddr(v);
drhec4ccdb2018-12-29 02:26:59 +00002977 iContinue = sqlite3VdbeMakeLabel(pParse);
drh0acb7e42008-06-25 00:12:41 +00002978
2979 /* Suppress duplicates for UNION, EXCEPT, and INTERSECT
2980 */
2981 if( regPrev ){
drh728e0f92015-10-10 14:41:28 +00002982 int addr1, addr2;
2983 addr1 = sqlite3VdbeAddOp1(v, OP_IfNot, regPrev); VdbeCoverage(v);
2984 addr2 = sqlite3VdbeAddOp4(v, OP_Compare, pIn->iSdst, regPrev+1, pIn->nSdst,
drh2ec2fb22013-11-06 19:59:23 +00002985 (char*)sqlite3KeyInfoRef(pKeyInfo), P4_KEYINFO);
drh728e0f92015-10-10 14:41:28 +00002986 sqlite3VdbeAddOp3(v, OP_Jump, addr2+2, iContinue, addr2+2); VdbeCoverage(v);
2987 sqlite3VdbeJumpHere(v, addr1);
drhe8e4af72012-09-21 00:04:28 +00002988 sqlite3VdbeAddOp3(v, OP_Copy, pIn->iSdst, regPrev+1, pIn->nSdst-1);
drhec86c722011-12-09 17:27:51 +00002989 sqlite3VdbeAddOp2(v, OP_Integer, 1, regPrev);
drh0acb7e42008-06-25 00:12:41 +00002990 }
danielk19771f9caa42008-07-02 16:10:45 +00002991 if( pParse->db->mallocFailed ) return 0;
drh0acb7e42008-06-25 00:12:41 +00002992
mistachkind5578432012-08-25 10:01:29 +00002993 /* Suppress the first OFFSET entries if there is an OFFSET clause
drh0acb7e42008-06-25 00:12:41 +00002994 */
drhaa9ce702014-01-22 18:07:04 +00002995 codeOffset(v, p->iOffset, iContinue);
drhb21e7c72008-06-22 12:37:57 +00002996
drhe2248cf2015-05-22 17:29:27 +00002997 assert( pDest->eDest!=SRT_Exists );
2998 assert( pDest->eDest!=SRT_Table );
drhb21e7c72008-06-22 12:37:57 +00002999 switch( pDest->eDest ){
3000 /* Store the result as data using a unique key.
3001 */
drhb21e7c72008-06-22 12:37:57 +00003002 case SRT_EphemTab: {
3003 int r1 = sqlite3GetTempReg(pParse);
3004 int r2 = sqlite3GetTempReg(pParse);
drh2b596da2012-07-23 21:43:19 +00003005 sqlite3VdbeAddOp3(v, OP_MakeRecord, pIn->iSdst, pIn->nSdst, r1);
3006 sqlite3VdbeAddOp2(v, OP_NewRowid, pDest->iSDParm, r2);
3007 sqlite3VdbeAddOp3(v, OP_Insert, pDest->iSDParm, r1, r2);
drhb21e7c72008-06-22 12:37:57 +00003008 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
3009 sqlite3ReleaseTempReg(pParse, r2);
3010 sqlite3ReleaseTempReg(pParse, r1);
3011 break;
3012 }
3013
3014#ifndef SQLITE_OMIT_SUBQUERY
drh14318072016-09-06 18:51:25 +00003015 /* If we are creating a set for an "expr IN (SELECT ...)".
drhb21e7c72008-06-22 12:37:57 +00003016 */
3017 case SRT_Set: {
drh6fccc352008-06-27 00:52:45 +00003018 int r1;
drh63cecc42016-09-06 19:08:21 +00003019 testcase( pIn->nSdst>1 );
drhb21e7c72008-06-22 12:37:57 +00003020 r1 = sqlite3GetTempReg(pParse);
dan71c57db2016-07-09 20:23:55 +00003021 sqlite3VdbeAddOp4(v, OP_MakeRecord, pIn->iSdst, pIn->nSdst,
drh14318072016-09-06 18:51:25 +00003022 r1, pDest->zAffSdst, pIn->nSdst);
drh9b4eaeb2016-11-09 00:10:33 +00003023 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, pDest->iSDParm, r1,
3024 pIn->iSdst, pIn->nSdst);
drhb21e7c72008-06-22 12:37:57 +00003025 sqlite3ReleaseTempReg(pParse, r1);
drhb21e7c72008-06-22 12:37:57 +00003026 break;
3027 }
3028
drhb21e7c72008-06-22 12:37:57 +00003029 /* If this is a scalar select that is part of an expression, then
3030 ** store the results in the appropriate memory cell and break out
drhcb99c572019-08-09 20:26:01 +00003031 ** of the scan loop. Note that the select might return multiple columns
3032 ** if it is the RHS of a row-value IN operator.
drhb21e7c72008-06-22 12:37:57 +00003033 */
3034 case SRT_Mem: {
drhcb99c572019-08-09 20:26:01 +00003035 if( pParse->nErr==0 ){
3036 testcase( pIn->nSdst>1 );
3037 sqlite3ExprCodeMove(pParse, pIn->iSdst, pDest->iSDParm, pIn->nSdst);
3038 }
drhb21e7c72008-06-22 12:37:57 +00003039 /* The LIMIT clause will jump out of the loop for us */
3040 break;
3041 }
3042#endif /* #ifndef SQLITE_OMIT_SUBQUERY */
3043
drh7d10d5a2008-08-20 16:35:10 +00003044 /* The results are stored in a sequence of registers
drh2b596da2012-07-23 21:43:19 +00003045 ** starting at pDest->iSdst. Then the co-routine yields.
drhb21e7c72008-06-22 12:37:57 +00003046 */
drh92b01d52008-06-24 00:32:35 +00003047 case SRT_Coroutine: {
drh2b596da2012-07-23 21:43:19 +00003048 if( pDest->iSdst==0 ){
3049 pDest->iSdst = sqlite3GetTempRange(pParse, pIn->nSdst);
3050 pDest->nSdst = pIn->nSdst;
drhb21e7c72008-06-22 12:37:57 +00003051 }
dan4b79bde2015-04-21 15:49:04 +00003052 sqlite3ExprCodeMove(pParse, pIn->iSdst, pDest->iSdst, pIn->nSdst);
drh2b596da2012-07-23 21:43:19 +00003053 sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm);
drh92b01d52008-06-24 00:32:35 +00003054 break;
3055 }
3056
drhccfcbce2009-05-18 15:46:07 +00003057 /* If none of the above, then the result destination must be
3058 ** SRT_Output. This routine is never called with any other
3059 ** destination other than the ones handled above or SRT_Output.
3060 **
3061 ** For SRT_Output, results are stored in a sequence of registers.
3062 ** Then the OP_ResultRow opcode is used to cause sqlite3_step() to
3063 ** return the next row of result.
drh7d10d5a2008-08-20 16:35:10 +00003064 */
drhccfcbce2009-05-18 15:46:07 +00003065 default: {
3066 assert( pDest->eDest==SRT_Output );
drh2b596da2012-07-23 21:43:19 +00003067 sqlite3VdbeAddOp2(v, OP_ResultRow, pIn->iSdst, pIn->nSdst);
drhb21e7c72008-06-22 12:37:57 +00003068 break;
3069 }
drhb21e7c72008-06-22 12:37:57 +00003070 }
drh92b01d52008-06-24 00:32:35 +00003071
3072 /* Jump to the end of the loop if the LIMIT is reached.
3073 */
3074 if( p->iLimit ){
drh16897072015-03-07 00:57:37 +00003075 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak); VdbeCoverage(v);
drh92b01d52008-06-24 00:32:35 +00003076 }
3077
drh92b01d52008-06-24 00:32:35 +00003078 /* Generate the subroutine return
3079 */
drh0acb7e42008-06-25 00:12:41 +00003080 sqlite3VdbeResolveLabel(v, iContinue);
drh92b01d52008-06-24 00:32:35 +00003081 sqlite3VdbeAddOp1(v, OP_Return, regReturn);
3082
3083 return addr;
drhb21e7c72008-06-22 12:37:57 +00003084}
3085
3086/*
3087** Alternative compound select code generator for cases when there
3088** is an ORDER BY clause.
3089**
3090** We assume a query of the following form:
3091**
3092** <selectA> <operator> <selectB> ORDER BY <orderbylist>
3093**
3094** <operator> is one of UNION ALL, UNION, EXCEPT, or INTERSECT. The idea
3095** is to code both <selectA> and <selectB> with the ORDER BY clause as
3096** co-routines. Then run the co-routines in parallel and merge the results
3097** into the output. In addition to the two coroutines (called selectA and
3098** selectB) there are 7 subroutines:
3099**
3100** outA: Move the output of the selectA coroutine into the output
3101** of the compound query.
3102**
3103** outB: Move the output of the selectB coroutine into the output
3104** of the compound query. (Only generated for UNION and
3105** UNION ALL. EXCEPT and INSERTSECT never output a row that
3106** appears only in B.)
3107**
3108** AltB: Called when there is data from both coroutines and A<B.
3109**
3110** AeqB: Called when there is data from both coroutines and A==B.
3111**
3112** AgtB: Called when there is data from both coroutines and A>B.
3113**
3114** EofA: Called when data is exhausted from selectA.
3115**
3116** EofB: Called when data is exhausted from selectB.
3117**
3118** The implementation of the latter five subroutines depend on which
3119** <operator> is used:
3120**
3121**
3122** UNION ALL UNION EXCEPT INTERSECT
3123** ------------- ----------------- -------------- -----------------
drh0acb7e42008-06-25 00:12:41 +00003124** AltB: outA, nextA outA, nextA outA, nextA nextA
drhb21e7c72008-06-22 12:37:57 +00003125**
drh0acb7e42008-06-25 00:12:41 +00003126** AeqB: outA, nextA nextA nextA outA, nextA
drhb21e7c72008-06-22 12:37:57 +00003127**
drh0acb7e42008-06-25 00:12:41 +00003128** AgtB: outB, nextB outB, nextB nextB nextB
drhb21e7c72008-06-22 12:37:57 +00003129**
drh0acb7e42008-06-25 00:12:41 +00003130** EofA: outB, nextB outB, nextB halt halt
drhb21e7c72008-06-22 12:37:57 +00003131**
drh0acb7e42008-06-25 00:12:41 +00003132** EofB: outA, nextA outA, nextA outA, nextA halt
3133**
3134** In the AltB, AeqB, and AgtB subroutines, an EOF on A following nextA
3135** causes an immediate jump to EofA and an EOF on B following nextB causes
3136** an immediate jump to EofB. Within EofA and EofB, and EOF on entry or
3137** following nextX causes a jump to the end of the select processing.
3138**
3139** Duplicate removal in the UNION, EXCEPT, and INTERSECT cases is handled
3140** within the output subroutine. The regPrev register set holds the previously
3141** output value. A comparison is made against this value and the output
3142** is skipped if the next results would be the same as the previous.
drhb21e7c72008-06-22 12:37:57 +00003143**
3144** The implementation plan is to implement the two coroutines and seven
3145** subroutines first, then put the control logic at the bottom. Like this:
3146**
3147** goto Init
3148** coA: coroutine for left query (A)
3149** coB: coroutine for right query (B)
3150** outA: output one row of A
3151** outB: output one row of B (UNION and UNION ALL only)
3152** EofA: ...
3153** EofB: ...
3154** AltB: ...
3155** AeqB: ...
3156** AgtB: ...
3157** Init: initialize coroutine registers
3158** yield coA
3159** if eof(A) goto EofA
3160** yield coB
3161** if eof(B) goto EofB
3162** Cmpr: Compare A, B
3163** Jump AltB, AeqB, AgtB
3164** End: ...
3165**
3166** We call AltB, AeqB, AgtB, EofA, and EofB "subroutines" but they are not
3167** actually called using Gosub and they do not Return. EofA and EofB loop
3168** until all data is exhausted then jump to the "end" labe. AltB, AeqB,
3169** and AgtB jump to either L2 or to one of EofA or EofB.
3170*/
danielk1977de3e41e2008-08-04 03:51:24 +00003171#ifndef SQLITE_OMIT_COMPOUND_SELECT
drhb21e7c72008-06-22 12:37:57 +00003172static int multiSelectOrderBy(
3173 Parse *pParse, /* Parsing context */
3174 Select *p, /* The right-most of SELECTs to be coded */
drha9671a22008-07-08 23:40:20 +00003175 SelectDest *pDest /* What to do with query results */
drhb21e7c72008-06-22 12:37:57 +00003176){
drh0acb7e42008-06-25 00:12:41 +00003177 int i, j; /* Loop counters */
drhb21e7c72008-06-22 12:37:57 +00003178 Select *pPrior; /* Another SELECT immediately to our left */
3179 Vdbe *v; /* Generate code to this VDBE */
drhb21e7c72008-06-22 12:37:57 +00003180 SelectDest destA; /* Destination for coroutine A */
3181 SelectDest destB; /* Destination for coroutine B */
drh92b01d52008-06-24 00:32:35 +00003182 int regAddrA; /* Address register for select-A coroutine */
drh92b01d52008-06-24 00:32:35 +00003183 int regAddrB; /* Address register for select-B coroutine */
drh92b01d52008-06-24 00:32:35 +00003184 int addrSelectA; /* Address of the select-A coroutine */
3185 int addrSelectB; /* Address of the select-B coroutine */
3186 int regOutA; /* Address register for the output-A subroutine */
3187 int regOutB; /* Address register for the output-B subroutine */
3188 int addrOutA; /* Address of the output-A subroutine */
drhb27b7f52008-12-10 18:03:45 +00003189 int addrOutB = 0; /* Address of the output-B subroutine */
drh92b01d52008-06-24 00:32:35 +00003190 int addrEofA; /* Address of the select-A-exhausted subroutine */
drh81cf13e2014-02-07 18:27:53 +00003191 int addrEofA_noB; /* Alternate addrEofA if B is uninitialized */
drh92b01d52008-06-24 00:32:35 +00003192 int addrEofB; /* Address of the select-B-exhausted subroutine */
3193 int addrAltB; /* Address of the A<B subroutine */
3194 int addrAeqB; /* Address of the A==B subroutine */
3195 int addrAgtB; /* Address of the A>B subroutine */
3196 int regLimitA; /* Limit register for select-A */
3197 int regLimitB; /* Limit register for select-A */
drh0acb7e42008-06-25 00:12:41 +00003198 int regPrev; /* A range of registers to hold previous output */
drh92b01d52008-06-24 00:32:35 +00003199 int savedLimit; /* Saved value of p->iLimit */
3200 int savedOffset; /* Saved value of p->iOffset */
3201 int labelCmpr; /* Label for the start of the merge algorithm */
3202 int labelEnd; /* Label for the end of the overall SELECT stmt */
drh728e0f92015-10-10 14:41:28 +00003203 int addr1; /* Jump instructions that get retargetted */
drh92b01d52008-06-24 00:32:35 +00003204 int op; /* One of TK_ALL, TK_UNION, TK_EXCEPT, TK_INTERSECT */
drh96067812008-09-23 09:36:10 +00003205 KeyInfo *pKeyDup = 0; /* Comparison information for duplicate removal */
drh0acb7e42008-06-25 00:12:41 +00003206 KeyInfo *pKeyMerge; /* Comparison information for merging rows */
3207 sqlite3 *db; /* Database connection */
3208 ExprList *pOrderBy; /* The ORDER BY clause */
3209 int nOrderBy; /* Number of terms in the ORDER BY clause */
drhabc38152020-07-22 13:38:04 +00003210 u32 *aPermute; /* Mapping from ORDER BY terms to result set columns */
drhb21e7c72008-06-22 12:37:57 +00003211
drh92b01d52008-06-24 00:32:35 +00003212 assert( p->pOrderBy!=0 );
drh96067812008-09-23 09:36:10 +00003213 assert( pKeyDup==0 ); /* "Managed" code needs this. Ticket #3382. */
drh0acb7e42008-06-25 00:12:41 +00003214 db = pParse->db;
drh92b01d52008-06-24 00:32:35 +00003215 v = pParse->pVdbe;
drhccfcbce2009-05-18 15:46:07 +00003216 assert( v!=0 ); /* Already thrown the error if VDBE alloc failed */
drhec4ccdb2018-12-29 02:26:59 +00003217 labelEnd = sqlite3VdbeMakeLabel(pParse);
3218 labelCmpr = sqlite3VdbeMakeLabel(pParse);
drh0acb7e42008-06-25 00:12:41 +00003219
drh92b01d52008-06-24 00:32:35 +00003220
3221 /* Patch up the ORDER BY clause
3222 */
3223 op = p->op;
drhb21e7c72008-06-22 12:37:57 +00003224 pPrior = p->pPrior;
drh92b01d52008-06-24 00:32:35 +00003225 assert( pPrior->pOrderBy==0 );
drh0acb7e42008-06-25 00:12:41 +00003226 pOrderBy = p->pOrderBy;
drh93a960a2008-07-10 00:32:42 +00003227 assert( pOrderBy );
drh93a960a2008-07-10 00:32:42 +00003228 nOrderBy = pOrderBy->nExpr;
3229
drh0acb7e42008-06-25 00:12:41 +00003230 /* For operators other than UNION ALL we have to make sure that
3231 ** the ORDER BY clause covers every term of the result set. Add
3232 ** terms to the ORDER BY clause as necessary.
3233 */
3234 if( op!=TK_ALL ){
3235 for(i=1; db->mallocFailed==0 && i<=p->pEList->nExpr; i++){
drh7d10d5a2008-08-20 16:35:10 +00003236 struct ExprList_item *pItem;
3237 for(j=0, pItem=pOrderBy->a; j<nOrderBy; j++, pItem++){
drhc2acc4e2013-11-15 18:15:19 +00003238 assert( pItem->u.x.iOrderByCol>0 );
3239 if( pItem->u.x.iOrderByCol==i ) break;
drh0acb7e42008-06-25 00:12:41 +00003240 }
3241 if( j==nOrderBy ){
drhb7916a72009-05-27 10:31:29 +00003242 Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0);
mistachkinfad30392016-02-13 23:43:46 +00003243 if( pNew==0 ) return SQLITE_NOMEM_BKPT;
drh0acb7e42008-06-25 00:12:41 +00003244 pNew->flags |= EP_IntValue;
drh33e619f2009-05-28 01:00:55 +00003245 pNew->u.iValue = i;
drh43606172017-04-05 11:32:13 +00003246 p->pOrderBy = pOrderBy = sqlite3ExprListAppend(pParse, pOrderBy, pNew);
drhc2acc4e2013-11-15 18:15:19 +00003247 if( pOrderBy ) pOrderBy->a[nOrderBy++].u.x.iOrderByCol = (u16)i;
drh0acb7e42008-06-25 00:12:41 +00003248 }
3249 }
3250 }
3251
3252 /* Compute the comparison permutation and keyinfo that is used with
drh10c081a2009-04-16 00:24:23 +00003253 ** the permutation used to determine if the next
drh0acb7e42008-06-25 00:12:41 +00003254 ** row of results comes from selectA or selectB. Also add explicit
3255 ** collations to the ORDER BY clause terms so that when the subqueries
3256 ** to the right and the left are evaluated, they use the correct
3257 ** collation.
3258 */
drhabc38152020-07-22 13:38:04 +00003259 aPermute = sqlite3DbMallocRawNN(db, sizeof(u32)*(nOrderBy + 1));
drh0acb7e42008-06-25 00:12:41 +00003260 if( aPermute ){
drh7d10d5a2008-08-20 16:35:10 +00003261 struct ExprList_item *pItem;
drhb1702022016-01-30 00:45:18 +00003262 aPermute[0] = nOrderBy;
3263 for(i=1, pItem=pOrderBy->a; i<=nOrderBy; i++, pItem++){
drh67366182015-04-16 14:33:35 +00003264 assert( pItem->u.x.iOrderByCol>0 );
drh2ec18a32015-06-23 23:31:52 +00003265 assert( pItem->u.x.iOrderByCol<=p->pEList->nExpr );
drhc2acc4e2013-11-15 18:15:19 +00003266 aPermute[i] = pItem->u.x.iOrderByCol - 1;
drh0acb7e42008-06-25 00:12:41 +00003267 }
dan53bed452014-01-24 20:37:18 +00003268 pKeyMerge = multiSelectOrderByKeyInfo(pParse, p, 1);
drh0acb7e42008-06-25 00:12:41 +00003269 }else{
3270 pKeyMerge = 0;
3271 }
3272
3273 /* Reattach the ORDER BY clause to the query.
3274 */
3275 p->pOrderBy = pOrderBy;
danielk19776ab3a2e2009-02-19 14:39:25 +00003276 pPrior->pOrderBy = sqlite3ExprListDup(pParse->db, pOrderBy, 0);
drh0acb7e42008-06-25 00:12:41 +00003277
3278 /* Allocate a range of temporary registers and the KeyInfo needed
3279 ** for the logic that removes duplicate result rows when the
3280 ** operator is UNION, EXCEPT, or INTERSECT (but not UNION ALL).
3281 */
3282 if( op==TK_ALL ){
3283 regPrev = 0;
3284 }else{
3285 int nExpr = p->pEList->nExpr;
drh1c0dc822008-10-30 22:13:23 +00003286 assert( nOrderBy>=nExpr || db->mallocFailed );
drhc8ac0d12013-02-16 02:41:01 +00003287 regPrev = pParse->nMem+1;
3288 pParse->nMem += nExpr+1;
drh0acb7e42008-06-25 00:12:41 +00003289 sqlite3VdbeAddOp2(v, OP_Integer, 0, regPrev);
drhad124322013-10-23 13:30:58 +00003290 pKeyDup = sqlite3KeyInfoAlloc(db, nExpr, 1);
drh0acb7e42008-06-25 00:12:41 +00003291 if( pKeyDup ){
drh2ec2fb22013-11-06 19:59:23 +00003292 assert( sqlite3KeyInfoIsWriteable(pKeyDup) );
drh0acb7e42008-06-25 00:12:41 +00003293 for(i=0; i<nExpr; i++){
3294 pKeyDup->aColl[i] = multiSelectCollSeq(pParse, p, i);
dan6e118922019-08-12 16:36:38 +00003295 pKeyDup->aSortFlags[i] = 0;
drh0acb7e42008-06-25 00:12:41 +00003296 }
3297 }
3298 }
drh92b01d52008-06-24 00:32:35 +00003299
3300 /* Separate the left and the right query from one another
3301 */
3302 p->pPrior = 0;
drhd227a292014-02-09 18:02:09 +00003303 pPrior->pNext = 0;
drh7d10d5a2008-08-20 16:35:10 +00003304 sqlite3ResolveOrderGroupBy(pParse, p, p->pOrderBy, "ORDER");
drh0acb7e42008-06-25 00:12:41 +00003305 if( pPrior->pPrior==0 ){
drh7d10d5a2008-08-20 16:35:10 +00003306 sqlite3ResolveOrderGroupBy(pParse, pPrior, pPrior->pOrderBy, "ORDER");
drh0acb7e42008-06-25 00:12:41 +00003307 }
3308
drh92b01d52008-06-24 00:32:35 +00003309 /* Compute the limit registers */
3310 computeLimitRegisters(pParse, p, labelEnd);
drh0acb7e42008-06-25 00:12:41 +00003311 if( p->iLimit && op==TK_ALL ){
drh92b01d52008-06-24 00:32:35 +00003312 regLimitA = ++pParse->nMem;
3313 regLimitB = ++pParse->nMem;
3314 sqlite3VdbeAddOp2(v, OP_Copy, p->iOffset ? p->iOffset+1 : p->iLimit,
3315 regLimitA);
3316 sqlite3VdbeAddOp2(v, OP_Copy, regLimitA, regLimitB);
3317 }else{
3318 regLimitA = regLimitB = 0;
3319 }
drh633e6d52008-07-28 19:34:53 +00003320 sqlite3ExprDelete(db, p->pLimit);
drh0acb7e42008-06-25 00:12:41 +00003321 p->pLimit = 0;
drh92b01d52008-06-24 00:32:35 +00003322
drhb21e7c72008-06-22 12:37:57 +00003323 regAddrA = ++pParse->nMem;
drhb21e7c72008-06-22 12:37:57 +00003324 regAddrB = ++pParse->nMem;
drhb21e7c72008-06-22 12:37:57 +00003325 regOutA = ++pParse->nMem;
3326 regOutB = ++pParse->nMem;
3327 sqlite3SelectDestInit(&destA, SRT_Coroutine, regAddrA);
3328 sqlite3SelectDestInit(&destB, SRT_Coroutine, regAddrB);
drhe2ca99c2018-05-02 00:33:43 +00003329
drhc631ded2018-05-02 02:22:22 +00003330 ExplainQueryPlan((pParse, 1, "MERGE (%s)", selectOpName(p->op)));
drhb21e7c72008-06-22 12:37:57 +00003331
drh92b01d52008-06-24 00:32:35 +00003332 /* Generate a coroutine to evaluate the SELECT statement to the
drh0acb7e42008-06-25 00:12:41 +00003333 ** left of the compound operator - the "A" select.
3334 */
drhed71a832014-02-07 19:18:10 +00003335 addrSelectA = sqlite3VdbeCurrentAddr(v) + 1;
drh728e0f92015-10-10 14:41:28 +00003336 addr1 = sqlite3VdbeAddOp3(v, OP_InitCoroutine, regAddrA, 0, addrSelectA);
drhed71a832014-02-07 19:18:10 +00003337 VdbeComment((v, "left SELECT"));
drh92b01d52008-06-24 00:32:35 +00003338 pPrior->iLimit = regLimitA;
drhc631ded2018-05-02 02:22:22 +00003339 ExplainQueryPlan((pParse, 1, "LEFT"));
drh7d10d5a2008-08-20 16:35:10 +00003340 sqlite3Select(pParse, pPrior, &destA);
drh2fade2f2016-02-09 02:12:20 +00003341 sqlite3VdbeEndCoroutine(v, regAddrA);
drh728e0f92015-10-10 14:41:28 +00003342 sqlite3VdbeJumpHere(v, addr1);
drhb21e7c72008-06-22 12:37:57 +00003343
drh92b01d52008-06-24 00:32:35 +00003344 /* Generate a coroutine to evaluate the SELECT statement on
3345 ** the right - the "B" select
3346 */
drhed71a832014-02-07 19:18:10 +00003347 addrSelectB = sqlite3VdbeCurrentAddr(v) + 1;
drh728e0f92015-10-10 14:41:28 +00003348 addr1 = sqlite3VdbeAddOp3(v, OP_InitCoroutine, regAddrB, 0, addrSelectB);
drhed71a832014-02-07 19:18:10 +00003349 VdbeComment((v, "right SELECT"));
drh92b01d52008-06-24 00:32:35 +00003350 savedLimit = p->iLimit;
3351 savedOffset = p->iOffset;
3352 p->iLimit = regLimitB;
3353 p->iOffset = 0;
drhc631ded2018-05-02 02:22:22 +00003354 ExplainQueryPlan((pParse, 1, "RIGHT"));
drh7d10d5a2008-08-20 16:35:10 +00003355 sqlite3Select(pParse, p, &destB);
drh92b01d52008-06-24 00:32:35 +00003356 p->iLimit = savedLimit;
3357 p->iOffset = savedOffset;
drh2fade2f2016-02-09 02:12:20 +00003358 sqlite3VdbeEndCoroutine(v, regAddrB);
drhb21e7c72008-06-22 12:37:57 +00003359
drh92b01d52008-06-24 00:32:35 +00003360 /* Generate a subroutine that outputs the current row of the A
drh0acb7e42008-06-25 00:12:41 +00003361 ** select as the next output row of the compound select.
drh92b01d52008-06-24 00:32:35 +00003362 */
drhb21e7c72008-06-22 12:37:57 +00003363 VdbeNoopComment((v, "Output routine for A"));
drh0acb7e42008-06-25 00:12:41 +00003364 addrOutA = generateOutputSubroutine(pParse,
3365 p, &destA, pDest, regOutA,
drh2ec2fb22013-11-06 19:59:23 +00003366 regPrev, pKeyDup, labelEnd);
drhb21e7c72008-06-22 12:37:57 +00003367
drh92b01d52008-06-24 00:32:35 +00003368 /* Generate a subroutine that outputs the current row of the B
drh0acb7e42008-06-25 00:12:41 +00003369 ** select as the next output row of the compound select.
drh92b01d52008-06-24 00:32:35 +00003370 */
drh0acb7e42008-06-25 00:12:41 +00003371 if( op==TK_ALL || op==TK_UNION ){
3372 VdbeNoopComment((v, "Output routine for B"));
3373 addrOutB = generateOutputSubroutine(pParse,
3374 p, &destB, pDest, regOutB,
drh2ec2fb22013-11-06 19:59:23 +00003375 regPrev, pKeyDup, labelEnd);
drh0acb7e42008-06-25 00:12:41 +00003376 }
drh2ec2fb22013-11-06 19:59:23 +00003377 sqlite3KeyInfoUnref(pKeyDup);
drhb21e7c72008-06-22 12:37:57 +00003378
drh92b01d52008-06-24 00:32:35 +00003379 /* Generate a subroutine to run when the results from select A
3380 ** are exhausted and only data in select B remains.
3381 */
drhb21e7c72008-06-22 12:37:57 +00003382 if( op==TK_EXCEPT || op==TK_INTERSECT ){
drh81cf13e2014-02-07 18:27:53 +00003383 addrEofA_noB = addrEofA = labelEnd;
drhb21e7c72008-06-22 12:37:57 +00003384 }else{
drh81cf13e2014-02-07 18:27:53 +00003385 VdbeNoopComment((v, "eof-A subroutine"));
3386 addrEofA = sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB);
3387 addrEofA_noB = sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, labelEnd);
drh688852a2014-02-17 22:40:43 +00003388 VdbeCoverage(v);
drh076e85f2015-09-03 13:46:12 +00003389 sqlite3VdbeGoto(v, addrEofA);
drhc3489bb2016-02-25 16:04:59 +00003390 p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow);
drhb21e7c72008-06-22 12:37:57 +00003391 }
3392
drh92b01d52008-06-24 00:32:35 +00003393 /* Generate a subroutine to run when the results from select B
3394 ** are exhausted and only data in select A remains.
3395 */
drhb21e7c72008-06-22 12:37:57 +00003396 if( op==TK_INTERSECT ){
drh92b01d52008-06-24 00:32:35 +00003397 addrEofB = addrEofA;
drh95aa47b2010-11-16 02:49:15 +00003398 if( p->nSelectRow > pPrior->nSelectRow ) p->nSelectRow = pPrior->nSelectRow;
drhb21e7c72008-06-22 12:37:57 +00003399 }else{
drh92b01d52008-06-24 00:32:35 +00003400 VdbeNoopComment((v, "eof-B subroutine"));
drh81cf13e2014-02-07 18:27:53 +00003401 addrEofB = sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA);
drh688852a2014-02-17 22:40:43 +00003402 sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, labelEnd); VdbeCoverage(v);
drh076e85f2015-09-03 13:46:12 +00003403 sqlite3VdbeGoto(v, addrEofB);
drhb21e7c72008-06-22 12:37:57 +00003404 }
3405
drh92b01d52008-06-24 00:32:35 +00003406 /* Generate code to handle the case of A<B
3407 */
drhb21e7c72008-06-22 12:37:57 +00003408 VdbeNoopComment((v, "A-lt-B subroutine"));
drh0acb7e42008-06-25 00:12:41 +00003409 addrAltB = sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA);
drh688852a2014-02-17 22:40:43 +00003410 sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, addrEofA); VdbeCoverage(v);
drh076e85f2015-09-03 13:46:12 +00003411 sqlite3VdbeGoto(v, labelCmpr);
drhb21e7c72008-06-22 12:37:57 +00003412
drh92b01d52008-06-24 00:32:35 +00003413 /* Generate code to handle the case of A==B
3414 */
drhb21e7c72008-06-22 12:37:57 +00003415 if( op==TK_ALL ){
3416 addrAeqB = addrAltB;
drh0acb7e42008-06-25 00:12:41 +00003417 }else if( op==TK_INTERSECT ){
3418 addrAeqB = addrAltB;
3419 addrAltB++;
drh92b01d52008-06-24 00:32:35 +00003420 }else{
drhb21e7c72008-06-22 12:37:57 +00003421 VdbeNoopComment((v, "A-eq-B subroutine"));
drh0acb7e42008-06-25 00:12:41 +00003422 addrAeqB =
drh688852a2014-02-17 22:40:43 +00003423 sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, addrEofA); VdbeCoverage(v);
drh076e85f2015-09-03 13:46:12 +00003424 sqlite3VdbeGoto(v, labelCmpr);
drhb21e7c72008-06-22 12:37:57 +00003425 }
3426
drh92b01d52008-06-24 00:32:35 +00003427 /* Generate code to handle the case of A>B
3428 */
drhb21e7c72008-06-22 12:37:57 +00003429 VdbeNoopComment((v, "A-gt-B subroutine"));
3430 addrAgtB = sqlite3VdbeCurrentAddr(v);
3431 if( op==TK_ALL || op==TK_UNION ){
3432 sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB);
3433 }
drh688852a2014-02-17 22:40:43 +00003434 sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, addrEofB); VdbeCoverage(v);
drh076e85f2015-09-03 13:46:12 +00003435 sqlite3VdbeGoto(v, labelCmpr);
drhb21e7c72008-06-22 12:37:57 +00003436
drh92b01d52008-06-24 00:32:35 +00003437 /* This code runs once to initialize everything.
3438 */
drh728e0f92015-10-10 14:41:28 +00003439 sqlite3VdbeJumpHere(v, addr1);
drh688852a2014-02-17 22:40:43 +00003440 sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, addrEofA_noB); VdbeCoverage(v);
3441 sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, addrEofB); VdbeCoverage(v);
drh92b01d52008-06-24 00:32:35 +00003442
3443 /* Implement the main merge loop
3444 */
3445 sqlite3VdbeResolveLabel(v, labelCmpr);
drh0acb7e42008-06-25 00:12:41 +00003446 sqlite3VdbeAddOp4(v, OP_Permutation, 0, 0, 0, (char*)aPermute, P4_INTARRAY);
drh2b596da2012-07-23 21:43:19 +00003447 sqlite3VdbeAddOp4(v, OP_Compare, destA.iSdst, destB.iSdst, nOrderBy,
drh2ec2fb22013-11-06 19:59:23 +00003448 (char*)pKeyMerge, P4_KEYINFO);
drh953f7612012-12-07 22:18:54 +00003449 sqlite3VdbeChangeP5(v, OPFLAG_PERMUTE);
drh688852a2014-02-17 22:40:43 +00003450 sqlite3VdbeAddOp3(v, OP_Jump, addrAltB, addrAeqB, addrAgtB); VdbeCoverage(v);
drh92b01d52008-06-24 00:32:35 +00003451
3452 /* Jump to the this point in order to terminate the query.
3453 */
drhb21e7c72008-06-22 12:37:57 +00003454 sqlite3VdbeResolveLabel(v, labelEnd);
drh92b01d52008-06-24 00:32:35 +00003455
drh0acb7e42008-06-25 00:12:41 +00003456 /* Reassembly the compound query so that it will be freed correctly
3457 ** by the calling function */
danielk19775e7ad502008-07-01 17:39:27 +00003458 if( p->pPrior ){
drh633e6d52008-07-28 19:34:53 +00003459 sqlite3SelectDelete(db, p->pPrior);
danielk19775e7ad502008-07-01 17:39:27 +00003460 }
drh0acb7e42008-06-25 00:12:41 +00003461 p->pPrior = pPrior;
drhd227a292014-02-09 18:02:09 +00003462 pPrior->pNext = p;
drh92b01d52008-06-24 00:32:35 +00003463
drh92b01d52008-06-24 00:32:35 +00003464 /*** TBD: Insert subroutine calls to close cursors on incomplete
3465 **** subqueries ****/
drhe2ca99c2018-05-02 00:33:43 +00003466 ExplainQueryPlanPop(pParse);
drh3dc4cc62015-04-15 07:10:25 +00003467 return pParse->nErr!=0;
drhb21e7c72008-06-22 12:37:57 +00003468}
danielk1977de3e41e2008-08-04 03:51:24 +00003469#endif
drhb21e7c72008-06-22 12:37:57 +00003470
shane3514b6f2008-07-22 05:00:55 +00003471#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
drh46967de2017-04-14 12:39:37 +00003472
3473/* An instance of the SubstContext object describes an substitution edit
3474** to be performed on a parse tree.
3475**
3476** All references to columns in table iTable are to be replaced by corresponding
3477** expressions in pEList.
3478*/
3479typedef struct SubstContext {
3480 Parse *pParse; /* The parsing context */
3481 int iTable; /* Replace references to this table */
drh31d6fd52017-04-14 19:03:10 +00003482 int iNewTable; /* New table number */
3483 int isLeftJoin; /* Add TK_IF_NULL_ROW opcodes on each replacement */
drh46967de2017-04-14 12:39:37 +00003484 ExprList *pEList; /* Replacement expressions */
3485} SubstContext;
3486
drh17435752007-08-16 04:30:38 +00003487/* Forward Declarations */
drh46967de2017-04-14 12:39:37 +00003488static void substExprList(SubstContext*, ExprList*);
3489static void substSelect(SubstContext*, Select*, int);
drh17435752007-08-16 04:30:38 +00003490
drh22827922000-06-06 17:27:05 +00003491/*
drh832508b2002-03-02 17:04:07 +00003492** Scan through the expression pExpr. Replace every reference to
drh6a3ea0e2003-05-02 14:32:12 +00003493** a column in table number iTable with a copy of the iColumn-th
drh84e59202002-03-14 14:33:31 +00003494** entry in pEList. (But leave references to the ROWID column
drh6a3ea0e2003-05-02 14:32:12 +00003495** unchanged.)
drh832508b2002-03-02 17:04:07 +00003496**
3497** This routine is part of the flattening procedure. A subquery
3498** whose result set is defined by pEList appears as entry in the
3499** FROM clause of a SELECT such that the VDBE cursor assigned to that
drhaca19e12017-04-07 19:41:31 +00003500** FORM clause entry is iTable. This routine makes the necessary
drh832508b2002-03-02 17:04:07 +00003501** changes to pExpr so that it refers directly to the source table
3502** of the subquery rather the result set of the subquery.
3503*/
drhb7916a72009-05-27 10:31:29 +00003504static Expr *substExpr(
drh46967de2017-04-14 12:39:37 +00003505 SubstContext *pSubst, /* Description of the substitution */
3506 Expr *pExpr /* Expr in which substitution occurs */
drh17435752007-08-16 04:30:38 +00003507){
drhb7916a72009-05-27 10:31:29 +00003508 if( pExpr==0 ) return 0;
drh3d240d22017-09-28 16:56:55 +00003509 if( ExprHasProperty(pExpr, EP_FromJoin)
3510 && pExpr->iRightJoinTable==pSubst->iTable
3511 ){
drh399c7e22017-04-14 17:18:45 +00003512 pExpr->iRightJoinTable = pSubst->iNewTable;
3513 }
drh2e52a9c2020-04-04 00:15:54 +00003514 if( pExpr->op==TK_COLUMN
3515 && pExpr->iTable==pSubst->iTable
3516 && !ExprHasProperty(pExpr, EP_FixedCol)
3517 ){
drh50350a12004-02-13 16:22:22 +00003518 if( pExpr->iColumn<0 ){
3519 pExpr->op = TK_NULL;
3520 }else{
3521 Expr *pNew;
drh46967de2017-04-14 12:39:37 +00003522 Expr *pCopy = pSubst->pEList->a[pExpr->iColumn].pExpr;
drh31d6fd52017-04-14 19:03:10 +00003523 Expr ifNullRow;
drh46967de2017-04-14 12:39:37 +00003524 assert( pSubst->pEList!=0 && pExpr->iColumn<pSubst->pEList->nExpr );
drh1fd4e7b2018-07-28 14:56:56 +00003525 assert( pExpr->pRight==0 );
dan44c56042016-12-07 15:38:37 +00003526 if( sqlite3ExprIsVector(pCopy) ){
drh46967de2017-04-14 12:39:37 +00003527 sqlite3VectorErrorMsg(pSubst->pParse, pCopy);
dan44c56042016-12-07 15:38:37 +00003528 }else{
drh46967de2017-04-14 12:39:37 +00003529 sqlite3 *db = pSubst->pParse->db;
drh31d6fd52017-04-14 19:03:10 +00003530 if( pSubst->isLeftJoin && pCopy->op!=TK_COLUMN ){
3531 memset(&ifNullRow, 0, sizeof(ifNullRow));
3532 ifNullRow.op = TK_IF_NULL_ROW;
3533 ifNullRow.pLeft = pCopy;
3534 ifNullRow.iTable = pSubst->iNewTable;
drh46fe1382020-08-19 23:32:06 +00003535 ifNullRow.flags = EP_IfNullRow;
drh31d6fd52017-04-14 19:03:10 +00003536 pCopy = &ifNullRow;
3537 }
drh11df7d22018-12-06 19:15:36 +00003538 testcase( ExprHasProperty(pCopy, EP_Subquery) );
dan44c56042016-12-07 15:38:37 +00003539 pNew = sqlite3ExprDup(db, pCopy, 0);
danbd11a2a2017-06-20 17:43:26 +00003540 if( pNew && pSubst->isLeftJoin ){
3541 ExprSetProperty(pNew, EP_CanBeNull);
3542 }
3543 if( pNew && ExprHasProperty(pExpr,EP_FromJoin) ){
drhaf371152020-09-30 15:36:03 +00003544 sqlite3SetJoinExpr(pNew, pExpr->iRightJoinTable);
dan44c56042016-12-07 15:38:37 +00003545 }
3546 sqlite3ExprDelete(db, pExpr);
3547 pExpr = pNew;
dane0866392019-09-09 19:49:42 +00003548
danfa508342019-09-10 15:33:52 +00003549 /* Ensure that the expression now has an implicit collation sequence,
3550 ** just as it did when it was a column of a view or sub-query. */
3551 if( pExpr ){
dane0866392019-09-09 19:49:42 +00003552 if( pExpr->op!=TK_COLUMN && pExpr->op!=TK_COLLATE ){
3553 CollSeq *pColl = sqlite3ExprCollSeq(pSubst->pParse, pExpr);
3554 pExpr = sqlite3ExprAddCollateString(pSubst->pParse, pExpr,
3555 (pColl ? pColl->zName : "BINARY")
3556 );
3557 }
3558 ExprClearProperty(pExpr, EP_Collate);
3559 }
dan92ddb3b2016-12-01 19:38:05 +00003560 }
drh50350a12004-02-13 16:22:22 +00003561 }
drh832508b2002-03-02 17:04:07 +00003562 }else{
drh7c1544e2017-05-23 12:44:57 +00003563 if( pExpr->op==TK_IF_NULL_ROW && pExpr->iTable==pSubst->iTable ){
3564 pExpr->iTable = pSubst->iNewTable;
3565 }
drh46967de2017-04-14 12:39:37 +00003566 pExpr->pLeft = substExpr(pSubst, pExpr->pLeft);
3567 pExpr->pRight = substExpr(pSubst, pExpr->pRight);
danielk19776ab3a2e2009-02-19 14:39:25 +00003568 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
drh46967de2017-04-14 12:39:37 +00003569 substSelect(pSubst, pExpr->x.pSelect, 1);
danielk19776ab3a2e2009-02-19 14:39:25 +00003570 }else{
drh46967de2017-04-14 12:39:37 +00003571 substExprList(pSubst, pExpr->x.pList);
danielk19776ab3a2e2009-02-19 14:39:25 +00003572 }
dan3703edf2019-10-10 15:17:09 +00003573#ifndef SQLITE_OMIT_WINDOWFUNC
3574 if( ExprHasProperty(pExpr, EP_WinFunc) ){
3575 Window *pWin = pExpr->y.pWin;
3576 pWin->pFilter = substExpr(pSubst, pWin->pFilter);
3577 substExprList(pSubst, pWin->pPartition);
3578 substExprList(pSubst, pWin->pOrderBy);
3579 }
3580#endif
drh832508b2002-03-02 17:04:07 +00003581 }
drhb7916a72009-05-27 10:31:29 +00003582 return pExpr;
drh832508b2002-03-02 17:04:07 +00003583}
drh17435752007-08-16 04:30:38 +00003584static void substExprList(
drh46967de2017-04-14 12:39:37 +00003585 SubstContext *pSubst, /* Description of the substitution */
3586 ExprList *pList /* List to scan and in which to make substitutes */
drh17435752007-08-16 04:30:38 +00003587){
drh832508b2002-03-02 17:04:07 +00003588 int i;
3589 if( pList==0 ) return;
3590 for(i=0; i<pList->nExpr; i++){
drh46967de2017-04-14 12:39:37 +00003591 pList->a[i].pExpr = substExpr(pSubst, pList->a[i].pExpr);
drh832508b2002-03-02 17:04:07 +00003592 }
3593}
drh17435752007-08-16 04:30:38 +00003594static void substSelect(
drh46967de2017-04-14 12:39:37 +00003595 SubstContext *pSubst, /* Description of the substitution */
3596 Select *p, /* SELECT statement in which to make substitutions */
3597 int doPrior /* Do substitutes on p->pPrior too */
drh17435752007-08-16 04:30:38 +00003598){
drh588a9a12008-09-01 15:52:10 +00003599 SrcList *pSrc;
drh76012942021-02-21 21:04:54 +00003600 SrcItem *pItem;
drh588a9a12008-09-01 15:52:10 +00003601 int i;
danielk1977b3bce662005-01-29 08:32:43 +00003602 if( !p ) return;
drhd12b6362015-10-11 19:46:59 +00003603 do{
drh46967de2017-04-14 12:39:37 +00003604 substExprList(pSubst, p->pEList);
3605 substExprList(pSubst, p->pGroupBy);
3606 substExprList(pSubst, p->pOrderBy);
3607 p->pHaving = substExpr(pSubst, p->pHaving);
3608 p->pWhere = substExpr(pSubst, p->pWhere);
drhd12b6362015-10-11 19:46:59 +00003609 pSrc = p->pSrc;
drh29064902015-10-11 20:08:31 +00003610 assert( pSrc!=0 );
drh588a9a12008-09-01 15:52:10 +00003611 for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){
drh46967de2017-04-14 12:39:37 +00003612 substSelect(pSubst, pItem->pSelect, 1);
drh29064902015-10-11 20:08:31 +00003613 if( pItem->fg.isTabFunc ){
drh46967de2017-04-14 12:39:37 +00003614 substExprList(pSubst, pItem->u1.pFuncArg);
drhd12b6362015-10-11 19:46:59 +00003615 }
drh588a9a12008-09-01 15:52:10 +00003616 }
drhd12b6362015-10-11 19:46:59 +00003617 }while( doPrior && (p = p->pPrior)!=0 );
danielk1977b3bce662005-01-29 08:32:43 +00003618}
shane3514b6f2008-07-22 05:00:55 +00003619#endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
drh832508b2002-03-02 17:04:07 +00003620
shane3514b6f2008-07-22 05:00:55 +00003621#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
drh832508b2002-03-02 17:04:07 +00003622/*
drh2aee5142020-03-21 00:05:53 +00003623** pSelect is a SELECT statement and pSrcItem is one item in the FROM
3624** clause of that SELECT.
3625**
3626** This routine scans the entire SELECT statement and recomputes the
3627** pSrcItem->colUsed mask.
3628*/
3629static int recomputeColumnsUsedExpr(Walker *pWalker, Expr *pExpr){
drh76012942021-02-21 21:04:54 +00003630 SrcItem *pItem;
drh2aee5142020-03-21 00:05:53 +00003631 if( pExpr->op!=TK_COLUMN ) return WRC_Continue;
3632 pItem = pWalker->u.pSrcItem;
3633 if( pItem->iCursor!=pExpr->iTable ) return WRC_Continue;
drh74a07982020-03-21 23:10:38 +00003634 if( pExpr->iColumn<0 ) return WRC_Continue;
3635 pItem->colUsed |= sqlite3ExprColUsed(pExpr);
drh2aee5142020-03-21 00:05:53 +00003636 return WRC_Continue;
3637}
3638static void recomputeColumnsUsed(
3639 Select *pSelect, /* The complete SELECT statement */
drh76012942021-02-21 21:04:54 +00003640 SrcItem *pSrcItem /* Which FROM clause item to recompute */
drh2aee5142020-03-21 00:05:53 +00003641){
3642 Walker w;
3643 if( NEVER(pSrcItem->pTab==0) ) return;
3644 memset(&w, 0, sizeof(w));
3645 w.xExprCallback = recomputeColumnsUsedExpr;
3646 w.xSelectCallback = sqlite3SelectWalkNoop;
3647 w.u.pSrcItem = pSrcItem;
3648 pSrcItem->colUsed = 0;
3649 sqlite3WalkSelect(&w, pSelect);
3650}
3651#endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
3652
3653#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
3654/*
dan964fa262020-12-18 16:13:39 +00003655** Assign new cursor numbers to each of the items in pSrc. For each
3656** new cursor number assigned, set an entry in the aCsrMap[] array
3657** to map the old cursor number to the new:
3658**
3659** aCsrMap[iOld] = iNew;
3660**
3661** The array is guaranteed by the caller to be large enough for all
3662** existing cursor numbers in pSrc.
3663**
3664** If pSrc contains any sub-selects, call this routine recursively
3665** on the FROM clause of each such sub-select, with iExcept set to -1.
3666*/
3667static void srclistRenumberCursors(
3668 Parse *pParse, /* Parse context */
3669 int *aCsrMap, /* Array to store cursor mappings in */
3670 SrcList *pSrc, /* FROM clause to renumber */
3671 int iExcept /* FROM clause item to skip */
3672){
3673 int i;
drh76012942021-02-21 21:04:54 +00003674 SrcItem *pItem;
dan964fa262020-12-18 16:13:39 +00003675 for(i=0, pItem=pSrc->a; i<pSrc->nSrc; i++, pItem++){
3676 if( i!=iExcept ){
dand131b512020-12-18 18:04:44 +00003677 Select *p;
3678 pItem->iCursor = aCsrMap[pItem->iCursor] = pParse->nTab++;
3679 for(p=pItem->pSelect; p; p=p->pPrior){
3680 srclistRenumberCursors(pParse, aCsrMap, p->pSrc, -1);
dan964fa262020-12-18 16:13:39 +00003681 }
3682 }
3683 }
3684}
3685
3686/*
3687** Expression walker callback used by renumberCursors() to update
3688** Expr objects to match newly assigned cursor numbers.
3689*/
3690static int renumberCursorsCb(Walker *pWalker, Expr *pExpr){
3691 int *aCsrMap = pWalker->u.aiCol;
dane8f14902021-02-13 14:26:25 +00003692 int op = pExpr->op;
3693 if( (op==TK_COLUMN || op==TK_IF_NULL_ROW) && aCsrMap[pExpr->iTable] ){
dan964fa262020-12-18 16:13:39 +00003694 pExpr->iTable = aCsrMap[pExpr->iTable];
3695 }
dan961a7262020-12-21 19:50:10 +00003696 if( ExprHasProperty(pExpr, EP_FromJoin) && aCsrMap[pExpr->iRightJoinTable] ){
3697 pExpr->iRightJoinTable = aCsrMap[pExpr->iRightJoinTable];
3698 }
dan964fa262020-12-18 16:13:39 +00003699 return WRC_Continue;
3700}
3701
3702/*
3703** Assign a new cursor number to each cursor in the FROM clause (Select.pSrc)
3704** of the SELECT statement passed as the second argument, and to each
3705** cursor in the FROM clause of any FROM clause sub-selects, recursively.
3706** Except, do not assign a new cursor number to the iExcept'th element in
3707** the FROM clause of (*p). Update all expressions and other references
3708** to refer to the new cursor numbers.
3709**
3710** Argument aCsrMap is an array that may be used for temporary working
3711** space. Two guarantees are made by the caller:
3712**
3713** * the array is larger than the largest cursor number used within the
3714** select statement passed as an argument, and
3715**
3716** * the array entries for all cursor numbers that do *not* appear in
3717** FROM clauses of the select statement as described above are
3718** initialized to zero.
3719*/
3720static void renumberCursors(
3721 Parse *pParse, /* Parse context */
3722 Select *p, /* Select to renumber cursors within */
3723 int iExcept, /* FROM clause item to skip */
3724 int *aCsrMap /* Working space */
3725){
3726 Walker w;
3727 srclistRenumberCursors(pParse, aCsrMap, p->pSrc, iExcept);
3728 memset(&w, 0, sizeof(w));
3729 w.u.aiCol = aCsrMap;
3730 w.xExprCallback = renumberCursorsCb;
3731 w.xSelectCallback = sqlite3SelectWalkNoop;
3732 sqlite3WalkSelect(&w, p);
3733}
3734#endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
3735
3736#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
3737/*
drh630d2962011-12-11 21:51:04 +00003738** This routine attempts to flatten subqueries as a performance optimization.
3739** This routine returns 1 if it makes changes and 0 if no flattening occurs.
drh1350b032002-02-27 19:00:20 +00003740**
3741** To understand the concept of flattening, consider the following
3742** query:
3743**
3744** SELECT a FROM (SELECT x+y AS a FROM t1 WHERE z<100) WHERE a>5
3745**
3746** The default way of implementing this query is to execute the
3747** subquery first and store the results in a temporary table, then
3748** run the outer query on that temporary table. This requires two
3749** passes over the data. Furthermore, because the temporary table
3750** has no indices, the WHERE clause on the outer query cannot be
drh832508b2002-03-02 17:04:07 +00003751** optimized.
drh1350b032002-02-27 19:00:20 +00003752**
drh832508b2002-03-02 17:04:07 +00003753** This routine attempts to rewrite queries such as the above into
drh1350b032002-02-27 19:00:20 +00003754** a single flat select, like this:
3755**
3756** SELECT x+y AS a FROM t1 WHERE z<100 AND a>5
3757**
peter.d.reid60ec9142014-09-06 16:39:46 +00003758** The code generated for this simplification gives the same result
drh832508b2002-03-02 17:04:07 +00003759** but only has to scan the data once. And because indices might
3760** exist on the table t1, a complete scan of the data might be
3761** avoided.
drh1350b032002-02-27 19:00:20 +00003762**
drhd981e822017-09-29 16:07:56 +00003763** Flattening is subject to the following constraints:
drh1350b032002-02-27 19:00:20 +00003764**
drh25c221e2017-09-29 22:13:24 +00003765** (**) We no longer attempt to flatten aggregate subqueries. Was:
3766** The subquery and the outer query cannot both be aggregates.
drh1350b032002-02-27 19:00:20 +00003767**
drh25c221e2017-09-29 22:13:24 +00003768** (**) We no longer attempt to flatten aggregate subqueries. Was:
3769** (2) If the subquery is an aggregate then
drhd981e822017-09-29 16:07:56 +00003770** (2a) the outer query must not be a join and
3771** (2b) the outer query must not use subqueries
3772** other than the one FROM-clause subquery that is a candidate
3773** for flattening. (This is due to ticket [2f7170d73bf9abf80]
3774** from 2015-02-09.)
drh832508b2002-03-02 17:04:07 +00003775**
drhd981e822017-09-29 16:07:56 +00003776** (3) If the subquery is the right operand of a LEFT JOIN then
3777** (3a) the subquery may not be a join and
3778** (3b) the FROM clause of the subquery may not contain a virtual
3779** table and
3780** (3c) the outer query may not be an aggregate.
drh396afe62019-12-18 20:51:58 +00003781** (3d) the outer query may not be DISTINCT.
drh832508b2002-03-02 17:04:07 +00003782**
drhd981e822017-09-29 16:07:56 +00003783** (4) The subquery can not be DISTINCT.
drh832508b2002-03-02 17:04:07 +00003784**
dan49ad3302010-08-13 16:38:48 +00003785** (**) At one point restrictions (4) and (5) defined a subset of DISTINCT
3786** sub-queries that were excluded from this optimization. Restriction
3787** (4) has since been expanded to exclude all DISTINCT subqueries.
drh832508b2002-03-02 17:04:07 +00003788**
drh25c221e2017-09-29 22:13:24 +00003789** (**) We no longer attempt to flatten aggregate subqueries. Was:
3790** If the subquery is aggregate, the outer query may not be DISTINCT.
drh832508b2002-03-02 17:04:07 +00003791**
drhd981e822017-09-29 16:07:56 +00003792** (7) The subquery must have a FROM clause. TODO: For subqueries without
drh31d6fd52017-04-14 19:03:10 +00003793** A FROM clause, consider adding a FROM clause with the special
drh630d2962011-12-11 21:51:04 +00003794** table sqlite_once that consists of a single row containing a
3795** single NULL.
drh08192d52002-04-30 19:20:28 +00003796**
drhd981e822017-09-29 16:07:56 +00003797** (8) If the subquery uses LIMIT then the outer query may not be a join.
drhdf199a22002-06-14 22:38:41 +00003798**
drhd981e822017-09-29 16:07:56 +00003799** (9) If the subquery uses LIMIT then the outer query may not be aggregate.
drhdf199a22002-06-14 22:38:41 +00003800**
drh6092d2b2014-09-15 11:14:50 +00003801** (**) Restriction (10) was removed from the code on 2005-02-05 but we
3802** accidently carried the comment forward until 2014-09-15. Original
drhd981e822017-09-29 16:07:56 +00003803** constraint: "If the subquery is aggregate then the outer query
3804** may not use LIMIT."
drhdf199a22002-06-14 22:38:41 +00003805**
drhd981e822017-09-29 16:07:56 +00003806** (11) The subquery and the outer query may not both have ORDER BY clauses.
drh174b6192002-12-03 02:22:52 +00003807**
drh7b688ed2009-12-22 00:29:53 +00003808** (**) Not implemented. Subsumed into restriction (3). Was previously
drh2b300d52008-08-14 00:19:48 +00003809** a separate restriction deriving from ticket #350.
drh3fc673e2003-06-16 00:40:34 +00003810**
drhd981e822017-09-29 16:07:56 +00003811** (13) The subquery and outer query may not both use LIMIT.
drhac839632006-01-21 22:19:54 +00003812**
drhd981e822017-09-29 16:07:56 +00003813** (14) The subquery may not use OFFSET.
drhac839632006-01-21 22:19:54 +00003814**
drhd981e822017-09-29 16:07:56 +00003815** (15) If the outer query is part of a compound select, then the
3816** subquery may not use LIMIT.
drhf3913272010-04-15 23:24:29 +00003817** (See ticket #2339 and ticket [02a8e81d44]).
drhad91c6c2007-05-06 20:04:24 +00003818**
drhd981e822017-09-29 16:07:56 +00003819** (16) If the outer query is aggregate, then the subquery may not
3820** use ORDER BY. (Ticket #2942) This used to not matter
drhc52e3552008-02-15 14:33:03 +00003821** until we introduced the group_concat() function.
3822**
drhd981e822017-09-29 16:07:56 +00003823** (17) If the subquery is a compound select, then
3824** (17a) all compound operators must be a UNION ALL, and
3825** (17b) no terms within the subquery compound may be aggregate
drhe76acc62017-10-04 02:30:45 +00003826** or DISTINCT, and
drhd981e822017-09-29 16:07:56 +00003827** (17c) every term within the subquery compound must have a FROM clause
3828** (17d) the outer query may not be
3829** (17d1) aggregate, or
dan8daf5ae2020-12-17 16:48:04 +00003830** (17d2) DISTINCT
3831** (17e) the subquery may not contain window functions, and
3832** (17f) the subquery must not be the RHS of a LEFT JOIN.
danielk1977f23329a2008-07-01 14:09:13 +00003833**
danielk19774914cf92008-07-01 18:26:49 +00003834** The parent and sub-query may contain WHERE clauses. Subject to
3835** rules (11), (13) and (14), they may also contain ORDER BY,
drh630d2962011-12-11 21:51:04 +00003836** LIMIT and OFFSET clauses. The subquery cannot use any compound
3837** operator other than UNION ALL because all the other compound
3838** operators have an implied DISTINCT which is disallowed by
3839** restriction (4).
danielk1977f23329a2008-07-01 14:09:13 +00003840**
dan67c70142012-08-28 14:45:50 +00003841** Also, each component of the sub-query must return the same number
3842** of result columns. This is actually a requirement for any compound
3843** SELECT statement, but all the code here does is make sure that no
3844** such (illegal) sub-query is flattened. The caller will detect the
3845** syntax error and return a detailed message.
3846**
danielk197749fc1f62008-07-08 17:43:56 +00003847** (18) If the sub-query is a compound select, then all terms of the
dan9353bea2020-12-17 17:17:12 +00003848** ORDER BY clause of the parent must be copies of a term returned
3849** by the parent query.
danielk197749fc1f62008-07-08 17:43:56 +00003850**
drhd981e822017-09-29 16:07:56 +00003851** (19) If the subquery uses LIMIT then the outer query may not
drh229cf702008-08-26 12:56:14 +00003852** have a WHERE clause.
3853**
drhfca23552017-10-28 20:51:54 +00003854** (20) If the sub-query is a compound select, then it must not use
3855** an ORDER BY clause. Ticket #3773. We could relax this constraint
3856** somewhat by saying that the terms of the ORDER BY clause must
3857** appear as unmodified result columns in the outer query. But we
3858** have other optimizations in mind to deal with that case.
drhe8902a72009-04-02 16:59:47 +00003859**
drhd981e822017-09-29 16:07:56 +00003860** (21) If the subquery uses LIMIT then the outer query may not be
shaneha91491e2011-02-11 20:52:20 +00003861** DISTINCT. (See ticket [752e1646fc]).
3862**
drhd981e822017-09-29 16:07:56 +00003863** (22) The subquery may not be a recursive CTE.
dan8290c2a2014-01-16 10:58:39 +00003864**
dan8daf5ae2020-12-17 16:48:04 +00003865** (23) If the outer query is a recursive CTE, then the sub-query may not be
3866** a compound query. This restriction is because transforming the
dan8290c2a2014-01-16 10:58:39 +00003867** parent to a compound query confuses the code that handles
3868** recursive queries in multiSelect().
3869**
drh508e2d02017-09-30 01:25:04 +00003870** (**) We no longer attempt to flatten aggregate subqueries. Was:
3871** The subquery may not be an aggregate that uses the built-in min() or
drh9588ad92014-09-15 14:46:02 +00003872** or max() functions. (Without this restriction, a query like:
3873** "SELECT x FROM (SELECT max(y), x FROM t1)" would not necessarily
3874** return the value X for which Y was maximal.)
3875**
dan9a947222018-06-14 19:06:36 +00003876** (25) If either the subquery or the parent query contains a window
3877** function in the select list or ORDER BY clause, flattening
3878** is not attempted.
3879**
dan8290c2a2014-01-16 10:58:39 +00003880**
drh832508b2002-03-02 17:04:07 +00003881** In this routine, the "p" parameter is a pointer to the outer query.
3882** The subquery is p->pSrc->a[iFrom]. isAgg is true if the outer query
drh25c221e2017-09-29 22:13:24 +00003883** uses aggregates.
drh832508b2002-03-02 17:04:07 +00003884**
drh665de472003-03-31 13:36:09 +00003885** If flattening is not attempted, this routine is a no-op and returns 0.
drh832508b2002-03-02 17:04:07 +00003886** If flattening is attempted this routine returns 1.
3887**
3888** All of the expression analysis must occur on both the outer query and
3889** the subquery before this routine runs.
drh1350b032002-02-27 19:00:20 +00003890*/
drh8c74a8c2002-08-25 19:20:40 +00003891static int flattenSubquery(
danielk1977524cc212008-07-02 13:13:51 +00003892 Parse *pParse, /* Parsing context */
drh8c74a8c2002-08-25 19:20:40 +00003893 Select *p, /* The parent or outer SELECT statement */
3894 int iFrom, /* Index in p->pSrc->a[] of the inner subquery */
drh25c221e2017-09-29 22:13:24 +00003895 int isAgg /* True if outer SELECT uses aggregate functions */
drh8c74a8c2002-08-25 19:20:40 +00003896){
danielk1977524cc212008-07-02 13:13:51 +00003897 const char *zSavedAuthContext = pParse->zAuthContext;
drhd12b6362015-10-11 19:46:59 +00003898 Select *pParent; /* Current UNION ALL term of the other query */
drh0bb28102002-05-08 11:54:14 +00003899 Select *pSub; /* The inner query or "subquery" */
danielk1977f23329a2008-07-01 14:09:13 +00003900 Select *pSub1; /* Pointer to the rightmost select in sub-query */
drhad3cab52002-05-24 02:04:32 +00003901 SrcList *pSrc; /* The FROM clause of the outer query */
3902 SrcList *pSubSrc; /* The FROM clause of the subquery */
drh6a3ea0e2003-05-02 14:32:12 +00003903 int iParent; /* VDBE cursor number of the pSub result set temp table */
drh399c7e22017-04-14 17:18:45 +00003904 int iNewParent = -1;/* Replacement table for iParent */
3905 int isLeftJoin = 0; /* True if pSub is the right side of a LEFT JOIN */
drh91bb0ee2004-09-01 03:06:34 +00003906 int i; /* Loop counter */
3907 Expr *pWhere; /* The WHERE clause */
drh76012942021-02-21 21:04:54 +00003908 SrcItem *pSubitem; /* The subquery */
danielk1977524cc212008-07-02 13:13:51 +00003909 sqlite3 *db = pParse->db;
drh89636622020-06-07 17:33:18 +00003910 Walker w; /* Walker to persist agginfo data */
dan964fa262020-12-18 16:13:39 +00003911 int *aCsrMap = 0;
drh1350b032002-02-27 19:00:20 +00003912
drh832508b2002-03-02 17:04:07 +00003913 /* Check to see if flattening is permitted. Return 0 if not.
3914 */
drha78c22c2008-11-11 18:28:58 +00003915 assert( p!=0 );
drhd981e822017-09-29 16:07:56 +00003916 assert( p->pPrior==0 );
drh7e5418e2012-09-27 15:05:54 +00003917 if( OptimizationDisabled(db, SQLITE_QueryFlattener) ) return 0;
drh832508b2002-03-02 17:04:07 +00003918 pSrc = p->pSrc;
drhad3cab52002-05-24 02:04:32 +00003919 assert( pSrc && iFrom>=0 && iFrom<pSrc->nSrc );
drh91bb0ee2004-09-01 03:06:34 +00003920 pSubitem = &pSrc->a[iFrom];
danielk197749fc1f62008-07-08 17:43:56 +00003921 iParent = pSubitem->iCursor;
drh91bb0ee2004-09-01 03:06:34 +00003922 pSub = pSubitem->pSelect;
drh832508b2002-03-02 17:04:07 +00003923 assert( pSub!=0 );
drh399c7e22017-04-14 17:18:45 +00003924
dan67a9b8e2018-06-22 20:51:35 +00003925#ifndef SQLITE_OMIT_WINDOWFUNC
dan9a947222018-06-14 19:06:36 +00003926 if( p->pWin || pSub->pWin ) return 0; /* Restriction (25) */
dan67a9b8e2018-06-22 20:51:35 +00003927#endif
dan86fb6e12018-05-16 20:58:07 +00003928
drh832508b2002-03-02 17:04:07 +00003929 pSubSrc = pSub->pSrc;
3930 assert( pSubSrc );
drhac839632006-01-21 22:19:54 +00003931 /* Prior to version 3.1.2, when LIMIT and OFFSET had to be simple constants,
peter.d.reid60ec9142014-09-06 16:39:46 +00003932 ** not arbitrary expressions, we allowed some combining of LIMIT and OFFSET
drhac839632006-01-21 22:19:54 +00003933 ** because they could be computed at compile-time. But when LIMIT and OFFSET
3934 ** became arbitrary expressions, we were forced to add restrictions (13)
3935 ** and (14). */
3936 if( pSub->pLimit && p->pLimit ) return 0; /* Restriction (13) */
drh8c0833f2017-11-14 23:48:23 +00003937 if( pSub->pLimit && pSub->pLimit->pRight ) return 0; /* Restriction (14) */
drhd227a292014-02-09 18:02:09 +00003938 if( (p->selFlags & SF_Compound)!=0 && pSub->pLimit ){
drhad91c6c2007-05-06 20:04:24 +00003939 return 0; /* Restriction (15) */
3940 }
drhac839632006-01-21 22:19:54 +00003941 if( pSubSrc->nSrc==0 ) return 0; /* Restriction (7) */
drhd981e822017-09-29 16:07:56 +00003942 if( pSub->selFlags & SF_Distinct ) return 0; /* Restriction (4) */
dan49ad3302010-08-13 16:38:48 +00003943 if( pSub->pLimit && (pSrc->nSrc>1 || isAgg) ){
3944 return 0; /* Restrictions (8)(9) */
drhdf199a22002-06-14 22:38:41 +00003945 }
drh7d10d5a2008-08-20 16:35:10 +00003946 if( p->pOrderBy && pSub->pOrderBy ){
drhac839632006-01-21 22:19:54 +00003947 return 0; /* Restriction (11) */
3948 }
drhc52e3552008-02-15 14:33:03 +00003949 if( isAgg && pSub->pOrderBy ) return 0; /* Restriction (16) */
drh229cf702008-08-26 12:56:14 +00003950 if( pSub->pLimit && p->pWhere ) return 0; /* Restriction (19) */
shaneha91491e2011-02-11 20:52:20 +00003951 if( pSub->pLimit && (p->selFlags & SF_Distinct)!=0 ){
3952 return 0; /* Restriction (21) */
3953 }
drh508e2d02017-09-30 01:25:04 +00003954 if( pSub->selFlags & (SF_Recursive) ){
3955 return 0; /* Restrictions (22) */
drh9588ad92014-09-15 14:46:02 +00003956 }
drh832508b2002-03-02 17:04:07 +00003957
drh399c7e22017-04-14 17:18:45 +00003958 /*
3959 ** If the subquery is the right operand of a LEFT JOIN, then the
drhd981e822017-09-29 16:07:56 +00003960 ** subquery may not be a join itself (3a). Example of why this is not
3961 ** allowed:
drh8af4d3a2003-05-06 20:35:16 +00003962 **
3963 ** t1 LEFT OUTER JOIN (t2 JOIN t3)
3964 **
3965 ** If we flatten the above, we would get
3966 **
3967 ** (t1 LEFT OUTER JOIN t2) JOIN t3
3968 **
3969 ** which is not at all the same thing.
drh2b300d52008-08-14 00:19:48 +00003970 **
drh3c790f22017-05-23 15:33:41 +00003971 ** If the subquery is the right operand of a LEFT JOIN, then the outer
drhd981e822017-09-29 16:07:56 +00003972 ** query cannot be an aggregate. (3c) This is an artifact of the way
3973 ** aggregates are processed - there is no mechanism to determine if
3974 ** the LEFT JOIN table should be all-NULL.
drh3c790f22017-05-23 15:33:41 +00003975 **
drh31d6fd52017-04-14 19:03:10 +00003976 ** See also tickets #306, #350, and #3300.
drh3fc673e2003-06-16 00:40:34 +00003977 */
drh8a48b9c2015-08-19 15:20:00 +00003978 if( (pSubitem->fg.jointype & JT_OUTER)!=0 ){
drh399c7e22017-04-14 17:18:45 +00003979 isLeftJoin = 1;
drh396afe62019-12-18 20:51:58 +00003980 if( pSubSrc->nSrc>1 /* (3a) */
3981 || isAgg /* (3b) */
3982 || IsVirtual(pSubSrc->a[0].pTab) /* (3c) */
3983 || (p->selFlags & SF_Distinct)!=0 /* (3d) */
3984 ){
drhd981e822017-09-29 16:07:56 +00003985 return 0;
drh399c7e22017-04-14 17:18:45 +00003986 }
drh3fc673e2003-06-16 00:40:34 +00003987 }
drhdc6de472017-05-25 11:39:50 +00003988#ifdef SQLITE_EXTRA_IFNULLROW
3989 else if( iFrom>0 && !isAgg ){
3990 /* Setting isLeftJoin to -1 causes OP_IfNullRow opcodes to be generated for
drh3d240d22017-09-28 16:56:55 +00003991 ** every reference to any result column from subquery in a join, even
3992 ** though they are not necessary. This will stress-test the OP_IfNullRow
3993 ** opcode. */
drhdc6de472017-05-25 11:39:50 +00003994 isLeftJoin = -1;
3995 }
3996#endif
drh3fc673e2003-06-16 00:40:34 +00003997
drhd981e822017-09-29 16:07:56 +00003998 /* Restriction (17): If the sub-query is a compound SELECT, then it must
danielk1977f23329a2008-07-01 14:09:13 +00003999 ** use only the UNION ALL operator. And none of the simple select queries
4000 ** that make up the compound SELECT are allowed to be aggregate or distinct
4001 ** queries.
4002 */
4003 if( pSub->pPrior ){
drhfca23552017-10-28 20:51:54 +00004004 if( pSub->pOrderBy ){
4005 return 0; /* Restriction (20) */
4006 }
dande9ed622020-12-16 20:00:46 +00004007 if( isAgg || (p->selFlags & SF_Distinct)!=0 || isLeftJoin>0 ){
dan8daf5ae2020-12-17 16:48:04 +00004008 return 0; /* (17d1), (17d2), or (17f) */
danielk1977f23329a2008-07-01 14:09:13 +00004009 }
4010 for(pSub1=pSub; pSub1; pSub1=pSub1->pPrior){
drhccfcbce2009-05-18 15:46:07 +00004011 testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct );
4012 testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate );
drh4b3ac732011-12-10 23:18:32 +00004013 assert( pSub->pSrc!=0 );
dan8daf5ae2020-12-17 16:48:04 +00004014 assert( (pSub->selFlags & SF_Recursive)==0 );
drh2ec18a32015-06-23 23:31:52 +00004015 assert( pSub->pEList->nExpr==pSub1->pEList->nExpr );
drhd981e822017-09-29 16:07:56 +00004016 if( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))!=0 /* (17b) */
4017 || (pSub1->pPrior && pSub1->op!=TK_ALL) /* (17a) */
4018 || pSub1->pSrc->nSrc<1 /* (17c) */
drhef9f7192020-01-17 19:14:08 +00004019#ifndef SQLITE_OMIT_WINDOWFUNC
drh8d95ed72019-12-30 20:42:17 +00004020 || pSub1->pWin /* (17e) */
drhef9f7192020-01-17 19:14:08 +00004021#endif
danielk197780b3c542008-07-10 17:59:12 +00004022 ){
danielk1977f23329a2008-07-01 14:09:13 +00004023 return 0;
4024 }
drh4b3ac732011-12-10 23:18:32 +00004025 testcase( pSub1->pSrc->nSrc>1 );
danielk1977f23329a2008-07-01 14:09:13 +00004026 }
danielk197749fc1f62008-07-08 17:43:56 +00004027
drhd981e822017-09-29 16:07:56 +00004028 /* Restriction (18). */
danielk197749fc1f62008-07-08 17:43:56 +00004029 if( p->pOrderBy ){
4030 int ii;
4031 for(ii=0; ii<p->pOrderBy->nExpr; ii++){
drhc2acc4e2013-11-15 18:15:19 +00004032 if( p->pOrderBy->a[ii].u.x.iOrderByCol==0 ) return 0;
danielk197749fc1f62008-07-08 17:43:56 +00004033 }
4034 }
danielk1977f23329a2008-07-01 14:09:13 +00004035
dande9ed622020-12-16 20:00:46 +00004036 /* Restriction (23) */
4037 if( (p->selFlags & SF_Recursive) ) return 0;
dan964fa262020-12-18 16:13:39 +00004038
4039 if( pSrc->nSrc>1 ){
4040 aCsrMap = sqlite3DbMallocZero(db, pParse->nTab*sizeof(int));
4041 }
dande9ed622020-12-16 20:00:46 +00004042 }
drhcdb2f602017-10-04 05:59:54 +00004043
drh7d10d5a2008-08-20 16:35:10 +00004044 /***** If we reach this point, flattening is permitted. *****/
drhfef37762018-07-10 19:48:35 +00004045 SELECTTRACE(1,pParse,p,("flatten %u.%p from term %d\n",
4046 pSub->selId, pSub, iFrom));
drh7d10d5a2008-08-20 16:35:10 +00004047
4048 /* Authorize the subquery */
danielk1977524cc212008-07-02 13:13:51 +00004049 pParse->zAuthContext = pSubitem->zName;
drha2acb0d2012-04-11 23:22:37 +00004050 TESTONLY(i =) sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0);
4051 testcase( i==SQLITE_DENY );
danielk1977524cc212008-07-02 13:13:51 +00004052 pParse->zAuthContext = zSavedAuthContext;
4053
dande9ed622020-12-16 20:00:46 +00004054 /* Delete the transient structures associated with thesubquery */
4055 pSub1 = pSubitem->pSelect;
4056 sqlite3DbFree(db, pSubitem->zDatabase);
4057 sqlite3DbFree(db, pSubitem->zName);
4058 sqlite3DbFree(db, pSubitem->zAlias);
4059 pSubitem->zDatabase = 0;
4060 pSubitem->zName = 0;
4061 pSubitem->zAlias = 0;
4062 pSubitem->pSelect = 0;
4063 assert( pSubitem->pOn==0 );
4064
drh7d10d5a2008-08-20 16:35:10 +00004065 /* If the sub-query is a compound SELECT statement, then (by restrictions
4066 ** 17 and 18 above) it must be a UNION ALL and the parent query must
4067 ** be of the form:
danielk1977f23329a2008-07-01 14:09:13 +00004068 **
4069 ** SELECT <expr-list> FROM (<sub-query>) <where-clause>
4070 **
4071 ** followed by any ORDER BY, LIMIT and/or OFFSET clauses. This block
drha78c22c2008-11-11 18:28:58 +00004072 ** creates N-1 copies of the parent query without any ORDER BY, LIMIT or
danielk1977f23329a2008-07-01 14:09:13 +00004073 ** OFFSET clauses and joins them to the left-hand-side of the original
4074 ** using UNION ALL operators. In this case N is the number of simple
4075 ** select statements in the compound sub-query.
drha78c22c2008-11-11 18:28:58 +00004076 **
4077 ** Example:
4078 **
4079 ** SELECT a+1 FROM (
4080 ** SELECT x FROM tab
4081 ** UNION ALL
4082 ** SELECT y FROM tab
4083 ** UNION ALL
4084 ** SELECT abs(z*2) FROM tab2
4085 ** ) WHERE a!=5 ORDER BY 1
4086 **
4087 ** Transformed into:
4088 **
4089 ** SELECT x+1 FROM tab WHERE x+1!=5
4090 ** UNION ALL
4091 ** SELECT y+1 FROM tab WHERE y+1!=5
4092 ** UNION ALL
4093 ** SELECT abs(z*2)+1 FROM tab2 WHERE abs(z*2)+1!=5
4094 ** ORDER BY 1
4095 **
4096 ** We call this the "compound-subquery flattening".
danielk1977f23329a2008-07-01 14:09:13 +00004097 */
4098 for(pSub=pSub->pPrior; pSub; pSub=pSub->pPrior){
4099 Select *pNew;
4100 ExprList *pOrderBy = p->pOrderBy;
danielk19774b86ef12008-07-01 14:39:35 +00004101 Expr *pLimit = p->pLimit;
danielk1977f23329a2008-07-01 14:09:13 +00004102 Select *pPrior = p->pPrior;
dande9ed622020-12-16 20:00:46 +00004103 Table *pItemTab = pSubitem->pTab;
4104 pSubitem->pTab = 0;
danielk1977f23329a2008-07-01 14:09:13 +00004105 p->pOrderBy = 0;
danielk1977f23329a2008-07-01 14:09:13 +00004106 p->pPrior = 0;
danielk19774b86ef12008-07-01 14:39:35 +00004107 p->pLimit = 0;
danielk19776ab3a2e2009-02-19 14:39:25 +00004108 pNew = sqlite3SelectDup(db, p, 0);
danielk19774b86ef12008-07-01 14:39:35 +00004109 p->pLimit = pLimit;
drha78c22c2008-11-11 18:28:58 +00004110 p->pOrderBy = pOrderBy;
drha78c22c2008-11-11 18:28:58 +00004111 p->op = TK_ALL;
dande9ed622020-12-16 20:00:46 +00004112 pSubitem->pTab = pItemTab;
drha78c22c2008-11-11 18:28:58 +00004113 if( pNew==0 ){
drhd227a292014-02-09 18:02:09 +00004114 p->pPrior = pPrior;
drha78c22c2008-11-11 18:28:58 +00004115 }else{
dan964fa262020-12-18 16:13:39 +00004116 if( aCsrMap && db->mallocFailed==0 ){
4117 renumberCursors(pParse, pNew, iFrom, aCsrMap);
4118 }
drha78c22c2008-11-11 18:28:58 +00004119 pNew->pPrior = pPrior;
drhd227a292014-02-09 18:02:09 +00004120 if( pPrior ) pPrior->pNext = pNew;
4121 pNew->pNext = p;
4122 p->pPrior = pNew;
drhe2243d22018-04-23 17:18:03 +00004123 SELECTTRACE(2,pParse,p,("compound-subquery flattener"
drhfef37762018-07-10 19:48:35 +00004124 " creates %u as peer\n",pNew->selId));
drha78c22c2008-11-11 18:28:58 +00004125 }
dande9ed622020-12-16 20:00:46 +00004126 assert( pSubitem->pSelect==0 );
dan964fa262020-12-18 16:13:39 +00004127 }
4128 sqlite3DbFree(db, aCsrMap);
4129 if( db->mallocFailed ){
4130 pSubitem->pSelect = pSub1;
4131 return 1;
danielk1977f23329a2008-07-01 14:09:13 +00004132 }
4133
drha78c22c2008-11-11 18:28:58 +00004134 /* Defer deleting the Table object associated with the
4135 ** subquery until code generation is
4136 ** complete, since there may still exist Expr.pTab entries that
4137 ** refer to the subquery even after flattening. Ticket #3346.
drhccfcbce2009-05-18 15:46:07 +00004138 **
4139 ** pSubitem->pTab is always non-NULL by test restrictions and tests above.
drha78c22c2008-11-11 18:28:58 +00004140 */
drhccfcbce2009-05-18 15:46:07 +00004141 if( ALWAYS(pSubitem->pTab!=0) ){
drha78c22c2008-11-11 18:28:58 +00004142 Table *pTabToDel = pSubitem->pTab;
drh79df7782016-12-14 14:07:35 +00004143 if( pTabToDel->nTabRef==1 ){
dan65a7cd12009-09-01 12:16:01 +00004144 Parse *pToplevel = sqlite3ParseToplevel(pParse);
drhcf3c0782021-01-11 20:37:02 +00004145 sqlite3ParserAddCleanup(pToplevel,
4146 (void(*)(sqlite3*,void*))sqlite3DeleteTable,
4147 pTabToDel);
drh21d4f5b2021-01-12 15:30:01 +00004148 testcase( pToplevel->earlyCleanup );
drha78c22c2008-11-11 18:28:58 +00004149 }else{
drh79df7782016-12-14 14:07:35 +00004150 pTabToDel->nTabRef--;
drha78c22c2008-11-11 18:28:58 +00004151 }
4152 pSubitem->pTab = 0;
4153 }
4154
4155 /* The following loop runs once for each term in a compound-subquery
4156 ** flattening (as described above). If we are doing a different kind
4157 ** of flattening - a flattening other than a compound-subquery flattening -
4158 ** then this loop only runs once.
4159 **
4160 ** This loop moves all of the FROM elements of the subquery into the
4161 ** the FROM clause of the outer query. Before doing this, remember
4162 ** the cursor number for the original outer query FROM element in
4163 ** iParent. The iParent cursor will never be used. Subsequent code
4164 ** will scan expressions looking for iParent references and replace
4165 ** those references with expressions that resolve to the subquery FROM
4166 ** elements we are now copying in.
4167 */
dande9ed622020-12-16 20:00:46 +00004168 pSub = pSub1;
danielk1977f23329a2008-07-01 14:09:13 +00004169 for(pParent=p; pParent; pParent=pParent->pPrior, pSub=pSub->pPrior){
drha78c22c2008-11-11 18:28:58 +00004170 int nSubSrc;
drhea678832008-12-10 19:26:22 +00004171 u8 jointype = 0;
drh55f66b32019-07-16 19:44:32 +00004172 assert( pSub!=0 );
drha78c22c2008-11-11 18:28:58 +00004173 pSubSrc = pSub->pSrc; /* FROM clause of subquery */
4174 nSubSrc = pSubSrc->nSrc; /* Number of terms in subquery FROM clause */
4175 pSrc = pParent->pSrc; /* FROM clause of the outer query */
drhc31c2eb2003-05-02 16:04:17 +00004176
dande9ed622020-12-16 20:00:46 +00004177 if( pParent==p ){
4178 jointype = pSubitem->fg.jointype; /* First time through the loop */
drha78c22c2008-11-11 18:28:58 +00004179 }
dande9ed622020-12-16 20:00:46 +00004180
drha78c22c2008-11-11 18:28:58 +00004181 /* The subquery uses a single slot of the FROM clause of the outer
4182 ** query. If the subquery has more than one element in its FROM clause,
4183 ** then expand the outer query to make space for it to hold all elements
4184 ** of the subquery.
4185 **
4186 ** Example:
4187 **
4188 ** SELECT * FROM tabA, (SELECT * FROM sub1, sub2), tabB;
4189 **
4190 ** The outer query has 3 slots in its FROM clause. One slot of the
4191 ** outer query (the middle slot) is used by the subquery. The next
drhd12b6362015-10-11 19:46:59 +00004192 ** block of code will expand the outer query FROM clause to 4 slots.
4193 ** The middle slot is expanded to two slots in order to make space
4194 ** for the two elements in the FROM clause of the subquery.
drha78c22c2008-11-11 18:28:58 +00004195 */
4196 if( nSubSrc>1 ){
drh29c992c2019-01-17 15:40:41 +00004197 pSrc = sqlite3SrcListEnlarge(pParse, pSrc, nSubSrc-1,iFrom+1);
4198 if( pSrc==0 ) break;
4199 pParent->pSrc = pSrc;
drhc31c2eb2003-05-02 16:04:17 +00004200 }
drha78c22c2008-11-11 18:28:58 +00004201
4202 /* Transfer the FROM clause terms from the subquery into the
4203 ** outer query.
4204 */
drhc31c2eb2003-05-02 16:04:17 +00004205 for(i=0; i<nSubSrc; i++){
drhc3a84022009-06-12 03:27:26 +00004206 sqlite3IdListDelete(db, pSrc->a[i+iFrom].pUsing);
drh20292312015-11-21 13:24:46 +00004207 assert( pSrc->a[i+iFrom].fg.isTabFunc==0 );
drhc31c2eb2003-05-02 16:04:17 +00004208 pSrc->a[i+iFrom] = pSubSrc->a[i];
drh399c7e22017-04-14 17:18:45 +00004209 iNewParent = pSubSrc->a[i].iCursor;
drhc31c2eb2003-05-02 16:04:17 +00004210 memset(&pSubSrc->a[i], 0, sizeof(pSubSrc->a[i]));
4211 }
drh8a48b9c2015-08-19 15:20:00 +00004212 pSrc->a[iFrom].fg.jointype = jointype;
danielk1977f23329a2008-07-01 14:09:13 +00004213
4214 /* Now begin substituting subquery result set expressions for
4215 ** references to the iParent in the outer query.
4216 **
4217 ** Example:
4218 **
4219 ** SELECT a+5, b*10 FROM (SELECT x*3 AS a, y+10 AS b FROM t1) WHERE a>b;
4220 ** \ \_____________ subquery __________/ /
4221 ** \_____________________ outer query ______________________________/
4222 **
4223 ** We look at every expression in the outer query and every place we see
4224 ** "a" we substitute "x*3" and every place we see "b" we substitute "y+10".
4225 */
drhb7cbf5c2020-06-15 13:51:34 +00004226 if( pSub->pOrderBy && (pParent->selFlags & SF_NoopOrderBy)==0 ){
dan7c0a4722014-09-20 20:38:48 +00004227 /* At this point, any non-zero iOrderByCol values indicate that the
4228 ** ORDER BY column expression is identical to the iOrderByCol'th
4229 ** expression returned by SELECT statement pSub. Since these values
4230 ** do not necessarily correspond to columns in SELECT statement pParent,
4231 ** zero them before transfering the ORDER BY clause.
4232 **
4233 ** Not doing this may cause an error if a subsequent call to this
4234 ** function attempts to flatten a compound sub-query into pParent
4235 ** (the only way this can happen is if the compound sub-query is
4236 ** currently part of pSub->pSrc). See ticket [d11a6e908f]. */
4237 ExprList *pOrderBy = pSub->pOrderBy;
4238 for(i=0; i<pOrderBy->nExpr; i++){
4239 pOrderBy->a[i].u.x.iOrderByCol = 0;
4240 }
danielk1977f23329a2008-07-01 14:09:13 +00004241 assert( pParent->pOrderBy==0 );
dan7c0a4722014-09-20 20:38:48 +00004242 pParent->pOrderBy = pOrderBy;
danielk1977f23329a2008-07-01 14:09:13 +00004243 pSub->pOrderBy = 0;
danielk1977f23329a2008-07-01 14:09:13 +00004244 }
drh11df7d22018-12-06 19:15:36 +00004245 pWhere = pSub->pWhere;
4246 pSub->pWhere = 0;
drhdc6de472017-05-25 11:39:50 +00004247 if( isLeftJoin>0 ){
drh8103a032019-11-15 00:52:13 +00004248 sqlite3SetJoinExpr(pWhere, iNewParent);
drh399c7e22017-04-14 17:18:45 +00004249 }
dancd653a32020-06-13 21:24:40 +00004250 if( pWhere ){
4251 if( pParent->pWhere ){
4252 pParent->pWhere = sqlite3PExpr(pParse, TK_AND, pWhere, pParent->pWhere);
4253 }else{
4254 pParent->pWhere = pWhere;
4255 }
4256 }
danc3becdd2017-03-13 14:30:40 +00004257 if( db->mallocFailed==0 ){
drh46967de2017-04-14 12:39:37 +00004258 SubstContext x;
4259 x.pParse = pParse;
4260 x.iTable = iParent;
drh399c7e22017-04-14 17:18:45 +00004261 x.iNewTable = iNewParent;
drh31d6fd52017-04-14 19:03:10 +00004262 x.isLeftJoin = isLeftJoin;
drh46967de2017-04-14 12:39:37 +00004263 x.pEList = pSub->pEList;
4264 substSelect(&x, pParent, 0);
danc3becdd2017-03-13 14:30:40 +00004265 }
danielk1977f23329a2008-07-01 14:09:13 +00004266
drh7cd5e852019-05-29 17:22:38 +00004267 /* The flattened query is a compound if either the inner or the
4268 ** outer query is a compound. */
4269 pParent->selFlags |= pSub->selFlags & SF_Compound;
4270 assert( (pSub->selFlags & SF_Distinct)==0 ); /* restriction (17b) */
danielk1977f23329a2008-07-01 14:09:13 +00004271
4272 /*
4273 ** SELECT ... FROM (SELECT ... LIMIT a OFFSET b) LIMIT x OFFSET y;
4274 **
4275 ** One is tempted to try to add a and b to combine the limits. But this
4276 ** does not work if either limit is negative.
4277 */
4278 if( pSub->pLimit ){
4279 pParent->pLimit = pSub->pLimit;
4280 pSub->pLimit = 0;
4281 }
drh2aee5142020-03-21 00:05:53 +00004282
4283 /* Recompute the SrcList_item.colUsed masks for the flattened
4284 ** tables. */
4285 for(i=0; i<nSubSrc; i++){
4286 recomputeColumnsUsed(pParent, &pSrc->a[i+iFrom]);
4287 }
drhdf199a22002-06-14 22:38:41 +00004288 }
drh8c74a8c2002-08-25 19:20:40 +00004289
drhc31c2eb2003-05-02 16:04:17 +00004290 /* Finially, delete what is left of the subquery and return
4291 ** success.
4292 */
drh89636622020-06-07 17:33:18 +00004293 sqlite3AggInfoPersistWalkerInit(&w, pParse);
4294 sqlite3WalkSelect(&w,pSub1);
drh633e6d52008-07-28 19:34:53 +00004295 sqlite3SelectDelete(db, pSub1);
danielk1977f23329a2008-07-01 14:09:13 +00004296
drhc90713d2014-09-30 13:46:49 +00004297#if SELECTTRACE_ENABLED
drhc0622a42020-12-04 01:17:57 +00004298 if( sqlite3SelectTrace & 0x100 ){
drhbc8edba2015-06-05 20:27:26 +00004299 SELECTTRACE(0x100,pParse,p,("After flattening:\n"));
drhc90713d2014-09-30 13:46:49 +00004300 sqlite3TreeViewSelect(0, p, 0);
4301 }
4302#endif
4303
drh832508b2002-03-02 17:04:07 +00004304 return 1;
4305}
shane3514b6f2008-07-22 05:00:55 +00004306#endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
drh1350b032002-02-27 19:00:20 +00004307
drh660ee552018-07-26 21:16:53 +00004308/*
drh8e5bfed2018-10-25 14:15:37 +00004309** A structure to keep track of all of the column values that are fixed to
drhefad2e22018-07-27 16:57:11 +00004310** a known value due to WHERE clause constraints of the form COLUMN=VALUE.
drh660ee552018-07-26 21:16:53 +00004311*/
4312typedef struct WhereConst WhereConst;
4313struct WhereConst {
drhefad2e22018-07-27 16:57:11 +00004314 Parse *pParse; /* Parsing context */
drh660ee552018-07-26 21:16:53 +00004315 int nConst; /* Number for COLUMN=CONSTANT terms */
4316 int nChng; /* Number of times a constant is propagated */
drhefad2e22018-07-27 16:57:11 +00004317 Expr **apExpr; /* [i*2] is COLUMN and [i*2+1] is VALUE */
drh660ee552018-07-26 21:16:53 +00004318};
drh69b72d52015-06-01 20:28:03 +00004319
drh660ee552018-07-26 21:16:53 +00004320/*
drh8e5bfed2018-10-25 14:15:37 +00004321** Add a new entry to the pConst object. Except, do not add duplicate
drhf8f76d62020-01-08 04:36:01 +00004322** pColumn entires. Also, do not add if doing so would not be appropriate.
4323**
4324** The caller guarantees the pColumn is a column and pValue is a constant.
4325** This routine has to do some additional checks before completing the
4326** insert.
drh660ee552018-07-26 21:16:53 +00004327*/
4328static void constInsert(
drhf8f76d62020-01-08 04:36:01 +00004329 WhereConst *pConst, /* The WhereConst into which we are inserting */
4330 Expr *pColumn, /* The COLUMN part of the constraint */
4331 Expr *pValue, /* The VALUE part of the constraint */
4332 Expr *pExpr /* Overall expression: COLUMN=VALUE or VALUE=COLUMN */
drh660ee552018-07-26 21:16:53 +00004333){
drh8e5bfed2018-10-25 14:15:37 +00004334 int i;
4335 assert( pColumn->op==TK_COLUMN );
drhf8f76d62020-01-08 04:36:01 +00004336 assert( sqlite3ExprIsConstant(pValue) );
4337
drhfdfd45a2020-02-13 22:12:35 +00004338 if( ExprHasProperty(pColumn, EP_FixedCol) ) return;
4339 if( sqlite3ExprAffinity(pValue)!=0 ) return;
drhf8f76d62020-01-08 04:36:01 +00004340 if( !sqlite3IsBinary(sqlite3ExprCompareCollSeq(pConst->pParse,pExpr)) ){
4341 return;
4342 }
drh8e5bfed2018-10-25 14:15:37 +00004343
4344 /* 2018-10-25 ticket [cf5ed20f]
4345 ** Make sure the same pColumn is not inserted more than once */
4346 for(i=0; i<pConst->nConst; i++){
drh7be5e3d2020-01-09 20:33:13 +00004347 const Expr *pE2 = pConst->apExpr[i*2];
4348 assert( pE2->op==TK_COLUMN );
4349 if( pE2->iTable==pColumn->iTable
4350 && pE2->iColumn==pColumn->iColumn
drh8e5bfed2018-10-25 14:15:37 +00004351 ){
4352 return; /* Already present. Return without doing anything. */
4353 }
4354 }
drh9cbf4f32018-07-27 20:01:00 +00004355
drh660ee552018-07-26 21:16:53 +00004356 pConst->nConst++;
drhefad2e22018-07-27 16:57:11 +00004357 pConst->apExpr = sqlite3DbReallocOrFree(pConst->pParse->db, pConst->apExpr,
drh660ee552018-07-26 21:16:53 +00004358 pConst->nConst*2*sizeof(Expr*));
4359 if( pConst->apExpr==0 ){
4360 pConst->nConst = 0;
4361 }else{
4362 pConst->apExpr[pConst->nConst*2-2] = pColumn;
4363 pConst->apExpr[pConst->nConst*2-1] = pValue;
4364 }
4365}
4366
4367/*
drhefad2e22018-07-27 16:57:11 +00004368** Find all terms of COLUMN=VALUE or VALUE=COLUMN in pExpr where VALUE
4369** is a constant expression and where the term must be true because it
4370** is part of the AND-connected terms of the expression. For each term
4371** found, add it to the pConst structure.
drh660ee552018-07-26 21:16:53 +00004372*/
4373static void findConstInWhere(WhereConst *pConst, Expr *pExpr){
drhefad2e22018-07-27 16:57:11 +00004374 Expr *pRight, *pLeft;
drh660ee552018-07-26 21:16:53 +00004375 if( pExpr==0 ) return;
4376 if( ExprHasProperty(pExpr, EP_FromJoin) ) return;
4377 if( pExpr->op==TK_AND ){
4378 findConstInWhere(pConst, pExpr->pRight);
4379 findConstInWhere(pConst, pExpr->pLeft);
4380 return;
4381 }
4382 if( pExpr->op!=TK_EQ ) return;
drhefad2e22018-07-27 16:57:11 +00004383 pRight = pExpr->pRight;
4384 pLeft = pExpr->pLeft;
4385 assert( pRight!=0 );
4386 assert( pLeft!=0 );
drhf8f76d62020-01-08 04:36:01 +00004387 if( pRight->op==TK_COLUMN && sqlite3ExprIsConstant(pLeft) ){
4388 constInsert(pConst,pRight,pLeft,pExpr);
4389 }
4390 if( pLeft->op==TK_COLUMN && sqlite3ExprIsConstant(pRight) ){
4391 constInsert(pConst,pLeft,pRight,pExpr);
drh660ee552018-07-26 21:16:53 +00004392 }
4393}
4394
4395/*
4396** This is a Walker expression callback. pExpr is a candidate expression
4397** to be replaced by a value. If pExpr is equivalent to one of the
4398** columns named in pWalker->u.pConst, then overwrite it with its
4399** corresponding value.
4400*/
4401static int propagateConstantExprRewrite(Walker *pWalker, Expr *pExpr){
4402 int i;
4403 WhereConst *pConst;
4404 if( pExpr->op!=TK_COLUMN ) return WRC_Continue;
drhbe0330e2020-01-16 17:53:24 +00004405 if( ExprHasProperty(pExpr, EP_FixedCol|EP_FromJoin) ){
4406 testcase( ExprHasProperty(pExpr, EP_FixedCol) );
4407 testcase( ExprHasProperty(pExpr, EP_FromJoin) );
4408 return WRC_Continue;
4409 }
drh660ee552018-07-26 21:16:53 +00004410 pConst = pWalker->u.pConst;
4411 for(i=0; i<pConst->nConst; i++){
4412 Expr *pColumn = pConst->apExpr[i*2];
4413 if( pColumn==pExpr ) continue;
4414 if( pColumn->iTable!=pExpr->iTable ) continue;
4415 if( pColumn->iColumn!=pExpr->iColumn ) continue;
drhefad2e22018-07-27 16:57:11 +00004416 /* A match is found. Add the EP_FixedCol property */
drh660ee552018-07-26 21:16:53 +00004417 pConst->nChng++;
4418 ExprClearProperty(pExpr, EP_Leaf);
drhefad2e22018-07-27 16:57:11 +00004419 ExprSetProperty(pExpr, EP_FixedCol);
4420 assert( pExpr->pLeft==0 );
4421 pExpr->pLeft = sqlite3ExprDup(pConst->pParse->db, pConst->apExpr[i*2+1], 0);
drh660ee552018-07-26 21:16:53 +00004422 break;
4423 }
4424 return WRC_Prune;
4425}
4426
4427/*
4428** The WHERE-clause constant propagation optimization.
4429**
4430** If the WHERE clause contains terms of the form COLUMN=CONSTANT or
drh97bffe62020-01-08 00:39:37 +00004431** CONSTANT=COLUMN that are top-level AND-connected terms that are not
4432** part of a ON clause from a LEFT JOIN, then throughout the query
4433** replace all other occurrences of COLUMN with CONSTANT.
drh660ee552018-07-26 21:16:53 +00004434**
4435** For example, the query:
4436**
4437** SELECT * FROM t1, t2, t3 WHERE t1.a=39 AND t2.b=t1.a AND t3.c=t2.b
4438**
4439** Is transformed into
4440**
4441** SELECT * FROM t1, t2, t3 WHERE t1.a=39 AND t2.b=39 AND t3.c=39
4442**
4443** Return true if any transformations where made and false if not.
drhefad2e22018-07-27 16:57:11 +00004444**
4445** Implementation note: Constant propagation is tricky due to affinity
4446** and collating sequence interactions. Consider this example:
4447**
4448** CREATE TABLE t1(a INT,b TEXT);
4449** INSERT INTO t1 VALUES(123,'0123');
4450** SELECT * FROM t1 WHERE a=123 AND b=a;
4451** SELECT * FROM t1 WHERE a=123 AND b=123;
4452**
4453** The two SELECT statements above should return different answers. b=a
4454** is alway true because the comparison uses numeric affinity, but b=123
4455** is false because it uses text affinity and '0123' is not the same as '123'.
4456** To work around this, the expression tree is not actually changed from
4457** "b=a" to "b=123" but rather the "a" in "b=a" is tagged with EP_FixedCol
4458** and the "123" value is hung off of the pLeft pointer. Code generator
4459** routines know to generate the constant "123" instead of looking up the
4460** column value. Also, to avoid collation problems, this optimization is
4461** only attempted if the "a=123" term uses the default BINARY collation.
drh660ee552018-07-26 21:16:53 +00004462*/
4463static int propagateConstants(
4464 Parse *pParse, /* The parsing context */
4465 Select *p /* The query in which to propagate constants */
4466){
4467 WhereConst x;
4468 Walker w;
4469 int nChng = 0;
drhefad2e22018-07-27 16:57:11 +00004470 x.pParse = pParse;
drh660ee552018-07-26 21:16:53 +00004471 do{
4472 x.nConst = 0;
4473 x.nChng = 0;
4474 x.apExpr = 0;
4475 findConstInWhere(&x, p->pWhere);
4476 if( x.nConst ){
4477 memset(&w, 0, sizeof(w));
4478 w.pParse = pParse;
4479 w.xExprCallback = propagateConstantExprRewrite;
4480 w.xSelectCallback = sqlite3SelectWalkNoop;
4481 w.xSelectCallback2 = 0;
4482 w.walkerDepth = 0;
4483 w.u.pConst = &x;
drhefad2e22018-07-27 16:57:11 +00004484 sqlite3WalkExpr(&w, p->pWhere);
4485 sqlite3DbFree(x.pParse->db, x.apExpr);
drh660ee552018-07-26 21:16:53 +00004486 nChng += x.nChng;
4487 }
4488 }while( x.nChng );
4489 return nChng;
4490}
drh69b72d52015-06-01 20:28:03 +00004491
4492#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
4493/*
4494** Make copies of relevant WHERE clause terms of the outer query into
4495** the WHERE clause of subquery. Example:
4496**
4497** SELECT * FROM (SELECT a AS x, c-d AS y FROM t1) WHERE x=5 AND y=10;
4498**
4499** Transformed into:
4500**
4501** SELECT * FROM (SELECT a AS x, c-d AS y FROM t1 WHERE a=5 AND c-d=10)
4502** WHERE x=5 AND y=10;
4503**
4504** The hope is that the terms added to the inner query will make it more
4505** efficient.
4506**
4507** Do not attempt this optimization if:
4508**
drh25c221e2017-09-29 22:13:24 +00004509** (1) (** This restriction was removed on 2017-09-29. We used to
4510** disallow this optimization for aggregate subqueries, but now
drh67cc51a2017-09-30 11:47:06 +00004511** it is allowed by putting the extra terms on the HAVING clause.
4512** The added HAVING clause is pointless if the subquery lacks
4513** a GROUP BY clause. But such a HAVING clause is also harmless
4514** so there does not appear to be any reason to add extra logic
4515** to suppress it. **)
drh69b72d52015-06-01 20:28:03 +00004516**
4517** (2) The inner query is the recursive part of a common table expression.
4518**
4519** (3) The inner query has a LIMIT clause (since the changes to the WHERE
dance103732018-06-23 07:59:39 +00004520** clause would change the meaning of the LIMIT).
drh69b72d52015-06-01 20:28:03 +00004521**
drh6a9b9522018-03-27 15:13:43 +00004522** (4) The inner query is the right operand of a LEFT JOIN and the
4523** expression to be pushed down does not come from the ON clause
4524** on that LEFT JOIN.
drh69b72d52015-06-01 20:28:03 +00004525**
drh38978dd2015-08-22 01:32:29 +00004526** (5) The WHERE clause expression originates in the ON or USING clause
drh7fbb1012018-03-21 01:59:46 +00004527** of a LEFT JOIN where iCursor is not the right-hand table of that
4528** left join. An example:
4529**
4530** SELECT *
4531** FROM (SELECT 1 AS a1 UNION ALL SELECT 2) AS aa
4532** JOIN (SELECT 1 AS b2 UNION ALL SELECT 2) AS bb ON (a1=b2)
4533** LEFT JOIN (SELECT 8 AS c3 UNION ALL SELECT 9) AS cc ON (b2=2);
4534**
4535** The correct answer is three rows: (1,1,NULL),(2,2,8),(2,2,9).
4536** But if the (b2=2) term were to be pushed down into the bb subquery,
4537** then the (1,1,NULL) row would be suppressed.
drh38978dd2015-08-22 01:32:29 +00004538**
dance103732018-06-23 07:59:39 +00004539** (6) The inner query features one or more window-functions (since
4540** changes to the WHERE clause of the inner query could change the
4541** window over which window functions are calculated).
4542**
drh69b72d52015-06-01 20:28:03 +00004543** Return 0 if no changes are made and non-zero if one or more WHERE clause
4544** terms are duplicated into the subquery.
4545*/
4546static int pushDownWhereTerms(
dan44c56042016-12-07 15:38:37 +00004547 Parse *pParse, /* Parse context (for malloc() and error reporting) */
drh69b72d52015-06-01 20:28:03 +00004548 Select *pSubq, /* The subquery whose WHERE clause is to be augmented */
4549 Expr *pWhere, /* The WHERE clause of the outer query */
drh6a9b9522018-03-27 15:13:43 +00004550 int iCursor, /* Cursor number of the subquery */
4551 int isLeftJoin /* True if pSubq is the right term of a LEFT JOIN */
drh69b72d52015-06-01 20:28:03 +00004552){
4553 Expr *pNew;
4554 int nChng = 0;
danf65e3792020-06-10 10:58:15 +00004555 Select *pSel;
drh69b72d52015-06-01 20:28:03 +00004556 if( pWhere==0 ) return 0;
drh508e2d02017-09-30 01:25:04 +00004557 if( pSubq->selFlags & SF_Recursive ) return 0; /* restriction (2) */
4558
dance103732018-06-23 07:59:39 +00004559#ifndef SQLITE_OMIT_WINDOWFUNC
danf65e3792020-06-10 10:58:15 +00004560 for(pSel=pSubq; pSel; pSel=pSel->pPrior){
4561 if( pSel->pWin ) return 0; /* restriction (6) */
4562 }
dance103732018-06-23 07:59:39 +00004563#endif
4564
drh508e2d02017-09-30 01:25:04 +00004565#ifdef SQLITE_DEBUG
4566 /* Only the first term of a compound can have a WITH clause. But make
4567 ** sure no other terms are marked SF_Recursive in case something changes
4568 ** in the future.
4569 */
4570 {
4571 Select *pX;
4572 for(pX=pSubq; pX; pX=pX->pPrior){
4573 assert( (pX->selFlags & (SF_Recursive))==0 );
drhb1ec87a2016-04-25 02:20:10 +00004574 }
drh69b72d52015-06-01 20:28:03 +00004575 }
drh508e2d02017-09-30 01:25:04 +00004576#endif
4577
drh69b72d52015-06-01 20:28:03 +00004578 if( pSubq->pLimit!=0 ){
drhb1ec87a2016-04-25 02:20:10 +00004579 return 0; /* restriction (3) */
drh69b72d52015-06-01 20:28:03 +00004580 }
4581 while( pWhere->op==TK_AND ){
drh6a9b9522018-03-27 15:13:43 +00004582 nChng += pushDownWhereTerms(pParse, pSubq, pWhere->pRight,
4583 iCursor, isLeftJoin);
drh69b72d52015-06-01 20:28:03 +00004584 pWhere = pWhere->pLeft;
4585 }
drh6a9b9522018-03-27 15:13:43 +00004586 if( isLeftJoin
4587 && (ExprHasProperty(pWhere,EP_FromJoin)==0
4588 || pWhere->iRightJoinTable!=iCursor)
4589 ){
4590 return 0; /* restriction (4) */
4591 }
drh7fbb1012018-03-21 01:59:46 +00004592 if( ExprHasProperty(pWhere,EP_FromJoin) && pWhere->iRightJoinTable!=iCursor ){
4593 return 0; /* restriction (5) */
4594 }
drh69b72d52015-06-01 20:28:03 +00004595 if( sqlite3ExprIsTableConstant(pWhere, iCursor) ){
4596 nChng++;
drh8794c682021-02-13 16:39:24 +00004597 pSubq->selFlags |= SF_PushDown;
drh69b72d52015-06-01 20:28:03 +00004598 while( pSubq ){
drh46967de2017-04-14 12:39:37 +00004599 SubstContext x;
dan44c56042016-12-07 15:38:37 +00004600 pNew = sqlite3ExprDup(pParse->db, pWhere, 0);
drh7fbb1012018-03-21 01:59:46 +00004601 unsetJoinExpr(pNew, -1);
drh46967de2017-04-14 12:39:37 +00004602 x.pParse = pParse;
4603 x.iTable = iCursor;
drh399c7e22017-04-14 17:18:45 +00004604 x.iNewTable = iCursor;
drh31d6fd52017-04-14 19:03:10 +00004605 x.isLeftJoin = 0;
drh46967de2017-04-14 12:39:37 +00004606 x.pEList = pSubq->pEList;
4607 pNew = substExpr(&x, pNew);
drh25c221e2017-09-29 22:13:24 +00004608 if( pSubq->selFlags & SF_Aggregate ){
drhd5c851c2019-04-19 13:38:34 +00004609 pSubq->pHaving = sqlite3ExprAnd(pParse, pSubq->pHaving, pNew);
drh25c221e2017-09-29 22:13:24 +00004610 }else{
drhd5c851c2019-04-19 13:38:34 +00004611 pSubq->pWhere = sqlite3ExprAnd(pParse, pSubq->pWhere, pNew);
drh25c221e2017-09-29 22:13:24 +00004612 }
drh69b72d52015-06-01 20:28:03 +00004613 pSubq = pSubq->pPrior;
4614 }
4615 }
4616 return nChng;
4617}
4618#endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
4619
drh1350b032002-02-27 19:00:20 +00004620/*
drh47d9f832017-10-26 20:04:28 +00004621** The pFunc is the only aggregate function in the query. Check to see
4622** if the query is a candidate for the min/max optimization.
danielk1977a9d1ccb2008-01-05 17:39:29 +00004623**
drh47d9f832017-10-26 20:04:28 +00004624** If the query is a candidate for the min/max optimization, then set
4625** *ppMinMax to be an ORDER BY clause to be used for the optimization
4626** and return either WHERE_ORDERBY_MIN or WHERE_ORDERBY_MAX depending on
4627** whether pFunc is a min() or max() function.
danielk1977738bdcf2008-01-07 10:16:40 +00004628**
drh47d9f832017-10-26 20:04:28 +00004629** If the query is not a candidate for the min/max optimization, return
4630** WHERE_ORDERBY_NORMAL (which must be zero).
dan4ac391f2012-12-13 16:37:10 +00004631**
drh47d9f832017-10-26 20:04:28 +00004632** This routine must be called after aggregate functions have been
4633** located but before their arguments have been subjected to aggregate
4634** analysis.
danielk1977a9d1ccb2008-01-05 17:39:29 +00004635*/
drh47d9f832017-10-26 20:04:28 +00004636static u8 minMaxQuery(sqlite3 *db, Expr *pFunc, ExprList **ppMinMax){
4637 int eRet = WHERE_ORDERBY_NORMAL; /* Return value */
4638 ExprList *pEList = pFunc->x.pList; /* Arguments to agg function */
4639 const char *zFunc; /* Name of aggregate function pFunc */
4640 ExprList *pOrderBy;
drhbe284e42020-02-27 16:21:39 +00004641 u8 sortFlags = 0;
danielk1977a9d1ccb2008-01-05 17:39:29 +00004642
drh47d9f832017-10-26 20:04:28 +00004643 assert( *ppMinMax==0 );
4644 assert( pFunc->op==TK_AGG_FUNCTION );
dan4f9adee2019-07-13 16:22:50 +00004645 assert( !IsWindowFunc(pFunc) );
drhaf7b7652021-01-13 19:28:17 +00004646 if( pEList==0
4647 || pEList->nExpr!=1
4648 || ExprHasProperty(pFunc, EP_WinFunc)
4649 || OptimizationDisabled(db, SQLITE_MinMaxOpt)
4650 ){
dan6ba7ab02019-07-02 11:56:47 +00004651 return eRet;
4652 }
drh47d9f832017-10-26 20:04:28 +00004653 zFunc = pFunc->u.zToken;
4654 if( sqlite3StrICmp(zFunc, "min")==0 ){
4655 eRet = WHERE_ORDERBY_MIN;
dan67e2bb92020-02-27 15:07:16 +00004656 if( sqlite3ExprCanBeNull(pEList->a[0].pExpr) ){
4657 sortFlags = KEYINFO_ORDER_BIGNULL;
4658 }
drh47d9f832017-10-26 20:04:28 +00004659 }else if( sqlite3StrICmp(zFunc, "max")==0 ){
4660 eRet = WHERE_ORDERBY_MAX;
dan5b32bdf2019-08-17 15:47:32 +00004661 sortFlags = KEYINFO_ORDER_DESC;
drh47d9f832017-10-26 20:04:28 +00004662 }else{
4663 return eRet;
danielk1977a9d1ccb2008-01-05 17:39:29 +00004664 }
drh47d9f832017-10-26 20:04:28 +00004665 *ppMinMax = pOrderBy = sqlite3ExprListDup(db, pEList, 0);
4666 assert( pOrderBy!=0 || db->mallocFailed );
dan5b32bdf2019-08-17 15:47:32 +00004667 if( pOrderBy ) pOrderBy->a[0].sortFlags = sortFlags;
dan4ac391f2012-12-13 16:37:10 +00004668 return eRet;
danielk1977a9d1ccb2008-01-05 17:39:29 +00004669}
4670
4671/*
danielk1977a5533162009-02-24 10:01:51 +00004672** The select statement passed as the first argument is an aggregate query.
peter.d.reid60ec9142014-09-06 16:39:46 +00004673** The second argument is the associated aggregate-info object. This
danielk1977a5533162009-02-24 10:01:51 +00004674** function tests if the SELECT is of the form:
4675**
4676** SELECT count(*) FROM <tbl>
4677**
4678** where table is a database table, not a sub-select or view. If the query
4679** does match this pattern, then a pointer to the Table object representing
4680** <tbl> is returned. Otherwise, 0 is returned.
4681*/
4682static Table *isSimpleCount(Select *p, AggInfo *pAggInfo){
4683 Table *pTab;
4684 Expr *pExpr;
4685
4686 assert( !p->pGroupBy );
4687
danielk19777a895a82009-02-24 18:33:15 +00004688 if( p->pWhere || p->pEList->nExpr!=1
danielk1977a5533162009-02-24 10:01:51 +00004689 || p->pSrc->nSrc!=1 || p->pSrc->a[0].pSelect
4690 ){
4691 return 0;
4692 }
danielk1977a5533162009-02-24 10:01:51 +00004693 pTab = p->pSrc->a[0].pTab;
4694 pExpr = p->pEList->a[0].pExpr;
danielk197702f33722009-02-25 08:56:47 +00004695 assert( pTab && !pTab->pSelect && pExpr );
4696
4697 if( IsVirtual(pTab) ) return 0;
danielk1977a5533162009-02-24 10:01:51 +00004698 if( pExpr->op!=TK_AGG_FUNCTION ) return 0;
drhfb0a6082012-08-24 01:07:52 +00004699 if( NEVER(pAggInfo->nFunc==0) ) return 0;
drhd36e1042013-09-06 13:10:12 +00004700 if( (pAggInfo->aFunc[0].pFunc->funcFlags&SQLITE_FUNC_COUNT)==0 ) return 0;
dan4f9adee2019-07-13 16:22:50 +00004701 if( ExprHasProperty(pExpr, EP_Distinct|EP_WinFunc) ) return 0;
danielk1977a5533162009-02-24 10:01:51 +00004702
4703 return pTab;
4704}
4705
4706/*
danielk1977b1c685b2008-10-06 16:18:39 +00004707** If the source-list item passed as an argument was augmented with an
4708** INDEXED BY clause, then try to locate the specified index. If there
4709** was such a clause and the named index cannot be found, return
4710** SQLITE_ERROR and leave an error in pParse. Otherwise, populate
4711** pFrom->pIndex and return SQLITE_OK.
4712*/
drh76012942021-02-21 21:04:54 +00004713int sqlite3IndexedByLookup(Parse *pParse, SrcItem *pFrom){
drh18622712021-02-20 21:20:54 +00004714 Table *pTab = pFrom->pTab;
4715 char *zIndexedBy = pFrom->u1.zIndexedBy;
4716 Index *pIdx;
4717 assert( pTab!=0 );
4718 assert( pFrom->fg.isIndexedBy!=0 );
4719
4720 for(pIdx=pTab->pIndex;
4721 pIdx && sqlite3StrICmp(pIdx->zName, zIndexedBy);
4722 pIdx=pIdx->pNext
4723 );
4724 if( !pIdx ){
4725 sqlite3ErrorMsg(pParse, "no such index: %s", zIndexedBy, 0);
4726 pParse->checkSchema = 1;
4727 return SQLITE_ERROR;
danielk1977b1c685b2008-10-06 16:18:39 +00004728 }
drha79e2a22021-02-21 23:44:14 +00004729 pFrom->u2.pIBIndex = pIdx;
danielk1977b1c685b2008-10-06 16:18:39 +00004730 return SQLITE_OK;
4731}
drh18622712021-02-20 21:20:54 +00004732
drhc01b7302013-05-07 17:49:08 +00004733/*
4734** Detect compound SELECT statements that use an ORDER BY clause with
4735** an alternative collating sequence.
4736**
4737** SELECT ... FROM t1 EXCEPT SELECT ... FROM t2 ORDER BY .. COLLATE ...
4738**
4739** These are rewritten as a subquery:
4740**
4741** SELECT * FROM (SELECT ... FROM t1 EXCEPT SELECT ... FROM t2)
4742** ORDER BY ... COLLATE ...
4743**
4744** This transformation is necessary because the multiSelectOrderBy() routine
4745** above that generates the code for a compound SELECT with an ORDER BY clause
4746** uses a merge algorithm that requires the same collating sequence on the
4747** result columns as on the ORDER BY clause. See ticket
4748** http://www.sqlite.org/src/info/6709574d2a
4749**
4750** This transformation is only needed for EXCEPT, INTERSECT, and UNION.
4751** The UNION ALL operator works fine with multiSelectOrderBy() even when
4752** there are COLLATE terms in the ORDER BY.
4753*/
4754static int convertCompoundSelectToSubquery(Walker *pWalker, Select *p){
4755 int i;
4756 Select *pNew;
4757 Select *pX;
4758 sqlite3 *db;
4759 struct ExprList_item *a;
4760 SrcList *pNewSrc;
4761 Parse *pParse;
4762 Token dummy;
4763
4764 if( p->pPrior==0 ) return WRC_Continue;
4765 if( p->pOrderBy==0 ) return WRC_Continue;
4766 for(pX=p; pX && (pX->op==TK_ALL || pX->op==TK_SELECT); pX=pX->pPrior){}
4767 if( pX==0 ) return WRC_Continue;
4768 a = p->pOrderBy->a;
dan46daa992020-06-11 15:53:54 +00004769#ifndef SQLITE_OMIT_WINDOWFUNC
4770 /* If iOrderByCol is already non-zero, then it has already been matched
4771 ** to a result column of the SELECT statement. This occurs when the
4772 ** SELECT is rewritten for window-functions processing and then passed
4773 ** to sqlite3SelectPrep() and similar a second time. The rewriting done
4774 ** by this function is not required in this case. */
4775 if( a[0].u.x.iOrderByCol ) return WRC_Continue;
4776#endif
drhc01b7302013-05-07 17:49:08 +00004777 for(i=p->pOrderBy->nExpr-1; i>=0; i--){
4778 if( a[i].pExpr->flags & EP_Collate ) break;
4779 }
4780 if( i<0 ) return WRC_Continue;
4781
4782 /* If we reach this point, that means the transformation is required. */
4783
4784 pParse = pWalker->pParse;
4785 db = pParse->db;
4786 pNew = sqlite3DbMallocZero(db, sizeof(*pNew) );
4787 if( pNew==0 ) return WRC_Abort;
4788 memset(&dummy, 0, sizeof(dummy));
4789 pNewSrc = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&dummy,pNew,0,0);
4790 if( pNewSrc==0 ) return WRC_Abort;
4791 *pNew = *p;
4792 p->pSrc = pNewSrc;
drh1a1d3cd2015-11-19 16:33:31 +00004793 p->pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ASTERISK, 0));
drhc01b7302013-05-07 17:49:08 +00004794 p->op = TK_SELECT;
4795 p->pWhere = 0;
4796 pNew->pGroupBy = 0;
4797 pNew->pHaving = 0;
4798 pNew->pOrderBy = 0;
4799 p->pPrior = 0;
drh8af9ad92014-02-10 18:56:05 +00004800 p->pNext = 0;
drhf932f712015-04-12 17:35:27 +00004801 p->pWith = 0;
danfcc057d2019-12-04 01:42:07 +00004802#ifndef SQLITE_OMIT_WINDOWFUNC
4803 p->pWinDefn = 0;
4804#endif
drh8af9ad92014-02-10 18:56:05 +00004805 p->selFlags &= ~SF_Compound;
danb33c50f2015-04-04 16:43:16 +00004806 assert( (p->selFlags & SF_Converted)==0 );
4807 p->selFlags |= SF_Converted;
drha6e3a8c2014-02-10 21:07:51 +00004808 assert( pNew->pPrior!=0 );
4809 pNew->pPrior->pNext = pNew;
drhc01b7302013-05-07 17:49:08 +00004810 pNew->pLimit = 0;
drhc01b7302013-05-07 17:49:08 +00004811 return WRC_Continue;
4812}
danielk1977b1c685b2008-10-06 16:18:39 +00004813
drh20292312015-11-21 13:24:46 +00004814/*
4815** Check to see if the FROM clause term pFrom has table-valued function
4816** arguments. If it does, leave an error message in pParse and return
4817** non-zero, since pFrom is not allowed to be a table-valued function.
4818*/
drh76012942021-02-21 21:04:54 +00004819static int cannotBeFunction(Parse *pParse, SrcItem *pFrom){
drh20292312015-11-21 13:24:46 +00004820 if( pFrom->fg.isTabFunc ){
4821 sqlite3ErrorMsg(pParse, "'%s' is not a function", pFrom->zName);
4822 return 1;
4823 }
4824 return 0;
4825}
4826
daneede6a52014-01-15 19:42:23 +00004827#ifndef SQLITE_OMIT_CTE
4828/*
4829** Argument pWith (which may be NULL) points to a linked list of nested
4830** WITH contexts, from inner to outermost. If the table identified by
4831** FROM clause element pItem is really a common-table-expression (CTE)
4832** then return a pointer to the CTE definition for that table. Otherwise
4833** return NULL.
dan98f45e52014-01-17 17:40:46 +00004834**
4835** If a non-NULL value is returned, set *ppContext to point to the With
4836** object that the returned CTE belongs to.
drh60c1a2f2014-01-15 18:23:00 +00004837*/
dan98f45e52014-01-17 17:40:46 +00004838static struct Cte *searchWith(
drh2476a6f2015-11-07 15:19:59 +00004839 With *pWith, /* Current innermost WITH clause */
drh76012942021-02-21 21:04:54 +00004840 SrcItem *pItem, /* FROM clause element to resolve */
dan98f45e52014-01-17 17:40:46 +00004841 With **ppContext /* OUT: WITH clause return value belongs to */
4842){
drh5abe1d32021-02-21 01:19:42 +00004843 const char *zName = pItem->zName;
4844 With *p;
4845 assert( pItem->zDatabase==0 );
4846 assert( zName!=0 );
4847 for(p=pWith; p; p=p->pOuter){
4848 int i;
4849 for(i=0; i<p->nCte; i++){
4850 if( sqlite3StrICmp(zName, p->a[i].zName)==0 ){
4851 *ppContext = p;
4852 return &p->a[i];
dan4e9119d2014-01-13 15:12:23 +00004853 }
4854 }
4855 }
4856 return 0;
4857}
4858
drhc49832c2014-01-15 18:35:52 +00004859/* The code generator maintains a stack of active WITH clauses
4860** with the inner-most WITH clause being at the top of the stack.
4861**
danb290f112014-01-17 14:59:27 +00004862** This routine pushes the WITH clause passed as the second argument
4863** onto the top of the stack. If argument bFree is true, then this
4864** WITH clause will never be popped from the stack. In this case it
4865** should be freed along with the Parse object. In other cases, when
4866** bFree==0, the With object will be freed along with the SELECT
4867** statement with which it is associated.
drhc49832c2014-01-15 18:35:52 +00004868*/
danb290f112014-01-17 14:59:27 +00004869void sqlite3WithPush(Parse *pParse, With *pWith, u8 bFree){
dan4e9119d2014-01-13 15:12:23 +00004870 if( pWith ){
drh2476a6f2015-11-07 15:19:59 +00004871 assert( pParse->pWith!=pWith );
dan4e9119d2014-01-13 15:12:23 +00004872 pWith->pOuter = pParse->pWith;
4873 pParse->pWith = pWith;
drhcf3c0782021-01-11 20:37:02 +00004874 if( bFree ){
4875 sqlite3ParserAddCleanup(pParse,
4876 (void(*)(sqlite3*,void*))sqlite3WithDelete,
4877 pWith);
drh21d4f5b2021-01-12 15:30:01 +00004878 testcase( pParse->earlyCleanup );
drhcf3c0782021-01-11 20:37:02 +00004879 }
dan4e9119d2014-01-13 15:12:23 +00004880 }
4881}
dan4e9119d2014-01-13 15:12:23 +00004882
daneede6a52014-01-15 19:42:23 +00004883/*
daneede6a52014-01-15 19:42:23 +00004884** This function checks if argument pFrom refers to a CTE declared by
drh5abe1d32021-02-21 01:19:42 +00004885** a WITH clause on the stack currently maintained by the parser (on the
4886** pParse->pWith linked list). And if currently processing a CTE
4887** CTE expression, through routine checks to see if the reference is
4888** a recursive reference to the CTE.
daneede6a52014-01-15 19:42:23 +00004889**
drh5abe1d32021-02-21 01:19:42 +00004890** If pFrom matches a CTE according to either of these two above, pFrom->pTab
4891** and other fields are populated accordingly.
daneede6a52014-01-15 19:42:23 +00004892**
drh5abe1d32021-02-21 01:19:42 +00004893** Return 0 if no match is found.
4894** Return 1 if a match is found.
4895** Return 2 if an error condition is detected.
daneede6a52014-01-15 19:42:23 +00004896*/
drh5abe1d32021-02-21 01:19:42 +00004897static int resolveFromTermToCte(
4898 Parse *pParse, /* The parsing context */
4899 Walker *pWalker, /* Current tree walker */
drh76012942021-02-21 21:04:54 +00004900 SrcItem *pFrom /* The FROM clause term to check */
dan8ce71842014-01-14 20:14:09 +00004901){
drh5abe1d32021-02-21 01:19:42 +00004902 Cte *pCte; /* Matched CTE (or NULL if no match) */
4903 With *pWith; /* The matching WITH */
dan8ce71842014-01-14 20:14:09 +00004904
dan8ce71842014-01-14 20:14:09 +00004905 assert( pFrom->pTab==0 );
drh5abe1d32021-02-21 01:19:42 +00004906 if( pParse->pWith==0 ){
4907 /* There are no WITH clauses in the stack. No match is possible */
4908 return 0;
drh46a31cd2019-11-09 14:38:58 +00004909 }
drh5abe1d32021-02-21 01:19:42 +00004910 if( pFrom->zDatabase!=0 ){
4911 /* The FROM term contains a schema qualifier (ex: main.t1) and so
4912 ** it cannot possibly be a CTE reference. */
4913 return 0;
4914 }
dan98f45e52014-01-17 17:40:46 +00004915 pCte = searchWith(pParse->pWith, pFrom, &pWith);
daneae73fb2014-01-16 18:34:33 +00004916 if( pCte ){
drh5abe1d32021-02-21 01:19:42 +00004917 sqlite3 *db = pParse->db;
dan98f45e52014-01-17 17:40:46 +00004918 Table *pTab;
dan8ce71842014-01-14 20:14:09 +00004919 ExprList *pEList;
4920 Select *pSel;
dan60e70682014-01-15 15:27:51 +00004921 Select *pLeft; /* Left-most SELECT statement */
drh34055852020-10-19 01:23:48 +00004922 Select *pRecTerm; /* Left-most recursive term */
danf2655fe2014-01-16 21:02:02 +00004923 int bMayRecursive; /* True if compound joined by UNION [ALL] */
dan98f45e52014-01-17 17:40:46 +00004924 With *pSavedWith; /* Initial value of pParse->pWith */
drh34055852020-10-19 01:23:48 +00004925 int iRecTab = -1; /* Cursor for recursive table */
danf2655fe2014-01-16 21:02:02 +00004926
drh0576bc52015-08-26 11:40:11 +00004927 /* If pCte->zCteErr is non-NULL at this point, then this is an illegal
danf2655fe2014-01-16 21:02:02 +00004928 ** recursive reference to CTE pCte. Leave an error in pParse and return
drh0576bc52015-08-26 11:40:11 +00004929 ** early. If pCte->zCteErr is NULL, then this is not a recursive reference.
danf2655fe2014-01-16 21:02:02 +00004930 ** In this case, proceed. */
drh0576bc52015-08-26 11:40:11 +00004931 if( pCte->zCteErr ){
4932 sqlite3ErrorMsg(pParse, pCte->zCteErr, pCte->zName);
drh5abe1d32021-02-21 01:19:42 +00004933 return 2;
danf2655fe2014-01-16 21:02:02 +00004934 }
drh5abe1d32021-02-21 01:19:42 +00004935 if( cannotBeFunction(pParse, pFrom) ) return 2;
dan8ce71842014-01-14 20:14:09 +00004936
drhc25e2eb2014-01-20 14:58:55 +00004937 assert( pFrom->pTab==0 );
drha79e2a22021-02-21 23:44:14 +00004938 pTab = sqlite3DbMallocZero(db, sizeof(Table));
drh5abe1d32021-02-21 01:19:42 +00004939 if( pTab==0 ) return 2;
drha79e2a22021-02-21 23:44:14 +00004940 if( pCte->pUse==0 ){
4941 pCte->pUse = sqlite3DbMallocZero(db, sizeof(pCte->pUse[0]));
4942 if( pCte->pUse==0
4943 || sqlite3ParserAddCleanup(pParse,sqlite3DbFree,pCte->pUse)==0
4944 ){
4945 sqlite3DbFree(db, pTab);
4946 return 2;
4947 }
4948 }
4949 pFrom->pTab = pTab;
drh79df7782016-12-14 14:07:35 +00004950 pTab->nTabRef = 1;
dan2d4dc5f2014-01-17 11:48:24 +00004951 pTab->zName = sqlite3DbStrDup(db, pCte->zName);
dan8ce71842014-01-14 20:14:09 +00004952 pTab->iPKey = -1;
dancfc9df72014-04-25 15:01:01 +00004953 pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
drhfccda8a2015-05-27 13:06:55 +00004954 pTab->tabFlags |= TF_Ephemeral | TF_NoVisibleRowid;
dan8ce71842014-01-14 20:14:09 +00004955 pFrom->pSelect = sqlite3SelectDup(db, pCte->pSelect, 0);
drh5abe1d32021-02-21 01:19:42 +00004956 if( db->mallocFailed ) return 2;
dan8ce71842014-01-14 20:14:09 +00004957 assert( pFrom->pSelect );
drha79e2a22021-02-21 23:44:14 +00004958 pFrom->fg.isCte = 1;
4959 pFrom->u2.pCteUse = pCte->pUse;
4960 pCte->pUse->nUse++;
dan8ce71842014-01-14 20:14:09 +00004961
daneae73fb2014-01-16 18:34:33 +00004962 /* Check if this is a recursive CTE. */
drh34055852020-10-19 01:23:48 +00004963 pRecTerm = pSel = pFrom->pSelect;
danf2655fe2014-01-16 21:02:02 +00004964 bMayRecursive = ( pSel->op==TK_ALL || pSel->op==TK_UNION );
drh34055852020-10-19 01:23:48 +00004965 while( bMayRecursive && pRecTerm->op==pSel->op ){
daneae73fb2014-01-16 18:34:33 +00004966 int i;
drh34055852020-10-19 01:23:48 +00004967 SrcList *pSrc = pRecTerm->pSrc;
4968 assert( pRecTerm->pPrior!=0 );
daneae73fb2014-01-16 18:34:33 +00004969 for(i=0; i<pSrc->nSrc; i++){
drh76012942021-02-21 21:04:54 +00004970 SrcItem *pItem = &pSrc->a[i];
daneae73fb2014-01-16 18:34:33 +00004971 if( pItem->zDatabase==0
4972 && pItem->zName!=0
4973 && 0==sqlite3StrICmp(pItem->zName, pCte->zName)
drh34055852020-10-19 01:23:48 +00004974 ){
daneae73fb2014-01-16 18:34:33 +00004975 pItem->pTab = pTab;
drh94d6f3f2020-10-19 20:49:54 +00004976 pTab->nTabRef++;
drh8a48b9c2015-08-19 15:20:00 +00004977 pItem->fg.isRecursive = 1;
drh34055852020-10-19 01:23:48 +00004978 if( pRecTerm->selFlags & SF_Recursive ){
4979 sqlite3ErrorMsg(pParse,
4980 "multiple references to recursive table: %s", pCte->zName
4981 );
drh5abe1d32021-02-21 01:19:42 +00004982 return 2;
drh34055852020-10-19 01:23:48 +00004983 }
drh34055852020-10-19 01:23:48 +00004984 pRecTerm->selFlags |= SF_Recursive;
4985 if( iRecTab<0 ) iRecTab = pParse->nTab++;
4986 pItem->iCursor = iRecTab;
daneae73fb2014-01-16 18:34:33 +00004987 }
4988 }
drh34055852020-10-19 01:23:48 +00004989 if( (pRecTerm->selFlags & SF_Recursive)==0 ) break;
4990 pRecTerm = pRecTerm->pPrior;
dan8ce71842014-01-14 20:14:09 +00004991 }
4992
drh0576bc52015-08-26 11:40:11 +00004993 pCte->zCteErr = "circular reference: %s";
dan98f45e52014-01-17 17:40:46 +00004994 pSavedWith = pParse->pWith;
4995 pParse->pWith = pWith;
drh34055852020-10-19 01:23:48 +00004996 if( pSel->selFlags & SF_Recursive ){
4997 assert( pRecTerm!=0 );
4998 assert( (pRecTerm->selFlags & SF_Recursive)==0 );
4999 assert( pRecTerm->pNext!=0 );
5000 assert( (pRecTerm->pNext->selFlags & SF_Recursive)!=0 );
5001 assert( pRecTerm->pWith==0 );
5002 pRecTerm->pWith = pSel->pWith;
5003 sqlite3WalkSelect(pWalker, pRecTerm);
5004 pRecTerm->pWith = 0;
dan067cd832017-02-03 19:16:39 +00005005 }else{
5006 sqlite3WalkSelect(pWalker, pSel);
5007 }
drh6e772262015-11-07 17:48:21 +00005008 pParse->pWith = pWith;
daneae73fb2014-01-16 18:34:33 +00005009
dan60e70682014-01-15 15:27:51 +00005010 for(pLeft=pSel; pLeft->pPrior; pLeft=pLeft->pPrior);
5011 pEList = pLeft->pEList;
dan8ce71842014-01-14 20:14:09 +00005012 if( pCte->pCols ){
drh8f9d0b22015-03-21 03:18:22 +00005013 if( pEList && pEList->nExpr!=pCte->pCols->nExpr ){
drh727a99f2014-01-16 21:59:51 +00005014 sqlite3ErrorMsg(pParse, "table %s has %d values for %d columns",
dan60e70682014-01-15 15:27:51 +00005015 pCte->zName, pEList->nExpr, pCte->pCols->nExpr
5016 );
dan98f45e52014-01-17 17:40:46 +00005017 pParse->pWith = pSavedWith;
drh5abe1d32021-02-21 01:19:42 +00005018 return 2;
dan60e70682014-01-15 15:27:51 +00005019 }
dan8ce71842014-01-14 20:14:09 +00005020 pEList = pCte->pCols;
dan8ce71842014-01-14 20:14:09 +00005021 }
dan8ce71842014-01-14 20:14:09 +00005022
drh8981b902015-08-24 17:42:49 +00005023 sqlite3ColumnsFromExprList(pParse, pEList, &pTab->nCol, &pTab->aCol);
danf2655fe2014-01-16 21:02:02 +00005024 if( bMayRecursive ){
5025 if( pSel->selFlags & SF_Recursive ){
drh0576bc52015-08-26 11:40:11 +00005026 pCte->zCteErr = "multiple recursive references: %s";
danf2655fe2014-01-16 21:02:02 +00005027 }else{
drh0576bc52015-08-26 11:40:11 +00005028 pCte->zCteErr = "recursive reference in a subquery: %s";
danf2655fe2014-01-16 21:02:02 +00005029 }
5030 sqlite3WalkSelect(pWalker, pSel);
5031 }
drh0576bc52015-08-26 11:40:11 +00005032 pCte->zCteErr = 0;
dan98f45e52014-01-17 17:40:46 +00005033 pParse->pWith = pSavedWith;
drh5abe1d32021-02-21 01:19:42 +00005034 return 1; /* Success */
dan8ce71842014-01-14 20:14:09 +00005035 }
drh5abe1d32021-02-21 01:19:42 +00005036 return 0; /* No match */
dan8ce71842014-01-14 20:14:09 +00005037}
daneede6a52014-01-15 19:42:23 +00005038#endif
dan4e9119d2014-01-13 15:12:23 +00005039
danb290f112014-01-17 14:59:27 +00005040#ifndef SQLITE_OMIT_CTE
dan71856942014-01-17 15:15:10 +00005041/*
5042** If the SELECT passed as the second argument has an associated WITH
5043** clause, pop it from the stack stored as part of the Parse object.
5044**
5045** This function is used as the xSelectCallback2() callback by
5046** sqlite3SelectExpand() when walking a SELECT tree to resolve table
5047** names and other FROM clause elements.
5048*/
danb290f112014-01-17 14:59:27 +00005049static void selectPopWith(Walker *pWalker, Select *p){
5050 Parse *pParse = pWalker->pParse;
drh2f65b2f2017-10-02 21:29:51 +00005051 if( OK_IF_ALWAYS_TRUE(pParse->pWith) && p->pPrior==0 ){
dan067cd832017-02-03 19:16:39 +00005052 With *pWith = findRightmost(p)->pWith;
5053 if( pWith!=0 ){
dan70a32702020-01-21 14:42:48 +00005054 assert( pParse->pWith==pWith || pParse->nErr );
dan067cd832017-02-03 19:16:39 +00005055 pParse->pWith = pWith->pOuter;
5056 }
danb290f112014-01-17 14:59:27 +00005057 }
danb290f112014-01-17 14:59:27 +00005058}
5059#else
5060#define selectPopWith 0
5061#endif
5062
dan9a947222018-06-14 19:06:36 +00005063/*
5064** The SrcList_item structure passed as the second argument represents a
5065** sub-query in the FROM clause of a SELECT statement. This function
5066** allocates and populates the SrcList_item.pTab object. If successful,
5067** SQLITE_OK is returned. Otherwise, if an OOM error is encountered,
5068** SQLITE_NOMEM.
5069*/
drh76012942021-02-21 21:04:54 +00005070int sqlite3ExpandSubquery(Parse *pParse, SrcItem *pFrom){
dan86fb6e12018-05-16 20:58:07 +00005071 Select *pSel = pFrom->pSelect;
5072 Table *pTab;
5073
dan9a947222018-06-14 19:06:36 +00005074 assert( pSel );
dan86fb6e12018-05-16 20:58:07 +00005075 pFrom->pTab = pTab = sqlite3DbMallocZero(pParse->db, sizeof(Table));
dan9a947222018-06-14 19:06:36 +00005076 if( pTab==0 ) return SQLITE_NOMEM;
dan86fb6e12018-05-16 20:58:07 +00005077 pTab->nTabRef = 1;
5078 if( pFrom->zAlias ){
5079 pTab->zName = sqlite3DbStrDup(pParse->db, pFrom->zAlias);
5080 }else{
drhfef37762018-07-10 19:48:35 +00005081 pTab->zName = sqlite3MPrintf(pParse->db, "subquery_%u", pSel->selId);
dan86fb6e12018-05-16 20:58:07 +00005082 }
5083 while( pSel->pPrior ){ pSel = pSel->pPrior; }
5084 sqlite3ColumnsFromExprList(pParse, pSel->pEList,&pTab->nCol,&pTab->aCol);
5085 pTab->iPKey = -1;
5086 pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
5087 pTab->tabFlags |= TF_Ephemeral;
5088
drhf4b33152019-04-23 12:30:15 +00005089 return pParse->nErr ? SQLITE_ERROR : SQLITE_OK;
dan86fb6e12018-05-16 20:58:07 +00005090}
5091
danielk1977b1c685b2008-10-06 16:18:39 +00005092/*
drh7d10d5a2008-08-20 16:35:10 +00005093** This routine is a Walker callback for "expanding" a SELECT statement.
5094** "Expanding" means to do the following:
5095**
5096** (1) Make sure VDBE cursor numbers have been assigned to every
5097** element of the FROM clause.
5098**
5099** (2) Fill in the pTabList->a[].pTab fields in the SrcList that
5100** defines FROM clause. When views appear in the FROM clause,
5101** fill pTabList->a[].pSelect with a copy of the SELECT statement
5102** that implements the view. A copy is made of the view's SELECT
5103** statement so that we can freely modify or delete that statement
peter.d.reid60ec9142014-09-06 16:39:46 +00005104** without worrying about messing up the persistent representation
drh7d10d5a2008-08-20 16:35:10 +00005105** of the view.
5106**
peter.d.reid60ec9142014-09-06 16:39:46 +00005107** (3) Add terms to the WHERE clause to accommodate the NATURAL keyword
drh7d10d5a2008-08-20 16:35:10 +00005108** on joins and the ON and USING clause of joins.
5109**
5110** (4) Scan the list of columns in the result set (pEList) looking
5111** for instances of the "*" operator or the TABLE.* operator.
5112** If found, expand each "*" to be every column in every table
5113** and TABLE.* to be every column in TABLE.
5114**
danielk1977b3bce662005-01-29 08:32:43 +00005115*/
drh7d10d5a2008-08-20 16:35:10 +00005116static int selectExpander(Walker *pWalker, Select *p){
5117 Parse *pParse = pWalker->pParse;
drh5abe1d32021-02-21 01:19:42 +00005118 int i, j, k, rc;
drh7d10d5a2008-08-20 16:35:10 +00005119 SrcList *pTabList;
5120 ExprList *pEList;
drh76012942021-02-21 21:04:54 +00005121 SrcItem *pFrom;
drh7d10d5a2008-08-20 16:35:10 +00005122 sqlite3 *db = pParse->db;
drh3e3f1a52013-01-03 00:45:56 +00005123 Expr *pE, *pRight, *pExpr;
drh785097d2013-02-12 22:09:48 +00005124 u16 selFlags = p->selFlags;
drhfca23552017-10-28 20:51:54 +00005125 u32 elistFlags = 0;
danielk1977b3bce662005-01-29 08:32:43 +00005126
drh785097d2013-02-12 22:09:48 +00005127 p->selFlags |= SF_Expanded;
drh7d10d5a2008-08-20 16:35:10 +00005128 if( db->mallocFailed ){
5129 return WRC_Abort;
danielk1977b3bce662005-01-29 08:32:43 +00005130 }
drh9d9c41e2017-10-31 03:40:15 +00005131 assert( p->pSrc!=0 );
5132 if( (selFlags & SF_Expanded)!=0 ){
drh7d10d5a2008-08-20 16:35:10 +00005133 return WRC_Prune;
danielk1977b3bce662005-01-29 08:32:43 +00005134 }
drh59145812019-05-22 22:49:23 +00005135 if( pWalker->eCode ){
5136 /* Renumber selId because it has been copied from a view */
5137 p->selId = ++pParse->nSelect;
5138 }
drh7d10d5a2008-08-20 16:35:10 +00005139 pTabList = p->pSrc;
danielk1977b3bce662005-01-29 08:32:43 +00005140 pEList = p->pEList;
drha5746e02018-04-09 20:36:09 +00005141 sqlite3WithPush(pParse, p->pWith, 0);
drh7d10d5a2008-08-20 16:35:10 +00005142
5143 /* Make sure cursor numbers have been assigned to all entries in
5144 ** the FROM clause of the SELECT statement.
5145 */
5146 sqlite3SrcListAssignCursors(pParse, pTabList);
5147
5148 /* Look up every table named in the FROM clause of the select. If
5149 ** an entry of the FROM clause is a subquery instead of a table or view,
5150 ** then create a transient table structure to describe the subquery.
5151 */
5152 for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
5153 Table *pTab;
drhe2b7d7a2015-09-29 15:50:04 +00005154 assert( pFrom->fg.isRecursive==0 || pFrom->pTab!=0 );
dan69887c92020-04-27 20:55:33 +00005155 if( pFrom->pTab ) continue;
5156 assert( pFrom->fg.isRecursive==0 );
drh7d10d5a2008-08-20 16:35:10 +00005157 if( pFrom->zName==0 ){
5158#ifndef SQLITE_OMIT_SUBQUERY
5159 Select *pSel = pFrom->pSelect;
5160 /* A sub-query in the FROM clause of a SELECT */
5161 assert( pSel!=0 );
5162 assert( pFrom->pTab==0 );
drh2b8c5a02015-01-22 12:00:17 +00005163 if( sqlite3WalkSelect(pWalker, pSel) ) return WRC_Abort;
dandfa552f2018-06-02 21:04:28 +00005164 if( sqlite3ExpandSubquery(pParse, pFrom) ) return WRC_Abort;
dan86fb6e12018-05-16 20:58:07 +00005165#endif
drh5abe1d32021-02-21 01:19:42 +00005166#ifndef SQLITE_OMIT_CTE
5167 }else if( (rc = resolveFromTermToCte(pParse, pWalker, pFrom))!=0 ){
5168 if( rc>1 ) return WRC_Abort;
5169 pTab = pFrom->pTab;
5170 assert( pTab!=0 );
5171#endif
drh7d10d5a2008-08-20 16:35:10 +00005172 }else{
5173 /* An ordinary table or view name in the FROM clause */
5174 assert( pFrom->pTab==0 );
dan41fb5cd2012-10-04 19:33:00 +00005175 pFrom->pTab = pTab = sqlite3LocateTableItem(pParse, 0, pFrom);
drh7d10d5a2008-08-20 16:35:10 +00005176 if( pTab==0 ) return WRC_Abort;
drh79df7782016-12-14 14:07:35 +00005177 if( pTab->nTabRef>=0xffff ){
drhd2a56232013-01-28 19:00:20 +00005178 sqlite3ErrorMsg(pParse, "too many references to \"%s\": max 65535",
5179 pTab->zName);
5180 pFrom->pTab = 0;
5181 return WRC_Abort;
5182 }
drh79df7782016-12-14 14:07:35 +00005183 pTab->nTabRef++;
drh20292312015-11-21 13:24:46 +00005184 if( !IsVirtual(pTab) && cannotBeFunction(pParse, pFrom) ){
5185 return WRC_Abort;
5186 }
dan8c812f92020-01-21 16:23:17 +00005187#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
drh20292312015-11-21 13:24:46 +00005188 if( IsVirtual(pTab) || pTab->pSelect ){
drhbfad7be2015-10-11 20:39:46 +00005189 i16 nCol;
drh59145812019-05-22 22:49:23 +00005190 u8 eCodeOrig = pWalker->eCode;
drh7d10d5a2008-08-20 16:35:10 +00005191 if( sqlite3ViewGetColumnNames(pParse, pTab) ) return WRC_Abort;
drh43152cf2009-05-19 19:04:58 +00005192 assert( pFrom->pSelect==0 );
drh11d88e62019-08-15 21:27:20 +00005193 if( pTab->pSelect && (db->flags & SQLITE_EnableView)==0 ){
5194 sqlite3ErrorMsg(pParse, "access to view \"%s\" prohibited",
drh3f681422020-01-07 18:10:56 +00005195 pTab->zName);
5196 }
dan8c812f92020-01-21 16:23:17 +00005197#ifndef SQLITE_OMIT_VIRTUALTABLE
drh3f681422020-01-07 18:10:56 +00005198 if( IsVirtual(pTab)
5199 && pFrom->fg.fromDDL
5200 && ALWAYS(pTab->pVTable!=0)
5201 && pTab->pVTable->eVtabRisk > ((db->flags & SQLITE_TrustedSchema)!=0)
5202 ){
drh32266a12020-01-09 13:08:28 +00005203 sqlite3ErrorMsg(pParse, "unsafe use of virtual table \"%s\"",
5204 pTab->zName);
drh11d88e62019-08-15 21:27:20 +00005205 }
dan8c812f92020-01-21 16:23:17 +00005206#endif
drh43152cf2009-05-19 19:04:58 +00005207 pFrom->pSelect = sqlite3SelectDup(db, pTab->pSelect, 0);
drhbfad7be2015-10-11 20:39:46 +00005208 nCol = pTab->nCol;
5209 pTab->nCol = -1;
drh59145812019-05-22 22:49:23 +00005210 pWalker->eCode = 1; /* Turn on Select.selId renumbering */
drh43152cf2009-05-19 19:04:58 +00005211 sqlite3WalkSelect(pWalker, pFrom->pSelect);
drh59145812019-05-22 22:49:23 +00005212 pWalker->eCode = eCodeOrig;
drhbfad7be2015-10-11 20:39:46 +00005213 pTab->nCol = nCol;
drh7d10d5a2008-08-20 16:35:10 +00005214 }
5215#endif
danielk1977b3bce662005-01-29 08:32:43 +00005216 }
danielk197785574e32008-10-06 05:32:18 +00005217
5218 /* Locate the index named by the INDEXED BY clause, if any. */
drh18622712021-02-20 21:20:54 +00005219 if( pFrom->fg.isIndexedBy && sqlite3IndexedByLookup(pParse, pFrom) ){
danielk1977b1c685b2008-10-06 16:18:39 +00005220 return WRC_Abort;
danielk197785574e32008-10-06 05:32:18 +00005221 }
danielk1977b3bce662005-01-29 08:32:43 +00005222 }
5223
drh7d10d5a2008-08-20 16:35:10 +00005224 /* Process NATURAL keywords, and ON and USING clauses of joins.
danielk1977b3bce662005-01-29 08:32:43 +00005225 */
dana6c1a712019-12-27 20:54:42 +00005226 if( pParse->nErr || db->mallocFailed || sqliteProcessJoin(pParse, p) ){
drh7d10d5a2008-08-20 16:35:10 +00005227 return WRC_Abort;
danielk1977b3bce662005-01-29 08:32:43 +00005228 }
5229
drh7d10d5a2008-08-20 16:35:10 +00005230 /* For every "*" that occurs in the column list, insert the names of
5231 ** all columns in all tables. And for every TABLE.* insert the names
5232 ** of all columns in TABLE. The parser inserted a special expression
drh1a1d3cd2015-11-19 16:33:31 +00005233 ** with the TK_ASTERISK operator for each "*" that it found in the column
5234 ** list. The following code just has to locate the TK_ASTERISK
5235 ** expressions and expand each one to the list of all columns in
5236 ** all tables.
danielk1977b3bce662005-01-29 08:32:43 +00005237 **
drh7d10d5a2008-08-20 16:35:10 +00005238 ** The first loop just checks to see if there are any "*" operators
5239 ** that need expanding.
danielk1977b3bce662005-01-29 08:32:43 +00005240 */
drh7d10d5a2008-08-20 16:35:10 +00005241 for(k=0; k<pEList->nExpr; k++){
drh3e3f1a52013-01-03 00:45:56 +00005242 pE = pEList->a[k].pExpr;
drh1a1d3cd2015-11-19 16:33:31 +00005243 if( pE->op==TK_ASTERISK ) break;
drh43152cf2009-05-19 19:04:58 +00005244 assert( pE->op!=TK_DOT || pE->pRight!=0 );
5245 assert( pE->op!=TK_DOT || (pE->pLeft!=0 && pE->pLeft->op==TK_ID) );
drh1a1d3cd2015-11-19 16:33:31 +00005246 if( pE->op==TK_DOT && pE->pRight->op==TK_ASTERISK ) break;
drhfca23552017-10-28 20:51:54 +00005247 elistFlags |= pE->flags;
danielk1977b3bce662005-01-29 08:32:43 +00005248 }
drh7d10d5a2008-08-20 16:35:10 +00005249 if( k<pEList->nExpr ){
5250 /*
5251 ** If we get here it means the result set contains one or more "*"
5252 ** operators that need to be expanded. Loop through each expression
5253 ** in the result set and expand them one by one.
5254 */
5255 struct ExprList_item *a = pEList->a;
5256 ExprList *pNew = 0;
5257 int flags = pParse->db->flags;
5258 int longNames = (flags & SQLITE_FullColNames)!=0
drh38b384a2013-01-03 17:34:28 +00005259 && (flags & SQLITE_ShortColNames)==0;
5260
drh7d10d5a2008-08-20 16:35:10 +00005261 for(k=0; k<pEList->nExpr; k++){
drh3e3f1a52013-01-03 00:45:56 +00005262 pE = a[k].pExpr;
drhfca23552017-10-28 20:51:54 +00005263 elistFlags |= pE->flags;
drh3e3f1a52013-01-03 00:45:56 +00005264 pRight = pE->pRight;
5265 assert( pE->op!=TK_DOT || pRight!=0 );
drh1a1d3cd2015-11-19 16:33:31 +00005266 if( pE->op!=TK_ASTERISK
5267 && (pE->op!=TK_DOT || pRight->op!=TK_ASTERISK)
5268 ){
drh7d10d5a2008-08-20 16:35:10 +00005269 /* This particular expression does not need to be expanded.
5270 */
drhb7916a72009-05-27 10:31:29 +00005271 pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr);
drh7d10d5a2008-08-20 16:35:10 +00005272 if( pNew ){
drh41cee662019-12-12 20:22:34 +00005273 pNew->a[pNew->nExpr-1].zEName = a[k].zEName;
drhcbb9da32019-12-12 22:11:33 +00005274 pNew->a[pNew->nExpr-1].eEName = a[k].eEName;
drh41cee662019-12-12 20:22:34 +00005275 a[k].zEName = 0;
drh7d10d5a2008-08-20 16:35:10 +00005276 }
5277 a[k].pExpr = 0;
drh7d10d5a2008-08-20 16:35:10 +00005278 }else{
5279 /* This expression is a "*" or a "TABLE.*" and needs to be
5280 ** expanded. */
5281 int tableSeen = 0; /* Set to 1 when TABLE matches */
drh3e3f1a52013-01-03 00:45:56 +00005282 char *zTName = 0; /* text of name of TABLE */
drh43152cf2009-05-19 19:04:58 +00005283 if( pE->op==TK_DOT ){
5284 assert( pE->pLeft!=0 );
drh33e619f2009-05-28 01:00:55 +00005285 assert( !ExprHasProperty(pE->pLeft, EP_IntValue) );
5286 zTName = pE->pLeft->u.zToken;
drh7d10d5a2008-08-20 16:35:10 +00005287 }
5288 for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
5289 Table *pTab = pFrom->pTab;
drh3e3f1a52013-01-03 00:45:56 +00005290 Select *pSub = pFrom->pSelect;
drh7d10d5a2008-08-20 16:35:10 +00005291 char *zTabName = pFrom->zAlias;
drh3e3f1a52013-01-03 00:45:56 +00005292 const char *zSchemaName = 0;
drhc75e09c2013-01-03 16:54:20 +00005293 int iDb;
drh43152cf2009-05-19 19:04:58 +00005294 if( zTabName==0 ){
drh7d10d5a2008-08-20 16:35:10 +00005295 zTabName = pTab->zName;
5296 }
5297 if( db->mallocFailed ) break;
drh3e3f1a52013-01-03 00:45:56 +00005298 if( pSub==0 || (pSub->selFlags & SF_NestedFrom)==0 ){
drh3e3f1a52013-01-03 00:45:56 +00005299 pSub = 0;
5300 if( zTName && sqlite3StrICmp(zTName, zTabName)!=0 ){
5301 continue;
5302 }
5303 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
drh69c33822016-08-18 14:33:11 +00005304 zSchemaName = iDb>=0 ? db->aDb[iDb].zDbSName : "*";
drh7d10d5a2008-08-20 16:35:10 +00005305 }
drh7d10d5a2008-08-20 16:35:10 +00005306 for(j=0; j<pTab->nCol; j++){
drh7d10d5a2008-08-20 16:35:10 +00005307 char *zName = pTab->aCol[j].zName;
drhb7916a72009-05-27 10:31:29 +00005308 char *zColname; /* The computed column name */
5309 char *zToFree; /* Malloced string that needs to be freed */
5310 Token sColname; /* Computed column name as a token */
drh7d10d5a2008-08-20 16:35:10 +00005311
drhc75e09c2013-01-03 16:54:20 +00005312 assert( zName );
drh3e3f1a52013-01-03 00:45:56 +00005313 if( zTName && pSub
drhc4938ea2019-12-13 00:49:42 +00005314 && sqlite3MatchEName(&pSub->pEList->a[j], 0, zTName, 0)==0
drh3e3f1a52013-01-03 00:45:56 +00005315 ){
5316 continue;
5317 }
5318
drh80090f92015-11-19 17:55:11 +00005319 /* If a column is marked as 'hidden', omit it from the expanded
5320 ** result-set list unless the SELECT has the SF_IncludeHidden
5321 ** bit set.
drh7d10d5a2008-08-20 16:35:10 +00005322 */
drh80090f92015-11-19 17:55:11 +00005323 if( (p->selFlags & SF_IncludeHidden)==0
5324 && IsHiddenColumn(&pTab->aCol[j])
5325 ){
drh7d10d5a2008-08-20 16:35:10 +00005326 continue;
5327 }
drh3e3f1a52013-01-03 00:45:56 +00005328 tableSeen = 1;
drh7d10d5a2008-08-20 16:35:10 +00005329
drhda55c482008-12-05 00:00:07 +00005330 if( i>0 && zTName==0 ){
drh8a48b9c2015-08-19 15:20:00 +00005331 if( (pFrom->fg.jointype & JT_NATURAL)!=0
dan9d41af22019-12-30 14:32:27 +00005332 && tableAndColumnIndex(pTabList, i, zName, 0, 0, 1)
drh2179b432009-12-09 17:36:39 +00005333 ){
drh7d10d5a2008-08-20 16:35:10 +00005334 /* In a NATURAL join, omit the join columns from the
drh2179b432009-12-09 17:36:39 +00005335 ** table to the right of the join */
drh7d10d5a2008-08-20 16:35:10 +00005336 continue;
5337 }
drh2179b432009-12-09 17:36:39 +00005338 if( sqlite3IdListIndex(pFrom->pUsing, zName)>=0 ){
drh7d10d5a2008-08-20 16:35:10 +00005339 /* In a join with a USING clause, omit columns in the
5340 ** using clause from the table on the right. */
5341 continue;
5342 }
5343 }
drhb7916a72009-05-27 10:31:29 +00005344 pRight = sqlite3Expr(db, TK_ID, zName);
5345 zColname = zName;
5346 zToFree = 0;
drh7d10d5a2008-08-20 16:35:10 +00005347 if( longNames || pTabList->nSrc>1 ){
drhb7916a72009-05-27 10:31:29 +00005348 Expr *pLeft;
5349 pLeft = sqlite3Expr(db, TK_ID, zTabName);
drhabfd35e2016-12-06 22:47:23 +00005350 pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight);
drh38b384a2013-01-03 17:34:28 +00005351 if( zSchemaName ){
drhc75e09c2013-01-03 16:54:20 +00005352 pLeft = sqlite3Expr(db, TK_ID, zSchemaName);
drhabfd35e2016-12-06 22:47:23 +00005353 pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pExpr);
drhc75e09c2013-01-03 16:54:20 +00005354 }
drhb7916a72009-05-27 10:31:29 +00005355 if( longNames ){
5356 zColname = sqlite3MPrintf(db, "%s.%s", zTabName, zName);
5357 zToFree = zColname;
5358 }
drh7d10d5a2008-08-20 16:35:10 +00005359 }else{
5360 pExpr = pRight;
drh7d10d5a2008-08-20 16:35:10 +00005361 }
drhb7916a72009-05-27 10:31:29 +00005362 pNew = sqlite3ExprListAppend(pParse, pNew, pExpr);
drh40aced52016-01-22 17:48:09 +00005363 sqlite3TokenInit(&sColname, zColname);
drhb7916a72009-05-27 10:31:29 +00005364 sqlite3ExprListSetName(pParse, pNew, &sColname, 0);
drh0990c412020-02-23 17:34:45 +00005365 if( pNew && (p->selFlags & SF_NestedFrom)!=0 && !IN_RENAME_OBJECT ){
drh3e3f1a52013-01-03 00:45:56 +00005366 struct ExprList_item *pX = &pNew->a[pNew->nExpr-1];
drhcbb9da32019-12-12 22:11:33 +00005367 sqlite3DbFree(db, pX->zEName);
drh3e3f1a52013-01-03 00:45:56 +00005368 if( pSub ){
drhcbb9da32019-12-12 22:11:33 +00005369 pX->zEName = sqlite3DbStrDup(db, pSub->pEList->a[j].zEName);
5370 testcase( pX->zEName==0 );
drh3e3f1a52013-01-03 00:45:56 +00005371 }else{
drhcbb9da32019-12-12 22:11:33 +00005372 pX->zEName = sqlite3MPrintf(db, "%s.%s.%s",
drh3e3f1a52013-01-03 00:45:56 +00005373 zSchemaName, zTabName, zColname);
drhcbb9da32019-12-12 22:11:33 +00005374 testcase( pX->zEName==0 );
drh3e3f1a52013-01-03 00:45:56 +00005375 }
drhcbb9da32019-12-12 22:11:33 +00005376 pX->eEName = ENAME_TAB;
drh8f25d182012-12-19 02:36:45 +00005377 }
drhb7916a72009-05-27 10:31:29 +00005378 sqlite3DbFree(db, zToFree);
drh7d10d5a2008-08-20 16:35:10 +00005379 }
5380 }
5381 if( !tableSeen ){
5382 if( zTName ){
5383 sqlite3ErrorMsg(pParse, "no such table: %s", zTName);
5384 }else{
5385 sqlite3ErrorMsg(pParse, "no tables specified");
5386 }
5387 }
drh7d10d5a2008-08-20 16:35:10 +00005388 }
drh9a993342007-12-13 02:45:31 +00005389 }
drh7d10d5a2008-08-20 16:35:10 +00005390 sqlite3ExprListDelete(db, pEList);
5391 p->pEList = pNew;
drh4c774312007-12-08 21:10:20 +00005392 }
drhfca23552017-10-28 20:51:54 +00005393 if( p->pEList ){
5394 if( p->pEList->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
5395 sqlite3ErrorMsg(pParse, "too many columns in result set");
5396 return WRC_Abort;
5397 }
5398 if( (elistFlags & (EP_HasFunc|EP_Subquery))!=0 ){
5399 p->selFlags |= SF_ComplexResult;
5400 }
drh994c80a2007-04-12 21:25:01 +00005401 }
drh7d10d5a2008-08-20 16:35:10 +00005402 return WRC_Continue;
5403}
danielk1977b3bce662005-01-29 08:32:43 +00005404
drh979dd1b2017-05-29 14:26:07 +00005405#if SQLITE_DEBUG
5406/*
5407** Always assert. This xSelectCallback2 implementation proves that the
5408** xSelectCallback2 is never invoked.
5409*/
5410void sqlite3SelectWalkAssert2(Walker *NotUsed, Select *NotUsed2){
5411 UNUSED_PARAMETER2(NotUsed, NotUsed2);
5412 assert( 0 );
5413}
5414#endif
5415/*
drh7d10d5a2008-08-20 16:35:10 +00005416** This routine "expands" a SELECT statement and all of its subqueries.
5417** For additional information on what it means to "expand" a SELECT
5418** statement, see the comment on the selectExpand worker callback above.
5419**
5420** Expanding a SELECT statement is the first step in processing a
5421** SELECT statement. The SELECT statement must be expanded before
5422** name resolution is performed.
5423**
5424** If anything goes wrong, an error message is written into pParse.
5425** The calling function can detect the problem by looking at pParse->nErr
5426** and/or pParse->db->mallocFailed.
5427*/
5428static void sqlite3SelectExpand(Parse *pParse, Select *pSelect){
5429 Walker w;
drh5b88bc42013-12-07 23:35:21 +00005430 w.xExprCallback = sqlite3ExprWalkNoop;
drh7d10d5a2008-08-20 16:35:10 +00005431 w.pParse = pParse;
drh878fcf92017-10-02 23:50:08 +00005432 if( OK_IF_ALWAYS_TRUE(pParse->hasCompound) ){
drhd58d3272013-08-05 22:05:02 +00005433 w.xSelectCallback = convertCompoundSelectToSubquery;
drh979dd1b2017-05-29 14:26:07 +00005434 w.xSelectCallback2 = 0;
drhd58d3272013-08-05 22:05:02 +00005435 sqlite3WalkSelect(&w, pSelect);
5436 }
drhc01b7302013-05-07 17:49:08 +00005437 w.xSelectCallback = selectExpander;
dan067cd832017-02-03 19:16:39 +00005438 w.xSelectCallback2 = selectPopWith;
drh59145812019-05-22 22:49:23 +00005439 w.eCode = 0;
drhc01b7302013-05-07 17:49:08 +00005440 sqlite3WalkSelect(&w, pSelect);
drh7d10d5a2008-08-20 16:35:10 +00005441}
5442
5443
5444#ifndef SQLITE_OMIT_SUBQUERY
5445/*
5446** This is a Walker.xSelectCallback callback for the sqlite3SelectTypeInfo()
5447** interface.
5448**
5449** For each FROM-clause subquery, add Column.zType and Column.zColl
5450** information to the Table structure that represents the result set
5451** of that subquery.
5452**
5453** The Table structure that represents the result set was constructed
5454** by selectExpander() but the type and collation information was omitted
5455** at that point because identifiers had not yet been resolved. This
5456** routine is called after identifier resolution.
5457*/
danb290f112014-01-17 14:59:27 +00005458static void selectAddSubqueryTypeInfo(Walker *pWalker, Select *p){
drh7d10d5a2008-08-20 16:35:10 +00005459 Parse *pParse;
5460 int i;
5461 SrcList *pTabList;
drh76012942021-02-21 21:04:54 +00005462 SrcItem *pFrom;
drh7d10d5a2008-08-20 16:35:10 +00005463
drh9d8b3072008-08-22 16:29:51 +00005464 assert( p->selFlags & SF_Resolved );
dancc464412018-06-19 18:11:05 +00005465 if( p->selFlags & SF_HasTypeInfo ) return;
drhe2b7d7a2015-09-29 15:50:04 +00005466 p->selFlags |= SF_HasTypeInfo;
5467 pParse = pWalker->pParse;
5468 pTabList = p->pSrc;
5469 for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
5470 Table *pTab = pFrom->pTab;
5471 assert( pTab!=0 );
5472 if( (pTab->tabFlags & TF_Ephemeral)!=0 ){
5473 /* A sub-query in the FROM clause of a SELECT */
5474 Select *pSel = pFrom->pSelect;
5475 if( pSel ){
5476 while( pSel->pPrior ) pSel = pSel->pPrior;
drh96fb16e2019-08-06 14:37:24 +00005477 sqlite3SelectAddColumnTypeAndCollation(pParse, pTab, pSel,
5478 SQLITE_AFF_NONE);
drh5a29d9c2010-02-24 15:10:14 +00005479 }
drh13449892005-09-07 21:22:45 +00005480 }
5481 }
drh7d10d5a2008-08-20 16:35:10 +00005482}
5483#endif
drh13449892005-09-07 21:22:45 +00005484
drh7d10d5a2008-08-20 16:35:10 +00005485
5486/*
5487** This routine adds datatype and collating sequence information to
5488** the Table structures of all FROM-clause subqueries in a
5489** SELECT statement.
5490**
5491** Use this routine after name resolution.
5492*/
5493static void sqlite3SelectAddTypeInfo(Parse *pParse, Select *pSelect){
5494#ifndef SQLITE_OMIT_SUBQUERY
5495 Walker w;
drh979dd1b2017-05-29 14:26:07 +00005496 w.xSelectCallback = sqlite3SelectWalkNoop;
danb290f112014-01-17 14:59:27 +00005497 w.xSelectCallback2 = selectAddSubqueryTypeInfo;
drh5b88bc42013-12-07 23:35:21 +00005498 w.xExprCallback = sqlite3ExprWalkNoop;
drh7d10d5a2008-08-20 16:35:10 +00005499 w.pParse = pParse;
5500 sqlite3WalkSelect(&w, pSelect);
5501#endif
5502}
5503
5504
5505/*
drh030796d2012-08-23 16:18:10 +00005506** This routine sets up a SELECT statement for processing. The
drh7d10d5a2008-08-20 16:35:10 +00005507** following is accomplished:
5508**
5509** * VDBE Cursor numbers are assigned to all FROM-clause terms.
5510** * Ephemeral Table objects are created for all FROM-clause subqueries.
5511** * ON and USING clauses are shifted into WHERE statements
5512** * Wildcards "*" and "TABLE.*" in result sets are expanded.
5513** * Identifiers in expression are matched to tables.
5514**
5515** This routine acts recursively on all subqueries within the SELECT.
5516*/
5517void sqlite3SelectPrep(
5518 Parse *pParse, /* The parser context */
5519 Select *p, /* The SELECT statement being coded. */
5520 NameContext *pOuterNC /* Name context for container */
5521){
drhe2463392017-10-03 14:24:24 +00005522 assert( p!=0 || pParse->db->mallocFailed );
5523 if( pParse->db->mallocFailed ) return;
drh7d10d5a2008-08-20 16:35:10 +00005524 if( p->selFlags & SF_HasTypeInfo ) return;
drh7d10d5a2008-08-20 16:35:10 +00005525 sqlite3SelectExpand(pParse, p);
drhb7651e62017-10-02 23:30:45 +00005526 if( pParse->nErr || pParse->db->mallocFailed ) return;
drh7d10d5a2008-08-20 16:35:10 +00005527 sqlite3ResolveSelectNames(pParse, p, pOuterNC);
drhb7651e62017-10-02 23:30:45 +00005528 if( pParse->nErr || pParse->db->mallocFailed ) return;
drh7d10d5a2008-08-20 16:35:10 +00005529 sqlite3SelectAddTypeInfo(pParse, p);
danielk1977b3bce662005-01-29 08:32:43 +00005530}
5531
5532/*
drh13449892005-09-07 21:22:45 +00005533** Reset the aggregate accumulator.
5534**
5535** The aggregate accumulator is a set of memory cells that hold
5536** intermediate results while calculating an aggregate. This
drh030796d2012-08-23 16:18:10 +00005537** routine generates code that stores NULLs in all of those memory
5538** cells.
danielk1977b3bce662005-01-29 08:32:43 +00005539*/
drh13449892005-09-07 21:22:45 +00005540static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){
5541 Vdbe *v = pParse->pVdbe;
5542 int i;
drhc99130f2005-09-11 11:56:27 +00005543 struct AggInfo_func *pFunc;
drh7e61d182013-12-20 13:11:45 +00005544 int nReg = pAggInfo->nFunc + pAggInfo->nColumn;
5545 if( nReg==0 ) return;
drh64185e32020-06-29 16:30:10 +00005546 if( pParse->nErr || pParse->db->mallocFailed ) return;
drh7e61d182013-12-20 13:11:45 +00005547#ifdef SQLITE_DEBUG
5548 /* Verify that all AggInfo registers are within the range specified by
5549 ** AggInfo.mnReg..AggInfo.mxReg */
5550 assert( nReg==pAggInfo->mxReg-pAggInfo->mnReg+1 );
drh13449892005-09-07 21:22:45 +00005551 for(i=0; i<pAggInfo->nColumn; i++){
drh7e61d182013-12-20 13:11:45 +00005552 assert( pAggInfo->aCol[i].iMem>=pAggInfo->mnReg
5553 && pAggInfo->aCol[i].iMem<=pAggInfo->mxReg );
drh13449892005-09-07 21:22:45 +00005554 }
drh7e61d182013-12-20 13:11:45 +00005555 for(i=0; i<pAggInfo->nFunc; i++){
5556 assert( pAggInfo->aFunc[i].iMem>=pAggInfo->mnReg
5557 && pAggInfo->aFunc[i].iMem<=pAggInfo->mxReg );
5558 }
5559#endif
5560 sqlite3VdbeAddOp3(v, OP_Null, 0, pAggInfo->mnReg, pAggInfo->mxReg);
drhc99130f2005-09-11 11:56:27 +00005561 for(pFunc=pAggInfo->aFunc, i=0; i<pAggInfo->nFunc; i++, pFunc++){
drhc99130f2005-09-11 11:56:27 +00005562 if( pFunc->iDistinct>=0 ){
drh81185a52020-06-09 13:38:12 +00005563 Expr *pE = pFunc->pFExpr;
danielk19776ab3a2e2009-02-19 14:39:25 +00005564 assert( !ExprHasProperty(pE, EP_xIsSelect) );
5565 if( pE->x.pList==0 || pE->x.pList->nExpr!=1 ){
drh0daa0022009-02-09 13:19:28 +00005566 sqlite3ErrorMsg(pParse, "DISTINCT aggregates must have exactly one "
5567 "argument");
drhc99130f2005-09-11 11:56:27 +00005568 pFunc->iDistinct = -1;
5569 }else{
danf9eae182018-05-21 19:45:11 +00005570 KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pE->x.pList,0,0);
drh66a51672008-01-03 00:01:23 +00005571 sqlite3VdbeAddOp4(v, OP_OpenEphemeral, pFunc->iDistinct, 0, 0,
drh2ec2fb22013-11-06 19:59:23 +00005572 (char*)pKeyInfo, P4_KEYINFO);
drhc99130f2005-09-11 11:56:27 +00005573 }
5574 }
drh13449892005-09-07 21:22:45 +00005575 }
danielk1977b3bce662005-01-29 08:32:43 +00005576}
5577
5578/*
drh13449892005-09-07 21:22:45 +00005579** Invoke the OP_AggFinalize opcode for every aggregate function
5580** in the AggInfo structure.
danielk1977b3bce662005-01-29 08:32:43 +00005581*/
drh13449892005-09-07 21:22:45 +00005582static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){
5583 Vdbe *v = pParse->pVdbe;
5584 int i;
5585 struct AggInfo_func *pF;
5586 for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
drh81185a52020-06-09 13:38:12 +00005587 ExprList *pList = pF->pFExpr->x.pList;
5588 assert( !ExprHasProperty(pF->pFExpr, EP_xIsSelect) );
drh2700aca2016-12-08 01:38:24 +00005589 sqlite3VdbeAddOp2(v, OP_AggFinal, pF->iMem, pList ? pList->nExpr : 0);
5590 sqlite3VdbeAppendP4(v, pF->pFunc, P4_FUNCDEF);
drh13449892005-09-07 21:22:45 +00005591 }
danielk1977b3bce662005-01-29 08:32:43 +00005592}
drh13449892005-09-07 21:22:45 +00005593
dan280c8942018-06-05 20:04:28 +00005594
drh13449892005-09-07 21:22:45 +00005595/*
5596** Update the accumulator memory cells for an aggregate based on
5597** the current cursor position.
dan280c8942018-06-05 20:04:28 +00005598**
5599** If regAcc is non-zero and there are no min() or max() aggregates
5600** in pAggInfo, then only populate the pAggInfo->nAccumulator accumulator
drh10cc16c2019-03-01 21:12:40 +00005601** registers if register regAcc contains 0. The caller will take care
dan280c8942018-06-05 20:04:28 +00005602** of setting and clearing regAcc.
drh13449892005-09-07 21:22:45 +00005603*/
dan280c8942018-06-05 20:04:28 +00005604static void updateAccumulator(Parse *pParse, int regAcc, AggInfo *pAggInfo){
drh13449892005-09-07 21:22:45 +00005605 Vdbe *v = pParse->pVdbe;
5606 int i;
drh7a957892012-02-02 17:35:43 +00005607 int regHit = 0;
5608 int addrHitTest = 0;
drh13449892005-09-07 21:22:45 +00005609 struct AggInfo_func *pF;
5610 struct AggInfo_col *pC;
drh13449892005-09-07 21:22:45 +00005611
5612 pAggInfo->directMode = 1;
5613 for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
5614 int nArg;
drhc99130f2005-09-11 11:56:27 +00005615 int addrNext = 0;
drh98757152008-01-09 23:04:12 +00005616 int regAgg;
drh81185a52020-06-09 13:38:12 +00005617 ExprList *pList = pF->pFExpr->x.pList;
5618 assert( !ExprHasProperty(pF->pFExpr, EP_xIsSelect) );
5619 assert( !IsWindowFunc(pF->pFExpr) );
5620 if( ExprHasProperty(pF->pFExpr, EP_WinFunc) ){
5621 Expr *pFilter = pF->pFExpr->y.pWin->pFilter;
daned09ddd2019-09-20 20:52:16 +00005622 if( pAggInfo->nAccumulator
5623 && (pF->pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL)
danfa4b0d42020-07-01 14:07:45 +00005624 && regAcc
daned09ddd2019-09-20 20:52:16 +00005625 ){
danfa4b0d42020-07-01 14:07:45 +00005626 /* If regAcc==0, there there exists some min() or max() function
5627 ** without a FILTER clause that will ensure the magnet registers
5628 ** are populated. */
daned09ddd2019-09-20 20:52:16 +00005629 if( regHit==0 ) regHit = ++pParse->nMem;
danfa4b0d42020-07-01 14:07:45 +00005630 /* If this is the first row of the group (regAcc contains 0), clear the
daned09ddd2019-09-20 20:52:16 +00005631 ** "magnet" register regHit so that the accumulator registers
danaf9b58b2019-09-20 21:12:40 +00005632 ** are populated if the FILTER clause jumps over the the
5633 ** invocation of min() or max() altogether. Or, if this is not
danfa4b0d42020-07-01 14:07:45 +00005634 ** the first row (regAcc contains 1), set the magnet register so that
5635 ** the accumulators are not populated unless the min()/max() is invoked
5636 ** and indicates that they should be. */
daned09ddd2019-09-20 20:52:16 +00005637 sqlite3VdbeAddOp2(v, OP_Copy, regAcc, regHit);
5638 }
dan6ba7ab02019-07-02 11:56:47 +00005639 addrNext = sqlite3VdbeMakeLabel(pParse);
5640 sqlite3ExprIfFalse(pParse, pFilter, addrNext, SQLITE_JUMPIFNULL);
5641 }
drh13449892005-09-07 21:22:45 +00005642 if( pList ){
5643 nArg = pList->nExpr;
drh892d3172008-01-10 03:46:36 +00005644 regAgg = sqlite3GetTempRange(pParse, nArg);
drh5579d592015-08-26 14:01:41 +00005645 sqlite3ExprCodeExprList(pParse, pList, regAgg, 0, SQLITE_ECEL_DUP);
drh13449892005-09-07 21:22:45 +00005646 }else{
5647 nArg = 0;
drh98757152008-01-09 23:04:12 +00005648 regAgg = 0;
drh13449892005-09-07 21:22:45 +00005649 }
drhc99130f2005-09-11 11:56:27 +00005650 if( pF->iDistinct>=0 ){
dan6ba7ab02019-07-02 11:56:47 +00005651 if( addrNext==0 ){
5652 addrNext = sqlite3VdbeMakeLabel(pParse);
5653 }
drh7c052da2015-04-21 15:16:48 +00005654 testcase( nArg==0 ); /* Error condition */
5655 testcase( nArg>1 ); /* Also an error */
drh2dcef112008-01-12 19:03:48 +00005656 codeDistinct(pParse, pF->iDistinct, addrNext, 1, regAgg);
drhc99130f2005-09-11 11:56:27 +00005657 }
drhd36e1042013-09-06 13:10:12 +00005658 if( pF->pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL ){
drh13449892005-09-07 21:22:45 +00005659 CollSeq *pColl = 0;
5660 struct ExprList_item *pItem;
5661 int j;
drhe82f5d02008-10-07 19:53:14 +00005662 assert( pList!=0 ); /* pList!=0 if pF->pFunc has NEEDCOLL */
drh43617e92006-03-06 20:55:46 +00005663 for(j=0, pItem=pList->a; !pColl && j<nArg; j++, pItem++){
drh13449892005-09-07 21:22:45 +00005664 pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
5665 }
5666 if( !pColl ){
5667 pColl = pParse->db->pDfltColl;
5668 }
drh7a957892012-02-02 17:35:43 +00005669 if( regHit==0 && pAggInfo->nAccumulator ) regHit = ++pParse->nMem;
5670 sqlite3VdbeAddOp4(v, OP_CollSeq, regHit, 0, 0, (char *)pColl, P4_COLLSEQ);
drh13449892005-09-07 21:22:45 +00005671 }
drh8f26da62018-07-05 21:22:57 +00005672 sqlite3VdbeAddOp3(v, OP_AggStep, 0, regAgg, pF->iMem);
drh2700aca2016-12-08 01:38:24 +00005673 sqlite3VdbeAppendP4(v, pF->pFunc, P4_FUNCDEF);
drhea678832008-12-10 19:26:22 +00005674 sqlite3VdbeChangeP5(v, (u8)nArg);
drhf49f3522009-12-30 14:12:38 +00005675 sqlite3ReleaseTempRange(pParse, regAgg, nArg);
drhc99130f2005-09-11 11:56:27 +00005676 if( addrNext ){
5677 sqlite3VdbeResolveLabel(v, addrNext);
5678 }
drh13449892005-09-07 21:22:45 +00005679 }
dan280c8942018-06-05 20:04:28 +00005680 if( regHit==0 && pAggInfo->nAccumulator ){
5681 regHit = regAcc;
5682 }
drh7a957892012-02-02 17:35:43 +00005683 if( regHit ){
drh688852a2014-02-17 22:40:43 +00005684 addrHitTest = sqlite3VdbeAddOp1(v, OP_If, regHit); VdbeCoverage(v);
drh7a957892012-02-02 17:35:43 +00005685 }
drh13449892005-09-07 21:22:45 +00005686 for(i=0, pC=pAggInfo->aCol; i<pAggInfo->nAccumulator; i++, pC++){
drh81185a52020-06-09 13:38:12 +00005687 sqlite3ExprCode(pParse, pC->pCExpr, pC->iMem);
drh13449892005-09-07 21:22:45 +00005688 }
daned09ddd2019-09-20 20:52:16 +00005689
drh13449892005-09-07 21:22:45 +00005690 pAggInfo->directMode = 0;
drh7a957892012-02-02 17:35:43 +00005691 if( addrHitTest ){
drhdc4f6fc2020-02-07 19:44:13 +00005692 sqlite3VdbeJumpHereOrPopInst(v, addrHitTest);
drh7a957892012-02-02 17:35:43 +00005693 }
drh13449892005-09-07 21:22:45 +00005694}
5695
danielk1977b3bce662005-01-29 08:32:43 +00005696/*
danef7075d2011-02-21 17:49:49 +00005697** Add a single OP_Explain instruction to the VDBE to explain a simple
5698** count(*) query ("SELECT count(*) FROM pTab").
5699*/
5700#ifndef SQLITE_OMIT_EXPLAIN
5701static void explainSimpleCount(
5702 Parse *pParse, /* Parse context */
5703 Table *pTab, /* Table being queried */
5704 Index *pIdx /* Index used to optimize scan, or NULL */
5705){
5706 if( pParse->explain==2 ){
drh48dd1d82014-05-27 18:18:58 +00005707 int bCover = (pIdx!=0 && (HasRowid(pTab) || !IsPrimaryKeyIndex(pIdx)));
drhe2ca99c2018-05-02 00:33:43 +00005708 sqlite3VdbeExplain(pParse, 0, "SCAN TABLE %s%s%s",
dane96f2df2014-05-23 17:17:06 +00005709 pTab->zName,
5710 bCover ? " USING COVERING INDEX " : "",
5711 bCover ? pIdx->zName : ""
danef7075d2011-02-21 17:49:49 +00005712 );
danef7075d2011-02-21 17:49:49 +00005713 }
5714}
5715#else
5716# define explainSimpleCount(a,b,c)
5717#endif
5718
5719/*
danab31a842017-04-29 20:53:09 +00005720** sqlite3WalkExpr() callback used by havingToWhere().
5721**
5722** If the node passed to the callback is a TK_AND node, return
5723** WRC_Continue to tell sqlite3WalkExpr() to iterate through child nodes.
5724**
5725** Otherwise, return WRC_Prune. In this case, also check if the
5726** sub-expression matches the criteria for being moved to the WHERE
5727** clause. If so, add it to the WHERE clause and replace the sub-expression
5728** within the HAVING expression with a constant "1".
5729*/
5730static int havingToWhereExprCb(Walker *pWalker, Expr *pExpr){
5731 if( pExpr->op!=TK_AND ){
drhcd0abc22018-03-20 18:08:33 +00005732 Select *pS = pWalker->u.pSelect;
danf39168e2020-12-22 16:23:29 +00005733 if( sqlite3ExprIsConstantOrGroupBy(pWalker->pParse, pExpr, pS->pGroupBy)
5734 && ExprAlwaysFalse(pExpr)==0
5735 ){
danab31a842017-04-29 20:53:09 +00005736 sqlite3 *db = pWalker->pParse->db;
drh5776ee52019-09-23 12:38:10 +00005737 Expr *pNew = sqlite3Expr(db, TK_INTEGER, "1");
danab31a842017-04-29 20:53:09 +00005738 if( pNew ){
drhcd0abc22018-03-20 18:08:33 +00005739 Expr *pWhere = pS->pWhere;
danab31a842017-04-29 20:53:09 +00005740 SWAP(Expr, *pNew, *pExpr);
drhd5c851c2019-04-19 13:38:34 +00005741 pNew = sqlite3ExprAnd(pWalker->pParse, pWhere, pNew);
drhcd0abc22018-03-20 18:08:33 +00005742 pS->pWhere = pNew;
5743 pWalker->eCode = 1;
danab31a842017-04-29 20:53:09 +00005744 }
5745 }
5746 return WRC_Prune;
5747 }
5748 return WRC_Continue;
5749}
5750
5751/*
5752** Transfer eligible terms from the HAVING clause of a query, which is
5753** processed after grouping, to the WHERE clause, which is processed before
5754** grouping. For example, the query:
5755**
5756** SELECT * FROM <tables> WHERE a=? GROUP BY b HAVING b=? AND c=?
5757**
5758** can be rewritten as:
5759**
5760** SELECT * FROM <tables> WHERE a=? AND b=? GROUP BY b HAVING c=?
5761**
5762** A term of the HAVING expression is eligible for transfer if it consists
5763** entirely of constants and expressions that are also GROUP BY terms that
5764** use the "BINARY" collation sequence.
5765*/
drhcd0abc22018-03-20 18:08:33 +00005766static void havingToWhere(Parse *pParse, Select *p){
danab31a842017-04-29 20:53:09 +00005767 Walker sWalker;
danab31a842017-04-29 20:53:09 +00005768 memset(&sWalker, 0, sizeof(sWalker));
5769 sWalker.pParse = pParse;
5770 sWalker.xExprCallback = havingToWhereExprCb;
drhcd0abc22018-03-20 18:08:33 +00005771 sWalker.u.pSelect = p;
5772 sqlite3WalkExpr(&sWalker, p->pHaving);
5773#if SELECTTRACE_ENABLED
drhc0622a42020-12-04 01:17:57 +00005774 if( sWalker.eCode && (sqlite3SelectTrace & 0x100)!=0 ){
drhcd0abc22018-03-20 18:08:33 +00005775 SELECTTRACE(0x100,pParse,p,("Move HAVING terms into WHERE:\n"));
5776 sqlite3TreeViewSelect(0, p, 0);
5777 }
5778#endif
danab31a842017-04-29 20:53:09 +00005779}
5780
5781/*
drhe08e8d62017-05-01 15:15:41 +00005782** Check to see if the pThis entry of pTabList is a self-join of a prior view.
5783** If it is, then return the SrcList_item for the prior view. If it is not,
5784** then return 0.
5785*/
drh76012942021-02-21 21:04:54 +00005786static SrcItem *isSelfJoinView(
drhe08e8d62017-05-01 15:15:41 +00005787 SrcList *pTabList, /* Search for self-joins in this FROM clause */
drh76012942021-02-21 21:04:54 +00005788 SrcItem *pThis /* Search for prior reference to this subquery */
drhe08e8d62017-05-01 15:15:41 +00005789){
drh76012942021-02-21 21:04:54 +00005790 SrcItem *pItem;
drh8794c682021-02-13 16:39:24 +00005791 assert( pThis->pSelect!=0 );
5792 if( pThis->pSelect->selFlags & SF_PushDown ) return 0;
drhe08e8d62017-05-01 15:15:41 +00005793 for(pItem = pTabList->a; pItem<pThis; pItem++){
drhbdefaf02018-12-27 02:16:01 +00005794 Select *pS1;
drhe08e8d62017-05-01 15:15:41 +00005795 if( pItem->pSelect==0 ) continue;
5796 if( pItem->fg.viaCoroutine ) continue;
drh33543c22017-05-01 16:37:20 +00005797 if( pItem->zName==0 ) continue;
drh30ad79a2019-05-23 16:38:12 +00005798 assert( pItem->pTab!=0 );
5799 assert( pThis->pTab!=0 );
5800 if( pItem->pTab->pSchema!=pThis->pTab->pSchema ) continue;
drhed712982017-05-01 17:04:35 +00005801 if( sqlite3_stricmp(pItem->zName, pThis->zName)!=0 ) continue;
drhbdefaf02018-12-27 02:16:01 +00005802 pS1 = pItem->pSelect;
drh30ad79a2019-05-23 16:38:12 +00005803 if( pItem->pTab->pSchema==0 && pThis->pSelect->selId!=pS1->selId ){
drhbdefaf02018-12-27 02:16:01 +00005804 /* The query flattener left two different CTE tables with identical
5805 ** names in the same FROM clause. */
5806 continue;
5807 }
drh8794c682021-02-13 16:39:24 +00005808 if( pItem->pSelect->selFlags & SF_PushDown ){
drhed712982017-05-01 17:04:35 +00005809 /* The view was modified by some other optimization such as
5810 ** pushDownWhereTerms() */
5811 continue;
5812 }
5813 return pItem;
drhe08e8d62017-05-01 15:15:41 +00005814 }
5815 return 0;
5816}
5817
drhc54246f2021-02-17 21:13:14 +00005818/*
5819** Deallocate a single AggInfo object
5820*/
5821static void agginfoFree(sqlite3 *db, AggInfo *p){
5822 sqlite3DbFree(db, p->aCol);
5823 sqlite3DbFree(db, p->aFunc);
5824 sqlite3DbFreeNN(db, p);
5825}
5826
drh269ba802017-07-04 19:34:36 +00005827#ifdef SQLITE_COUNTOFVIEW_OPTIMIZATION
5828/*
5829** Attempt to transform a query of the form
5830**
5831** SELECT count(*) FROM (SELECT x FROM t1 UNION ALL SELECT y FROM t2)
5832**
5833** Into this:
5834**
5835** SELECT (SELECT count(*) FROM t1)+(SELECT count(*) FROM t2)
5836**
5837** The transformation only works if all of the following are true:
5838**
5839** * The subquery is a UNION ALL of two or more terms
dana4b5fb52018-08-03 20:19:52 +00005840** * The subquery does not have a LIMIT clause
drh269ba802017-07-04 19:34:36 +00005841** * There is no WHERE or GROUP BY or HAVING clauses on the subqueries
drh73c53b32019-05-15 18:42:15 +00005842** * The outer query is a simple count(*) with no WHERE clause or other
5843** extraneous syntax.
drh269ba802017-07-04 19:34:36 +00005844**
5845** Return TRUE if the optimization is undertaken.
5846*/
5847static int countOfViewOptimization(Parse *pParse, Select *p){
5848 Select *pSub, *pPrior;
5849 Expr *pExpr;
5850 Expr *pCount;
5851 sqlite3 *db;
drh3d240d22017-09-28 16:56:55 +00005852 if( (p->selFlags & SF_Aggregate)==0 ) return 0; /* This is an aggregate */
drh269ba802017-07-04 19:34:36 +00005853 if( p->pEList->nExpr!=1 ) return 0; /* Single result column */
drh73c53b32019-05-15 18:42:15 +00005854 if( p->pWhere ) return 0;
5855 if( p->pGroupBy ) return 0;
drh269ba802017-07-04 19:34:36 +00005856 pExpr = p->pEList->a[0].pExpr;
5857 if( pExpr->op!=TK_AGG_FUNCTION ) return 0; /* Result is an aggregate */
drh3d240d22017-09-28 16:56:55 +00005858 if( sqlite3_stricmp(pExpr->u.zToken,"count") ) return 0; /* Is count() */
drh269ba802017-07-04 19:34:36 +00005859 if( pExpr->x.pList!=0 ) return 0; /* Must be count(*) */
drh3d240d22017-09-28 16:56:55 +00005860 if( p->pSrc->nSrc!=1 ) return 0; /* One table in FROM */
drh269ba802017-07-04 19:34:36 +00005861 pSub = p->pSrc->a[0].pSelect;
5862 if( pSub==0 ) return 0; /* The FROM is a subquery */
drh3d240d22017-09-28 16:56:55 +00005863 if( pSub->pPrior==0 ) return 0; /* Must be a compound ry */
drh269ba802017-07-04 19:34:36 +00005864 do{
5865 if( pSub->op!=TK_ALL && pSub->pPrior ) return 0; /* Must be UNION ALL */
5866 if( pSub->pWhere ) return 0; /* No WHERE clause */
dana4b5fb52018-08-03 20:19:52 +00005867 if( pSub->pLimit ) return 0; /* No LIMIT clause */
drh269ba802017-07-04 19:34:36 +00005868 if( pSub->selFlags & SF_Aggregate ) return 0; /* Not an aggregate */
drh3d240d22017-09-28 16:56:55 +00005869 pSub = pSub->pPrior; /* Repeat over compound */
drh269ba802017-07-04 19:34:36 +00005870 }while( pSub );
5871
drh3d240d22017-09-28 16:56:55 +00005872 /* If we reach this point then it is OK to perform the transformation */
drh269ba802017-07-04 19:34:36 +00005873
5874 db = pParse->db;
5875 pCount = pExpr;
5876 pExpr = 0;
5877 pSub = p->pSrc->a[0].pSelect;
5878 p->pSrc->a[0].pSelect = 0;
5879 sqlite3SrcListDelete(db, p->pSrc);
5880 p->pSrc = sqlite3DbMallocZero(pParse->db, sizeof(*p->pSrc));
5881 while( pSub ){
5882 Expr *pTerm;
5883 pPrior = pSub->pPrior;
5884 pSub->pPrior = 0;
5885 pSub->pNext = 0;
5886 pSub->selFlags |= SF_Aggregate;
5887 pSub->selFlags &= ~SF_Compound;
5888 pSub->nSelectRow = 0;
5889 sqlite3ExprListDelete(db, pSub->pEList);
5890 pTerm = pPrior ? sqlite3ExprDup(db, pCount, 0) : pCount;
5891 pSub->pEList = sqlite3ExprListAppend(pParse, 0, pTerm);
5892 pTerm = sqlite3PExpr(pParse, TK_SELECT, 0, 0);
5893 sqlite3PExprAddSelect(pParse, pTerm, pSub);
5894 if( pExpr==0 ){
5895 pExpr = pTerm;
5896 }else{
5897 pExpr = sqlite3PExpr(pParse, TK_PLUS, pTerm, pExpr);
5898 }
5899 pSub = pPrior;
5900 }
5901 p->pEList->a[0].pExpr = pExpr;
5902 p->selFlags &= ~SF_Aggregate;
5903
5904#if SELECTTRACE_ENABLED
drhc0622a42020-12-04 01:17:57 +00005905 if( sqlite3SelectTrace & 0x400 ){
drh269ba802017-07-04 19:34:36 +00005906 SELECTTRACE(0x400,pParse,p,("After count-of-view optimization:\n"));
5907 sqlite3TreeViewSelect(0, p, 0);
5908 }
5909#endif
5910 return 1;
5911}
5912#endif /* SQLITE_COUNTOFVIEW_OPTIMIZATION */
5913
drhe08e8d62017-05-01 15:15:41 +00005914/*
drh7d10d5a2008-08-20 16:35:10 +00005915** Generate code for the SELECT statement given in the p argument.
drh9bb61fe2000-06-05 16:01:39 +00005916**
drh340309f2014-01-22 00:23:49 +00005917** The results are returned according to the SelectDest structure.
5918** See comments in sqliteInt.h for further information.
drhe78e8282003-01-19 03:59:45 +00005919**
drh9bb61fe2000-06-05 16:01:39 +00005920** This routine returns the number of errors. If any errors are
5921** encountered, then an appropriate error message is left in
5922** pParse->zErrMsg.
5923**
5924** This routine does NOT free the Select structure passed in. The
5925** calling function needs to do that.
5926*/
danielk19774adee202004-05-08 08:23:19 +00005927int sqlite3Select(
drhcce7d172000-05-31 15:34:51 +00005928 Parse *pParse, /* The parser context */
drh9bb61fe2000-06-05 16:01:39 +00005929 Select *p, /* The SELECT statement being coded. */
drh7d10d5a2008-08-20 16:35:10 +00005930 SelectDest *pDest /* What to do with the query results */
drhcce7d172000-05-31 15:34:51 +00005931){
drh13449892005-09-07 21:22:45 +00005932 int i, j; /* Loop counters */
5933 WhereInfo *pWInfo; /* Return from sqlite3WhereBegin() */
5934 Vdbe *v; /* The virtual machine under construction */
danielk1977b3bce662005-01-29 08:32:43 +00005935 int isAgg; /* True for select lists like "count(*)" */
mistachkinc29cbb02015-07-02 16:52:01 +00005936 ExprList *pEList = 0; /* List of columns to extract. */
drhad3cab52002-05-24 02:04:32 +00005937 SrcList *pTabList; /* List of tables to select from */
drh9bb61fe2000-06-05 16:01:39 +00005938 Expr *pWhere; /* The WHERE clause. May be NULL */
drh22827922000-06-06 17:27:05 +00005939 ExprList *pGroupBy; /* The GROUP BY clause. May be NULL */
5940 Expr *pHaving; /* The HAVING clause. May be NULL */
drhbf790972020-06-07 20:18:07 +00005941 AggInfo *pAggInfo = 0; /* Aggregate information */
drh1d83f052002-02-17 00:30:36 +00005942 int rc = 1; /* Value to return from this function */
drhe8e4af72012-09-21 00:04:28 +00005943 DistinctCtx sDistinct; /* Info on how to code the DISTINCT keyword */
drh079a3072014-03-19 14:10:55 +00005944 SortCtx sSort; /* Info on how to code the ORDER BY clause */
drhec7429a2005-10-06 16:53:14 +00005945 int iEnd; /* Address of the end of the query */
drh17435752007-08-16 04:30:38 +00005946 sqlite3 *db; /* The database connection */
drh47d9f832017-10-26 20:04:28 +00005947 ExprList *pMinMaxOrderBy = 0; /* Added ORDER BY for min/max queries */
5948 u8 minMaxFlag; /* Flag for min/max queries */
drh9bb61fe2000-06-05 16:01:39 +00005949
drh17435752007-08-16 04:30:38 +00005950 db = pParse->db;
drhe2ca99c2018-05-02 00:33:43 +00005951 v = sqlite3GetVdbe(pParse);
drh17435752007-08-16 04:30:38 +00005952 if( p==0 || db->mallocFailed || pParse->nErr ){
drh6f7adc82006-01-11 21:41:20 +00005953 return 1;
5954 }
danielk19774adee202004-05-08 08:23:19 +00005955 if( sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1;
drhe2ca99c2018-05-02 00:33:43 +00005956#if SELECTTRACE_ENABLED
5957 SELECTTRACE(1,pParse,p, ("begin processing:\n", pParse->addrExplain));
drhc0622a42020-12-04 01:17:57 +00005958 if( sqlite3SelectTrace & 0x100 ){
drhc90713d2014-09-30 13:46:49 +00005959 sqlite3TreeViewSelect(0, p, 0);
5960 }
drheb9b8842014-09-21 00:27:26 +00005961#endif
drhdaffd0e2001-04-11 14:28:42 +00005962
drh8e1ee882014-03-21 19:56:09 +00005963 assert( p->pOrderBy==0 || pDest->eDest!=SRT_DistFifo );
5964 assert( p->pOrderBy==0 || pDest->eDest!=SRT_Fifo );
dan9afccba2014-03-21 19:27:54 +00005965 assert( p->pOrderBy==0 || pDest->eDest!=SRT_DistQueue );
5966 assert( p->pOrderBy==0 || pDest->eDest!=SRT_Queue );
drhf1ea4252020-09-17 00:46:09 +00005967 if( IgnorableDistinct(pDest) ){
5968 assert(pDest->eDest==SRT_Exists || pDest->eDest==SRT_Union ||
5969 pDest->eDest==SRT_Except || pDest->eDest==SRT_Discard ||
5970 pDest->eDest==SRT_DistQueue || pDest->eDest==SRT_DistFifo );
5971 /* All of these destinations are also able to ignore the ORDER BY clause */
drhccfcbce2009-05-18 15:46:07 +00005972 sqlite3ExprListDelete(db, p->pOrderBy);
5973 p->pOrderBy = 0;
drh7d10d5a2008-08-20 16:35:10 +00005974 p->selFlags &= ~SF_Distinct;
drhb7cbf5c2020-06-15 13:51:34 +00005975 p->selFlags |= SF_NoopOrderBy;
drh9a993342007-12-13 02:45:31 +00005976 }
drh7d10d5a2008-08-20 16:35:10 +00005977 sqlite3SelectPrep(pParse, p, 0);
danielk1977956f4312008-11-21 09:43:20 +00005978 if( pParse->nErr || db->mallocFailed ){
drh9a993342007-12-13 02:45:31 +00005979 goto select_end;
5980 }
drhadc57f62015-06-06 00:18:01 +00005981 assert( p->pEList!=0 );
drh17645f52015-02-09 13:42:59 +00005982#if SELECTTRACE_ENABLED
drhc0622a42020-12-04 01:17:57 +00005983 if( sqlite3SelectTrace & 0x104 ){
drhe2243d22018-04-23 17:18:03 +00005984 SELECTTRACE(0x104,pParse,p, ("after name resolution:\n"));
drh17645f52015-02-09 13:42:59 +00005985 sqlite3TreeViewSelect(0, p, 0);
5986 }
5987#endif
drhcce7d172000-05-31 15:34:51 +00005988
dan07ca7d62020-07-17 16:31:37 +00005989 /* If the SF_UpdateFrom flag is set, then this function is being called
5990 ** as part of populating the temp table for an UPDATE...FROM statement.
5991 ** In this case, it is an error if the target object (pSrc->a[0]) name
5992 ** or alias is duplicated within FROM clause (pSrc->a[1..n]). */
5993 if( p->selFlags & SF_UpdateFrom ){
drh76012942021-02-21 21:04:54 +00005994 SrcItem *p0 = &p->pSrc->a[0];
dan07ca7d62020-07-17 16:31:37 +00005995 for(i=1; i<p->pSrc->nSrc; i++){
drh76012942021-02-21 21:04:54 +00005996 SrcItem *p1 = &p->pSrc->a[i];
dan07ca7d62020-07-17 16:31:37 +00005997 if( p0->pTab==p1->pTab && 0==sqlite3_stricmp(p0->zAlias, p1->zAlias) ){
5998 sqlite3ErrorMsg(pParse,
5999 "target object/alias may not appear in FROM clause: %s",
6000 p0->zAlias ? p0->zAlias : p0->pTab->zName
6001 );
6002 goto select_end;
6003 }
6004 }
6005 }
6006
drhf35f2f92017-07-29 16:01:55 +00006007 if( pDest->eDest==SRT_Output ){
6008 generateColumnNames(pParse, p);
6009 }
6010
dan67a9b8e2018-06-22 20:51:35 +00006011#ifndef SQLITE_OMIT_WINDOWFUNC
drha9ebfe22019-12-25 23:54:21 +00006012 rc = sqlite3WindowRewrite(pParse, p);
6013 if( rc ){
drhaaa5ba02019-12-26 00:53:43 +00006014 assert( db->mallocFailed || pParse->nErr>0 );
dan86fb6e12018-05-16 20:58:07 +00006015 goto select_end;
6016 }
dandfa552f2018-06-02 21:04:28 +00006017#if SELECTTRACE_ENABLED
drhc0622a42020-12-04 01:17:57 +00006018 if( p->pWin && (sqlite3SelectTrace & 0x108)!=0 ){
dandfa552f2018-06-02 21:04:28 +00006019 SELECTTRACE(0x104,pParse,p, ("after window rewrite:\n"));
6020 sqlite3TreeViewSelect(0, p, 0);
6021 }
6022#endif
dan67a9b8e2018-06-22 20:51:35 +00006023#endif /* SQLITE_OMIT_WINDOWFUNC */
dan86fb6e12018-05-16 20:58:07 +00006024 pTabList = p->pSrc;
dan73925692018-06-12 18:40:17 +00006025 isAgg = (p->selFlags & SF_Aggregate)!=0;
danf02cdd32018-06-27 19:48:50 +00006026 memset(&sSort, 0, sizeof(sSort));
6027 sSort.pOrderBy = p->pOrderBy;
dan86fb6e12018-05-16 20:58:07 +00006028
drh9216de82020-06-11 00:57:09 +00006029 /* Try to do various optimizations (flattening subqueries, and strength
drh25897872018-03-20 21:16:15 +00006030 ** reduction of join operators) in the FROM clause up into the main query
drhd820cb12002-02-18 03:21:45 +00006031 */
drh51522cd2005-01-20 13:36:19 +00006032#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
danielk1977f23329a2008-07-01 14:09:13 +00006033 for(i=0; !p->pPrior && i<pTabList->nSrc; i++){
drh76012942021-02-21 21:04:54 +00006034 SrcItem *pItem = &pTabList->a[i];
danielk1977daf79ac2008-06-30 18:12:28 +00006035 Select *pSub = pItem->pSelect;
drh2679f142015-09-25 13:42:55 +00006036 Table *pTab = pItem->pTab;
drh25897872018-03-20 21:16:15 +00006037
drhb5aaee52020-06-11 16:04:10 +00006038 /* The expander should have already created transient Table objects
6039 ** even for FROM clause elements such as subqueries that do not correspond
6040 ** to a real table */
6041 assert( pTab!=0 );
6042
drh25897872018-03-20 21:16:15 +00006043 /* Convert LEFT JOIN into JOIN if there are terms of the right table
6044 ** of the LEFT JOIN used in the WHERE clause.
6045 */
6046 if( (pItem->fg.jointype & JT_LEFT)!=0
6047 && sqlite3ExprImpliesNonNullRow(p->pWhere, pItem->iCursor)
6048 && OptimizationEnabled(db, SQLITE_SimplifyJoin)
6049 ){
6050 SELECTTRACE(0x100,pParse,p,
6051 ("LEFT-JOIN simplifies to JOIN on term %d\n",i));
drhefce69d2018-03-20 22:52:27 +00006052 pItem->fg.jointype &= ~(JT_LEFT|JT_OUTER);
drh25897872018-03-20 21:16:15 +00006053 unsetJoinExpr(p->pWhere, pItem->iCursor);
6054 }
6055
6056 /* No futher action if this term of the FROM clause is no a subquery */
drh4490c402015-06-05 22:33:39 +00006057 if( pSub==0 ) continue;
drh2679f142015-09-25 13:42:55 +00006058
6059 /* Catch mismatch in the declared columns of a view and the number of
6060 ** columns in the SELECT on the RHS */
6061 if( pTab->nCol!=pSub->pEList->nExpr ){
6062 sqlite3ErrorMsg(pParse, "expected %d columns for '%s' but got %d",
6063 pTab->nCol, pTab->zName, pSub->pEList->nExpr);
6064 goto select_end;
6065 }
6066
drh25c221e2017-09-29 22:13:24 +00006067 /* Do not try to flatten an aggregate subquery.
6068 **
6069 ** Flattening an aggregate subquery is only possible if the outer query
6070 ** is not a join. But if the outer query is not a join, then the subquery
6071 ** will be implemented as a co-routine and there is no advantage to
6072 ** flattening in that case.
6073 */
6074 if( (pSub->selFlags & SF_Aggregate)!=0 ) continue;
6075 assert( pSub->pGroupBy==0 );
6076
drhfca23552017-10-28 20:51:54 +00006077 /* If the outer query contains a "complex" result set (that is,
6078 ** if the result set of the outer query uses functions or subqueries)
6079 ** and if the subquery contains an ORDER BY clause and if
drh648fe492017-09-28 20:06:53 +00006080 ** it will be implemented as a co-routine, then do not flatten. This
6081 ** restriction allows SQL constructs like this:
6082 **
6083 ** SELECT expensive_function(x)
6084 ** FROM (SELECT x FROM tab ORDER BY y LIMIT 10);
6085 **
6086 ** The expensive_function() is only computed on the 10 rows that
6087 ** are output, rather than every row of the table.
drhfca23552017-10-28 20:51:54 +00006088 **
6089 ** The requirement that the outer query have a complex result set
6090 ** means that flattening does occur on simpler SQL constraints without
6091 ** the expensive_function() like:
6092 **
6093 ** SELECT x FROM (SELECT x FROM tab ORDER BY y LIMIT 10);
drh648fe492017-09-28 20:06:53 +00006094 */
drh25c221e2017-09-29 22:13:24 +00006095 if( pSub->pOrderBy!=0
drh648fe492017-09-28 20:06:53 +00006096 && i==0
drhfca23552017-10-28 20:51:54 +00006097 && (p->selFlags & SF_ComplexResult)!=0
drh648fe492017-09-28 20:06:53 +00006098 && (pTabList->nSrc==1
6099 || (pTabList->a[1].fg.jointype&(JT_LEFT|JT_CROSS))!=0)
drh648fe492017-09-28 20:06:53 +00006100 ){
6101 continue;
6102 }
6103
drh25c221e2017-09-29 22:13:24 +00006104 if( flattenSubquery(pParse, p, i, isAgg) ){
drh4acd7542019-02-06 00:55:47 +00006105 if( pParse->nErr ) goto select_end;
drh4490c402015-06-05 22:33:39 +00006106 /* This subquery can be absorbed into its parent. */
drh4490c402015-06-05 22:33:39 +00006107 i = -1;
6108 }
6109 pTabList = p->pSrc;
6110 if( db->mallocFailed ) goto select_end;
6111 if( !IgnorableOrderby(pDest) ){
6112 sSort.pOrderBy = p->pOrderBy;
6113 }
6114 }
6115#endif
6116
drh4490c402015-06-05 22:33:39 +00006117#ifndef SQLITE_OMIT_COMPOUND_SELECT
6118 /* Handle compound SELECT statements using the separate multiSelect()
6119 ** procedure.
6120 */
6121 if( p->pPrior ){
6122 rc = multiSelect(pParse, p, pDest);
drh4490c402015-06-05 22:33:39 +00006123#if SELECTTRACE_ENABLED
drhf20609d2018-04-23 17:43:35 +00006124 SELECTTRACE(0x1,pParse,p,("end compound-select processing\n"));
drhc0622a42020-12-04 01:17:57 +00006125 if( (sqlite3SelectTrace & 0x2000)!=0 && ExplainQueryPlanParent(pParse)==0 ){
drhf20609d2018-04-23 17:43:35 +00006126 sqlite3TreeViewSelect(0, p, 0);
6127 }
drh4490c402015-06-05 22:33:39 +00006128#endif
drhc631ded2018-05-02 02:22:22 +00006129 if( p->pNext==0 ) ExplainQueryPlanPop(pParse);
drh4490c402015-06-05 22:33:39 +00006130 return rc;
6131 }
6132#endif
6133
drh7810ab62018-07-27 17:51:20 +00006134 /* Do the WHERE-clause constant propagation optimization if this is
6135 ** a join. No need to speed time on this operation for non-join queries
6136 ** as the equivalent optimization will be handled by query planner in
6137 ** sqlite3WhereBegin().
6138 */
6139 if( pTabList->nSrc>1
6140 && OptimizationEnabled(db, SQLITE_PropagateConst)
drh24e11162018-07-26 23:47:11 +00006141 && propagateConstants(pParse, p)
6142 ){
6143#if SELECTTRACE_ENABLED
drhc0622a42020-12-04 01:17:57 +00006144 if( sqlite3SelectTrace & 0x100 ){
drh24e11162018-07-26 23:47:11 +00006145 SELECTTRACE(0x100,pParse,p,("After constant propagation:\n"));
6146 sqlite3TreeViewSelect(0, p, 0);
6147 }
6148#endif
6149 }else{
drh7810ab62018-07-27 17:51:20 +00006150 SELECTTRACE(0x100,pParse,p,("Constant propagation not helpful\n"));
drh24e11162018-07-26 23:47:11 +00006151 }
6152
dana4b5fb52018-08-03 20:19:52 +00006153#ifdef SQLITE_COUNTOFVIEW_OPTIMIZATION
6154 if( OptimizationEnabled(db, SQLITE_QueryFlattener|SQLITE_CountOfView)
6155 && countOfViewOptimization(pParse, p)
6156 ){
6157 if( db->mallocFailed ) goto select_end;
6158 pEList = p->pEList;
6159 pTabList = p->pSrc;
6160 }
6161#endif
6162
drh701caf12017-05-10 16:12:00 +00006163 /* For each term in the FROM clause, do two things:
6164 ** (1) Authorized unreferenced tables
6165 ** (2) Generate code for all sub-queries
drhd820cb12002-02-18 03:21:45 +00006166 */
drh4490c402015-06-05 22:33:39 +00006167 for(i=0; i<pTabList->nSrc; i++){
drh76012942021-02-21 21:04:54 +00006168 SrcItem *pItem = &pTabList->a[i];
drha79e2a22021-02-21 23:44:14 +00006169 SrcItem *pPrior;
drh13449892005-09-07 21:22:45 +00006170 SelectDest dest;
drh701caf12017-05-10 16:12:00 +00006171 Select *pSub;
drh824d21a2017-09-29 12:44:52 +00006172#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
6173 const char *zSavedAuthContext;
6174#endif
drh701caf12017-05-10 16:12:00 +00006175
drh3d240d22017-09-28 16:56:55 +00006176 /* Issue SQLITE_READ authorizations with a fake column name for any
6177 ** tables that are referenced but from which no values are extracted.
6178 ** Examples of where these kinds of null SQLITE_READ authorizations
6179 ** would occur:
drh701caf12017-05-10 16:12:00 +00006180 **
drh2336c932017-05-11 12:05:23 +00006181 ** SELECT count(*) FROM t1; -- SQLITE_READ t1.""
6182 ** SELECT t1.* FROM t1, t2; -- SQLITE_READ t2.""
6183 **
6184 ** The fake column name is an empty string. It is possible for a table to
6185 ** have a column named by the empty string, in which case there is no way to
6186 ** distinguish between an unreferenced table and an actual reference to the
drh3d240d22017-09-28 16:56:55 +00006187 ** "" column. The original design was for the fake column name to be a NULL,
drh2336c932017-05-11 12:05:23 +00006188 ** which would be unambiguous. But legacy authorization callbacks might
drh3d240d22017-09-28 16:56:55 +00006189 ** assume the column name is non-NULL and segfault. The use of an empty
6190 ** string for the fake column name seems safer.
drh701caf12017-05-10 16:12:00 +00006191 */
drh74c490e2019-08-07 13:25:21 +00006192 if( pItem->colUsed==0 && pItem->zName!=0 ){
drh2336c932017-05-11 12:05:23 +00006193 sqlite3AuthCheck(pParse, SQLITE_READ, pItem->zName, "", pItem->zDatabase);
drh701caf12017-05-10 16:12:00 +00006194 }
6195
6196#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
6197 /* Generate code for all sub-queries in the FROM clause
6198 */
6199 pSub = pItem->pSelect;
drh5b6a9ed2011-09-15 23:58:14 +00006200 if( pSub==0 ) continue;
drh21172c42012-10-30 00:29:07 +00006201
drhd471bcb2018-12-31 20:13:12 +00006202 /* The code for a subquery should only be generated once, though it is
6203 ** technically harmless for it to be generated multiple times. The
6204 ** following assert() will detect if something changes to cause
6205 ** the same subquery to be coded multiple times, as a signal to the
drh00c12a52019-07-24 23:15:19 +00006206 ** developers to try to optimize the situation.
6207 **
6208 ** Update 2019-07-24:
6209 ** See ticket https://sqlite.org/src/tktview/c52b09c7f38903b1311cec40.
6210 ** The dbsqlfuzz fuzzer found a case where the same subquery gets
6211 ** coded twice. So this assert() now becomes a testcase(). It should
6212 ** be very rare, though.
6213 */
6214 testcase( pItem->addrFillSub!=0 );
danielk1977daf79ac2008-06-30 18:12:28 +00006215
danielk1977fc976062007-05-10 10:46:56 +00006216 /* Increment Parse.nHeight by the height of the largest expression
drhf7b54962013-05-28 12:11:54 +00006217 ** tree referred to by this, the parent select. The child select
danielk1977fc976062007-05-10 10:46:56 +00006218 ** may contain expression trees of at most
6219 ** (SQLITE_MAX_EXPR_DEPTH-Parse.nHeight) height. This is a bit
6220 ** more conservative than necessary, but much easier than enforcing
6221 ** an exact limit.
6222 */
6223 pParse->nHeight += sqlite3SelectExprHeight(p);
danielk1977daf79ac2008-06-30 18:12:28 +00006224
drhadc57f62015-06-06 00:18:01 +00006225 /* Make copies of constant WHERE-clause terms in the outer query down
6226 ** inside the subquery. This can help the subquery to run more efficiently.
6227 */
drh7fbb1012018-03-21 01:59:46 +00006228 if( OptimizationEnabled(db, SQLITE_PushDown)
drha79e2a22021-02-21 23:44:14 +00006229 && (pItem->fg.isCte==0 || pItem->u2.pCteUse->nUse<=1)
drh6a9b9522018-03-27 15:13:43 +00006230 && pushDownWhereTerms(pParse, pSub, p->pWhere, pItem->iCursor,
6231 (pItem->fg.jointype & JT_OUTER)!=0)
drh4490c402015-06-05 22:33:39 +00006232 ){
drh69b72d52015-06-01 20:28:03 +00006233#if SELECTTRACE_ENABLED
drhc0622a42020-12-04 01:17:57 +00006234 if( sqlite3SelectTrace & 0x100 ){
drhd2a44012018-07-28 14:34:22 +00006235 SELECTTRACE(0x100,pParse,p,
6236 ("After WHERE-clause push-down into subquery %d:\n", pSub->selId));
drh4490c402015-06-05 22:33:39 +00006237 sqlite3TreeViewSelect(0, p, 0);
danielk1977daf79ac2008-06-30 18:12:28 +00006238 }
drh69b72d52015-06-01 20:28:03 +00006239#endif
drh8794c682021-02-13 16:39:24 +00006240 assert( pItem->pSelect && (pItem->pSelect->selFlags & SF_PushDown)!=0 );
drh2d277bb2018-03-20 11:24:30 +00006241 }else{
6242 SELECTTRACE(0x100,pParse,p,("Push-down not possible\n"));
drh4490c402015-06-05 22:33:39 +00006243 }
drhadc57f62015-06-06 00:18:01 +00006244
drh824d21a2017-09-29 12:44:52 +00006245 zSavedAuthContext = pParse->zAuthContext;
6246 pParse->zAuthContext = pItem->zName;
6247
drhadc57f62015-06-06 00:18:01 +00006248 /* Generate code to implement the subquery
drh0ff47e92016-03-15 17:52:12 +00006249 **
drha79e2a22021-02-21 23:44:14 +00006250 ** The subquery is implemented as a co-routine if:
6251 ** (1) the subquery is guaranteed to be the outer loop (so that
6252 ** it does not need to be computed more than once), and
6253 ** (2) the subquery is not a CTE that is used more then once.
drh0ff47e92016-03-15 17:52:12 +00006254 **
drha79e2a22021-02-21 23:44:14 +00006255 ** TODO: Are there other reasons beside (1) and (2) to use a co-routine
drh0ff47e92016-03-15 17:52:12 +00006256 ** implementation?
drhadc57f62015-06-06 00:18:01 +00006257 */
drh0ff47e92016-03-15 17:52:12 +00006258 if( i==0
6259 && (pTabList->nSrc==1
6260 || (pTabList->a[1].fg.jointype&(JT_LEFT|JT_CROSS))!=0) /* (1) */
drha79e2a22021-02-21 23:44:14 +00006261 && (pItem->fg.isCte==0 || pItem->u2.pCteUse->nUse<2) /* (2) */
drha5759672012-10-30 14:39:12 +00006262 ){
drh21172c42012-10-30 00:29:07 +00006263 /* Implement a co-routine that will return a single row of the result
6264 ** set on each invocation.
6265 */
drh4490c402015-06-05 22:33:39 +00006266 int addrTop = sqlite3VdbeCurrentAddr(v)+1;
drh824d21a2017-09-29 12:44:52 +00006267
drh21172c42012-10-30 00:29:07 +00006268 pItem->regReturn = ++pParse->nMem;
drh4490c402015-06-05 22:33:39 +00006269 sqlite3VdbeAddOp3(v, OP_InitCoroutine, pItem->regReturn, 0, addrTop);
6270 VdbeComment((v, "%s", pItem->pTab->zName));
drh21172c42012-10-30 00:29:07 +00006271 pItem->addrFillSub = addrTop;
drh21172c42012-10-30 00:29:07 +00006272 sqlite3SelectDestInit(&dest, SRT_Coroutine, pItem->regReturn);
drhfef37762018-07-10 19:48:35 +00006273 ExplainQueryPlan((pParse, 1, "CO-ROUTINE %u", pSub->selId));
drh21172c42012-10-30 00:29:07 +00006274 sqlite3Select(pParse, pSub, &dest);
drhc3489bb2016-02-25 16:04:59 +00006275 pItem->pTab->nRowLogEst = pSub->nSelectRow;
drh8a48b9c2015-08-19 15:20:00 +00006276 pItem->fg.viaCoroutine = 1;
drh4490c402015-06-05 22:33:39 +00006277 pItem->regResult = dest.iSdst;
drh2fade2f2016-02-09 02:12:20 +00006278 sqlite3VdbeEndCoroutine(v, pItem->regReturn);
drh21172c42012-10-30 00:29:07 +00006279 sqlite3VdbeJumpHere(v, addrTop-1);
6280 sqlite3ClearTempRegCache(pParse);
drha79e2a22021-02-21 23:44:14 +00006281 }else if( pItem->fg.isCte && pItem->u2.pCteUse->addrM9e>0 ){
6282 /* This is a CTE for which materialization code has already been
6283 ** generated. Invoke the subroutine to compute the materialization,
6284 ** the make the pItem->iCursor be a copy of the ephemerial table that
6285 ** holds the result of the materialization. */
6286 CteUse *pCteUse = pItem->u2.pCteUse;
6287 sqlite3VdbeAddOp2(v, OP_Gosub, pCteUse->regRtn, pCteUse->addrM9e);
6288 if( pItem->iCursor!=pCteUse->iCur ){
6289 sqlite3VdbeAddOp2(v, OP_OpenDup, pItem->iCursor, pCteUse->iCur);
6290 }
6291 pSub->nSelectRow = pCteUse->nRowEst;
6292 }else if( (pPrior = isSelfJoinView(pTabList, pItem))!=0 ){
6293 /* This view has already been materialized by a prior entry in
6294 ** this same FROM clause. Reuse it. */
6295 if( pPrior->addrFillSub ){
6296 sqlite3VdbeAddOp2(v, OP_Gosub, pPrior->regReturn, pPrior->addrFillSub);
6297 }
6298 sqlite3VdbeAddOp2(v, OP_OpenDup, pItem->iCursor, pPrior->iCursor);
6299 pSub->nSelectRow = pPrior->pSelect->nSelectRow;
danielk1977daf79ac2008-06-30 18:12:28 +00006300 }else{
drha79e2a22021-02-21 23:44:14 +00006301 /* Generate a subroutine that will materialize the view. */
drh7157e8e2011-09-16 16:00:51 +00006302 int topAddr;
drh48f2d3b2011-09-16 01:34:43 +00006303 int onceAddr = 0;
drh7157e8e2011-09-16 16:00:51 +00006304 int retAddr;
drhe08e8d62017-05-01 15:15:41 +00006305
drh00c12a52019-07-24 23:15:19 +00006306 testcase( pItem->addrFillSub==0 ); /* Ticket c52b09c7f38903b1311 */
drh5b6a9ed2011-09-15 23:58:14 +00006307 pItem->regReturn = ++pParse->nMem;
drh7157e8e2011-09-16 16:00:51 +00006308 topAddr = sqlite3VdbeAddOp2(v, OP_Integer, 0, pItem->regReturn);
6309 pItem->addrFillSub = topAddr+1;
drh8a48b9c2015-08-19 15:20:00 +00006310 if( pItem->fg.isCorrelated==0 ){
drhed171672013-04-24 13:50:09 +00006311 /* If the subquery is not correlated and if we are not inside of
drh5b6a9ed2011-09-15 23:58:14 +00006312 ** a trigger, then we only need to compute the value of the subquery
6313 ** once. */
drh511f9e82016-09-22 18:53:13 +00006314 onceAddr = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
drh4490c402015-06-05 22:33:39 +00006315 VdbeComment((v, "materialize \"%s\"", pItem->pTab->zName));
drh69b72d52015-06-01 20:28:03 +00006316 }else{
drh4490c402015-06-05 22:33:39 +00006317 VdbeNoopComment((v, "materialize \"%s\"", pItem->pTab->zName));
drh5b6a9ed2011-09-15 23:58:14 +00006318 }
drha79e2a22021-02-21 23:44:14 +00006319 sqlite3SelectDestInit(&dest, SRT_EphemTab, pItem->iCursor);
6320 ExplainQueryPlan((pParse, 1, "MATERIALIZE %u", pSub->selId));
6321 sqlite3Select(pParse, pSub, &dest);
drhc3489bb2016-02-25 16:04:59 +00006322 pItem->pTab->nRowLogEst = pSub->nSelectRow;
drh48f2d3b2011-09-16 01:34:43 +00006323 if( onceAddr ) sqlite3VdbeJumpHere(v, onceAddr);
drh7157e8e2011-09-16 16:00:51 +00006324 retAddr = sqlite3VdbeAddOp1(v, OP_Return, pItem->regReturn);
6325 VdbeComment((v, "end %s", pItem->pTab->zName));
6326 sqlite3VdbeChangeP1(v, topAddr, retAddr);
drhcdc69552011-12-06 13:24:59 +00006327 sqlite3ClearTempRegCache(pParse);
drha79e2a22021-02-21 23:44:14 +00006328 if( pItem->fg.isCte ){
6329 CteUse *pCteUse = pItem->u2.pCteUse;
6330 pCteUse->addrM9e = pItem->addrFillSub;
6331 pCteUse->regRtn = pItem->regReturn;
6332 pCteUse->iCur = pItem->iCursor;
6333 pCteUse->nRowEst = pSub->nSelectRow;
6334 }
danielk1977daf79ac2008-06-30 18:12:28 +00006335 }
drhadc57f62015-06-06 00:18:01 +00006336 if( db->mallocFailed ) goto select_end;
danielk1977fc976062007-05-10 10:46:56 +00006337 pParse->nHeight -= sqlite3SelectExprHeight(p);
drh824d21a2017-09-29 12:44:52 +00006338 pParse->zAuthContext = zSavedAuthContext;
drh51522cd2005-01-20 13:36:19 +00006339#endif
drh701caf12017-05-10 16:12:00 +00006340 }
drhadc57f62015-06-06 00:18:01 +00006341
drh38b41492015-06-08 15:08:15 +00006342 /* Various elements of the SELECT copied into local variables for
6343 ** convenience */
drhadc57f62015-06-06 00:18:01 +00006344 pEList = p->pEList;
danielk1977daf79ac2008-06-30 18:12:28 +00006345 pWhere = p->pWhere;
6346 pGroupBy = p->pGroupBy;
6347 pHaving = p->pHaving;
drhe8e4af72012-09-21 00:04:28 +00006348 sDistinct.isTnct = (p->selFlags & SF_Distinct)!=0;
drh832508b2002-03-02 17:04:07 +00006349
drhbc8edba2015-06-05 20:27:26 +00006350#if SELECTTRACE_ENABLED
drhc0622a42020-12-04 01:17:57 +00006351 if( sqlite3SelectTrace & 0x400 ){
drhbc8edba2015-06-05 20:27:26 +00006352 SELECTTRACE(0x400,pParse,p,("After all FROM-clause analysis:\n"));
6353 sqlite3TreeViewSelect(0, p, 0);
danielk1977f23329a2008-07-01 14:09:13 +00006354 }
6355#endif
6356
dan50118cd2011-07-01 14:21:38 +00006357 /* If the query is DISTINCT with an ORDER BY but is not an aggregate, and
6358 ** if the select-list is the same as the ORDER BY list, then this query
6359 ** can be rewritten as a GROUP BY. In other words, this:
6360 **
6361 ** SELECT DISTINCT xyz FROM ... ORDER BY xyz
6362 **
6363 ** is transformed to:
6364 **
drhdea7d702014-12-04 21:54:58 +00006365 ** SELECT xyz FROM ... GROUP BY xyz ORDER BY xyz
dan50118cd2011-07-01 14:21:38 +00006366 **
6367 ** The second form is preferred as a single index (or temp-table) may be
6368 ** used for both the ORDER BY and DISTINCT processing. As originally
6369 ** written the query must use a temp-table for at least one of the ORDER
6370 ** BY and DISTINCT, and an index or separate temp-table for the other.
6371 */
6372 if( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct
drhadc57f62015-06-06 00:18:01 +00006373 && sqlite3ExprListCompare(sSort.pOrderBy, pEList, -1)==0
drhef9f7192020-01-17 19:14:08 +00006374#ifndef SQLITE_OMIT_WINDOWFUNC
dane59c5622019-11-22 10:14:01 +00006375 && p->pWin==0
drhef9f7192020-01-17 19:14:08 +00006376#endif
dan50118cd2011-07-01 14:21:38 +00006377 ){
6378 p->selFlags &= ~SF_Distinct;
drhadc57f62015-06-06 00:18:01 +00006379 pGroupBy = p->pGroupBy = sqlite3ExprListDup(db, pEList, 0);
dan9e10f9a2020-01-06 17:06:12 +00006380 p->selFlags |= SF_Aggregate;
drhe8e4af72012-09-21 00:04:28 +00006381 /* Notice that even thought SF_Distinct has been cleared from p->selFlags,
6382 ** the sDistinct.isTnct is still set. Hence, isTnct represents the
6383 ** original setting of the SF_Distinct flag, not the current setting */
6384 assert( sDistinct.isTnct );
drh7512cb42016-04-14 13:06:49 +00006385
6386#if SELECTTRACE_ENABLED
drhc0622a42020-12-04 01:17:57 +00006387 if( sqlite3SelectTrace & 0x400 ){
drh7512cb42016-04-14 13:06:49 +00006388 SELECTTRACE(0x400,pParse,p,("Transform DISTINCT into GROUP BY:\n"));
6389 sqlite3TreeViewSelect(0, p, 0);
6390 }
6391#endif
dan50118cd2011-07-01 14:21:38 +00006392 }
6393
drhadc57f62015-06-06 00:18:01 +00006394 /* If there is an ORDER BY clause, then create an ephemeral index to
6395 ** do the sorting. But this sorting ephemeral index might end up
6396 ** being unused if the data can be extracted in pre-sorted order.
6397 ** If that is the case, then the OP_OpenEphemeral instruction will be
6398 ** changed to an OP_Noop once we figure out that the sorting index is
6399 ** not needed. The sSort.addrSortIndex variable is used to facilitate
6400 ** that change.
danielk19777cedc8d2004-06-10 10:50:08 +00006401 */
drh079a3072014-03-19 14:10:55 +00006402 if( sSort.pOrderBy ){
drh0342b1f2005-09-01 03:07:44 +00006403 KeyInfo *pKeyInfo;
danf9eae182018-05-21 19:45:11 +00006404 pKeyInfo = sqlite3KeyInfoFromExprList(
6405 pParse, sSort.pOrderBy, 0, pEList->nExpr);
drh079a3072014-03-19 14:10:55 +00006406 sSort.iECursor = pParse->nTab++;
6407 sSort.addrSortIndex =
drh66a51672008-01-03 00:01:23 +00006408 sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
drhf45f2322014-03-23 17:45:03 +00006409 sSort.iECursor, sSort.pOrderBy->nExpr+1+pEList->nExpr, 0,
6410 (char*)pKeyInfo, P4_KEYINFO
6411 );
drh9d2985c2005-09-08 01:58:42 +00006412 }else{
drh079a3072014-03-19 14:10:55 +00006413 sSort.addrSortIndex = -1;
danielk19777cedc8d2004-06-10 10:50:08 +00006414 }
6415
drh2d0794e2002-03-03 03:03:52 +00006416 /* If the output is destined for a temporary table, open that table.
6417 */
danielk19776c8c8ce2008-01-02 16:27:09 +00006418 if( pDest->eDest==SRT_EphemTab ){
drh2b596da2012-07-23 21:43:19 +00006419 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pDest->iSDParm, pEList->nExpr);
drh2d0794e2002-03-03 03:03:52 +00006420 }
6421
drhf42bacc2006-04-26 17:39:34 +00006422 /* Set the limiter.
6423 */
drhec4ccdb2018-12-29 02:26:59 +00006424 iEnd = sqlite3VdbeMakeLabel(pParse);
dan69b93832016-12-16 15:05:40 +00006425 if( (p->selFlags & SF_FixedLimit)==0 ){
6426 p->nSelectRow = 320; /* 4 billion rows */
6427 }
drhf42bacc2006-04-26 17:39:34 +00006428 computeLimitRegisters(pParse, p, iEnd);
drh079a3072014-03-19 14:10:55 +00006429 if( p->iLimit==0 && sSort.addrSortIndex>=0 ){
drh0ff287f2015-09-02 18:40:33 +00006430 sqlite3VdbeChangeOpcode(v, sSort.addrSortIndex, OP_SorterOpen);
drh079a3072014-03-19 14:10:55 +00006431 sSort.sortFlags |= SORTFLAG_UseSorter;
drhc6aff302011-09-01 15:32:47 +00006432 }
drhf42bacc2006-04-26 17:39:34 +00006433
drhadc57f62015-06-06 00:18:01 +00006434 /* Open an ephemeral index to use for the distinct set.
drhefb72512000-05-31 20:00:52 +00006435 */
dan2ce22452010-11-08 19:01:16 +00006436 if( p->selFlags & SF_Distinct ){
drhe8e4af72012-09-21 00:04:28 +00006437 sDistinct.tabTnct = pParse->nTab++;
6438 sDistinct.addrTnct = sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
danf9eae182018-05-21 19:45:11 +00006439 sDistinct.tabTnct, 0, 0,
6440 (char*)sqlite3KeyInfoFromExprList(pParse, p->pEList,0,0),
6441 P4_KEYINFO);
drhd4187c72010-08-30 22:15:45 +00006442 sqlite3VdbeChangeP5(v, BTREE_UNORDERED);
drhe8e4af72012-09-21 00:04:28 +00006443 sDistinct.eTnctType = WHERE_DISTINCT_UNORDERED;
drh832508b2002-03-02 17:04:07 +00006444 }else{
drhe8e4af72012-09-21 00:04:28 +00006445 sDistinct.eTnctType = WHERE_DISTINCT_NOOP;
drhefb72512000-05-31 20:00:52 +00006446 }
drh832508b2002-03-02 17:04:07 +00006447
drh13449892005-09-07 21:22:45 +00006448 if( !isAgg && pGroupBy==0 ){
drhe8e4af72012-09-21 00:04:28 +00006449 /* No aggregate functions and no GROUP BY clause */
dan67a9b8e2018-06-22 20:51:35 +00006450 u16 wctrlFlags = (sDistinct.isTnct ? WHERE_WANT_DISTINCT : 0)
6451 | (p->selFlags & SF_FixedLimit);
6452#ifndef SQLITE_OMIT_WINDOWFUNC
drh067b92b2020-06-19 15:24:12 +00006453 Window *pWin = p->pWin; /* Main window object (or NULL) */
danf9eae182018-05-21 19:45:11 +00006454 if( pWin ){
dan4ea562e2020-01-01 20:17:15 +00006455 sqlite3WindowCodeInit(pParse, p);
dan86fb6e12018-05-16 20:58:07 +00006456 }
dan67a9b8e2018-06-22 20:51:35 +00006457#endif
6458 assert( WHERE_USE_LIMIT==SF_FixedLimit );
6459
dan86fb6e12018-05-16 20:58:07 +00006460
dan38cc40c2011-06-30 20:17:15 +00006461 /* Begin the database scan. */
drhcfd74702018-03-19 22:28:34 +00006462 SELECTTRACE(1,pParse,p,("WhereBegin\n"));
drh079a3072014-03-19 14:10:55 +00006463 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, sSort.pOrderBy,
drhc3489bb2016-02-25 16:04:59 +00006464 p->pEList, wctrlFlags, p->nSelectRow);
drh13449892005-09-07 21:22:45 +00006465 if( pWInfo==0 ) goto select_end;
drh6f328482013-06-05 23:39:34 +00006466 if( sqlite3WhereOutputRowCount(pWInfo) < p->nSelectRow ){
6467 p->nSelectRow = sqlite3WhereOutputRowCount(pWInfo);
6468 }
drh6457a352013-06-21 00:35:37 +00006469 if( sDistinct.isTnct && sqlite3WhereIsDistinct(pWInfo) ){
drh6f328482013-06-05 23:39:34 +00006470 sDistinct.eTnctType = sqlite3WhereIsDistinct(pWInfo);
6471 }
drh079a3072014-03-19 14:10:55 +00006472 if( sSort.pOrderBy ){
6473 sSort.nOBSat = sqlite3WhereIsOrdered(pWInfo);
drh6ee5a7b2018-09-08 20:09:46 +00006474 sSort.labelOBLopt = sqlite3WhereOrderByLimitOptLabel(pWInfo);
drh079a3072014-03-19 14:10:55 +00006475 if( sSort.nOBSat==sSort.pOrderBy->nExpr ){
6476 sSort.pOrderBy = 0;
6477 }
6478 }
drh13162ef2021-02-16 20:01:08 +00006479 SELECTTRACE(1,pParse,p,("WhereBegin returns\n"));
drhcce7d172000-05-31 15:34:51 +00006480
drhb9bb7c12006-06-11 23:41:55 +00006481 /* If sorting index that was created by a prior OP_OpenEphemeral
6482 ** instruction ended up not being needed, then change the OP_OpenEphemeral
drh9d2985c2005-09-08 01:58:42 +00006483 ** into an OP_Noop.
6484 */
drh079a3072014-03-19 14:10:55 +00006485 if( sSort.addrSortIndex>=0 && sSort.pOrderBy==0 ){
6486 sqlite3VdbeChangeToNoop(v, sSort.addrSortIndex);
drh9d2985c2005-09-08 01:58:42 +00006487 }
6488
drh2def2f72017-09-15 17:40:34 +00006489 assert( p->pEList==pEList );
dan67a9b8e2018-06-22 20:51:35 +00006490#ifndef SQLITE_OMIT_WINDOWFUNC
danf9eae182018-05-21 19:45:11 +00006491 if( pWin ){
drhec4ccdb2018-12-29 02:26:59 +00006492 int addrGosub = sqlite3VdbeMakeLabel(pParse);
6493 int iCont = sqlite3VdbeMakeLabel(pParse);
6494 int iBreak = sqlite3VdbeMakeLabel(pParse);
danf9eae182018-05-21 19:45:11 +00006495 int regGosub = ++pParse->nMem;
drhefb72512000-05-31 20:00:52 +00006496
dandacf1de2018-06-08 16:11:55 +00006497 sqlite3WindowCodeStep(pParse, p, pWInfo, regGosub, addrGosub);
dan86fb6e12018-05-16 20:58:07 +00006498
danefa3a3c2018-06-23 16:26:20 +00006499 sqlite3VdbeAddOp2(v, OP_Goto, 0, iBreak);
danf9eae182018-05-21 19:45:11 +00006500 sqlite3VdbeResolveLabel(v, addrGosub);
drhb0225bc2018-07-10 20:50:27 +00006501 VdbeNoopComment((v, "inner-loop subroutine"));
drhd4cb09e2018-09-17 15:19:13 +00006502 sSort.labelOBLopt = 0;
danefa3a3c2018-06-23 16:26:20 +00006503 selectInnerLoop(pParse, p, -1, &sSort, &sDistinct, pDest, iCont, iBreak);
dandacf1de2018-06-08 16:11:55 +00006504 sqlite3VdbeResolveLabel(v, iCont);
dan86fb6e12018-05-16 20:58:07 +00006505 sqlite3VdbeAddOp1(v, OP_Return, regGosub);
drh0b3b0dd2018-07-10 05:11:03 +00006506 VdbeComment((v, "end inner-loop subroutine"));
danefa3a3c2018-06-23 16:26:20 +00006507 sqlite3VdbeResolveLabel(v, iBreak);
dan67a9b8e2018-06-22 20:51:35 +00006508 }else
6509#endif /* SQLITE_OMIT_WINDOWFUNC */
6510 {
dan86fb6e12018-05-16 20:58:07 +00006511 /* Use the standard inner loop. */
6512 selectInnerLoop(pParse, p, -1, &sSort, &sDistinct, pDest,
6513 sqlite3WhereContinueLabel(pWInfo),
6514 sqlite3WhereBreakLabel(pWInfo));
6515
6516 /* End the database scan loop.
6517 */
drh13162ef2021-02-16 20:01:08 +00006518 SELECTTRACE(1,pParse,p,("WhereEnd\n"));
dan86fb6e12018-05-16 20:58:07 +00006519 sqlite3WhereEnd(pWInfo);
6520 }
drh13449892005-09-07 21:22:45 +00006521 }else{
drhe8e4af72012-09-21 00:04:28 +00006522 /* This case when there exist aggregate functions or a GROUP BY clause
6523 ** or both */
drh13449892005-09-07 21:22:45 +00006524 NameContext sNC; /* Name context for processing aggregate information */
6525 int iAMem; /* First Mem address for storing current GROUP BY */
6526 int iBMem; /* First Mem address for previous GROUP BY */
6527 int iUseFlag; /* Mem address holding flag indicating that at least
6528 ** one row of the input to the aggregator has been
6529 ** processed */
6530 int iAbortFlag; /* Mem address which causes query abort if positive */
6531 int groupBySort; /* Rows come from source in GROUP BY order */
drhd1766112008-09-17 00:13:12 +00006532 int addrEnd; /* End of processing for this SELECT */
drh1c9d8352011-09-01 16:01:27 +00006533 int sortPTab = 0; /* Pseudotable used to decode sorting results */
6534 int sortOut = 0; /* Output register from the sorter */
dan374cd782014-04-21 13:21:56 +00006535 int orderByGrp = 0; /* True if the GROUP BY and ORDER BY are the same */
drhcce7d172000-05-31 15:34:51 +00006536
drhd1766112008-09-17 00:13:12 +00006537 /* Remove any and all aliases between the result set and the
6538 ** GROUP BY clause.
6539 */
6540 if( pGroupBy ){
drhdc5ea5c2008-12-10 17:19:59 +00006541 int k; /* Loop counter */
drhd1766112008-09-17 00:13:12 +00006542 struct ExprList_item *pItem; /* For looping over expression in a list */
drhcce7d172000-05-31 15:34:51 +00006543
drhdc5ea5c2008-12-10 17:19:59 +00006544 for(k=p->pEList->nExpr, pItem=p->pEList->a; k>0; k--, pItem++){
drhc2acc4e2013-11-15 18:15:19 +00006545 pItem->u.x.iAlias = 0;
drhd1766112008-09-17 00:13:12 +00006546 }
drhdc5ea5c2008-12-10 17:19:59 +00006547 for(k=pGroupBy->nExpr, pItem=pGroupBy->a; k>0; k--, pItem++){
drhc2acc4e2013-11-15 18:15:19 +00006548 pItem->u.x.iAlias = 0;
drhd1766112008-09-17 00:13:12 +00006549 }
drhc3489bb2016-02-25 16:04:59 +00006550 assert( 66==sqlite3LogEst(100) );
6551 if( p->nSelectRow>66 ) p->nSelectRow = 66;
dan8c9bcb22019-09-21 15:44:12 +00006552
6553 /* If there is both a GROUP BY and an ORDER BY clause and they are
6554 ** identical, then it may be possible to disable the ORDER BY clause
6555 ** on the grounds that the GROUP BY will cause elements to come out
6556 ** in the correct order. It also may not - the GROUP BY might use a
6557 ** database index that causes rows to be grouped together as required
6558 ** but not actually sorted. Either way, record the fact that the
6559 ** ORDER BY and GROUP BY clauses are the same by setting the orderByGrp
6560 ** variable. */
6561 if( sSort.pOrderBy && pGroupBy->nExpr==sSort.pOrderBy->nExpr ){
drhe39f3882019-09-21 17:31:03 +00006562 int ii;
dan8c9bcb22019-09-21 15:44:12 +00006563 /* The GROUP BY processing doesn't care whether rows are delivered in
6564 ** ASC or DESC order - only that each group is returned contiguously.
6565 ** So set the ASC/DESC flags in the GROUP BY to match those in the
6566 ** ORDER BY to maximize the chances of rows being delivered in an
6567 ** order that makes the ORDER BY redundant. */
drhe39f3882019-09-21 17:31:03 +00006568 for(ii=0; ii<pGroupBy->nExpr; ii++){
6569 u8 sortFlags = sSort.pOrderBy->a[ii].sortFlags & KEYINFO_ORDER_DESC;
6570 pGroupBy->a[ii].sortFlags = sortFlags;
dan8c9bcb22019-09-21 15:44:12 +00006571 }
6572 if( sqlite3ExprListCompare(pGroupBy, sSort.pOrderBy, -1)==0 ){
6573 orderByGrp = 1;
6574 }
6575 }
drh95aa47b2010-11-16 02:49:15 +00006576 }else{
drhc3489bb2016-02-25 16:04:59 +00006577 assert( 0==sqlite3LogEst(1) );
6578 p->nSelectRow = 0;
drhd1766112008-09-17 00:13:12 +00006579 }
drh13449892005-09-07 21:22:45 +00006580
drhd1766112008-09-17 00:13:12 +00006581 /* Create a label to jump to when we want to abort the query */
drhec4ccdb2018-12-29 02:26:59 +00006582 addrEnd = sqlite3VdbeMakeLabel(pParse);
drh13449892005-09-07 21:22:45 +00006583
6584 /* Convert TK_COLUMN nodes into TK_AGG_COLUMN and make entries in
6585 ** sAggInfo for all TK_AGG_FUNCTION nodes in expressions of the
6586 ** SELECT statement.
6587 */
drhbf790972020-06-07 20:18:07 +00006588 pAggInfo = sqlite3DbMallocZero(db, sizeof(*pAggInfo) );
drhc54246f2021-02-17 21:13:14 +00006589 if( pAggInfo ){
6590 sqlite3ParserAddCleanup(pParse,
6591 (void(*)(sqlite3*,void*))agginfoFree, pAggInfo);
6592 }
6593 if( db->mallocFailed ){
drhbf790972020-06-07 20:18:07 +00006594 goto select_end;
6595 }
drhe26d4282020-06-09 11:59:15 +00006596 pAggInfo->selId = p->selId;
drh13449892005-09-07 21:22:45 +00006597 memset(&sNC, 0, sizeof(sNC));
6598 sNC.pParse = pParse;
6599 sNC.pSrcList = pTabList;
drhbf790972020-06-07 20:18:07 +00006600 sNC.uNC.pAggInfo = pAggInfo;
drh25c3b8c2018-04-16 10:34:13 +00006601 VVA_ONLY( sNC.ncFlags = NC_UAggInfo; )
drhbf790972020-06-07 20:18:07 +00006602 pAggInfo->mnReg = pParse->nMem+1;
6603 pAggInfo->nSortingColumn = pGroupBy ? pGroupBy->nExpr : 0;
6604 pAggInfo->pGroupBy = pGroupBy;
drhd2b3e232008-01-23 14:51:49 +00006605 sqlite3ExprAnalyzeAggList(&sNC, pEList);
drh079a3072014-03-19 14:10:55 +00006606 sqlite3ExprAnalyzeAggList(&sNC, sSort.pOrderBy);
drhd2b3e232008-01-23 14:51:49 +00006607 if( pHaving ){
danab31a842017-04-29 20:53:09 +00006608 if( pGroupBy ){
6609 assert( pWhere==p->pWhere );
drhcd0abc22018-03-20 18:08:33 +00006610 assert( pHaving==p->pHaving );
6611 assert( pGroupBy==p->pGroupBy );
6612 havingToWhere(pParse, p);
danab31a842017-04-29 20:53:09 +00006613 pWhere = p->pWhere;
6614 }
drhd2b3e232008-01-23 14:51:49 +00006615 sqlite3ExprAnalyzeAggregates(&sNC, pHaving);
drh13449892005-09-07 21:22:45 +00006616 }
drhbf790972020-06-07 20:18:07 +00006617 pAggInfo->nAccumulator = pAggInfo->nColumn;
6618 if( p->pGroupBy==0 && p->pHaving==0 && pAggInfo->nFunc==1 ){
drh81185a52020-06-09 13:38:12 +00006619 minMaxFlag = minMaxQuery(db, pAggInfo->aFunc[0].pFExpr, &pMinMaxOrderBy);
drh47d9f832017-10-26 20:04:28 +00006620 }else{
6621 minMaxFlag = WHERE_ORDERBY_NORMAL;
6622 }
drhbf790972020-06-07 20:18:07 +00006623 for(i=0; i<pAggInfo->nFunc; i++){
drh81185a52020-06-09 13:38:12 +00006624 Expr *pExpr = pAggInfo->aFunc[i].pFExpr;
dan6ba7ab02019-07-02 11:56:47 +00006625 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
drh3a8c4be2012-05-21 20:13:39 +00006626 sNC.ncFlags |= NC_InAggFunc;
dan6ba7ab02019-07-02 11:56:47 +00006627 sqlite3ExprAnalyzeAggList(&sNC, pExpr->x.pList);
6628#ifndef SQLITE_OMIT_WINDOWFUNC
dan4f9adee2019-07-13 16:22:50 +00006629 assert( !IsWindowFunc(pExpr) );
6630 if( ExprHasProperty(pExpr, EP_WinFunc) ){
6631 sqlite3ExprAnalyzeAggregates(&sNC, pExpr->y.pWin->pFilter);
danb28c4e52019-07-05 17:38:55 +00006632 }
dan6ba7ab02019-07-02 11:56:47 +00006633#endif
drh3a8c4be2012-05-21 20:13:39 +00006634 sNC.ncFlags &= ~NC_InAggFunc;
drh13449892005-09-07 21:22:45 +00006635 }
drhbf790972020-06-07 20:18:07 +00006636 pAggInfo->mxReg = pParse->nMem;
drh17435752007-08-16 04:30:38 +00006637 if( db->mallocFailed ) goto select_end;
drh7ea11062017-10-26 18:43:19 +00006638#if SELECTTRACE_ENABLED
drhc0622a42020-12-04 01:17:57 +00006639 if( sqlite3SelectTrace & 0x400 ){
drh7ea11062017-10-26 18:43:19 +00006640 int ii;
drhbf790972020-06-07 20:18:07 +00006641 SELECTTRACE(0x400,pParse,p,("After aggregate analysis %p:\n", pAggInfo));
drh7ea11062017-10-26 18:43:19 +00006642 sqlite3TreeViewSelect(0, p, 0);
drhb9366f82021-01-13 11:44:51 +00006643 if( minMaxFlag ){
6644 sqlite3DebugPrintf("MIN/MAX Optimization (0x%02x) adds:\n", minMaxFlag);
6645 sqlite3TreeViewExprList(0, pMinMaxOrderBy, 0, "ORDERBY");
6646 }
drhbf790972020-06-07 20:18:07 +00006647 for(ii=0; ii<pAggInfo->nColumn; ii++){
drh7ea11062017-10-26 18:43:19 +00006648 sqlite3DebugPrintf("agg-column[%d] iMem=%d\n",
drhbf790972020-06-07 20:18:07 +00006649 ii, pAggInfo->aCol[ii].iMem);
drh81185a52020-06-09 13:38:12 +00006650 sqlite3TreeViewExpr(0, pAggInfo->aCol[ii].pCExpr, 0);
drh7ea11062017-10-26 18:43:19 +00006651 }
drhbf790972020-06-07 20:18:07 +00006652 for(ii=0; ii<pAggInfo->nFunc; ii++){
drh7ea11062017-10-26 18:43:19 +00006653 sqlite3DebugPrintf("agg-func[%d]: iMem=%d\n",
drhbf790972020-06-07 20:18:07 +00006654 ii, pAggInfo->aFunc[ii].iMem);
drh81185a52020-06-09 13:38:12 +00006655 sqlite3TreeViewExpr(0, pAggInfo->aFunc[ii].pFExpr, 0);
drh7ea11062017-10-26 18:43:19 +00006656 }
6657 }
6658#endif
6659
drh13449892005-09-07 21:22:45 +00006660
6661 /* Processing for aggregates with GROUP BY is very different and
danielk19773c4809a2007-11-12 15:29:18 +00006662 ** much more complex than aggregates without a GROUP BY.
drh13449892005-09-07 21:22:45 +00006663 */
6664 if( pGroupBy ){
6665 KeyInfo *pKeyInfo; /* Keying information for the group by clause */
drh728e0f92015-10-10 14:41:28 +00006666 int addr1; /* A-vs-B comparision jump */
drhd1766112008-09-17 00:13:12 +00006667 int addrOutputRow; /* Start of subroutine that outputs a result row */
6668 int regOutputRow; /* Return address register for output subroutine */
6669 int addrSetAbort; /* Set the abort flag and return */
6670 int addrTopOfLoop; /* Top of the input loop */
6671 int addrSortingIdx; /* The OP_OpenEphemeral for the sorting index */
6672 int addrReset; /* Subroutine for resetting the accumulator */
6673 int regReset; /* Return address register for reset subroutine */
drh13449892005-09-07 21:22:45 +00006674
6675 /* If there is a GROUP BY clause we might need a sorting index to
6676 ** implement it. Allocate that sorting index now. If it turns out
drh1c9d8352011-09-01 16:01:27 +00006677 ** that we do not need it after all, the OP_SorterOpen instruction
drh13449892005-09-07 21:22:45 +00006678 ** will be converted into a Noop.
6679 */
drhbf790972020-06-07 20:18:07 +00006680 pAggInfo->sortingIdx = pParse->nTab++;
6681 pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pGroupBy,
6682 0, pAggInfo->nColumn);
drh1c9d8352011-09-01 16:01:27 +00006683 addrSortingIdx = sqlite3VdbeAddOp4(v, OP_SorterOpen,
drhbf790972020-06-07 20:18:07 +00006684 pAggInfo->sortingIdx, pAggInfo->nSortingColumn,
drh2ec2fb22013-11-06 19:59:23 +00006685 0, (char*)pKeyInfo, P4_KEYINFO);
drh13449892005-09-07 21:22:45 +00006686
6687 /* Initialize memory locations used by GROUP BY aggregate processing
6688 */
drh0a07c102008-01-03 18:03:08 +00006689 iUseFlag = ++pParse->nMem;
6690 iAbortFlag = ++pParse->nMem;
drhd1766112008-09-17 00:13:12 +00006691 regOutputRow = ++pParse->nMem;
drhec4ccdb2018-12-29 02:26:59 +00006692 addrOutputRow = sqlite3VdbeMakeLabel(pParse);
drhd1766112008-09-17 00:13:12 +00006693 regReset = ++pParse->nMem;
drhec4ccdb2018-12-29 02:26:59 +00006694 addrReset = sqlite3VdbeMakeLabel(pParse);
drh0a07c102008-01-03 18:03:08 +00006695 iAMem = pParse->nMem + 1;
drh13449892005-09-07 21:22:45 +00006696 pParse->nMem += pGroupBy->nExpr;
drh0a07c102008-01-03 18:03:08 +00006697 iBMem = pParse->nMem + 1;
drh13449892005-09-07 21:22:45 +00006698 pParse->nMem += pGroupBy->nExpr;
drh4c583122008-01-04 22:01:03 +00006699 sqlite3VdbeAddOp2(v, OP_Integer, 0, iAbortFlag);
drhd4e70eb2008-01-02 00:34:36 +00006700 VdbeComment((v, "clear abort flag"));
drhb8475df2011-12-09 16:21:19 +00006701 sqlite3VdbeAddOp3(v, OP_Null, 0, iAMem, iAMem+pGroupBy->nExpr-1);
drhe3133822005-09-20 13:11:59 +00006702
drh13449892005-09-07 21:22:45 +00006703 /* Begin a loop that will extract all source rows in GROUP BY order.
6704 ** This might involve two separate loops with an OP_Sort in between, or
6705 ** it might be a single loop that uses an index to extract information
6706 ** in the right order to begin with.
6707 */
drh2eb95372008-06-06 15:04:36 +00006708 sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset);
drhcfd74702018-03-19 22:28:34 +00006709 SELECTTRACE(1,pParse,p,("WhereBegin\n"));
drh079a3072014-03-19 14:10:55 +00006710 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pGroupBy, 0,
dan374cd782014-04-21 13:21:56 +00006711 WHERE_GROUPBY | (orderByGrp ? WHERE_SORTBYGROUP : 0), 0
6712 );
drh5360ad32005-09-08 00:13:27 +00006713 if( pWInfo==0 ) goto select_end;
drh13162ef2021-02-16 20:01:08 +00006714 SELECTTRACE(1,pParse,p,("WhereBegin returns\n"));
drhddba0c22014-03-18 20:33:42 +00006715 if( sqlite3WhereIsOrdered(pWInfo)==pGroupBy->nExpr ){
drh13449892005-09-07 21:22:45 +00006716 /* The optimizer is able to deliver rows in group by order so
drhb9bb7c12006-06-11 23:41:55 +00006717 ** we do not have to sort. The OP_OpenEphemeral table will be
drh13449892005-09-07 21:22:45 +00006718 ** cancelled later because we still need to use the pKeyInfo
6719 */
drh13449892005-09-07 21:22:45 +00006720 groupBySort = 0;
6721 }else{
6722 /* Rows are coming out in undetermined order. We have to push
6723 ** each row into a sorting index, terminate the first loop,
6724 ** then loop over the sorting index in order to get the output
6725 ** in sorted order
6726 */
drh892d3172008-01-10 03:46:36 +00006727 int regBase;
6728 int regRecord;
6729 int nCol;
6730 int nGroupBy;
6731
dan2ce22452010-11-08 19:01:16 +00006732 explainTempTable(pParse,
drhe8e4af72012-09-21 00:04:28 +00006733 (sDistinct.isTnct && (p->selFlags&SF_Distinct)==0) ?
6734 "DISTINCT" : "GROUP BY");
dan2ce22452010-11-08 19:01:16 +00006735
drh13449892005-09-07 21:22:45 +00006736 groupBySort = 1;
drh892d3172008-01-10 03:46:36 +00006737 nGroupBy = pGroupBy->nExpr;
dandd23c6b2014-03-24 20:19:07 +00006738 nCol = nGroupBy;
6739 j = nGroupBy;
drhbf790972020-06-07 20:18:07 +00006740 for(i=0; i<pAggInfo->nColumn; i++){
6741 if( pAggInfo->aCol[i].iSorterColumn>=j ){
drh892d3172008-01-10 03:46:36 +00006742 nCol++;
6743 j++;
6744 }
6745 }
6746 regBase = sqlite3GetTempRange(pParse, nCol);
drh5579d592015-08-26 14:01:41 +00006747 sqlite3ExprCodeExprList(pParse, pGroupBy, regBase, 0, 0);
dandd23c6b2014-03-24 20:19:07 +00006748 j = nGroupBy;
drhbf790972020-06-07 20:18:07 +00006749 for(i=0; i<pAggInfo->nColumn; i++){
6750 struct AggInfo_col *pCol = &pAggInfo->aCol[i];
drh892d3172008-01-10 03:46:36 +00006751 if( pCol->iSorterColumn>=j ){
drhe55cbd72008-03-31 23:48:03 +00006752 int r1 = j + regBase;
drh8c607192018-08-04 15:53:55 +00006753 sqlite3ExprCodeGetColumnOfTable(v,
6754 pCol->pTab, pCol->iTable, pCol->iColumn, r1);
drh6a012f02008-08-21 14:15:59 +00006755 j++;
drh892d3172008-01-10 03:46:36 +00006756 }
drh13449892005-09-07 21:22:45 +00006757 }
drh892d3172008-01-10 03:46:36 +00006758 regRecord = sqlite3GetTempReg(pParse);
drh1db639c2008-01-17 02:36:28 +00006759 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord);
drhbf790972020-06-07 20:18:07 +00006760 sqlite3VdbeAddOp2(v, OP_SorterInsert, pAggInfo->sortingIdx, regRecord);
drh892d3172008-01-10 03:46:36 +00006761 sqlite3ReleaseTempReg(pParse, regRecord);
6762 sqlite3ReleaseTempRange(pParse, regBase, nCol);
drh13162ef2021-02-16 20:01:08 +00006763 SELECTTRACE(1,pParse,p,("WhereEnd\n"));
drh13449892005-09-07 21:22:45 +00006764 sqlite3WhereEnd(pWInfo);
drhbf790972020-06-07 20:18:07 +00006765 pAggInfo->sortingIdxPTab = sortPTab = pParse->nTab++;
drh1c9d8352011-09-01 16:01:27 +00006766 sortOut = sqlite3GetTempReg(pParse);
6767 sqlite3VdbeAddOp3(v, OP_OpenPseudo, sortPTab, sortOut, nCol);
drhbf790972020-06-07 20:18:07 +00006768 sqlite3VdbeAddOp2(v, OP_SorterSort, pAggInfo->sortingIdx, addrEnd);
drh688852a2014-02-17 22:40:43 +00006769 VdbeComment((v, "GROUP BY sort")); VdbeCoverage(v);
drhbf790972020-06-07 20:18:07 +00006770 pAggInfo->useSortingIdx = 1;
dan374cd782014-04-21 13:21:56 +00006771 }
6772
6773 /* If the index or temporary table used by the GROUP BY sort
6774 ** will naturally deliver rows in the order required by the ORDER BY
6775 ** clause, cancel the ephemeral table open coded earlier.
6776 **
6777 ** This is an optimization - the correct answer should result regardless.
6778 ** Use the SQLITE_GroupByOrder flag with SQLITE_TESTCTRL_OPTIMIZER to
6779 ** disable this optimization for testing purposes. */
6780 if( orderByGrp && OptimizationEnabled(db, SQLITE_GroupByOrder)
6781 && (groupBySort || sqlite3WhereIsSorted(pWInfo))
6782 ){
6783 sSort.pOrderBy = 0;
6784 sqlite3VdbeChangeToNoop(v, sSort.addrSortIndex);
drh13449892005-09-07 21:22:45 +00006785 }
6786
6787 /* Evaluate the current GROUP BY terms and store in b0, b1, b2...
6788 ** (b0 is memory location iBMem+0, b1 is iBMem+1, and so forth)
6789 ** Then compare the current GROUP BY terms against the GROUP BY terms
6790 ** from the previous row currently stored in a0, a1, a2...
6791 */
6792 addrTopOfLoop = sqlite3VdbeCurrentAddr(v);
drh1c9d8352011-09-01 16:01:27 +00006793 if( groupBySort ){
drhbf790972020-06-07 20:18:07 +00006794 sqlite3VdbeAddOp3(v, OP_SorterData, pAggInfo->sortingIdx,
drh38b41492015-06-08 15:08:15 +00006795 sortOut, sortPTab);
drh1c9d8352011-09-01 16:01:27 +00006796 }
drh13449892005-09-07 21:22:45 +00006797 for(j=0; j<pGroupBy->nExpr; j++){
6798 if( groupBySort ){
drh1c9d8352011-09-01 16:01:27 +00006799 sqlite3VdbeAddOp3(v, OP_Column, sortPTab, j, iBMem+j);
drh13449892005-09-07 21:22:45 +00006800 }else{
drhbf790972020-06-07 20:18:07 +00006801 pAggInfo->directMode = 1;
drh2dcef112008-01-12 19:03:48 +00006802 sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr, iBMem+j);
drh13449892005-09-07 21:22:45 +00006803 }
drh13449892005-09-07 21:22:45 +00006804 }
drh16ee60f2008-06-20 18:13:25 +00006805 sqlite3VdbeAddOp4(v, OP_Compare, iAMem, iBMem, pGroupBy->nExpr,
drh2ec2fb22013-11-06 19:59:23 +00006806 (char*)sqlite3KeyInfoRef(pKeyInfo), P4_KEYINFO);
drh728e0f92015-10-10 14:41:28 +00006807 addr1 = sqlite3VdbeCurrentAddr(v);
6808 sqlite3VdbeAddOp3(v, OP_Jump, addr1+1, 0, addr1+1); VdbeCoverage(v);
drh13449892005-09-07 21:22:45 +00006809
6810 /* Generate code that runs whenever the GROUP BY changes.
drhe00ee6e2008-06-20 15:24:01 +00006811 ** Changes in the GROUP BY are detected by the previous code
drh13449892005-09-07 21:22:45 +00006812 ** block. If there were no changes, this block is skipped.
6813 **
6814 ** This code copies current group by terms in b0,b1,b2,...
6815 ** over to a0,a1,a2. It then calls the output subroutine
6816 ** and resets the aggregate accumulator registers in preparation
6817 ** for the next GROUP BY batch.
6818 */
drhb21e7c72008-06-22 12:37:57 +00006819 sqlite3ExprCodeMove(pParse, iBMem, iAMem, pGroupBy->nExpr);
drh2eb95372008-06-06 15:04:36 +00006820 sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow);
drhd4e70eb2008-01-02 00:34:36 +00006821 VdbeComment((v, "output one row"));
drh688852a2014-02-17 22:40:43 +00006822 sqlite3VdbeAddOp2(v, OP_IfPos, iAbortFlag, addrEnd); VdbeCoverage(v);
drhd4e70eb2008-01-02 00:34:36 +00006823 VdbeComment((v, "check abort flag"));
drh2eb95372008-06-06 15:04:36 +00006824 sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset);
drhd4e70eb2008-01-02 00:34:36 +00006825 VdbeComment((v, "reset accumulator"));
drh13449892005-09-07 21:22:45 +00006826
6827 /* Update the aggregate accumulators based on the content of
6828 ** the current row
6829 */
drh728e0f92015-10-10 14:41:28 +00006830 sqlite3VdbeJumpHere(v, addr1);
drhbf790972020-06-07 20:18:07 +00006831 updateAccumulator(pParse, iUseFlag, pAggInfo);
drh4c583122008-01-04 22:01:03 +00006832 sqlite3VdbeAddOp2(v, OP_Integer, 1, iUseFlag);
drhd4e70eb2008-01-02 00:34:36 +00006833 VdbeComment((v, "indicate data in accumulator"));
drh13449892005-09-07 21:22:45 +00006834
6835 /* End of the loop
6836 */
6837 if( groupBySort ){
drhd1930572021-01-13 15:23:17 +00006838 sqlite3VdbeAddOp2(v, OP_SorterNext, pAggInfo->sortingIdx,addrTopOfLoop);
drh688852a2014-02-17 22:40:43 +00006839 VdbeCoverage(v);
drh13449892005-09-07 21:22:45 +00006840 }else{
drh13162ef2021-02-16 20:01:08 +00006841 SELECTTRACE(1,pParse,p,("WhereEnd\n"));
drh13449892005-09-07 21:22:45 +00006842 sqlite3WhereEnd(pWInfo);
drh48f2d3b2011-09-16 01:34:43 +00006843 sqlite3VdbeChangeToNoop(v, addrSortingIdx);
drh13449892005-09-07 21:22:45 +00006844 }
6845
6846 /* Output the final row of result
6847 */
drh2eb95372008-06-06 15:04:36 +00006848 sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow);
drhd4e70eb2008-01-02 00:34:36 +00006849 VdbeComment((v, "output final row"));
drhd1766112008-09-17 00:13:12 +00006850
6851 /* Jump over the subroutines
6852 */
drh076e85f2015-09-03 13:46:12 +00006853 sqlite3VdbeGoto(v, addrEnd);
drhd1766112008-09-17 00:13:12 +00006854
6855 /* Generate a subroutine that outputs a single row of the result
6856 ** set. This subroutine first looks at the iUseFlag. If iUseFlag
6857 ** is less than or equal to zero, the subroutine is a no-op. If
6858 ** the processing calls for the query to abort, this subroutine
6859 ** increments the iAbortFlag memory location before returning in
6860 ** order to signal the caller to abort.
6861 */
6862 addrSetAbort = sqlite3VdbeCurrentAddr(v);
6863 sqlite3VdbeAddOp2(v, OP_Integer, 1, iAbortFlag);
6864 VdbeComment((v, "set abort flag"));
6865 sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);
6866 sqlite3VdbeResolveLabel(v, addrOutputRow);
6867 addrOutputRow = sqlite3VdbeCurrentAddr(v);
6868 sqlite3VdbeAddOp2(v, OP_IfPos, iUseFlag, addrOutputRow+2);
drh38b41492015-06-08 15:08:15 +00006869 VdbeCoverage(v);
drhd1766112008-09-17 00:13:12 +00006870 VdbeComment((v, "Groupby result generator entry point"));
6871 sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);
drhbf790972020-06-07 20:18:07 +00006872 finalizeAggFunctions(pParse, pAggInfo);
drh33cd4902009-05-30 20:49:20 +00006873 sqlite3ExprIfFalse(pParse, pHaving, addrOutputRow+1, SQLITE_JUMPIFNULL);
drh2def2f72017-09-15 17:40:34 +00006874 selectInnerLoop(pParse, p, -1, &sSort,
drhe8e4af72012-09-21 00:04:28 +00006875 &sDistinct, pDest,
drhd1766112008-09-17 00:13:12 +00006876 addrOutputRow+1, addrSetAbort);
6877 sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);
6878 VdbeComment((v, "end groupby result generator"));
6879
6880 /* Generate a subroutine that will reset the group-by accumulator
6881 */
6882 sqlite3VdbeResolveLabel(v, addrReset);
drhbf790972020-06-07 20:18:07 +00006883 resetAccumulator(pParse, pAggInfo);
dan280c8942018-06-05 20:04:28 +00006884 sqlite3VdbeAddOp2(v, OP_Integer, 0, iUseFlag);
6885 VdbeComment((v, "indicate accumulator empty"));
drhd1766112008-09-17 00:13:12 +00006886 sqlite3VdbeAddOp1(v, OP_Return, regReset);
6887
drh43152cf2009-05-19 19:04:58 +00006888 } /* endif pGroupBy. Begin aggregate queries without GROUP BY: */
drh13449892005-09-07 21:22:45 +00006889 else {
danielk1977a5533162009-02-24 10:01:51 +00006890 Table *pTab;
drhbf790972020-06-07 20:18:07 +00006891 if( (pTab = isSimpleCount(p, pAggInfo))!=0 ){
danielk1977a5533162009-02-24 10:01:51 +00006892 /* If isSimpleCount() returns a pointer to a Table structure, then
6893 ** the SQL statement is of the form:
6894 **
6895 ** SELECT count(*) FROM <tbl>
6896 **
6897 ** where the Table structure returned represents table <tbl>.
6898 **
6899 ** This statement is so common that it is optimized specially. The
6900 ** OP_Count instruction is executed either on the intkey table that
6901 ** contains the data for table <tbl> or on one of its indexes. It
6902 ** is better to execute the op on an index, as indexes are almost
6903 ** always spread across less pages than their corresponding tables.
6904 */
6905 const int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
6906 const int iCsr = pParse->nTab++; /* Cursor to scan b-tree */
6907 Index *pIdx; /* Iterator variable */
6908 KeyInfo *pKeyInfo = 0; /* Keyinfo for scanned index */
6909 Index *pBest = 0; /* Best index found so far */
drh013e7bb2020-07-30 17:37:49 +00006910 Pgno iRoot = pTab->tnum; /* Root page of scanned b-tree */
danielk1977a9d1ccb2008-01-05 17:39:29 +00006911
danielk1977a5533162009-02-24 10:01:51 +00006912 sqlite3CodeVerifySchema(pParse, iDb);
6913 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
6914
drhd9e3cad2013-10-04 02:36:19 +00006915 /* Search for the index that has the lowest scan cost.
danielk1977a5533162009-02-24 10:01:51 +00006916 **
drh3e9548b2011-04-15 14:46:27 +00006917 ** (2011-04-15) Do not do a full scan of an unordered index.
6918 **
drhabcc1942013-11-12 14:55:40 +00006919 ** (2013-10-03) Do not count the entries in a partial index.
drh5f33f372013-10-04 00:00:12 +00006920 **
danielk1977a5533162009-02-24 10:01:51 +00006921 ** In practice the KeyInfo structure will not be used. It is only
6922 ** passed to keep OP_OpenRead happy.
6923 */
drh5c7917e2013-11-12 15:33:40 +00006924 if( !HasRowid(pTab) ) pBest = sqlite3PrimaryKeyIndex(pTab);
drh98aa1d72020-05-08 18:22:00 +00006925 if( !p->pSrc->a[0].fg.notIndexed ){
6926 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
6927 if( pIdx->bUnordered==0
6928 && pIdx->szIdxRow<pTab->szTabRow
6929 && pIdx->pPartIdxWhere==0
6930 && (!pBest || pIdx->szIdxRow<pBest->szIdxRow)
6931 ){
6932 pBest = pIdx;
6933 }
danielk1977a5533162009-02-24 10:01:51 +00006934 }
6935 }
drhd9e3cad2013-10-04 02:36:19 +00006936 if( pBest ){
danielk1977a5533162009-02-24 10:01:51 +00006937 iRoot = pBest->tnum;
drh2ec2fb22013-11-06 19:59:23 +00006938 pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pBest);
danielk1977a5533162009-02-24 10:01:51 +00006939 }
6940
6941 /* Open a read-only cursor, execute the OP_Count, close the cursor. */
drh013e7bb2020-07-30 17:37:49 +00006942 sqlite3VdbeAddOp4Int(v, OP_OpenRead, iCsr, (int)iRoot, iDb, 1);
danielk1977a5533162009-02-24 10:01:51 +00006943 if( pKeyInfo ){
drh2ec2fb22013-11-06 19:59:23 +00006944 sqlite3VdbeChangeP4(v, -1, (char *)pKeyInfo, P4_KEYINFO);
danielk1977a5533162009-02-24 10:01:51 +00006945 }
drhbf790972020-06-07 20:18:07 +00006946 sqlite3VdbeAddOp2(v, OP_Count, iCsr, pAggInfo->aFunc[0].iMem);
danielk1977a5533162009-02-24 10:01:51 +00006947 sqlite3VdbeAddOp1(v, OP_Close, iCsr);
danef7075d2011-02-21 17:49:49 +00006948 explainSimpleCount(pParse, pTab, pBest);
drhe50478d2020-03-17 13:41:51 +00006949 }else{
dan280c8942018-06-05 20:04:28 +00006950 int regAcc = 0; /* "populate accumulators" flag */
6951
daned09ddd2019-09-20 20:52:16 +00006952 /* If there are accumulator registers but no min() or max() functions
6953 ** without FILTER clauses, allocate register regAcc. Register regAcc
6954 ** will contain 0 the first time the inner loop runs, and 1 thereafter.
6955 ** The code generated by updateAccumulator() uses this to ensure
6956 ** that the accumulator registers are (a) updated only once if
6957 ** there are no min() or max functions or (b) always updated for the
6958 ** first row visited by the aggregate, so that they are updated at
6959 ** least once even if the FILTER clause means the min() or max()
6960 ** function visits zero rows. */
drhbf790972020-06-07 20:18:07 +00006961 if( pAggInfo->nAccumulator ){
6962 for(i=0; i<pAggInfo->nFunc; i++){
drh81185a52020-06-09 13:38:12 +00006963 if( ExprHasProperty(pAggInfo->aFunc[i].pFExpr, EP_WinFunc) ){
drhbf790972020-06-07 20:18:07 +00006964 continue;
6965 }
6966 if( pAggInfo->aFunc[i].pFunc->funcFlags&SQLITE_FUNC_NEEDCOLL ){
6967 break;
6968 }
dan280c8942018-06-05 20:04:28 +00006969 }
drhbf790972020-06-07 20:18:07 +00006970 if( i==pAggInfo->nFunc ){
dan280c8942018-06-05 20:04:28 +00006971 regAcc = ++pParse->nMem;
6972 sqlite3VdbeAddOp2(v, OP_Integer, 0, regAcc);
6973 }
6974 }
6975
danielk1977a5533162009-02-24 10:01:51 +00006976 /* This case runs if the aggregate has no GROUP BY clause. The
6977 ** processing is much simpler since there is only a single row
6978 ** of output.
6979 */
drh47d9f832017-10-26 20:04:28 +00006980 assert( p->pGroupBy==0 );
drhbf790972020-06-07 20:18:07 +00006981 resetAccumulator(pParse, pAggInfo);
drh47d9f832017-10-26 20:04:28 +00006982
6983 /* If this query is a candidate for the min/max optimization, then
6984 ** minMaxFlag will have been previously set to either
6985 ** WHERE_ORDERBY_MIN or WHERE_ORDERBY_MAX and pMinMaxOrderBy will
6986 ** be an appropriate ORDER BY expression for the optimization.
6987 */
6988 assert( minMaxFlag==WHERE_ORDERBY_NORMAL || pMinMaxOrderBy!=0 );
6989 assert( pMinMaxOrderBy==0 || pMinMaxOrderBy->nExpr==1 );
6990
drhcfd74702018-03-19 22:28:34 +00006991 SELECTTRACE(1,pParse,p,("WhereBegin\n"));
drh47d9f832017-10-26 20:04:28 +00006992 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pMinMaxOrderBy,
6993 0, minMaxFlag, 0);
danielk1977a5533162009-02-24 10:01:51 +00006994 if( pWInfo==0 ){
danielk1977a5533162009-02-24 10:01:51 +00006995 goto select_end;
6996 }
drh13162ef2021-02-16 20:01:08 +00006997 SELECTTRACE(1,pParse,p,("WhereBegin returns\n"));
drhbf790972020-06-07 20:18:07 +00006998 updateAccumulator(pParse, regAcc, pAggInfo);
dan280c8942018-06-05 20:04:28 +00006999 if( regAcc ) sqlite3VdbeAddOp2(v, OP_Integer, 1, regAcc);
drhd1930572021-01-13 15:23:17 +00007000 if( minMaxFlag ){
7001 sqlite3WhereMinMaxOptEarlyOut(v, pWInfo);
danielk1977a5533162009-02-24 10:01:51 +00007002 }
drh13162ef2021-02-16 20:01:08 +00007003 SELECTTRACE(1,pParse,p,("WhereEnd\n"));
danielk1977a5533162009-02-24 10:01:51 +00007004 sqlite3WhereEnd(pWInfo);
drhbf790972020-06-07 20:18:07 +00007005 finalizeAggFunctions(pParse, pAggInfo);
danielk1977a9d1ccb2008-01-05 17:39:29 +00007006 }
7007
drh079a3072014-03-19 14:10:55 +00007008 sSort.pOrderBy = 0;
drh33cd4902009-05-30 20:49:20 +00007009 sqlite3ExprIfFalse(pParse, pHaving, addrEnd, SQLITE_JUMPIFNULL);
drh2def2f72017-09-15 17:40:34 +00007010 selectInnerLoop(pParse, p, -1, 0, 0,
drha9671a22008-07-08 23:40:20 +00007011 pDest, addrEnd, addrEnd);
drh13449892005-09-07 21:22:45 +00007012 }
7013 sqlite3VdbeResolveLabel(v, addrEnd);
7014
7015 } /* endif aggregate query */
drh22827922000-06-06 17:27:05 +00007016
drhe8e4af72012-09-21 00:04:28 +00007017 if( sDistinct.eTnctType==WHERE_DISTINCT_UNORDERED ){
dan2ce22452010-11-08 19:01:16 +00007018 explainTempTable(pParse, "DISTINCT");
7019 }
7020
drhcce7d172000-05-31 15:34:51 +00007021 /* If there is an ORDER BY clause, then we need to sort the results
7022 ** and send them to the callback one by one.
7023 */
drh079a3072014-03-19 14:10:55 +00007024 if( sSort.pOrderBy ){
drh38b41492015-06-08 15:08:15 +00007025 explainTempTable(pParse,
7026 sSort.nOBSat>0 ? "RIGHT PART OF ORDER BY":"ORDER BY");
dan24e25d32018-04-14 18:46:20 +00007027 assert( p->pEList==pEList );
drh079a3072014-03-19 14:10:55 +00007028 generateSortTail(pParse, p, &sSort, pEList->nExpr, pDest);
drhcce7d172000-05-31 15:34:51 +00007029 }
drh6a535342001-10-19 16:44:56 +00007030
drhec7429a2005-10-06 16:53:14 +00007031 /* Jump here to skip this query
7032 */
7033 sqlite3VdbeResolveLabel(v, iEnd);
7034
dan5b1c07e2015-04-16 07:19:23 +00007035 /* The SELECT has been coded. If there is an error in the Parse structure,
7036 ** set the return code to 1. Otherwise 0. */
7037 rc = (pParse->nErr>0);
drh1d83f052002-02-17 00:30:36 +00007038
7039 /* Control jumps to here if an error is encountered above, or upon
7040 ** successful coding of the SELECT.
7041 */
7042select_end:
drh47d9f832017-10-26 20:04:28 +00007043 sqlite3ExprListDelete(db, pMinMaxOrderBy);
drh89636622020-06-07 17:33:18 +00007044#ifdef SQLITE_DEBUG
drh7b4c4d42020-06-10 03:07:26 +00007045 if( pAggInfo && !db->mallocFailed ){
drhbf790972020-06-07 20:18:07 +00007046 for(i=0; i<pAggInfo->nColumn; i++){
drh81185a52020-06-09 13:38:12 +00007047 Expr *pExpr = pAggInfo->aCol[i].pCExpr;
drh06ddb082020-12-22 14:54:20 +00007048 assert( pExpr!=0 );
drhbf790972020-06-07 20:18:07 +00007049 assert( pExpr->pAggInfo==pAggInfo );
drh89636622020-06-07 17:33:18 +00007050 assert( pExpr->iAgg==i );
7051 }
drhbf790972020-06-07 20:18:07 +00007052 for(i=0; i<pAggInfo->nFunc; i++){
drh81185a52020-06-09 13:38:12 +00007053 Expr *pExpr = pAggInfo->aFunc[i].pFExpr;
drh06ddb082020-12-22 14:54:20 +00007054 assert( pExpr!=0 );
drhbf790972020-06-07 20:18:07 +00007055 assert( pExpr->pAggInfo==pAggInfo );
drh89636622020-06-07 17:33:18 +00007056 assert( pExpr->iAgg==i );
7057 }
drh89636622020-06-07 17:33:18 +00007058 }
drh89636622020-06-07 17:33:18 +00007059#endif
7060
drheb9b8842014-09-21 00:27:26 +00007061#if SELECTTRACE_ENABLED
drhf20609d2018-04-23 17:43:35 +00007062 SELECTTRACE(0x1,pParse,p,("end processing\n"));
drhc0622a42020-12-04 01:17:57 +00007063 if( (sqlite3SelectTrace & 0x2000)!=0 && ExplainQueryPlanParent(pParse)==0 ){
drhf20609d2018-04-23 17:43:35 +00007064 sqlite3TreeViewSelect(0, p, 0);
7065 }
drheb9b8842014-09-21 00:27:26 +00007066#endif
drhe2ca99c2018-05-02 00:33:43 +00007067 ExplainQueryPlanPop(pParse);
drh1d83f052002-02-17 00:30:36 +00007068 return rc;
drhcce7d172000-05-31 15:34:51 +00007069}