4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
7 ** May you do good and not evil.
8 ** May you find forgiveness for yourself and forgive others.
9 ** May you share freely, never taking more than you give.
11 *************************************************************************
12 ** This file contains C code routines that are called by the parser
13 ** to handle SELECT statements in SQLite.
15 #include "sqliteInt.h"
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.
22 typedef struct DistinctCtx DistinctCtx
;
24 u8 isTnct
; /* 0: Not distinct. 1: DISTICT 2: DISTINCT and ORDER BY */
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 */
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.
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,
38 ** SELECT a, bigblob FROM t1 ORDER BY a LIMIT 10;
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.
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.
48 typedef struct SortCtx 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 */
56 int labelDone
; /* Jump here when done, ex: LIMIT reached */
57 int labelOBLopt
; /* Jump here when sorter is full */
58 u8 sortFlags
; /* Zero or more SORTFLAG_* bits */
59 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
60 u8 nDefer
; /* Number of valid entries in aDefer[] */
62 Table
*pTab
; /* Table definition */
63 int iCsr
; /* Cursor number for table */
64 int nKey
; /* Number of PK columns for table pTab (>=1) */
67 struct RowLoadInfo
*pDeferredRowLoad
; /* Deferred row loading info or NULL */
68 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
69 int addrPush
; /* First instruction to push data into sorter */
70 int addrPushEnd
; /* Last instruction that pushes data into sorter */
73 #define SORTFLAG_UseSorter 0x01 /* Use SorterOpen instead of OpenEphemeral */
76 ** Delete all the content of a Select structure. Deallocate the structure
77 ** itself depending on the value of bFree
79 ** If bFree==1, call sqlite3DbFree() on the p object.
80 ** If bFree==0, Leave the first Select object unfreed
82 static void clearSelect(sqlite3
*db
, Select
*p
, int bFree
){
85 Select
*pPrior
= p
->pPrior
;
86 sqlite3ExprListDelete(db
, p
->pEList
);
87 sqlite3SrcListDelete(db
, p
->pSrc
);
88 sqlite3ExprDelete(db
, p
->pWhere
);
89 sqlite3ExprListDelete(db
, p
->pGroupBy
);
90 sqlite3ExprDelete(db
, p
->pHaving
);
91 sqlite3ExprListDelete(db
, p
->pOrderBy
);
92 sqlite3ExprDelete(db
, p
->pLimit
);
93 if( OK_IF_ALWAYS_TRUE(p
->pWith
) ) sqlite3WithDelete(db
, p
->pWith
);
94 #ifndef SQLITE_OMIT_WINDOWFUNC
95 if( OK_IF_ALWAYS_TRUE(p
->pWinDefn
) ){
96 sqlite3WindowListDelete(db
, p
->pWinDefn
);
99 assert( p
->pWin
->ppThis
==&p
->pWin
);
100 sqlite3WindowUnlinkFromSelect(p
->pWin
);
103 if( bFree
) sqlite3DbNNFreeNN(db
, p
);
110 ** Initialize a SelectDest structure.
112 void sqlite3SelectDestInit(SelectDest
*pDest
, int eDest
, int iParm
){
113 pDest
->eDest
= (u8
)eDest
;
114 pDest
->iSDParm
= iParm
;
123 ** Allocate a new Select structure and return a pointer to that
126 Select
*sqlite3SelectNew(
127 Parse
*pParse
, /* Parsing context */
128 ExprList
*pEList
, /* which columns to include in the result */
129 SrcList
*pSrc
, /* the FROM clause -- which tables to scan */
130 Expr
*pWhere
, /* the WHERE clause */
131 ExprList
*pGroupBy
, /* the GROUP BY clause */
132 Expr
*pHaving
, /* the HAVING clause */
133 ExprList
*pOrderBy
, /* the ORDER BY clause */
134 u32 selFlags
, /* Flag parameters, such as SF_Distinct */
135 Expr
*pLimit
/* LIMIT value. NULL means not used */
137 Select
*pNew
, *pAllocated
;
139 pAllocated
= pNew
= sqlite3DbMallocRawNN(pParse
->db
, sizeof(*pNew
) );
141 assert( pParse
->db
->mallocFailed
);
145 pEList
= sqlite3ExprListAppend(pParse
, 0,
146 sqlite3Expr(pParse
->db
,TK_ASTERISK
,0));
148 pNew
->pEList
= pEList
;
149 pNew
->op
= TK_SELECT
;
150 pNew
->selFlags
= selFlags
;
153 pNew
->selId
= ++pParse
->nSelect
;
154 pNew
->addrOpenEphm
[0] = -1;
155 pNew
->addrOpenEphm
[1] = -1;
156 pNew
->nSelectRow
= 0;
157 if( pSrc
==0 ) pSrc
= sqlite3DbMallocZero(pParse
->db
, sizeof(*pSrc
));
159 pNew
->pWhere
= pWhere
;
160 pNew
->pGroupBy
= pGroupBy
;
161 pNew
->pHaving
= pHaving
;
162 pNew
->pOrderBy
= pOrderBy
;
165 pNew
->pLimit
= pLimit
;
167 #ifndef SQLITE_OMIT_WINDOWFUNC
171 if( pParse
->db
->mallocFailed
) {
172 clearSelect(pParse
->db
, pNew
, pNew
!=&standin
);
175 assert( pNew
->pSrc
!=0 || pParse
->nErr
>0 );
182 ** Delete the given Select structure and all of its substructures.
184 void sqlite3SelectDelete(sqlite3
*db
, Select
*p
){
185 if( OK_IF_ALWAYS_TRUE(p
) ) clearSelect(db
, p
, 1);
187 void sqlite3SelectDeleteGeneric(sqlite3
*db
, void *p
){
188 if( ALWAYS(p
) ) clearSelect(db
, (Select
*)p
, 1);
192 ** Return a pointer to the right-most SELECT statement in a compound.
194 static Select
*findRightmost(Select
*p
){
195 while( p
->pNext
) p
= p
->pNext
;
200 ** Given 1 to 3 identifiers preceding the JOIN keyword, determine the
201 ** type of join. Return an integer constant that expresses that type
202 ** in terms of the following bit values:
211 ** A full outer join is the combination of JT_LEFT and JT_RIGHT.
213 ** If an illegal or unsupported join type is seen, then still return
214 ** a join type, but put an error in the pParse structure.
216 ** These are the valid join types:
219 ** pA pB pC Return Value
220 ** ------- ----- ----- ------------
221 ** CROSS - - JT_CROSS
222 ** INNER - - JT_INNER
223 ** LEFT - - JT_LEFT|JT_OUTER
224 ** LEFT OUTER - JT_LEFT|JT_OUTER
225 ** RIGHT - - JT_RIGHT|JT_OUTER
226 ** RIGHT OUTER - JT_RIGHT|JT_OUTER
227 ** FULL - - JT_LEFT|JT_RIGHT|JT_OUTER
228 ** FULL OUTER - JT_LEFT|JT_RIGHT|JT_OUTER
229 ** NATURAL INNER - JT_NATURAL|JT_INNER
230 ** NATURAL LEFT - JT_NATURAL|JT_LEFT|JT_OUTER
231 ** NATURAL LEFT OUTER JT_NATURAL|JT_LEFT|JT_OUTER
232 ** NATURAL RIGHT - JT_NATURAL|JT_RIGHT|JT_OUTER
233 ** NATURAL RIGHT OUTER JT_NATURAL|JT_RIGHT|JT_OUTER
234 ** NATURAL FULL - JT_NATURAL|JT_LEFT|JT_RIGHT
235 ** NATURAL FULL OUTER JT_NATRUAL|JT_LEFT|JT_RIGHT
237 ** To preserve historical compatibly, SQLite also accepts a variety
238 ** of other non-standard and in many cases nonsensical join types.
239 ** This routine makes as much sense at it can from the nonsense join
240 ** type and returns a result. Examples of accepted nonsense join types
241 ** include but are not limited to:
243 ** INNER CROSS JOIN -> same as JOIN
244 ** NATURAL CROSS JOIN -> same as NATURAL JOIN
245 ** OUTER LEFT JOIN -> same as LEFT JOIN
246 ** LEFT NATURAL JOIN -> same as NATURAL LEFT JOIN
247 ** LEFT RIGHT JOIN -> same as FULL JOIN
248 ** RIGHT OUTER FULL JOIN -> same as FULL JOIN
249 ** CROSS CROSS CROSS JOIN -> same as JOIN
251 ** The only restrictions on the join type name are:
253 ** * "INNER" cannot appear together with "OUTER", "LEFT", "RIGHT",
256 ** * "CROSS" cannot appear together with "OUTER", "LEFT", "RIGHT,
259 ** * If "OUTER" is present then there must also be one of
260 ** "LEFT", "RIGHT", or "FULL"
262 int sqlite3JoinType(Parse
*pParse
, Token
*pA
, Token
*pB
, Token
*pC
){
266 /* 0123456789 123456789 123456789 123 */
267 static const char zKeyText
[] = "naturaleftouterightfullinnercross";
268 static const struct {
269 u8 i
; /* Beginning of keyword text in zKeyText[] */
270 u8 nChar
; /* Length of the keyword in characters */
271 u8 code
; /* Join type mask */
273 /* (0) natural */ { 0, 7, JT_NATURAL
},
274 /* (1) left */ { 6, 4, JT_LEFT
|JT_OUTER
},
275 /* (2) outer */ { 10, 5, JT_OUTER
},
276 /* (3) right */ { 14, 5, JT_RIGHT
|JT_OUTER
},
277 /* (4) full */ { 19, 4, JT_LEFT
|JT_RIGHT
|JT_OUTER
},
278 /* (5) inner */ { 23, 5, JT_INNER
},
279 /* (6) cross */ { 28, 5, JT_INNER
|JT_CROSS
},
285 for(i
=0; i
<3 && apAll
[i
]; i
++){
287 for(j
=0; j
<ArraySize(aKeyword
); j
++){
288 if( p
->n
==aKeyword
[j
].nChar
289 && sqlite3StrNICmp((char*)p
->z
, &zKeyText
[aKeyword
[j
].i
], p
->n
)==0 ){
290 jointype
|= aKeyword
[j
].code
;
294 testcase( j
==0 || j
==1 || j
==2 || j
==3 || j
==4 || j
==5 || j
==6 );
295 if( j
>=ArraySize(aKeyword
) ){
296 jointype
|= JT_ERROR
;
301 (jointype
& (JT_INNER
|JT_OUTER
))==(JT_INNER
|JT_OUTER
) ||
302 (jointype
& JT_ERROR
)!=0 ||
303 (jointype
& (JT_OUTER
|JT_LEFT
|JT_RIGHT
))==JT_OUTER
305 const char *zSp1
= " ";
306 const char *zSp2
= " ";
307 if( pB
==0 ){ zSp1
++; }
308 if( pC
==0 ){ zSp2
++; }
309 sqlite3ErrorMsg(pParse
, "unknown join type: "
310 "%T%s%T%s%T", pA
, zSp1
, pB
, zSp2
, pC
);
317 ** Return the index of a column in a table. Return -1 if the column
318 ** is not contained in the table.
320 int sqlite3ColumnIndex(Table
*pTab
, const char *zCol
){
322 u8 h
= sqlite3StrIHash(zCol
);
324 for(pCol
=pTab
->aCol
, i
=0; i
<pTab
->nCol
; pCol
++, i
++){
325 if( pCol
->hName
==h
&& sqlite3StrICmp(pCol
->zCnName
, zCol
)==0 ) return i
;
331 ** Mark a subquery result column as having been used.
333 void sqlite3SrcItemColumnUsed(SrcItem
*pItem
, int iCol
){
335 assert( (int)pItem
->fg
.isNestedFrom
== IsNestedFrom(pItem
->pSelect
) );
336 if( pItem
->fg
.isNestedFrom
){
338 assert( pItem
->pSelect
!=0 );
339 pResults
= pItem
->pSelect
->pEList
;
340 assert( pResults
!=0 );
341 assert( iCol
>=0 && iCol
<pResults
->nExpr
);
342 pResults
->a
[iCol
].fg
.bUsed
= 1;
347 ** Search the tables iStart..iEnd (inclusive) in pSrc, looking for a
348 ** table that has a column named zCol. The search is left-to-right.
349 ** The first match found is returned.
351 ** When found, set *piTab and *piCol to the table index and column index
352 ** of the matching column and return TRUE.
354 ** If not found, return FALSE.
356 static int tableAndColumnIndex(
357 SrcList
*pSrc
, /* Array of tables to search */
358 int iStart
, /* First member of pSrc->a[] to check */
359 int iEnd
, /* Last member of pSrc->a[] to check */
360 const char *zCol
, /* Name of the column we are looking for */
361 int *piTab
, /* Write index of pSrc->a[] here */
362 int *piCol
, /* Write index of pSrc->a[*piTab].pTab->aCol[] here */
363 int bIgnoreHidden
/* Ignore hidden columns */
365 int i
; /* For looping over tables in pSrc */
366 int iCol
; /* Index of column matching zCol */
368 assert( iEnd
<pSrc
->nSrc
);
370 assert( (piTab
==0)==(piCol
==0) ); /* Both or neither are NULL */
372 for(i
=iStart
; i
<=iEnd
; i
++){
373 iCol
= sqlite3ColumnIndex(pSrc
->a
[i
].pTab
, zCol
);
375 && (bIgnoreHidden
==0 || IsHiddenColumn(&pSrc
->a
[i
].pTab
->aCol
[iCol
])==0)
378 sqlite3SrcItemColumnUsed(&pSrc
->a
[i
], iCol
);
389 ** Set the EP_OuterON property on all terms of the given expression.
390 ** And set the Expr.w.iJoin to iTable for every term in the
393 ** The EP_OuterON property is used on terms of an expression to tell
394 ** the OUTER JOIN processing logic that this term is part of the
395 ** join restriction specified in the ON or USING clause and not a part
396 ** of the more general WHERE clause. These terms are moved over to the
397 ** WHERE clause during join processing but we need to remember that they
398 ** originated in the ON or USING clause.
400 ** The Expr.w.iJoin tells the WHERE clause processing that the
401 ** expression depends on table w.iJoin even if that table is not
402 ** explicitly mentioned in the expression. That information is needed
403 ** for cases like this:
405 ** SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.b AND t1.x=5
407 ** The where clause needs to defer the handling of the t1.x=5
408 ** term until after the t2 loop of the join. In that way, a
409 ** NULL t2 row will be inserted whenever t1.x!=5. If we do not
410 ** defer the handling of t1.x=5, it will be processed immediately
411 ** after the t1 loop and rows with t1.x!=5 will never appear in
412 ** the output, which is incorrect.
414 void sqlite3SetJoinExpr(Expr
*p
, int iTable
, u32 joinFlag
){
415 assert( joinFlag
==EP_OuterON
|| joinFlag
==EP_InnerON
);
417 ExprSetProperty(p
, joinFlag
);
418 assert( !ExprHasProperty(p
, EP_TokenOnly
|EP_Reduced
) );
419 ExprSetVVAProperty(p
, EP_NoReduce
);
421 if( p
->op
==TK_FUNCTION
){
422 assert( ExprUseXList(p
) );
425 for(i
=0; i
<p
->x
.pList
->nExpr
; i
++){
426 sqlite3SetJoinExpr(p
->x
.pList
->a
[i
].pExpr
, iTable
, joinFlag
);
430 sqlite3SetJoinExpr(p
->pLeft
, iTable
, joinFlag
);
435 /* Undo the work of sqlite3SetJoinExpr(). This is used when a LEFT JOIN
436 ** is simplified into an ordinary JOIN, and when an ON expression is
437 ** "pushed down" into the WHERE clause of a subquery.
439 ** Convert every term that is marked with EP_OuterON and w.iJoin==iTable into
440 ** an ordinary term that omits the EP_OuterON mark. Or if iTable<0, then
441 ** just clear every EP_OuterON and EP_InnerON mark from the expression tree.
443 ** If nullable is true, that means that Expr p might evaluate to NULL even
444 ** if it is a reference to a NOT NULL column. This can happen, for example,
445 ** if the table that p references is on the left side of a RIGHT JOIN.
446 ** If nullable is true, then take care to not remove the EP_CanBeNull bit.
447 ** See forum thread https://sqlite.org/forum/forumpost/b40696f50145d21c
449 static void unsetJoinExpr(Expr
*p
, int iTable
, int nullable
){
451 if( iTable
<0 || (ExprHasProperty(p
, EP_OuterON
) && p
->w
.iJoin
==iTable
) ){
452 ExprClearProperty(p
, EP_OuterON
|EP_InnerON
);
453 if( iTable
>=0 ) ExprSetProperty(p
, EP_InnerON
);
455 if( p
->op
==TK_COLUMN
&& p
->iTable
==iTable
&& !nullable
){
456 ExprClearProperty(p
, EP_CanBeNull
);
458 if( p
->op
==TK_FUNCTION
){
459 assert( ExprUseXList(p
) );
460 assert( p
->pLeft
==0 );
463 for(i
=0; i
<p
->x
.pList
->nExpr
; i
++){
464 unsetJoinExpr(p
->x
.pList
->a
[i
].pExpr
, iTable
, nullable
);
468 unsetJoinExpr(p
->pLeft
, iTable
, nullable
);
474 ** This routine processes the join information for a SELECT statement.
476 ** * A NATURAL join is converted into a USING join. After that, we
477 ** do not need to be concerned with NATURAL joins and we only have
478 ** think about USING joins.
480 ** * ON and USING clauses result in extra terms being added to the
481 ** WHERE clause to enforce the specified constraints. The extra
482 ** WHERE clause terms will be tagged with EP_OuterON or
483 ** EP_InnerON so that we know that they originated in ON/USING.
485 ** The terms of a FROM clause are contained in the Select.pSrc structure.
486 ** The left most table is the first entry in Select.pSrc. The right-most
487 ** table is the last entry. The join operator is held in the entry to
488 ** the right. Thus entry 1 contains the join operator for the join between
489 ** entries 0 and 1. Any ON or USING clauses associated with the join are
490 ** also attached to the right entry.
492 ** This routine returns the number of errors encountered.
494 static int sqlite3ProcessJoin(Parse
*pParse
, Select
*p
){
495 SrcList
*pSrc
; /* All tables in the FROM clause */
496 int i
, j
; /* Loop counters */
497 SrcItem
*pLeft
; /* Left table being joined */
498 SrcItem
*pRight
; /* Right table being joined */
503 for(i
=0; i
<pSrc
->nSrc
-1; i
++, pRight
++, pLeft
++){
504 Table
*pRightTab
= pRight
->pTab
;
507 if( NEVER(pLeft
->pTab
==0 || pRightTab
==0) ) continue;
508 joinType
= (pRight
->fg
.jointype
& JT_OUTER
)!=0 ? EP_OuterON
: EP_InnerON
;
510 /* If this is a NATURAL join, synthesize an appropriate USING clause
511 ** to specify which columns should be joined.
513 if( pRight
->fg
.jointype
& JT_NATURAL
){
515 if( pRight
->fg
.isUsing
|| pRight
->u3
.pOn
){
516 sqlite3ErrorMsg(pParse
, "a NATURAL join may not have "
517 "an ON or USING clause", 0);
520 for(j
=0; j
<pRightTab
->nCol
; j
++){
521 char *zName
; /* Name of column in the right table */
523 if( IsHiddenColumn(&pRightTab
->aCol
[j
]) ) continue;
524 zName
= pRightTab
->aCol
[j
].zCnName
;
525 if( tableAndColumnIndex(pSrc
, 0, i
, zName
, 0, 0, 1) ){
526 pUsing
= sqlite3IdListAppend(pParse
, pUsing
, 0);
528 assert( pUsing
->nId
>0 );
529 assert( pUsing
->a
[pUsing
->nId
-1].zName
==0 );
530 pUsing
->a
[pUsing
->nId
-1].zName
= sqlite3DbStrDup(pParse
->db
, zName
);
535 pRight
->fg
.isUsing
= 1;
536 pRight
->fg
.isSynthUsing
= 1;
537 pRight
->u3
.pUsing
= pUsing
;
539 if( pParse
->nErr
) return 1;
542 /* Create extra terms on the WHERE clause for each column named
543 ** in the USING clause. Example: If the two tables to be joined are
544 ** A and B and the USING clause names X, Y, and Z, then add this
545 ** to the WHERE clause: A.X=B.X AND A.Y=B.Y AND A.Z=B.Z
546 ** Report an error if any column mentioned in the USING clause is
547 ** not contained in both tables to be joined.
549 if( pRight
->fg
.isUsing
){
550 IdList
*pList
= pRight
->u3
.pUsing
;
551 sqlite3
*db
= pParse
->db
;
553 for(j
=0; j
<pList
->nId
; j
++){
554 char *zName
; /* Name of the term in the USING clause */
555 int iLeft
; /* Table on the left with matching column name */
556 int iLeftCol
; /* Column number of matching column on the left */
557 int iRightCol
; /* Column number of matching column on the right */
558 Expr
*pE1
; /* Reference to the column on the LEFT of the join */
559 Expr
*pE2
; /* Reference to the column on the RIGHT of the join */
560 Expr
*pEq
; /* Equality constraint. pE1 == pE2 */
562 zName
= pList
->a
[j
].zName
;
563 iRightCol
= sqlite3ColumnIndex(pRightTab
, zName
);
565 || tableAndColumnIndex(pSrc
, 0, i
, zName
, &iLeft
, &iLeftCol
,
566 pRight
->fg
.isSynthUsing
)==0
568 sqlite3ErrorMsg(pParse
, "cannot join using column %s - column "
569 "not present in both tables", zName
);
572 pE1
= sqlite3CreateColumnExpr(db
, pSrc
, iLeft
, iLeftCol
);
573 sqlite3SrcItemColumnUsed(&pSrc
->a
[iLeft
], iLeftCol
);
574 if( (pSrc
->a
[0].fg
.jointype
& JT_LTORJ
)!=0 ){
575 /* This branch runs if the query contains one or more RIGHT or FULL
576 ** JOINs. If only a single table on the left side of this join
577 ** contains the zName column, then this branch is a no-op.
578 ** But if there are two or more tables on the left side
579 ** of the join, construct a coalesce() function that gathers all
580 ** such tables. Raise an error if more than one of those references
581 ** to zName is not also within a prior USING clause.
583 ** We really ought to raise an error if there are two or more
584 ** non-USING references to zName on the left of an INNER or LEFT
585 ** JOIN. But older versions of SQLite do not do that, so we avoid
586 ** adding a new error so as to not break legacy applications.
588 ExprList
*pFuncArgs
= 0; /* Arguments to the coalesce() */
589 static const Token tkCoalesce
= { "coalesce", 8 };
590 while( tableAndColumnIndex(pSrc
, iLeft
+1, i
, zName
, &iLeft
, &iLeftCol
,
591 pRight
->fg
.isSynthUsing
)!=0 ){
592 if( pSrc
->a
[iLeft
].fg
.isUsing
==0
593 || sqlite3IdListIndex(pSrc
->a
[iLeft
].u3
.pUsing
, zName
)<0
595 sqlite3ErrorMsg(pParse
, "ambiguous reference to %s in USING()",
599 pFuncArgs
= sqlite3ExprListAppend(pParse
, pFuncArgs
, pE1
);
600 pE1
= sqlite3CreateColumnExpr(db
, pSrc
, iLeft
, iLeftCol
);
601 sqlite3SrcItemColumnUsed(&pSrc
->a
[iLeft
], iLeftCol
);
604 pFuncArgs
= sqlite3ExprListAppend(pParse
, pFuncArgs
, pE1
);
605 pE1
= sqlite3ExprFunction(pParse
, pFuncArgs
, &tkCoalesce
, 0);
608 pE2
= sqlite3CreateColumnExpr(db
, pSrc
, i
+1, iRightCol
);
609 sqlite3SrcItemColumnUsed(pRight
, iRightCol
);
610 pEq
= sqlite3PExpr(pParse
, TK_EQ
, pE1
, pE2
);
611 assert( pE2
!=0 || pEq
==0 );
613 ExprSetProperty(pEq
, joinType
);
614 assert( !ExprHasProperty(pEq
, EP_TokenOnly
|EP_Reduced
) );
615 ExprSetVVAProperty(pEq
, EP_NoReduce
);
616 pEq
->w
.iJoin
= pE2
->iTable
;
618 p
->pWhere
= sqlite3ExprAnd(pParse
, p
->pWhere
, pEq
);
622 /* Add the ON clause to the end of the WHERE clause, connected by
625 else if( pRight
->u3
.pOn
){
626 sqlite3SetJoinExpr(pRight
->u3
.pOn
, pRight
->iCursor
, joinType
);
627 p
->pWhere
= sqlite3ExprAnd(pParse
, p
->pWhere
, pRight
->u3
.pOn
);
636 ** An instance of this object holds information (beyond pParse and pSelect)
637 ** needed to load the next result row that is to be added to the sorter.
639 typedef struct RowLoadInfo RowLoadInfo
;
641 int regResult
; /* Store results in array of registers here */
642 u8 ecelFlags
; /* Flag argument to ExprCodeExprList() */
643 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
644 ExprList
*pExtra
; /* Extra columns needed by sorter refs */
645 int regExtraResult
; /* Where to load the extra columns */
650 ** This routine does the work of loading query data into an array of
651 ** registers so that it can be added to the sorter.
653 static void innerLoopLoadRow(
654 Parse
*pParse
, /* Statement under construction */
655 Select
*pSelect
, /* The query being coded */
656 RowLoadInfo
*pInfo
/* Info needed to complete the row load */
658 sqlite3ExprCodeExprList(pParse
, pSelect
->pEList
, pInfo
->regResult
,
659 0, pInfo
->ecelFlags
);
660 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
662 sqlite3ExprCodeExprList(pParse
, pInfo
->pExtra
, pInfo
->regExtraResult
, 0, 0);
663 sqlite3ExprListDelete(pParse
->db
, pInfo
->pExtra
);
669 ** Code the OP_MakeRecord instruction that generates the entry to be
670 ** added into the sorter.
672 ** Return the register in which the result is stored.
674 static int makeSorterRecord(
681 int nOBSat
= pSort
->nOBSat
;
682 Vdbe
*v
= pParse
->pVdbe
;
683 int regOut
= ++pParse
->nMem
;
684 if( pSort
->pDeferredRowLoad
){
685 innerLoopLoadRow(pParse
, pSelect
, pSort
->pDeferredRowLoad
);
687 sqlite3VdbeAddOp3(v
, OP_MakeRecord
, regBase
+nOBSat
, nBase
-nOBSat
, regOut
);
692 ** Generate code that will push the record in registers regData
693 ** through regData+nData-1 onto the sorter.
695 static void pushOntoSorter(
696 Parse
*pParse
, /* Parser context */
697 SortCtx
*pSort
, /* Information about the ORDER BY clause */
698 Select
*pSelect
, /* The whole SELECT statement */
699 int regData
, /* First register holding data to be sorted */
700 int regOrigData
, /* First register holding data before packing */
701 int nData
, /* Number of elements in the regData data array */
702 int nPrefixReg
/* No. of reg prior to regData available for use */
704 Vdbe
*v
= pParse
->pVdbe
; /* Stmt under construction */
705 int bSeq
= ((pSort
->sortFlags
& SORTFLAG_UseSorter
)==0);
706 int nExpr
= pSort
->pOrderBy
->nExpr
; /* No. of ORDER BY terms */
707 int nBase
= nExpr
+ bSeq
+ nData
; /* Fields in sorter record */
708 int regBase
; /* Regs for sorter record */
709 int regRecord
= 0; /* Assembled sorter record */
710 int nOBSat
= pSort
->nOBSat
; /* ORDER BY terms to skip */
711 int op
; /* Opcode to add sorter record to sorter */
712 int iLimit
; /* LIMIT counter */
713 int iSkip
= 0; /* End of the sorter insert loop */
715 assert( bSeq
==0 || bSeq
==1 );
718 ** (1) The data to be sorted has already been packed into a Record
719 ** by a prior OP_MakeRecord. In this case nData==1 and regData
720 ** will be completely unrelated to regOrigData.
721 ** (2) All output columns are included in the sort record. In that
722 ** case regData==regOrigData.
723 ** (3) Some output columns are omitted from the sort record due to
724 ** the SQLITE_ENABLE_SORTER_REFERENCES optimization, or due to the
725 ** SQLITE_ECEL_OMITREF optimization, or due to the
726 ** SortCtx.pDeferredRowLoad optimization. In any of these cases
727 ** regOrigData is 0 to prevent this routine from trying to copy
728 ** values that might not yet exist.
730 assert( nData
==1 || regData
==regOrigData
|| regOrigData
==0 );
732 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
733 pSort
->addrPush
= sqlite3VdbeCurrentAddr(v
);
737 assert( nPrefixReg
==nExpr
+bSeq
);
738 regBase
= regData
- nPrefixReg
;
740 regBase
= pParse
->nMem
+ 1;
741 pParse
->nMem
+= nBase
;
743 assert( pSelect
->iOffset
==0 || pSelect
->iLimit
!=0 );
744 iLimit
= pSelect
->iOffset
? pSelect
->iOffset
+1 : pSelect
->iLimit
;
745 pSort
->labelDone
= sqlite3VdbeMakeLabel(pParse
);
746 sqlite3ExprCodeExprList(pParse
, pSort
->pOrderBy
, regBase
, regOrigData
,
747 SQLITE_ECEL_DUP
| (regOrigData
? SQLITE_ECEL_REF
: 0));
749 sqlite3VdbeAddOp2(v
, OP_Sequence
, pSort
->iECursor
, regBase
+nExpr
);
751 if( nPrefixReg
==0 && nData
>0 ){
752 sqlite3ExprCodeMove(pParse
, regData
, regBase
+nExpr
+bSeq
, nData
);
755 int regPrevKey
; /* The first nOBSat columns of the previous row */
756 int addrFirst
; /* Address of the OP_IfNot opcode */
757 int addrJmp
; /* Address of the OP_Jump opcode */
758 VdbeOp
*pOp
; /* Opcode that opens the sorter */
759 int nKey
; /* Number of sorting key columns, including OP_Sequence */
760 KeyInfo
*pKI
; /* Original KeyInfo on the sorter table */
762 regRecord
= makeSorterRecord(pParse
, pSort
, pSelect
, regBase
, nBase
);
763 regPrevKey
= pParse
->nMem
+1;
764 pParse
->nMem
+= pSort
->nOBSat
;
765 nKey
= nExpr
- pSort
->nOBSat
+ bSeq
;
767 addrFirst
= sqlite3VdbeAddOp1(v
, OP_IfNot
, regBase
+nExpr
);
769 addrFirst
= sqlite3VdbeAddOp1(v
, OP_SequenceTest
, pSort
->iECursor
);
772 sqlite3VdbeAddOp3(v
, OP_Compare
, regPrevKey
, regBase
, pSort
->nOBSat
);
773 pOp
= sqlite3VdbeGetOp(v
, pSort
->addrSortIndex
);
774 if( pParse
->db
->mallocFailed
) return;
775 pOp
->p2
= nKey
+ nData
;
776 pKI
= pOp
->p4
.pKeyInfo
;
777 memset(pKI
->aSortFlags
, 0, pKI
->nKeyField
); /* Makes OP_Jump testable */
778 sqlite3VdbeChangeP4(v
, -1, (char*)pKI
, P4_KEYINFO
);
779 testcase( pKI
->nAllField
> pKI
->nKeyField
+2 );
780 pOp
->p4
.pKeyInfo
= sqlite3KeyInfoFromExprList(pParse
,pSort
->pOrderBy
,nOBSat
,
781 pKI
->nAllField
-pKI
->nKeyField
-1);
782 pOp
= 0; /* Ensure pOp not used after sqlite3VdbeAddOp3() */
783 addrJmp
= sqlite3VdbeCurrentAddr(v
);
784 sqlite3VdbeAddOp3(v
, OP_Jump
, addrJmp
+1, 0, addrJmp
+1); VdbeCoverage(v
);
785 pSort
->labelBkOut
= sqlite3VdbeMakeLabel(pParse
);
786 pSort
->regReturn
= ++pParse
->nMem
;
787 sqlite3VdbeAddOp2(v
, OP_Gosub
, pSort
->regReturn
, pSort
->labelBkOut
);
788 sqlite3VdbeAddOp1(v
, OP_ResetSorter
, pSort
->iECursor
);
790 sqlite3VdbeAddOp2(v
, OP_IfNot
, iLimit
, pSort
->labelDone
);
793 sqlite3VdbeJumpHere(v
, addrFirst
);
794 sqlite3ExprCodeMove(pParse
, regBase
, regPrevKey
, pSort
->nOBSat
);
795 sqlite3VdbeJumpHere(v
, addrJmp
);
798 /* At this point the values for the new sorter entry are stored
799 ** in an array of registers. They need to be composed into a record
800 ** and inserted into the sorter if either (a) there are currently
801 ** less than LIMIT+OFFSET items or (b) the new record is smaller than
802 ** the largest record currently in the sorter. If (b) is true and there
803 ** are already LIMIT+OFFSET items in the sorter, delete the largest
804 ** entry before inserting the new one. This way there are never more
805 ** than LIMIT+OFFSET items in the sorter.
807 ** If the new record does not need to be inserted into the sorter,
808 ** jump to the next iteration of the loop. If the pSort->labelOBLopt
809 ** value is not zero, then it is a label of where to jump. Otherwise,
810 ** just bypass the row insert logic. See the header comment on the
811 ** sqlite3WhereOrderByLimitOptLabel() function for additional info.
813 int iCsr
= pSort
->iECursor
;
814 sqlite3VdbeAddOp2(v
, OP_IfNotZero
, iLimit
, sqlite3VdbeCurrentAddr(v
)+4);
816 sqlite3VdbeAddOp2(v
, OP_Last
, iCsr
, 0);
817 iSkip
= sqlite3VdbeAddOp4Int(v
, OP_IdxLE
,
818 iCsr
, 0, regBase
+nOBSat
, nExpr
-nOBSat
);
820 sqlite3VdbeAddOp1(v
, OP_Delete
, iCsr
);
823 regRecord
= makeSorterRecord(pParse
, pSort
, pSelect
, regBase
, nBase
);
825 if( pSort
->sortFlags
& SORTFLAG_UseSorter
){
826 op
= OP_SorterInsert
;
830 sqlite3VdbeAddOp4Int(v
, op
, pSort
->iECursor
, regRecord
,
831 regBase
+nOBSat
, nBase
-nOBSat
);
833 sqlite3VdbeChangeP2(v
, iSkip
,
834 pSort
->labelOBLopt
? pSort
->labelOBLopt
: sqlite3VdbeCurrentAddr(v
));
836 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
837 pSort
->addrPushEnd
= sqlite3VdbeCurrentAddr(v
)-1;
842 ** Add code to implement the OFFSET
844 static void codeOffset(
845 Vdbe
*v
, /* Generate code into this VM */
846 int iOffset
, /* Register holding the offset counter */
847 int iContinue
/* Jump here to skip the current record */
850 sqlite3VdbeAddOp3(v
, OP_IfPos
, iOffset
, iContinue
, 1); VdbeCoverage(v
);
851 VdbeComment((v
, "OFFSET"));
856 ** Add code that will check to make sure the array of registers starting at
857 ** iMem form a distinct entry. This is used by both "SELECT DISTINCT ..." and
858 ** distinct aggregates ("SELECT count(DISTINCT <expr>) ..."). Three strategies
859 ** are available. Which is used depends on the value of parameter eTnctType,
862 ** WHERE_DISTINCT_UNORDERED/WHERE_DISTINCT_NOOP:
863 ** Build an ephemeral table that contains all entries seen before and
864 ** skip entries which have been seen before.
866 ** Parameter iTab is the cursor number of an ephemeral table that must
867 ** be opened before the VM code generated by this routine is executed.
868 ** The ephemeral cursor table is queried for a record identical to the
869 ** record formed by the current array of registers. If one is found,
870 ** jump to VM address addrRepeat. Otherwise, insert a new record into
871 ** the ephemeral cursor and proceed.
873 ** The returned value in this case is a copy of parameter iTab.
875 ** WHERE_DISTINCT_ORDERED:
876 ** In this case rows are being delivered sorted order. The ephemeral
877 ** table is not required. Instead, the current set of values
878 ** is compared against previous row. If they match, the new row
879 ** is not distinct and control jumps to VM address addrRepeat. Otherwise,
880 ** the VM program proceeds with processing the new row.
882 ** The returned value in this case is the register number of the first
883 ** in an array of registers used to store the previous result row so that
884 ** it can be compared to the next. The caller must ensure that this
885 ** register is initialized to NULL. (The fixDistinctOpenEph() routine
886 ** will take care of this initialization.)
888 ** WHERE_DISTINCT_UNIQUE:
889 ** In this case it has already been determined that the rows are distinct.
890 ** No special action is required. The return value is zero.
892 ** Parameter pEList is the list of expressions used to generated the
893 ** contents of each row. It is used by this routine to determine (a)
894 ** how many elements there are in the array of registers and (b) the
895 ** collation sequences that should be used for the comparisons if
896 ** eTnctType is WHERE_DISTINCT_ORDERED.
898 static int codeDistinct(
899 Parse
*pParse
, /* Parsing and code generating context */
900 int eTnctType
, /* WHERE_DISTINCT_* value */
901 int iTab
, /* A sorting index used to test for distinctness */
902 int addrRepeat
, /* Jump to here if not distinct */
903 ExprList
*pEList
, /* Expression for each element */
904 int regElem
/* First element */
907 int nResultCol
= pEList
->nExpr
;
908 Vdbe
*v
= pParse
->pVdbe
;
911 case WHERE_DISTINCT_ORDERED
: {
913 int iJump
; /* Jump destination */
914 int regPrev
; /* Previous row content */
916 /* Allocate space for the previous row */
917 iRet
= regPrev
= pParse
->nMem
+1;
918 pParse
->nMem
+= nResultCol
;
920 iJump
= sqlite3VdbeCurrentAddr(v
) + nResultCol
;
921 for(i
=0; i
<nResultCol
; i
++){
922 CollSeq
*pColl
= sqlite3ExprCollSeq(pParse
, pEList
->a
[i
].pExpr
);
923 if( i
<nResultCol
-1 ){
924 sqlite3VdbeAddOp3(v
, OP_Ne
, regElem
+i
, iJump
, regPrev
+i
);
927 sqlite3VdbeAddOp3(v
, OP_Eq
, regElem
+i
, addrRepeat
, regPrev
+i
);
930 sqlite3VdbeChangeP4(v
, -1, (const char *)pColl
, P4_COLLSEQ
);
931 sqlite3VdbeChangeP5(v
, SQLITE_NULLEQ
);
933 assert( sqlite3VdbeCurrentAddr(v
)==iJump
|| pParse
->db
->mallocFailed
);
934 sqlite3VdbeAddOp3(v
, OP_Copy
, regElem
, regPrev
, nResultCol
-1);
938 case WHERE_DISTINCT_UNIQUE
: {
944 int r1
= sqlite3GetTempReg(pParse
);
945 sqlite3VdbeAddOp4Int(v
, OP_Found
, iTab
, addrRepeat
, regElem
, nResultCol
);
947 sqlite3VdbeAddOp3(v
, OP_MakeRecord
, regElem
, nResultCol
, r1
);
948 sqlite3VdbeAddOp4Int(v
, OP_IdxInsert
, iTab
, r1
, regElem
, nResultCol
);
949 sqlite3VdbeChangeP5(v
, OPFLAG_USESEEKRESULT
);
950 sqlite3ReleaseTempReg(pParse
, r1
);
960 ** This routine runs after codeDistinct(). It makes necessary
961 ** adjustments to the OP_OpenEphemeral opcode that the codeDistinct()
962 ** routine made use of. This processing must be done separately since
963 ** sometimes codeDistinct is called before the OP_OpenEphemeral is actually
966 ** WHERE_DISTINCT_NOOP:
967 ** WHERE_DISTINCT_UNORDERED:
969 ** No adjustments necessary. This function is a no-op.
971 ** WHERE_DISTINCT_UNIQUE:
973 ** The ephemeral table is not needed. So change the
974 ** OP_OpenEphemeral opcode into an OP_Noop.
976 ** WHERE_DISTINCT_ORDERED:
978 ** The ephemeral table is not needed. But we do need register
979 ** iVal to be initialized to NULL. So change the OP_OpenEphemeral
980 ** into an OP_Null on the iVal register.
982 static void fixDistinctOpenEph(
983 Parse
*pParse
, /* Parsing and code generating context */
984 int eTnctType
, /* WHERE_DISTINCT_* value */
985 int iVal
, /* Value returned by codeDistinct() */
986 int iOpenEphAddr
/* Address of OP_OpenEphemeral instruction for iTab */
989 && (eTnctType
==WHERE_DISTINCT_UNIQUE
|| eTnctType
==WHERE_DISTINCT_ORDERED
)
991 Vdbe
*v
= pParse
->pVdbe
;
992 sqlite3VdbeChangeToNoop(v
, iOpenEphAddr
);
993 if( sqlite3VdbeGetOp(v
, iOpenEphAddr
+1)->opcode
==OP_Explain
){
994 sqlite3VdbeChangeToNoop(v
, iOpenEphAddr
+1);
996 if( eTnctType
==WHERE_DISTINCT_ORDERED
){
997 /* Change the OP_OpenEphemeral to an OP_Null that sets the MEM_Cleared
998 ** bit on the first register of the previous value. This will cause the
999 ** OP_Ne added in codeDistinct() to always fail on the first iteration of
1000 ** the loop even if the first row is all NULLs. */
1001 VdbeOp
*pOp
= sqlite3VdbeGetOp(v
, iOpenEphAddr
);
1002 pOp
->opcode
= OP_Null
;
1009 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
1011 ** This function is called as part of inner-loop generation for a SELECT
1012 ** statement with an ORDER BY that is not optimized by an index. It
1013 ** determines the expressions, if any, that the sorter-reference
1014 ** optimization should be used for. The sorter-reference optimization
1015 ** is used for SELECT queries like:
1017 ** SELECT a, bigblob FROM t1 ORDER BY a LIMIT 10
1019 ** If the optimization is used for expression "bigblob", then instead of
1020 ** storing values read from that column in the sorter records, the PK of
1021 ** the row from table t1 is stored instead. Then, as records are extracted from
1022 ** the sorter to return to the user, the required value of bigblob is
1023 ** retrieved directly from table t1. If the values are very large, this
1024 ** can be more efficient than storing them directly in the sorter records.
1026 ** The ExprList_item.fg.bSorterRef flag is set for each expression in pEList
1027 ** for which the sorter-reference optimization should be enabled.
1028 ** Additionally, the pSort->aDefer[] array is populated with entries
1029 ** for all cursors required to evaluate all selected expressions. Finally.
1030 ** output variable (*ppExtra) is set to an expression list containing
1031 ** expressions for all extra PK values that should be stored in the
1034 static void selectExprDefer(
1035 Parse
*pParse
, /* Leave any error here */
1036 SortCtx
*pSort
, /* Sorter context */
1037 ExprList
*pEList
, /* Expressions destined for sorter */
1038 ExprList
**ppExtra
/* Expressions to append to sorter record */
1042 ExprList
*pExtra
= 0;
1043 for(i
=0; i
<pEList
->nExpr
; i
++){
1044 struct ExprList_item
*pItem
= &pEList
->a
[i
];
1045 if( pItem
->u
.x
.iOrderByCol
==0 ){
1046 Expr
*pExpr
= pItem
->pExpr
;
1048 if( pExpr
->op
==TK_COLUMN
1049 && pExpr
->iColumn
>=0
1050 && ALWAYS( ExprUseYTab(pExpr
) )
1051 && (pTab
= pExpr
->y
.pTab
)!=0
1052 && IsOrdinaryTable(pTab
)
1053 && (pTab
->aCol
[pExpr
->iColumn
].colFlags
& COLFLAG_SORTERREF
)!=0
1056 for(j
=0; j
<nDefer
; j
++){
1057 if( pSort
->aDefer
[j
].iCsr
==pExpr
->iTable
) break;
1060 if( nDefer
==ArraySize(pSort
->aDefer
) ){
1066 if( !HasRowid(pTab
) ){
1067 pPk
= sqlite3PrimaryKeyIndex(pTab
);
1068 nKey
= pPk
->nKeyCol
;
1070 for(k
=0; k
<nKey
; k
++){
1071 Expr
*pNew
= sqlite3PExpr(pParse
, TK_COLUMN
, 0, 0);
1073 pNew
->iTable
= pExpr
->iTable
;
1074 assert( ExprUseYTab(pNew
) );
1075 pNew
->y
.pTab
= pExpr
->y
.pTab
;
1076 pNew
->iColumn
= pPk
? pPk
->aiColumn
[k
] : -1;
1077 pExtra
= sqlite3ExprListAppend(pParse
, pExtra
, pNew
);
1080 pSort
->aDefer
[nDefer
].pTab
= pExpr
->y
.pTab
;
1081 pSort
->aDefer
[nDefer
].iCsr
= pExpr
->iTable
;
1082 pSort
->aDefer
[nDefer
].nKey
= nKey
;
1086 pItem
->fg
.bSorterRef
= 1;
1090 pSort
->nDefer
= (u8
)nDefer
;
1096 ** This routine generates the code for the inside of the inner loop
1099 ** If srcTab is negative, then the p->pEList expressions
1100 ** are evaluated in order to get the data for this row. If srcTab is
1101 ** zero or more, then data is pulled from srcTab and p->pEList is used only
1102 ** to get the number of columns and the collation sequence for each column.
1104 static void selectInnerLoop(
1105 Parse
*pParse
, /* The parser context */
1106 Select
*p
, /* The complete select statement being coded */
1107 int srcTab
, /* Pull data from this table if non-negative */
1108 SortCtx
*pSort
, /* If not NULL, info on how to process ORDER BY */
1109 DistinctCtx
*pDistinct
, /* If not NULL, info on how to process DISTINCT */
1110 SelectDest
*pDest
, /* How to dispose of the results */
1111 int iContinue
, /* Jump here to continue with next row */
1112 int iBreak
/* Jump here to break out of the inner loop */
1114 Vdbe
*v
= pParse
->pVdbe
;
1116 int hasDistinct
; /* True if the DISTINCT keyword is present */
1117 int eDest
= pDest
->eDest
; /* How to dispose of results */
1118 int iParm
= pDest
->iSDParm
; /* First argument to disposal method */
1119 int nResultCol
; /* Number of result columns */
1120 int nPrefixReg
= 0; /* Number of extra registers before regResult */
1121 RowLoadInfo sRowLoadInfo
; /* Info for deferred row loading */
1123 /* Usually, regResult is the first cell in an array of memory cells
1124 ** containing the current result row. In this case regOrig is set to the
1125 ** same value. However, if the results are being sent to the sorter, the
1126 ** values for any expressions that are also part of the sort-key are omitted
1127 ** from this array. In this case regOrig is set to zero. */
1128 int regResult
; /* Start of memory holding current results */
1129 int regOrig
; /* Start of memory holding full result (or 0) */
1132 assert( p
->pEList
!=0 );
1133 hasDistinct
= pDistinct
? pDistinct
->eTnctType
: WHERE_DISTINCT_NOOP
;
1134 if( pSort
&& pSort
->pOrderBy
==0 ) pSort
= 0;
1135 if( pSort
==0 && !hasDistinct
){
1136 assert( iContinue
!=0 );
1137 codeOffset(v
, p
->iOffset
, iContinue
);
1140 /* Pull the requested columns.
1142 nResultCol
= p
->pEList
->nExpr
;
1144 if( pDest
->iSdst
==0 ){
1146 nPrefixReg
= pSort
->pOrderBy
->nExpr
;
1147 if( !(pSort
->sortFlags
& SORTFLAG_UseSorter
) ) nPrefixReg
++;
1148 pParse
->nMem
+= nPrefixReg
;
1150 pDest
->iSdst
= pParse
->nMem
+1;
1151 pParse
->nMem
+= nResultCol
;
1152 }else if( pDest
->iSdst
+nResultCol
> pParse
->nMem
){
1153 /* This is an error condition that can result, for example, when a SELECT
1154 ** on the right-hand side of an INSERT contains more result columns than
1155 ** there are columns in the table on the left. The error will be caught
1156 ** and reported later. But we need to make sure enough memory is allocated
1157 ** to avoid other spurious errors in the meantime. */
1158 pParse
->nMem
+= nResultCol
;
1160 pDest
->nSdst
= nResultCol
;
1161 regOrig
= regResult
= pDest
->iSdst
;
1163 for(i
=0; i
<nResultCol
; i
++){
1164 sqlite3VdbeAddOp3(v
, OP_Column
, srcTab
, i
, regResult
+i
);
1165 VdbeComment((v
, "%s", p
->pEList
->a
[i
].zEName
));
1167 }else if( eDest
!=SRT_Exists
){
1168 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
1169 ExprList
*pExtra
= 0;
1171 /* If the destination is an EXISTS(...) expression, the actual
1172 ** values returned by the SELECT are not required.
1174 u8 ecelFlags
; /* "ecel" is an abbreviation of "ExprCodeExprList" */
1176 if( eDest
==SRT_Mem
|| eDest
==SRT_Output
|| eDest
==SRT_Coroutine
){
1177 ecelFlags
= SQLITE_ECEL_DUP
;
1181 if( pSort
&& hasDistinct
==0 && eDest
!=SRT_EphemTab
&& eDest
!=SRT_Table
){
1182 /* For each expression in p->pEList that is a copy of an expression in
1183 ** the ORDER BY clause (pSort->pOrderBy), set the associated
1184 ** iOrderByCol value to one more than the index of the ORDER BY
1185 ** expression within the sort-key that pushOntoSorter() will generate.
1186 ** This allows the p->pEList field to be omitted from the sorted record,
1187 ** saving space and CPU cycles. */
1188 ecelFlags
|= (SQLITE_ECEL_OMITREF
|SQLITE_ECEL_REF
);
1190 for(i
=pSort
->nOBSat
; i
<pSort
->pOrderBy
->nExpr
; i
++){
1192 if( (j
= pSort
->pOrderBy
->a
[i
].u
.x
.iOrderByCol
)>0 ){
1193 p
->pEList
->a
[j
-1].u
.x
.iOrderByCol
= i
+1-pSort
->nOBSat
;
1196 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
1197 selectExprDefer(pParse
, pSort
, p
->pEList
, &pExtra
);
1198 if( pExtra
&& pParse
->db
->mallocFailed
==0 ){
1199 /* If there are any extra PK columns to add to the sorter records,
1200 ** allocate extra memory cells and adjust the OpenEphemeral
1201 ** instruction to account for the larger records. This is only
1202 ** required if there are one or more WITHOUT ROWID tables with
1203 ** composite primary keys in the SortCtx.aDefer[] array. */
1204 VdbeOp
*pOp
= sqlite3VdbeGetOp(v
, pSort
->addrSortIndex
);
1205 pOp
->p2
+= (pExtra
->nExpr
- pSort
->nDefer
);
1206 pOp
->p4
.pKeyInfo
->nAllField
+= (pExtra
->nExpr
- pSort
->nDefer
);
1207 pParse
->nMem
+= pExtra
->nExpr
;
1211 /* Adjust nResultCol to account for columns that are omitted
1212 ** from the sorter by the optimizations in this branch */
1214 for(i
=0; i
<pEList
->nExpr
; i
++){
1215 if( pEList
->a
[i
].u
.x
.iOrderByCol
>0
1216 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
1217 || pEList
->a
[i
].fg
.bSorterRef
1225 testcase( regOrig
);
1226 testcase( eDest
==SRT_Set
);
1227 testcase( eDest
==SRT_Mem
);
1228 testcase( eDest
==SRT_Coroutine
);
1229 testcase( eDest
==SRT_Output
);
1230 assert( eDest
==SRT_Set
|| eDest
==SRT_Mem
1231 || eDest
==SRT_Coroutine
|| eDest
==SRT_Output
1232 || eDest
==SRT_Upfrom
);
1234 sRowLoadInfo
.regResult
= regResult
;
1235 sRowLoadInfo
.ecelFlags
= ecelFlags
;
1236 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
1237 sRowLoadInfo
.pExtra
= pExtra
;
1238 sRowLoadInfo
.regExtraResult
= regResult
+ nResultCol
;
1239 if( pExtra
) nResultCol
+= pExtra
->nExpr
;
1242 && (ecelFlags
& SQLITE_ECEL_OMITREF
)!=0
1246 assert( hasDistinct
==0 );
1247 pSort
->pDeferredRowLoad
= &sRowLoadInfo
;
1250 innerLoopLoadRow(pParse
, p
, &sRowLoadInfo
);
1254 /* If the DISTINCT keyword was present on the SELECT statement
1255 ** and this row has been seen before, then do not make this row
1256 ** part of the result.
1259 int eType
= pDistinct
->eTnctType
;
1260 int iTab
= pDistinct
->tabTnct
;
1261 assert( nResultCol
==p
->pEList
->nExpr
);
1262 iTab
= codeDistinct(pParse
, eType
, iTab
, iContinue
, p
->pEList
, regResult
);
1263 fixDistinctOpenEph(pParse
, eType
, iTab
, pDistinct
->addrTnct
);
1265 codeOffset(v
, p
->iOffset
, iContinue
);
1270 /* In this mode, write each query result to the key of the temporary
1273 #ifndef SQLITE_OMIT_COMPOUND_SELECT
1276 r1
= sqlite3GetTempReg(pParse
);
1277 sqlite3VdbeAddOp3(v
, OP_MakeRecord
, regResult
, nResultCol
, r1
);
1278 sqlite3VdbeAddOp4Int(v
, OP_IdxInsert
, iParm
, r1
, regResult
, nResultCol
);
1279 sqlite3ReleaseTempReg(pParse
, r1
);
1283 /* Construct a record from the query result, but instead of
1284 ** saving that record, use it as a key to delete elements from
1285 ** the temporary table iParm.
1288 sqlite3VdbeAddOp3(v
, OP_IdxDelete
, iParm
, regResult
, nResultCol
);
1291 #endif /* SQLITE_OMIT_COMPOUND_SELECT */
1293 /* Store the result as data using a unique key.
1298 case SRT_EphemTab
: {
1299 int r1
= sqlite3GetTempRange(pParse
, nPrefixReg
+1);
1300 testcase( eDest
==SRT_Table
);
1301 testcase( eDest
==SRT_EphemTab
);
1302 testcase( eDest
==SRT_Fifo
);
1303 testcase( eDest
==SRT_DistFifo
);
1304 sqlite3VdbeAddOp3(v
, OP_MakeRecord
, regResult
, nResultCol
, r1
+nPrefixReg
);
1305 #if !defined(SQLITE_ENABLE_NULL_TRIM) && defined(SQLITE_DEBUG)
1306 /* A destination of SRT_Table and a non-zero iSDParm2 parameter means
1307 ** that this is an "UPDATE ... FROM" on a virtual table or view. In this
1308 ** case set the p5 parameter of the OP_MakeRecord to OPFLAG_NOCHNG_MAGIC.
1309 ** This does not affect operation in any way - it just allows MakeRecord
1310 ** to process OPFLAG_NOCHANGE values without an assert() failing. */
1311 if( eDest
==SRT_Table
&& pDest
->iSDParm2
){
1312 sqlite3VdbeChangeP5(v
, OPFLAG_NOCHNG_MAGIC
);
1315 #ifndef SQLITE_OMIT_CTE
1316 if( eDest
==SRT_DistFifo
){
1317 /* If the destination is DistFifo, then cursor (iParm+1) is open
1318 ** on an ephemeral index. If the current row is already present
1319 ** in the index, do not write it to the output. If not, add the
1320 ** current row to the index and proceed with writing it to the
1321 ** output table as well. */
1322 int addr
= sqlite3VdbeCurrentAddr(v
) + 4;
1323 sqlite3VdbeAddOp4Int(v
, OP_Found
, iParm
+1, addr
, r1
, 0);
1325 sqlite3VdbeAddOp4Int(v
, OP_IdxInsert
, iParm
+1, r1
,regResult
,nResultCol
);
1330 assert( regResult
==regOrig
);
1331 pushOntoSorter(pParse
, pSort
, p
, r1
+nPrefixReg
, regOrig
, 1, nPrefixReg
);
1333 int r2
= sqlite3GetTempReg(pParse
);
1334 sqlite3VdbeAddOp2(v
, OP_NewRowid
, iParm
, r2
);
1335 sqlite3VdbeAddOp3(v
, OP_Insert
, iParm
, r1
, r2
);
1336 sqlite3VdbeChangeP5(v
, OPFLAG_APPEND
);
1337 sqlite3ReleaseTempReg(pParse
, r2
);
1339 sqlite3ReleaseTempRange(pParse
, r1
, nPrefixReg
+1);
1346 pParse
, pSort
, p
, regResult
, regOrig
, nResultCol
, nPrefixReg
);
1348 int i2
= pDest
->iSDParm2
;
1349 int r1
= sqlite3GetTempReg(pParse
);
1351 /* If the UPDATE FROM join is an aggregate that matches no rows, it
1352 ** might still be trying to return one row, because that is what
1353 ** aggregates do. Don't record that empty row in the output table. */
1354 sqlite3VdbeAddOp2(v
, OP_IsNull
, regResult
, iBreak
); VdbeCoverage(v
);
1356 sqlite3VdbeAddOp3(v
, OP_MakeRecord
,
1357 regResult
+(i2
<0), nResultCol
-(i2
<0), r1
);
1359 sqlite3VdbeAddOp3(v
, OP_Insert
, iParm
, r1
, regResult
);
1361 sqlite3VdbeAddOp4Int(v
, OP_IdxInsert
, iParm
, r1
, regResult
, i2
);
1367 #ifndef SQLITE_OMIT_SUBQUERY
1368 /* If we are creating a set for an "expr IN (SELECT ...)" construct,
1369 ** then there should be a single item on the stack. Write this
1370 ** item into the set table with bogus data.
1374 /* At first glance you would think we could optimize out the
1375 ** ORDER BY in this case since the order of entries in the set
1376 ** does not matter. But there might be a LIMIT clause, in which
1377 ** case the order does matter */
1379 pParse
, pSort
, p
, regResult
, regOrig
, nResultCol
, nPrefixReg
);
1381 int r1
= sqlite3GetTempReg(pParse
);
1382 assert( sqlite3Strlen30(pDest
->zAffSdst
)==nResultCol
);
1383 sqlite3VdbeAddOp4(v
, OP_MakeRecord
, regResult
, nResultCol
,
1384 r1
, pDest
->zAffSdst
, nResultCol
);
1385 sqlite3VdbeAddOp4Int(v
, OP_IdxInsert
, iParm
, r1
, regResult
, nResultCol
);
1386 sqlite3ReleaseTempReg(pParse
, r1
);
1392 /* If any row exist in the result set, record that fact and abort.
1395 sqlite3VdbeAddOp2(v
, OP_Integer
, 1, iParm
);
1396 /* The LIMIT clause will terminate the loop for us */
1400 /* If this is a scalar select that is part of an expression, then
1401 ** store the results in the appropriate memory cell or array of
1402 ** memory cells and break out of the scan loop.
1406 assert( nResultCol
<=pDest
->nSdst
);
1408 pParse
, pSort
, p
, regResult
, regOrig
, nResultCol
, nPrefixReg
);
1410 assert( nResultCol
==pDest
->nSdst
);
1411 assert( regResult
==iParm
);
1412 /* The LIMIT clause will jump out of the loop for us */
1416 #endif /* #ifndef SQLITE_OMIT_SUBQUERY */
1418 case SRT_Coroutine
: /* Send data to a co-routine */
1419 case SRT_Output
: { /* Return the results */
1420 testcase( eDest
==SRT_Coroutine
);
1421 testcase( eDest
==SRT_Output
);
1423 pushOntoSorter(pParse
, pSort
, p
, regResult
, regOrig
, nResultCol
,
1425 }else if( eDest
==SRT_Coroutine
){
1426 sqlite3VdbeAddOp1(v
, OP_Yield
, pDest
->iSDParm
);
1428 sqlite3VdbeAddOp2(v
, OP_ResultRow
, regResult
, nResultCol
);
1433 #ifndef SQLITE_OMIT_CTE
1434 /* Write the results into a priority queue that is order according to
1435 ** pDest->pOrderBy (in pSO). pDest->iSDParm (in iParm) is the cursor for an
1436 ** index with pSO->nExpr+2 columns. Build a key using pSO for the first
1437 ** pSO->nExpr columns, then make sure all keys are unique by adding a
1438 ** final OP_Sequence column. The last column is the record as a blob.
1446 pSO
= pDest
->pOrderBy
;
1449 r1
= sqlite3GetTempReg(pParse
);
1450 r2
= sqlite3GetTempRange(pParse
, nKey
+2);
1452 if( eDest
==SRT_DistQueue
){
1453 /* If the destination is DistQueue, then cursor (iParm+1) is open
1454 ** on a second ephemeral index that holds all values every previously
1455 ** added to the queue. */
1456 addrTest
= sqlite3VdbeAddOp4Int(v
, OP_Found
, iParm
+1, 0,
1457 regResult
, nResultCol
);
1460 sqlite3VdbeAddOp3(v
, OP_MakeRecord
, regResult
, nResultCol
, r3
);
1461 if( eDest
==SRT_DistQueue
){
1462 sqlite3VdbeAddOp2(v
, OP_IdxInsert
, iParm
+1, r3
);
1463 sqlite3VdbeChangeP5(v
, OPFLAG_USESEEKRESULT
);
1465 for(i
=0; i
<nKey
; i
++){
1466 sqlite3VdbeAddOp2(v
, OP_SCopy
,
1467 regResult
+ pSO
->a
[i
].u
.x
.iOrderByCol
- 1,
1470 sqlite3VdbeAddOp2(v
, OP_Sequence
, iParm
, r2
+nKey
);
1471 sqlite3VdbeAddOp3(v
, OP_MakeRecord
, r2
, nKey
+2, r1
);
1472 sqlite3VdbeAddOp4Int(v
, OP_IdxInsert
, iParm
, r1
, r2
, nKey
+2);
1473 if( addrTest
) sqlite3VdbeJumpHere(v
, addrTest
);
1474 sqlite3ReleaseTempReg(pParse
, r1
);
1475 sqlite3ReleaseTempRange(pParse
, r2
, nKey
+2);
1478 #endif /* SQLITE_OMIT_CTE */
1482 #if !defined(SQLITE_OMIT_TRIGGER)
1483 /* Discard the results. This is used for SELECT statements inside
1484 ** the body of a TRIGGER. The purpose of such selects is to call
1485 ** user-defined functions that have side effects. We do not care
1486 ** about the actual results of the select.
1489 assert( eDest
==SRT_Discard
);
1495 /* Jump to the end of the loop if the LIMIT is reached. Except, if
1496 ** there is a sorter, in which case the sorter has already limited
1497 ** the output for us.
1499 if( pSort
==0 && p
->iLimit
){
1500 sqlite3VdbeAddOp2(v
, OP_DecrJumpZero
, p
->iLimit
, iBreak
); VdbeCoverage(v
);
1505 ** Allocate a KeyInfo object sufficient for an index of N key columns and
1508 KeyInfo
*sqlite3KeyInfoAlloc(sqlite3
*db
, int N
, int X
){
1509 int nExtra
= (N
+X
)*(sizeof(CollSeq
*)+1) - sizeof(CollSeq
*);
1510 KeyInfo
*p
= sqlite3DbMallocRawNN(db
, sizeof(KeyInfo
) + nExtra
);
1512 p
->aSortFlags
= (u8
*)&p
->aColl
[N
+X
];
1513 p
->nKeyField
= (u16
)N
;
1514 p
->nAllField
= (u16
)(N
+X
);
1518 memset(&p
[1], 0, nExtra
);
1520 return (KeyInfo
*)sqlite3OomFault(db
);
1526 ** Deallocate a KeyInfo object
1528 void sqlite3KeyInfoUnref(KeyInfo
*p
){
1531 assert( p
->nRef
>0 );
1533 if( p
->nRef
==0 ) sqlite3DbNNFreeNN(p
->db
, p
);
1538 ** Make a new pointer to a KeyInfo object
1540 KeyInfo
*sqlite3KeyInfoRef(KeyInfo
*p
){
1542 assert( p
->nRef
>0 );
1550 ** Return TRUE if a KeyInfo object can be change. The KeyInfo object
1551 ** can only be changed if this is just a single reference to the object.
1553 ** This routine is used only inside of assert() statements.
1555 int sqlite3KeyInfoIsWriteable(KeyInfo
*p
){ return p
->nRef
==1; }
1556 #endif /* SQLITE_DEBUG */
1559 ** Given an expression list, generate a KeyInfo structure that records
1560 ** the collating sequence for each expression in that expression list.
1562 ** If the ExprList is an ORDER BY or GROUP BY clause then the resulting
1563 ** KeyInfo structure is appropriate for initializing a virtual index to
1564 ** implement that clause. If the ExprList is the result set of a SELECT
1565 ** then the KeyInfo structure is appropriate for initializing a virtual
1566 ** index to implement a DISTINCT test.
1568 ** Space to hold the KeyInfo structure is obtained from malloc. The calling
1569 ** function is responsible for seeing that this structure is eventually
1572 KeyInfo
*sqlite3KeyInfoFromExprList(
1573 Parse
*pParse
, /* Parsing context */
1574 ExprList
*pList
, /* Form the KeyInfo object from this ExprList */
1575 int iStart
, /* Begin with this column of pList */
1576 int nExtra
/* Add this many extra columns to the end */
1580 struct ExprList_item
*pItem
;
1581 sqlite3
*db
= pParse
->db
;
1584 nExpr
= pList
->nExpr
;
1585 pInfo
= sqlite3KeyInfoAlloc(db
, nExpr
-iStart
, nExtra
+1);
1587 assert( sqlite3KeyInfoIsWriteable(pInfo
) );
1588 for(i
=iStart
, pItem
=pList
->a
+iStart
; i
<nExpr
; i
++, pItem
++){
1589 pInfo
->aColl
[i
-iStart
] = sqlite3ExprNNCollSeq(pParse
, pItem
->pExpr
);
1590 pInfo
->aSortFlags
[i
-iStart
] = pItem
->fg
.sortFlags
;
1597 ** Name of the connection operator, used for error messages.
1599 const char *sqlite3SelectOpName(int id
){
1602 case TK_ALL
: z
= "UNION ALL"; break;
1603 case TK_INTERSECT
: z
= "INTERSECT"; break;
1604 case TK_EXCEPT
: z
= "EXCEPT"; break;
1605 default: z
= "UNION"; break;
1610 #ifndef SQLITE_OMIT_EXPLAIN
1612 ** Unless an "EXPLAIN QUERY PLAN" command is being processed, this function
1613 ** is a no-op. Otherwise, it adds a single row of output to the EQP result,
1614 ** where the caption is of the form:
1616 ** "USE TEMP B-TREE FOR xxx"
1618 ** where xxx is one of "DISTINCT", "ORDER BY" or "GROUP BY". Exactly which
1619 ** is determined by the zUsage argument.
1621 static void explainTempTable(Parse
*pParse
, const char *zUsage
){
1622 ExplainQueryPlan((pParse
, 0, "USE TEMP B-TREE FOR %s", zUsage
));
1626 ** Assign expression b to lvalue a. A second, no-op, version of this macro
1627 ** is provided when SQLITE_OMIT_EXPLAIN is defined. This allows the code
1628 ** in sqlite3Select() to assign values to structure member variables that
1629 ** only exist if SQLITE_OMIT_EXPLAIN is not defined without polluting the
1630 ** code with #ifndef directives.
1632 # define explainSetInteger(a, b) a = b
1635 /* No-op versions of the explainXXX() functions and macros. */
1636 # define explainTempTable(y,z)
1637 # define explainSetInteger(y,z)
1642 ** If the inner loop was generated using a non-null pOrderBy argument,
1643 ** then the results were placed in a sorter. After the loop is terminated
1644 ** we need to run the sorter and output the results. The following
1645 ** routine generates the code needed to do that.
1647 static void generateSortTail(
1648 Parse
*pParse
, /* Parsing context */
1649 Select
*p
, /* The SELECT statement */
1650 SortCtx
*pSort
, /* Information on the ORDER BY clause */
1651 int nColumn
, /* Number of columns of data */
1652 SelectDest
*pDest
/* Write the sorted results here */
1654 Vdbe
*v
= pParse
->pVdbe
; /* The prepared statement */
1655 int addrBreak
= pSort
->labelDone
; /* Jump here to exit loop */
1656 int addrContinue
= sqlite3VdbeMakeLabel(pParse
);/* Jump here for next cycle */
1657 int addr
; /* Top of output loop. Jump for Next. */
1660 ExprList
*pOrderBy
= pSort
->pOrderBy
;
1661 int eDest
= pDest
->eDest
;
1662 int iParm
= pDest
->iSDParm
;
1666 int nKey
; /* Number of key columns in sorter record */
1667 int iSortTab
; /* Sorter cursor to read from */
1669 int bSeq
; /* True if sorter record includes seq. no. */
1671 struct ExprList_item
*aOutEx
= p
->pEList
->a
;
1672 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
1673 int addrExplain
; /* Address of OP_Explain instruction */
1676 ExplainQueryPlan2(addrExplain
, (pParse
, 0,
1677 "USE TEMP B-TREE FOR %sORDER BY", pSort
->nOBSat
>0?"RIGHT PART OF ":"")
1679 sqlite3VdbeScanStatusRange(v
, addrExplain
,pSort
->addrPush
,pSort
->addrPushEnd
);
1680 sqlite3VdbeScanStatusCounters(v
, addrExplain
, addrExplain
, pSort
->addrPush
);
1683 assert( addrBreak
<0 );
1684 if( pSort
->labelBkOut
){
1685 sqlite3VdbeAddOp2(v
, OP_Gosub
, pSort
->regReturn
, pSort
->labelBkOut
);
1686 sqlite3VdbeGoto(v
, addrBreak
);
1687 sqlite3VdbeResolveLabel(v
, pSort
->labelBkOut
);
1690 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
1691 /* Open any cursors needed for sorter-reference expressions */
1692 for(i
=0; i
<pSort
->nDefer
; i
++){
1693 Table
*pTab
= pSort
->aDefer
[i
].pTab
;
1694 int iDb
= sqlite3SchemaToIndex(pParse
->db
, pTab
->pSchema
);
1695 sqlite3OpenTable(pParse
, pSort
->aDefer
[i
].iCsr
, iDb
, pTab
, OP_OpenRead
);
1696 nRefKey
= MAX(nRefKey
, pSort
->aDefer
[i
].nKey
);
1700 iTab
= pSort
->iECursor
;
1701 if( eDest
==SRT_Output
|| eDest
==SRT_Coroutine
|| eDest
==SRT_Mem
){
1702 if( eDest
==SRT_Mem
&& p
->iOffset
){
1703 sqlite3VdbeAddOp2(v
, OP_Null
, 0, pDest
->iSdst
);
1706 regRow
= pDest
->iSdst
;
1708 regRowid
= sqlite3GetTempReg(pParse
);
1709 if( eDest
==SRT_EphemTab
|| eDest
==SRT_Table
){
1710 regRow
= sqlite3GetTempReg(pParse
);
1713 regRow
= sqlite3GetTempRange(pParse
, nColumn
);
1716 nKey
= pOrderBy
->nExpr
- pSort
->nOBSat
;
1717 if( pSort
->sortFlags
& SORTFLAG_UseSorter
){
1718 int regSortOut
= ++pParse
->nMem
;
1719 iSortTab
= pParse
->nTab
++;
1720 if( pSort
->labelBkOut
){
1721 addrOnce
= sqlite3VdbeAddOp0(v
, OP_Once
); VdbeCoverage(v
);
1723 sqlite3VdbeAddOp3(v
, OP_OpenPseudo
, iSortTab
, regSortOut
,
1724 nKey
+1+nColumn
+nRefKey
);
1725 if( addrOnce
) sqlite3VdbeJumpHere(v
, addrOnce
);
1726 addr
= 1 + sqlite3VdbeAddOp2(v
, OP_SorterSort
, iTab
, addrBreak
);
1728 assert( p
->iLimit
==0 && p
->iOffset
==0 );
1729 sqlite3VdbeAddOp3(v
, OP_SorterData
, iTab
, regSortOut
, iSortTab
);
1732 addr
= 1 + sqlite3VdbeAddOp2(v
, OP_Sort
, iTab
, addrBreak
); VdbeCoverage(v
);
1733 codeOffset(v
, p
->iOffset
, addrContinue
);
1737 sqlite3VdbeAddOp2(v
, OP_AddImm
, p
->iLimit
, -1);
1740 for(i
=0, iCol
=nKey
+bSeq
-1; i
<nColumn
; i
++){
1741 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
1742 if( aOutEx
[i
].fg
.bSorterRef
) continue;
1744 if( aOutEx
[i
].u
.x
.iOrderByCol
==0 ) iCol
++;
1746 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
1747 if( pSort
->nDefer
){
1749 int regKey
= sqlite3GetTempRange(pParse
, nRefKey
);
1751 for(i
=0; i
<pSort
->nDefer
; i
++){
1752 int iCsr
= pSort
->aDefer
[i
].iCsr
;
1753 Table
*pTab
= pSort
->aDefer
[i
].pTab
;
1754 int nKey
= pSort
->aDefer
[i
].nKey
;
1756 sqlite3VdbeAddOp1(v
, OP_NullRow
, iCsr
);
1757 if( HasRowid(pTab
) ){
1758 sqlite3VdbeAddOp3(v
, OP_Column
, iSortTab
, iKey
++, regKey
);
1759 sqlite3VdbeAddOp3(v
, OP_SeekRowid
, iCsr
,
1760 sqlite3VdbeCurrentAddr(v
)+1, regKey
);
1764 assert( sqlite3PrimaryKeyIndex(pTab
)->nKeyCol
==nKey
);
1765 for(k
=0; k
<nKey
; k
++){
1766 sqlite3VdbeAddOp3(v
, OP_Column
, iSortTab
, iKey
++, regKey
+k
);
1768 iJmp
= sqlite3VdbeCurrentAddr(v
);
1769 sqlite3VdbeAddOp4Int(v
, OP_SeekGE
, iCsr
, iJmp
+2, regKey
, nKey
);
1770 sqlite3VdbeAddOp4Int(v
, OP_IdxLE
, iCsr
, iJmp
+3, regKey
, nKey
);
1771 sqlite3VdbeAddOp1(v
, OP_NullRow
, iCsr
);
1774 sqlite3ReleaseTempRange(pParse
, regKey
, nRefKey
);
1777 for(i
=nColumn
-1; i
>=0; i
--){
1778 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
1779 if( aOutEx
[i
].fg
.bSorterRef
){
1780 sqlite3ExprCode(pParse
, aOutEx
[i
].pExpr
, regRow
+i
);
1785 if( aOutEx
[i
].u
.x
.iOrderByCol
){
1786 iRead
= aOutEx
[i
].u
.x
.iOrderByCol
-1;
1790 sqlite3VdbeAddOp3(v
, OP_Column
, iSortTab
, iRead
, regRow
+i
);
1791 VdbeComment((v
, "%s", aOutEx
[i
].zEName
));
1794 sqlite3VdbeScanStatusRange(v
, addrExplain
, addrExplain
, -1);
1797 case SRT_EphemTab
: {
1798 sqlite3VdbeAddOp3(v
, OP_Column
, iSortTab
, nKey
+bSeq
, regRow
);
1799 sqlite3VdbeAddOp2(v
, OP_NewRowid
, iParm
, regRowid
);
1800 sqlite3VdbeAddOp3(v
, OP_Insert
, iParm
, regRow
, regRowid
);
1801 sqlite3VdbeChangeP5(v
, OPFLAG_APPEND
);
1804 #ifndef SQLITE_OMIT_SUBQUERY
1806 assert( nColumn
==sqlite3Strlen30(pDest
->zAffSdst
) );
1807 sqlite3VdbeAddOp4(v
, OP_MakeRecord
, regRow
, nColumn
, regRowid
,
1808 pDest
->zAffSdst
, nColumn
);
1809 sqlite3VdbeAddOp4Int(v
, OP_IdxInsert
, iParm
, regRowid
, regRow
, nColumn
);
1813 /* The LIMIT clause will terminate the loop for us */
1818 int i2
= pDest
->iSDParm2
;
1819 int r1
= sqlite3GetTempReg(pParse
);
1820 sqlite3VdbeAddOp3(v
, OP_MakeRecord
,regRow
+(i2
<0),nColumn
-(i2
<0),r1
);
1822 sqlite3VdbeAddOp3(v
, OP_Insert
, iParm
, r1
, regRow
);
1824 sqlite3VdbeAddOp4Int(v
, OP_IdxInsert
, iParm
, r1
, regRow
, i2
);
1829 assert( eDest
==SRT_Output
|| eDest
==SRT_Coroutine
);
1830 testcase( eDest
==SRT_Output
);
1831 testcase( eDest
==SRT_Coroutine
);
1832 if( eDest
==SRT_Output
){
1833 sqlite3VdbeAddOp2(v
, OP_ResultRow
, pDest
->iSdst
, nColumn
);
1835 sqlite3VdbeAddOp1(v
, OP_Yield
, pDest
->iSDParm
);
1841 if( eDest
==SRT_Set
){
1842 sqlite3ReleaseTempRange(pParse
, regRow
, nColumn
);
1844 sqlite3ReleaseTempReg(pParse
, regRow
);
1846 sqlite3ReleaseTempReg(pParse
, regRowid
);
1848 /* The bottom of the loop
1850 sqlite3VdbeResolveLabel(v
, addrContinue
);
1851 if( pSort
->sortFlags
& SORTFLAG_UseSorter
){
1852 sqlite3VdbeAddOp2(v
, OP_SorterNext
, iTab
, addr
); VdbeCoverage(v
);
1854 sqlite3VdbeAddOp2(v
, OP_Next
, iTab
, addr
); VdbeCoverage(v
);
1856 sqlite3VdbeScanStatusRange(v
, addrExplain
, sqlite3VdbeCurrentAddr(v
)-1, -1);
1857 if( pSort
->regReturn
) sqlite3VdbeAddOp1(v
, OP_Return
, pSort
->regReturn
);
1858 sqlite3VdbeResolveLabel(v
, addrBreak
);
1862 ** Return a pointer to a string containing the 'declaration type' of the
1863 ** expression pExpr. The string may be treated as static by the caller.
1865 ** The declaration type is the exact datatype definition extracted from the
1866 ** original CREATE TABLE statement if the expression is a column. The
1867 ** declaration type for a ROWID field is INTEGER. Exactly when an expression
1868 ** is considered a column can be complex in the presence of subqueries. The
1869 ** result-set expression in all of the following SELECT statements is
1870 ** considered a column by this function.
1872 ** SELECT col FROM tbl;
1873 ** SELECT (SELECT col FROM tbl;
1874 ** SELECT (SELECT col FROM tbl);
1875 ** SELECT abc FROM (SELECT col AS abc FROM tbl);
1877 ** The declaration type for any expression other than a column is NULL.
1879 ** This routine has either 3 or 6 parameters depending on whether or not
1880 ** the SQLITE_ENABLE_COLUMN_METADATA compile-time option is used.
1882 #ifdef SQLITE_ENABLE_COLUMN_METADATA
1883 # define columnType(A,B,C,D,E) columnTypeImpl(A,B,C,D,E)
1884 #else /* if !defined(SQLITE_ENABLE_COLUMN_METADATA) */
1885 # define columnType(A,B,C,D,E) columnTypeImpl(A,B)
1887 static const char *columnTypeImpl(
1889 #ifndef SQLITE_ENABLE_COLUMN_METADATA
1893 const char **pzOrigDb
,
1894 const char **pzOrigTab
,
1895 const char **pzOrigCol
1898 char const *zType
= 0;
1900 #ifdef SQLITE_ENABLE_COLUMN_METADATA
1901 char const *zOrigDb
= 0;
1902 char const *zOrigTab
= 0;
1903 char const *zOrigCol
= 0;
1907 assert( pNC
->pSrcList
!=0 );
1908 switch( pExpr
->op
){
1910 /* The expression is a column. Locate the table the column is being
1911 ** extracted from in NameContext.pSrcList. This table may be real
1912 ** database table or a subquery.
1914 Table
*pTab
= 0; /* Table structure column is extracted from */
1915 Select
*pS
= 0; /* Select the column is extracted from */
1916 int iCol
= pExpr
->iColumn
; /* Index of column in pTab */
1917 while( pNC
&& !pTab
){
1918 SrcList
*pTabList
= pNC
->pSrcList
;
1919 for(j
=0;j
<pTabList
->nSrc
&& pTabList
->a
[j
].iCursor
!=pExpr
->iTable
;j
++);
1920 if( j
<pTabList
->nSrc
){
1921 pTab
= pTabList
->a
[j
].pTab
;
1922 pS
= pTabList
->a
[j
].pSelect
;
1929 /* At one time, code such as "SELECT new.x" within a trigger would
1930 ** cause this condition to run. Since then, we have restructured how
1931 ** trigger code is generated and so this condition is no longer
1932 ** possible. However, it can still be true for statements like
1935 ** CREATE TABLE t1(col INTEGER);
1936 ** SELECT (SELECT t1.col) FROM FROM t1;
1938 ** when columnType() is called on the expression "t1.col" in the
1939 ** sub-select. In this case, set the column type to NULL, even
1940 ** though it should really be "INTEGER".
1942 ** This is not a problem, as the column type of "t1.col" is never
1943 ** used. When columnType() is called on the expression
1944 ** "(SELECT t1.col)", the correct type is returned (see the TK_SELECT
1949 assert( pTab
&& ExprUseYTab(pExpr
) && pExpr
->y
.pTab
==pTab
);
1951 /* The "table" is actually a sub-select or a view in the FROM clause
1952 ** of the SELECT statement. Return the declaration type and origin
1953 ** data for the result-set column of the sub-select.
1955 if( iCol
<pS
->pEList
->nExpr
1956 #ifdef SQLITE_ALLOW_ROWID_IN_VIEW
1962 /* If iCol is less than zero, then the expression requests the
1963 ** rowid of the sub-select or view. This expression is legal (see
1964 ** test case misc2.2.2) - it always evaluates to NULL.
1967 Expr
*p
= pS
->pEList
->a
[iCol
].pExpr
;
1968 sNC
.pSrcList
= pS
->pSrc
;
1970 sNC
.pParse
= pNC
->pParse
;
1971 zType
= columnType(&sNC
, p
,&zOrigDb
,&zOrigTab
,&zOrigCol
);
1974 /* A real table or a CTE table */
1976 #ifdef SQLITE_ENABLE_COLUMN_METADATA
1977 if( iCol
<0 ) iCol
= pTab
->iPKey
;
1978 assert( iCol
==XN_ROWID
|| (iCol
>=0 && iCol
<pTab
->nCol
) );
1983 zOrigCol
= pTab
->aCol
[iCol
].zCnName
;
1984 zType
= sqlite3ColumnType(&pTab
->aCol
[iCol
],0);
1986 zOrigTab
= pTab
->zName
;
1987 if( pNC
->pParse
&& pTab
->pSchema
){
1988 int iDb
= sqlite3SchemaToIndex(pNC
->pParse
->db
, pTab
->pSchema
);
1989 zOrigDb
= pNC
->pParse
->db
->aDb
[iDb
].zDbSName
;
1992 assert( iCol
==XN_ROWID
|| (iCol
>=0 && iCol
<pTab
->nCol
) );
1996 zType
= sqlite3ColumnType(&pTab
->aCol
[iCol
],0);
2002 #ifndef SQLITE_OMIT_SUBQUERY
2004 /* The expression is a sub-select. Return the declaration type and
2005 ** origin info for the single column in the result set of the SELECT
2011 assert( ExprUseXSelect(pExpr
) );
2012 pS
= pExpr
->x
.pSelect
;
2013 p
= pS
->pEList
->a
[0].pExpr
;
2014 sNC
.pSrcList
= pS
->pSrc
;
2016 sNC
.pParse
= pNC
->pParse
;
2017 zType
= columnType(&sNC
, p
, &zOrigDb
, &zOrigTab
, &zOrigCol
);
2023 #ifdef SQLITE_ENABLE_COLUMN_METADATA
2025 assert( pzOrigTab
&& pzOrigCol
);
2026 *pzOrigDb
= zOrigDb
;
2027 *pzOrigTab
= zOrigTab
;
2028 *pzOrigCol
= zOrigCol
;
2035 ** Generate code that will tell the VDBE the declaration types of columns
2036 ** in the result set.
2038 static void generateColumnTypes(
2039 Parse
*pParse
, /* Parser context */
2040 SrcList
*pTabList
, /* List of tables */
2041 ExprList
*pEList
/* Expressions defining the result set */
2043 #ifndef SQLITE_OMIT_DECLTYPE
2044 Vdbe
*v
= pParse
->pVdbe
;
2047 sNC
.pSrcList
= pTabList
;
2048 sNC
.pParse
= pParse
;
2050 for(i
=0; i
<pEList
->nExpr
; i
++){
2051 Expr
*p
= pEList
->a
[i
].pExpr
;
2053 #ifdef SQLITE_ENABLE_COLUMN_METADATA
2054 const char *zOrigDb
= 0;
2055 const char *zOrigTab
= 0;
2056 const char *zOrigCol
= 0;
2057 zType
= columnType(&sNC
, p
, &zOrigDb
, &zOrigTab
, &zOrigCol
);
2059 /* The vdbe must make its own copy of the column-type and other
2060 ** column specific strings, in case the schema is reset before this
2061 ** virtual machine is deleted.
2063 sqlite3VdbeSetColName(v
, i
, COLNAME_DATABASE
, zOrigDb
, SQLITE_TRANSIENT
);
2064 sqlite3VdbeSetColName(v
, i
, COLNAME_TABLE
, zOrigTab
, SQLITE_TRANSIENT
);
2065 sqlite3VdbeSetColName(v
, i
, COLNAME_COLUMN
, zOrigCol
, SQLITE_TRANSIENT
);
2067 zType
= columnType(&sNC
, p
, 0, 0, 0);
2069 sqlite3VdbeSetColName(v
, i
, COLNAME_DECLTYPE
, zType
, SQLITE_TRANSIENT
);
2071 #endif /* !defined(SQLITE_OMIT_DECLTYPE) */
2076 ** Compute the column names for a SELECT statement.
2078 ** The only guarantee that SQLite makes about column names is that if the
2079 ** column has an AS clause assigning it a name, that will be the name used.
2080 ** That is the only documented guarantee. However, countless applications
2081 ** developed over the years have made baseless assumptions about column names
2082 ** and will break if those assumptions changes. Hence, use extreme caution
2083 ** when modifying this routine to avoid breaking legacy.
2085 ** See Also: sqlite3ColumnsFromExprList()
2087 ** The PRAGMA short_column_names and PRAGMA full_column_names settings are
2088 ** deprecated. The default setting is short=ON, full=OFF. 99.9% of all
2089 ** applications should operate this way. Nevertheless, we need to support the
2090 ** other modes for legacy:
2092 ** short=OFF, full=OFF: Column name is the text of the expression has it
2093 ** originally appears in the SELECT statement. In
2094 ** other words, the zSpan of the result expression.
2096 ** short=ON, full=OFF: (This is the default setting). If the result
2097 ** refers directly to a table column, then the
2098 ** result column name is just the table column
2099 ** name: COLUMN. Otherwise use zSpan.
2101 ** full=ON, short=ANY: If the result refers directly to a table column,
2102 ** then the result column name with the table name
2103 ** prefix, ex: TABLE.COLUMN. Otherwise use zSpan.
2105 void sqlite3GenerateColumnNames(
2106 Parse
*pParse
, /* Parser context */
2107 Select
*pSelect
/* Generate column names for this SELECT statement */
2109 Vdbe
*v
= pParse
->pVdbe
;
2114 sqlite3
*db
= pParse
->db
;
2115 int fullName
; /* TABLE.COLUMN if no AS clause and is a direct table ref */
2116 int srcName
; /* COLUMN or TABLE.COLUMN if no AS clause and is direct */
2118 if( pParse
->colNamesSet
) return;
2119 /* Column names are determined by the left-most term of a compound select */
2120 while( pSelect
->pPrior
) pSelect
= pSelect
->pPrior
;
2121 TREETRACE(0x80,pParse
,pSelect
,("generating column names\n"));
2122 pTabList
= pSelect
->pSrc
;
2123 pEList
= pSelect
->pEList
;
2125 assert( pTabList
!=0 );
2126 pParse
->colNamesSet
= 1;
2127 fullName
= (db
->flags
& SQLITE_FullColNames
)!=0;
2128 srcName
= (db
->flags
& SQLITE_ShortColNames
)!=0 || fullName
;
2129 sqlite3VdbeSetNumCols(v
, pEList
->nExpr
);
2130 for(i
=0; i
<pEList
->nExpr
; i
++){
2131 Expr
*p
= pEList
->a
[i
].pExpr
;
2134 assert( p
->op
!=TK_AGG_COLUMN
); /* Agg processing has not run yet */
2135 assert( p
->op
!=TK_COLUMN
2136 || (ExprUseYTab(p
) && p
->y
.pTab
!=0) ); /* Covering idx not yet coded */
2137 if( pEList
->a
[i
].zEName
&& pEList
->a
[i
].fg
.eEName
==ENAME_NAME
){
2138 /* An AS clause always takes first priority */
2139 char *zName
= pEList
->a
[i
].zEName
;
2140 sqlite3VdbeSetColName(v
, i
, COLNAME_NAME
, zName
, SQLITE_TRANSIENT
);
2141 }else if( srcName
&& p
->op
==TK_COLUMN
){
2143 int iCol
= p
->iColumn
;
2146 if( iCol
<0 ) iCol
= pTab
->iPKey
;
2147 assert( iCol
==-1 || (iCol
>=0 && iCol
<pTab
->nCol
) );
2151 zCol
= pTab
->aCol
[iCol
].zCnName
;
2155 zName
= sqlite3MPrintf(db
, "%s.%s", pTab
->zName
, zCol
);
2156 sqlite3VdbeSetColName(v
, i
, COLNAME_NAME
, zName
, SQLITE_DYNAMIC
);
2158 sqlite3VdbeSetColName(v
, i
, COLNAME_NAME
, zCol
, SQLITE_TRANSIENT
);
2161 const char *z
= pEList
->a
[i
].zEName
;
2162 z
= z
==0 ? sqlite3MPrintf(db
, "column%d", i
+1) : sqlite3DbStrDup(db
, z
);
2163 sqlite3VdbeSetColName(v
, i
, COLNAME_NAME
, z
, SQLITE_DYNAMIC
);
2166 generateColumnTypes(pParse
, pTabList
, pEList
);
2170 ** Given an expression list (which is really the list of expressions
2171 ** that form the result set of a SELECT statement) compute appropriate
2172 ** column names for a table that would hold the expression list.
2174 ** All column names will be unique.
2176 ** Only the column names are computed. Column.zType, Column.zColl,
2177 ** and other fields of Column are zeroed.
2179 ** Return SQLITE_OK on success. If a memory allocation error occurs,
2180 ** store NULL in *paCol and 0 in *pnCol and return SQLITE_NOMEM.
2182 ** The only guarantee that SQLite makes about column names is that if the
2183 ** column has an AS clause assigning it a name, that will be the name used.
2184 ** That is the only documented guarantee. However, countless applications
2185 ** developed over the years have made baseless assumptions about column names
2186 ** and will break if those assumptions changes. Hence, use extreme caution
2187 ** when modifying this routine to avoid breaking legacy.
2189 ** See Also: sqlite3GenerateColumnNames()
2191 int sqlite3ColumnsFromExprList(
2192 Parse
*pParse
, /* Parsing context */
2193 ExprList
*pEList
, /* Expr list from which to derive column names */
2194 i16
*pnCol
, /* Write the number of columns here */
2195 Column
**paCol
/* Write the new column list here */
2197 sqlite3
*db
= pParse
->db
; /* Database connection */
2198 int i
, j
; /* Loop counters */
2199 u32 cnt
; /* Index added to make the name unique */
2200 Column
*aCol
, *pCol
; /* For looping over result columns */
2201 int nCol
; /* Number of columns in the result set */
2202 char *zName
; /* Column name */
2203 int nName
; /* Size of name in zName[] */
2204 Hash ht
; /* Hash table of column names */
2207 sqlite3HashInit(&ht
);
2209 nCol
= pEList
->nExpr
;
2210 aCol
= sqlite3DbMallocZero(db
, sizeof(aCol
[0])*nCol
);
2211 testcase( aCol
==0 );
2212 if( NEVER(nCol
>32767) ) nCol
= 32767;
2217 assert( nCol
==(i16
)nCol
);
2221 for(i
=0, pCol
=aCol
; i
<nCol
&& !pParse
->nErr
; i
++, pCol
++){
2222 struct ExprList_item
*pX
= &pEList
->a
[i
];
2223 struct ExprList_item
*pCollide
;
2224 /* Get an appropriate name for the column
2226 if( (zName
= pX
->zEName
)!=0 && pX
->fg
.eEName
==ENAME_NAME
){
2227 /* If the column contains an "AS <name>" phrase, use <name> as the name */
2229 Expr
*pColExpr
= sqlite3ExprSkipCollateAndLikely(pX
->pExpr
);
2230 while( ALWAYS(pColExpr
!=0) && pColExpr
->op
==TK_DOT
){
2231 pColExpr
= pColExpr
->pRight
;
2232 assert( pColExpr
!=0 );
2234 if( pColExpr
->op
==TK_COLUMN
2235 && ALWAYS( ExprUseYTab(pColExpr
) )
2236 && ALWAYS( pColExpr
->y
.pTab
!=0 )
2238 /* For columns use the column name name */
2239 int iCol
= pColExpr
->iColumn
;
2240 pTab
= pColExpr
->y
.pTab
;
2241 if( iCol
<0 ) iCol
= pTab
->iPKey
;
2242 zName
= iCol
>=0 ? pTab
->aCol
[iCol
].zCnName
: "rowid";
2243 }else if( pColExpr
->op
==TK_ID
){
2244 assert( !ExprHasProperty(pColExpr
, EP_IntValue
) );
2245 zName
= pColExpr
->u
.zToken
;
2247 /* Use the original text of the column expression as its name */
2248 assert( zName
==pX
->zEName
); /* pointer comparison intended */
2251 if( zName
&& !sqlite3IsTrueOrFalse(zName
) ){
2252 zName
= sqlite3DbStrDup(db
, zName
);
2254 zName
= sqlite3MPrintf(db
,"column%d",i
+1);
2257 /* Make sure the column name is unique. If the name is not unique,
2258 ** append an integer to the name so that it becomes unique.
2261 while( zName
&& (pCollide
= sqlite3HashFind(&ht
, zName
))!=0 ){
2262 if( pCollide
->fg
.bUsingTerm
){
2263 pCol
->colFlags
|= COLFLAG_NOEXPAND
;
2265 nName
= sqlite3Strlen30(zName
);
2267 for(j
=nName
-1; j
>0 && sqlite3Isdigit(zName
[j
]); j
--){}
2268 if( zName
[j
]==':' ) nName
= j
;
2270 zName
= sqlite3MPrintf(db
, "%.*z:%u", nName
, zName
, ++cnt
);
2271 sqlite3ProgressCheck(pParse
);
2273 sqlite3_randomness(sizeof(cnt
), &cnt
);
2276 pCol
->zCnName
= zName
;
2277 pCol
->hName
= sqlite3StrIHash(zName
);
2278 if( pX
->fg
.bNoExpand
){
2279 pCol
->colFlags
|= COLFLAG_NOEXPAND
;
2281 sqlite3ColumnPropertiesFromName(0, pCol
);
2282 if( zName
&& sqlite3HashInsert(&ht
, zName
, pX
)==pX
){
2283 sqlite3OomFault(db
);
2286 sqlite3HashClear(&ht
);
2289 sqlite3DbFree(db
, aCol
[j
].zCnName
);
2291 sqlite3DbFree(db
, aCol
);
2300 ** pTab is a transient Table object that represents a subquery of some
2301 ** kind (maybe a parenthesized subquery in the FROM clause of a larger
2302 ** query, or a VIEW, or a CTE). This routine computes type information
2303 ** for that Table object based on the Select object that implements the
2304 ** subquery. For the purposes of this routine, "type information" means:
2306 ** * The datatype name, as it might appear in a CREATE TABLE statement
2307 ** * Which collating sequence to use for the column
2308 ** * The affinity of the column
2310 void sqlite3SubqueryColumnTypes(
2311 Parse
*pParse
, /* Parsing contexts */
2312 Table
*pTab
, /* Add column type information to this table */
2313 Select
*pSelect
, /* SELECT used to determine types and collations */
2314 char aff
/* Default affinity. */
2316 sqlite3
*db
= pParse
->db
;
2321 struct ExprList_item
*a
;
2324 assert( pSelect
!=0 );
2325 testcase( (pSelect
->selFlags
& SF_Resolved
)==0 );
2326 assert( (pSelect
->selFlags
& SF_Resolved
)!=0 || IN_RENAME_OBJECT
);
2327 assert( pTab
->nCol
==pSelect
->pEList
->nExpr
|| pParse
->nErr
>0 );
2328 assert( aff
==SQLITE_AFF_NONE
|| aff
==SQLITE_AFF_BLOB
);
2329 if( db
->mallocFailed
|| IN_RENAME_OBJECT
) return;
2330 while( pSelect
->pPrior
) pSelect
= pSelect
->pPrior
;
2331 a
= pSelect
->pEList
->a
;
2332 memset(&sNC
, 0, sizeof(sNC
));
2333 sNC
.pSrcList
= pSelect
->pSrc
;
2334 for(i
=0, pCol
=pTab
->aCol
; i
<pTab
->nCol
; i
++, pCol
++){
2337 pTab
->tabFlags
|= (pCol
->colFlags
& COLFLAG_NOINSERT
);
2339 /* pCol->szEst = ... // Column size est for SELECT tables never used */
2340 pCol
->affinity
= sqlite3ExprAffinity(p
);
2341 if( pCol
->affinity
<=SQLITE_AFF_NONE
){
2342 pCol
->affinity
= aff
;
2344 if( pCol
->affinity
>=SQLITE_AFF_TEXT
&& pSelect
->pNext
){
2347 for(m
=0, pS2
=pSelect
->pNext
; pS2
; pS2
=pS2
->pNext
){
2348 m
|= sqlite3ExprDataType(pS2
->pEList
->a
[i
].pExpr
);
2350 if( pCol
->affinity
==SQLITE_AFF_TEXT
&& (m
&0x01)!=0 ){
2351 pCol
->affinity
= SQLITE_AFF_BLOB
;
2353 if( pCol
->affinity
>=SQLITE_AFF_NUMERIC
&& (m
&0x02)!=0 ){
2354 pCol
->affinity
= SQLITE_AFF_BLOB
;
2356 if( pCol
->affinity
>=SQLITE_AFF_NUMERIC
&& p
->op
==TK_CAST
){
2357 pCol
->affinity
= SQLITE_AFF_FLEXNUM
;
2360 zType
= columnType(&sNC
, p
, 0, 0, 0);
2361 if( zType
==0 || pCol
->affinity
!=sqlite3AffinityType(zType
, 0) ){
2362 if( pCol
->affinity
==SQLITE_AFF_NUMERIC
2363 || pCol
->affinity
==SQLITE_AFF_FLEXNUM
2368 for(j
=1; j
<SQLITE_N_STDTYPE
; j
++){
2369 if( sqlite3StdTypeAffinity
[j
]==pCol
->affinity
){
2370 zType
= sqlite3StdType
[j
];
2377 i64 m
= sqlite3Strlen30(zType
);
2378 n
= sqlite3Strlen30(pCol
->zCnName
);
2379 pCol
->zCnName
= sqlite3DbReallocOrFree(db
, pCol
->zCnName
, n
+m
+2);
2380 pCol
->colFlags
&= ~(COLFLAG_HASTYPE
|COLFLAG_HASCOLL
);
2381 if( pCol
->zCnName
){
2382 memcpy(&pCol
->zCnName
[n
+1], zType
, m
+1);
2383 pCol
->colFlags
|= COLFLAG_HASTYPE
;
2386 pColl
= sqlite3ExprCollSeq(pParse
, p
);
2388 assert( pTab
->pIndex
==0 );
2389 sqlite3ColumnSetColl(db
, pCol
, pColl
->zName
);
2392 pTab
->szTabRow
= 1; /* Any non-zero value works */
2396 ** Given a SELECT statement, generate a Table structure that describes
2397 ** the result set of that SELECT.
2399 Table
*sqlite3ResultSetOfSelect(Parse
*pParse
, Select
*pSelect
, char aff
){
2401 sqlite3
*db
= pParse
->db
;
2404 savedFlags
= db
->flags
;
2405 db
->flags
&= ~(u64
)SQLITE_FullColNames
;
2406 db
->flags
|= SQLITE_ShortColNames
;
2407 sqlite3SelectPrep(pParse
, pSelect
, 0);
2408 db
->flags
= savedFlags
;
2409 if( pParse
->nErr
) return 0;
2410 while( pSelect
->pPrior
) pSelect
= pSelect
->pPrior
;
2411 pTab
= sqlite3DbMallocZero(db
, sizeof(Table
) );
2417 pTab
->nRowLogEst
= 200; assert( 200==sqlite3LogEst(1048576) );
2418 sqlite3ColumnsFromExprList(pParse
, pSelect
->pEList
, &pTab
->nCol
, &pTab
->aCol
);
2419 sqlite3SubqueryColumnTypes(pParse
, pTab
, pSelect
, aff
);
2421 if( db
->mallocFailed
){
2422 sqlite3DeleteTable(db
, pTab
);
2429 ** Get a VDBE for the given parser context. Create a new one if necessary.
2430 ** If an error occurs, return NULL and leave a message in pParse.
2432 Vdbe
*sqlite3GetVdbe(Parse
*pParse
){
2433 if( pParse
->pVdbe
){
2434 return pParse
->pVdbe
;
2436 if( pParse
->pToplevel
==0
2437 && OptimizationEnabled(pParse
->db
,SQLITE_FactorOutConst
)
2439 pParse
->okConstFactor
= 1;
2441 return sqlite3VdbeCreate(pParse
);
2446 ** Compute the iLimit and iOffset fields of the SELECT based on the
2447 ** pLimit expressions. pLimit->pLeft and pLimit->pRight hold the expressions
2448 ** that appear in the original SQL statement after the LIMIT and OFFSET
2449 ** keywords. Or NULL if those keywords are omitted. iLimit and iOffset
2450 ** are the integer memory register numbers for counters used to compute
2451 ** the limit and offset. If there is no limit and/or offset, then
2452 ** iLimit and iOffset are negative.
2454 ** This routine changes the values of iLimit and iOffset only if
2455 ** a limit or offset is defined by pLimit->pLeft and pLimit->pRight. iLimit
2456 ** and iOffset should have been preset to appropriate default values (zero)
2457 ** prior to calling this routine.
2459 ** The iOffset register (if it exists) is initialized to the value
2460 ** of the OFFSET. The iLimit register is initialized to LIMIT. Register
2461 ** iOffset+1 is initialized to LIMIT+OFFSET.
2463 ** Only if pLimit->pLeft!=0 do the limit registers get
2464 ** redefined. The UNION ALL operator uses this property to force
2465 ** the reuse of the same limit and offset registers across multiple
2466 ** SELECT statements.
2468 static void computeLimitRegisters(Parse
*pParse
, Select
*p
, int iBreak
){
2473 Expr
*pLimit
= p
->pLimit
;
2475 if( p
->iLimit
) return;
2478 ** "LIMIT -1" always shows all rows. There is some
2479 ** controversy about what the correct behavior should be.
2480 ** The current implementation interprets "LIMIT 0" to mean
2484 assert( pLimit
->op
==TK_LIMIT
);
2485 assert( pLimit
->pLeft
!=0 );
2486 p
->iLimit
= iLimit
= ++pParse
->nMem
;
2487 v
= sqlite3GetVdbe(pParse
);
2489 if( sqlite3ExprIsInteger(pLimit
->pLeft
, &n
) ){
2490 sqlite3VdbeAddOp2(v
, OP_Integer
, n
, iLimit
);
2491 VdbeComment((v
, "LIMIT counter"));
2493 sqlite3VdbeGoto(v
, iBreak
);
2494 }else if( n
>=0 && p
->nSelectRow
>sqlite3LogEst((u64
)n
) ){
2495 p
->nSelectRow
= sqlite3LogEst((u64
)n
);
2496 p
->selFlags
|= SF_FixedLimit
;
2499 sqlite3ExprCode(pParse
, pLimit
->pLeft
, iLimit
);
2500 sqlite3VdbeAddOp1(v
, OP_MustBeInt
, iLimit
); VdbeCoverage(v
);
2501 VdbeComment((v
, "LIMIT counter"));
2502 sqlite3VdbeAddOp2(v
, OP_IfNot
, iLimit
, iBreak
); VdbeCoverage(v
);
2504 if( pLimit
->pRight
){
2505 p
->iOffset
= iOffset
= ++pParse
->nMem
;
2506 pParse
->nMem
++; /* Allocate an extra register for limit+offset */
2507 sqlite3ExprCode(pParse
, pLimit
->pRight
, iOffset
);
2508 sqlite3VdbeAddOp1(v
, OP_MustBeInt
, iOffset
); VdbeCoverage(v
);
2509 VdbeComment((v
, "OFFSET counter"));
2510 sqlite3VdbeAddOp3(v
, OP_OffsetLimit
, iLimit
, iOffset
+1, iOffset
);
2511 VdbeComment((v
, "LIMIT+OFFSET"));
2516 #ifndef SQLITE_OMIT_COMPOUND_SELECT
2518 ** Return the appropriate collating sequence for the iCol-th column of
2519 ** the result set for the compound-select statement "p". Return NULL if
2520 ** the column has no default collating sequence.
2522 ** The collating sequence for the compound select is taken from the
2523 ** left-most term of the select that has a collating sequence.
2525 static CollSeq
*multiSelectCollSeq(Parse
*pParse
, Select
*p
, int iCol
){
2528 pRet
= multiSelectCollSeq(pParse
, p
->pPrior
, iCol
);
2533 /* iCol must be less than p->pEList->nExpr. Otherwise an error would
2534 ** have been thrown during name resolution and we would not have gotten
2536 if( pRet
==0 && ALWAYS(iCol
<p
->pEList
->nExpr
) ){
2537 pRet
= sqlite3ExprCollSeq(pParse
, p
->pEList
->a
[iCol
].pExpr
);
2543 ** The select statement passed as the second parameter is a compound SELECT
2544 ** with an ORDER BY clause. This function allocates and returns a KeyInfo
2545 ** structure suitable for implementing the ORDER BY.
2547 ** Space to hold the KeyInfo structure is obtained from malloc. The calling
2548 ** function is responsible for ensuring that this structure is eventually
2551 static KeyInfo
*multiSelectOrderByKeyInfo(Parse
*pParse
, Select
*p
, int nExtra
){
2552 ExprList
*pOrderBy
= p
->pOrderBy
;
2553 int nOrderBy
= ALWAYS(pOrderBy
!=0) ? pOrderBy
->nExpr
: 0;
2554 sqlite3
*db
= pParse
->db
;
2555 KeyInfo
*pRet
= sqlite3KeyInfoAlloc(db
, nOrderBy
+nExtra
, 1);
2558 for(i
=0; i
<nOrderBy
; i
++){
2559 struct ExprList_item
*pItem
= &pOrderBy
->a
[i
];
2560 Expr
*pTerm
= pItem
->pExpr
;
2563 if( pTerm
->flags
& EP_Collate
){
2564 pColl
= sqlite3ExprCollSeq(pParse
, pTerm
);
2566 pColl
= multiSelectCollSeq(pParse
, p
, pItem
->u
.x
.iOrderByCol
-1);
2567 if( pColl
==0 ) pColl
= db
->pDfltColl
;
2568 pOrderBy
->a
[i
].pExpr
=
2569 sqlite3ExprAddCollateString(pParse
, pTerm
, pColl
->zName
);
2571 assert( sqlite3KeyInfoIsWriteable(pRet
) );
2572 pRet
->aColl
[i
] = pColl
;
2573 pRet
->aSortFlags
[i
] = pOrderBy
->a
[i
].fg
.sortFlags
;
2580 #ifndef SQLITE_OMIT_CTE
2582 ** This routine generates VDBE code to compute the content of a WITH RECURSIVE
2583 ** query of the form:
2585 ** <recursive-table> AS (<setup-query> UNION [ALL] <recursive-query>)
2586 ** \___________/ \_______________/
2590 ** There is exactly one reference to the recursive-table in the FROM clause
2591 ** of recursive-query, marked with the SrcList->a[].fg.isRecursive flag.
2593 ** The setup-query runs once to generate an initial set of rows that go
2594 ** into a Queue table. Rows are extracted from the Queue table one by
2595 ** one. Each row extracted from Queue is output to pDest. Then the single
2596 ** extracted row (now in the iCurrent table) becomes the content of the
2597 ** recursive-table for a recursive-query run. The output of the recursive-query
2598 ** is added back into the Queue table. Then another row is extracted from Queue
2599 ** and the iteration continues until the Queue table is empty.
2601 ** If the compound query operator is UNION then no duplicate rows are ever
2602 ** inserted into the Queue table. The iDistinct table keeps a copy of all rows
2603 ** that have ever been inserted into Queue and causes duplicates to be
2604 ** discarded. If the operator is UNION ALL, then duplicates are allowed.
2606 ** If the query has an ORDER BY, then entries in the Queue table are kept in
2607 ** ORDER BY order and the first entry is extracted for each cycle. Without
2608 ** an ORDER BY, the Queue table is just a FIFO.
2610 ** If a LIMIT clause is provided, then the iteration stops after LIMIT rows
2611 ** have been output to pDest. A LIMIT of zero means to output no rows and a
2612 ** negative LIMIT means to output all rows. If there is also an OFFSET clause
2613 ** with a positive value, then the first OFFSET outputs are discarded rather
2614 ** than being sent to pDest. The LIMIT count does not begin until after OFFSET
2615 ** rows have been skipped.
2617 static void generateWithRecursiveQuery(
2618 Parse
*pParse
, /* Parsing context */
2619 Select
*p
, /* The recursive SELECT to be coded */
2620 SelectDest
*pDest
/* What to do with query results */
2622 SrcList
*pSrc
= p
->pSrc
; /* The FROM clause of the recursive query */
2623 int nCol
= p
->pEList
->nExpr
; /* Number of columns in the recursive table */
2624 Vdbe
*v
= pParse
->pVdbe
; /* The prepared statement under construction */
2625 Select
*pSetup
; /* The setup query */
2626 Select
*pFirstRec
; /* Left-most recursive term */
2627 int addrTop
; /* Top of the loop */
2628 int addrCont
, addrBreak
; /* CONTINUE and BREAK addresses */
2629 int iCurrent
= 0; /* The Current table */
2630 int regCurrent
; /* Register holding Current table */
2631 int iQueue
; /* The Queue table */
2632 int iDistinct
= 0; /* To ensure unique results if UNION */
2633 int eDest
= SRT_Fifo
; /* How to write to Queue */
2634 SelectDest destQueue
; /* SelectDest targeting the Queue table */
2635 int i
; /* Loop counter */
2636 int rc
; /* Result code */
2637 ExprList
*pOrderBy
; /* The ORDER BY clause */
2638 Expr
*pLimit
; /* Saved LIMIT and OFFSET */
2639 int regLimit
, regOffset
; /* Registers used by LIMIT and OFFSET */
2641 #ifndef SQLITE_OMIT_WINDOWFUNC
2643 sqlite3ErrorMsg(pParse
, "cannot use window functions in recursive queries");
2648 /* Obtain authorization to do a recursive query */
2649 if( sqlite3AuthCheck(pParse
, SQLITE_RECURSIVE
, 0, 0, 0) ) return;
2651 /* Process the LIMIT and OFFSET clauses, if they exist */
2652 addrBreak
= sqlite3VdbeMakeLabel(pParse
);
2653 p
->nSelectRow
= 320; /* 4 billion rows */
2654 computeLimitRegisters(pParse
, p
, addrBreak
);
2656 regLimit
= p
->iLimit
;
2657 regOffset
= p
->iOffset
;
2659 p
->iLimit
= p
->iOffset
= 0;
2660 pOrderBy
= p
->pOrderBy
;
2662 /* Locate the cursor number of the Current table */
2663 for(i
=0; ALWAYS(i
<pSrc
->nSrc
); i
++){
2664 if( pSrc
->a
[i
].fg
.isRecursive
){
2665 iCurrent
= pSrc
->a
[i
].iCursor
;
2670 /* Allocate cursors numbers for Queue and Distinct. The cursor number for
2671 ** the Distinct table must be exactly one greater than Queue in order
2672 ** for the SRT_DistFifo and SRT_DistQueue destinations to work. */
2673 iQueue
= pParse
->nTab
++;
2674 if( p
->op
==TK_UNION
){
2675 eDest
= pOrderBy
? SRT_DistQueue
: SRT_DistFifo
;
2676 iDistinct
= pParse
->nTab
++;
2678 eDest
= pOrderBy
? SRT_Queue
: SRT_Fifo
;
2680 sqlite3SelectDestInit(&destQueue
, eDest
, iQueue
);
2682 /* Allocate cursors for Current, Queue, and Distinct. */
2683 regCurrent
= ++pParse
->nMem
;
2684 sqlite3VdbeAddOp3(v
, OP_OpenPseudo
, iCurrent
, regCurrent
, nCol
);
2686 KeyInfo
*pKeyInfo
= multiSelectOrderByKeyInfo(pParse
, p
, 1);
2687 sqlite3VdbeAddOp4(v
, OP_OpenEphemeral
, iQueue
, pOrderBy
->nExpr
+2, 0,
2688 (char*)pKeyInfo
, P4_KEYINFO
);
2689 destQueue
.pOrderBy
= pOrderBy
;
2691 sqlite3VdbeAddOp2(v
, OP_OpenEphemeral
, iQueue
, nCol
);
2693 VdbeComment((v
, "Queue table"));
2695 p
->addrOpenEphm
[0] = sqlite3VdbeAddOp2(v
, OP_OpenEphemeral
, iDistinct
, 0);
2696 p
->selFlags
|= SF_UsesEphemeral
;
2699 /* Detach the ORDER BY clause from the compound SELECT */
2702 /* Figure out how many elements of the compound SELECT are part of the
2703 ** recursive query. Make sure no recursive elements use aggregate
2704 ** functions. Mark the recursive elements as UNION ALL even if they
2705 ** are really UNION because the distinctness will be enforced by the
2706 ** iDistinct table. pFirstRec is left pointing to the left-most
2707 ** recursive term of the CTE.
2709 for(pFirstRec
=p
; ALWAYS(pFirstRec
!=0); pFirstRec
=pFirstRec
->pPrior
){
2710 if( pFirstRec
->selFlags
& SF_Aggregate
){
2711 sqlite3ErrorMsg(pParse
, "recursive aggregate queries not supported");
2712 goto end_of_recursive_query
;
2714 pFirstRec
->op
= TK_ALL
;
2715 if( (pFirstRec
->pPrior
->selFlags
& SF_Recursive
)==0 ) break;
2718 /* Store the results of the setup-query in Queue. */
2719 pSetup
= pFirstRec
->pPrior
;
2721 ExplainQueryPlan((pParse
, 1, "SETUP"));
2722 rc
= sqlite3Select(pParse
, pSetup
, &destQueue
);
2724 if( rc
) goto end_of_recursive_query
;
2726 /* Find the next row in the Queue and output that row */
2727 addrTop
= sqlite3VdbeAddOp2(v
, OP_Rewind
, iQueue
, addrBreak
); VdbeCoverage(v
);
2729 /* Transfer the next row in Queue over to Current */
2730 sqlite3VdbeAddOp1(v
, OP_NullRow
, iCurrent
); /* To reset column cache */
2732 sqlite3VdbeAddOp3(v
, OP_Column
, iQueue
, pOrderBy
->nExpr
+1, regCurrent
);
2734 sqlite3VdbeAddOp2(v
, OP_RowData
, iQueue
, regCurrent
);
2736 sqlite3VdbeAddOp1(v
, OP_Delete
, iQueue
);
2738 /* Output the single row in Current */
2739 addrCont
= sqlite3VdbeMakeLabel(pParse
);
2740 codeOffset(v
, regOffset
, addrCont
);
2741 selectInnerLoop(pParse
, p
, iCurrent
,
2742 0, 0, pDest
, addrCont
, addrBreak
);
2744 sqlite3VdbeAddOp2(v
, OP_DecrJumpZero
, regLimit
, addrBreak
);
2747 sqlite3VdbeResolveLabel(v
, addrCont
);
2749 /* Execute the recursive SELECT taking the single row in Current as
2750 ** the value for the recursive-table. Store the results in the Queue.
2752 pFirstRec
->pPrior
= 0;
2753 ExplainQueryPlan((pParse
, 1, "RECURSIVE STEP"));
2754 sqlite3Select(pParse
, p
, &destQueue
);
2755 assert( pFirstRec
->pPrior
==0 );
2756 pFirstRec
->pPrior
= pSetup
;
2758 /* Keep running the loop until the Queue is empty */
2759 sqlite3VdbeGoto(v
, addrTop
);
2760 sqlite3VdbeResolveLabel(v
, addrBreak
);
2762 end_of_recursive_query
:
2763 sqlite3ExprListDelete(pParse
->db
, p
->pOrderBy
);
2764 p
->pOrderBy
= pOrderBy
;
2768 #endif /* SQLITE_OMIT_CTE */
2770 /* Forward references */
2771 static int multiSelectOrderBy(
2772 Parse
*pParse
, /* Parsing context */
2773 Select
*p
, /* The right-most of SELECTs to be coded */
2774 SelectDest
*pDest
/* What to do with query results */
2778 ** Handle the special case of a compound-select that originates from a
2779 ** VALUES clause. By handling this as a special case, we avoid deep
2780 ** recursion, and thus do not need to enforce the SQLITE_LIMIT_COMPOUND_SELECT
2781 ** on a VALUES clause.
2783 ** Because the Select object originates from a VALUES clause:
2784 ** (1) There is no LIMIT or OFFSET or else there is a LIMIT of exactly 1
2785 ** (2) All terms are UNION ALL
2786 ** (3) There is no ORDER BY clause
2788 ** The "LIMIT of exactly 1" case of condition (1) comes about when a VALUES
2789 ** clause occurs within scalar expression (ex: "SELECT (VALUES(1),(2),(3))").
2790 ** The sqlite3CodeSubselect will have added the LIMIT 1 clause in tht case.
2791 ** Since the limit is exactly 1, we only need to evaluate the left-most VALUES.
2793 static int multiSelectValues(
2794 Parse
*pParse
, /* Parsing context */
2795 Select
*p
, /* The right-most of SELECTs to be coded */
2796 SelectDest
*pDest
/* What to do with query results */
2800 int bShowAll
= p
->pLimit
==0;
2801 assert( p
->selFlags
& SF_MultiValue
);
2803 assert( p
->selFlags
& SF_Values
);
2804 assert( p
->op
==TK_ALL
|| (p
->op
==TK_SELECT
&& p
->pPrior
==0) );
2805 assert( p
->pNext
==0 || p
->pEList
->nExpr
==p
->pNext
->pEList
->nExpr
);
2806 #ifndef SQLITE_OMIT_WINDOWFUNC
2807 if( p
->pWin
) return -1;
2809 if( p
->pPrior
==0 ) break;
2810 assert( p
->pPrior
->pNext
==p
);
2814 ExplainQueryPlan((pParse
, 0, "SCAN %d CONSTANT ROW%s", nRow
,
2815 nRow
==1 ? "" : "S"));
2817 selectInnerLoop(pParse
, p
, -1, 0, 0, pDest
, 1, 1);
2818 if( !bShowAll
) break;
2819 p
->nSelectRow
= nRow
;
2826 ** Return true if the SELECT statement which is known to be the recursive
2827 ** part of a recursive CTE still has its anchor terms attached. If the
2828 ** anchor terms have already been removed, then return false.
2830 static int hasAnchor(Select
*p
){
2831 while( p
&& (p
->selFlags
& SF_Recursive
)!=0 ){ p
= p
->pPrior
; }
2836 ** This routine is called to process a compound query form from
2837 ** two or more separate queries using UNION, UNION ALL, EXCEPT, or
2840 ** "p" points to the right-most of the two queries. the query on the
2841 ** left is p->pPrior. The left query could also be a compound query
2842 ** in which case this routine will be called recursively.
2844 ** The results of the total query are to be written into a destination
2845 ** of type eDest with parameter iParm.
2847 ** Example 1: Consider a three-way compound SQL statement.
2849 ** SELECT a FROM t1 UNION SELECT b FROM t2 UNION SELECT c FROM t3
2851 ** This statement is parsed up as follows:
2855 ** `-----> SELECT b FROM t2
2857 ** `------> SELECT a FROM t1
2859 ** The arrows in the diagram above represent the Select.pPrior pointer.
2860 ** So if this routine is called with p equal to the t3 query, then
2861 ** pPrior will be the t2 query. p->op will be TK_UNION in this case.
2863 ** Notice that because of the way SQLite parses compound SELECTs, the
2864 ** individual selects always group from left to right.
2866 static int multiSelect(
2867 Parse
*pParse
, /* Parsing context */
2868 Select
*p
, /* The right-most of SELECTs to be coded */
2869 SelectDest
*pDest
/* What to do with query results */
2871 int rc
= SQLITE_OK
; /* Success code from a subroutine */
2872 Select
*pPrior
; /* Another SELECT immediately to our left */
2873 Vdbe
*v
; /* Generate code to this VDBE */
2874 SelectDest dest
; /* Alternative data destination */
2875 Select
*pDelete
= 0; /* Chain of simple selects to delete */
2876 sqlite3
*db
; /* Database connection */
2878 /* Make sure there is no ORDER BY or LIMIT clause on prior SELECTs. Only
2879 ** the last (right-most) SELECT in the series may have an ORDER BY or LIMIT.
2881 assert( p
&& p
->pPrior
); /* Calling function guarantees this much */
2882 assert( (p
->selFlags
& SF_Recursive
)==0 || p
->op
==TK_ALL
|| p
->op
==TK_UNION
);
2883 assert( p
->selFlags
& SF_Compound
);
2887 assert( pPrior
->pOrderBy
==0 );
2888 assert( pPrior
->pLimit
==0 );
2890 v
= sqlite3GetVdbe(pParse
);
2891 assert( v
!=0 ); /* The VDBE already created by calling function */
2893 /* Create the destination temporary table if necessary
2895 if( dest
.eDest
==SRT_EphemTab
){
2896 assert( p
->pEList
);
2897 sqlite3VdbeAddOp2(v
, OP_OpenEphemeral
, dest
.iSDParm
, p
->pEList
->nExpr
);
2898 dest
.eDest
= SRT_Table
;
2901 /* Special handling for a compound-select that originates as a VALUES clause.
2903 if( p
->selFlags
& SF_MultiValue
){
2904 rc
= multiSelectValues(pParse
, p
, &dest
);
2905 if( rc
>=0 ) goto multi_select_end
;
2909 /* Make sure all SELECTs in the statement have the same number of elements
2910 ** in their result sets.
2912 assert( p
->pEList
&& pPrior
->pEList
);
2913 assert( p
->pEList
->nExpr
==pPrior
->pEList
->nExpr
);
2915 #ifndef SQLITE_OMIT_CTE
2916 if( (p
->selFlags
& SF_Recursive
)!=0 && hasAnchor(p
) ){
2917 generateWithRecursiveQuery(pParse
, p
, &dest
);
2921 /* Compound SELECTs that have an ORDER BY clause are handled separately.
2924 return multiSelectOrderBy(pParse
, p
, pDest
);
2927 #ifndef SQLITE_OMIT_EXPLAIN
2928 if( pPrior
->pPrior
==0 ){
2929 ExplainQueryPlan((pParse
, 1, "COMPOUND QUERY"));
2930 ExplainQueryPlan((pParse
, 1, "LEFT-MOST SUBQUERY"));
2934 /* Generate code for the left and right SELECT statements.
2939 int nLimit
= 0; /* Initialize to suppress harmless compiler warning */
2940 assert( !pPrior
->pLimit
);
2941 pPrior
->iLimit
= p
->iLimit
;
2942 pPrior
->iOffset
= p
->iOffset
;
2943 pPrior
->pLimit
= p
->pLimit
;
2944 TREETRACE(0x200, pParse
, p
, ("multiSelect UNION ALL left...\n"));
2945 rc
= sqlite3Select(pParse
, pPrior
, &dest
);
2948 goto multi_select_end
;
2951 p
->iLimit
= pPrior
->iLimit
;
2952 p
->iOffset
= pPrior
->iOffset
;
2954 addr
= sqlite3VdbeAddOp1(v
, OP_IfNot
, p
->iLimit
); VdbeCoverage(v
);
2955 VdbeComment((v
, "Jump ahead if LIMIT reached"));
2957 sqlite3VdbeAddOp3(v
, OP_OffsetLimit
,
2958 p
->iLimit
, p
->iOffset
+1, p
->iOffset
);
2961 ExplainQueryPlan((pParse
, 1, "UNION ALL"));
2962 TREETRACE(0x200, pParse
, p
, ("multiSelect UNION ALL right...\n"));
2963 rc
= sqlite3Select(pParse
, p
, &dest
);
2964 testcase( rc
!=SQLITE_OK
);
2965 pDelete
= p
->pPrior
;
2967 p
->nSelectRow
= sqlite3LogEstAdd(p
->nSelectRow
, pPrior
->nSelectRow
);
2969 && sqlite3ExprIsInteger(p
->pLimit
->pLeft
, &nLimit
)
2970 && nLimit
>0 && p
->nSelectRow
> sqlite3LogEst((u64
)nLimit
)
2972 p
->nSelectRow
= sqlite3LogEst((u64
)nLimit
);
2975 sqlite3VdbeJumpHere(v
, addr
);
2981 int unionTab
; /* Cursor number of the temp table holding result */
2982 u8 op
= 0; /* One of the SRT_ operations to apply to self */
2983 int priorOp
; /* The SRT_ operation to apply to prior selects */
2984 Expr
*pLimit
; /* Saved values of p->nLimit */
2986 SelectDest uniondest
;
2988 testcase( p
->op
==TK_EXCEPT
);
2989 testcase( p
->op
==TK_UNION
);
2990 priorOp
= SRT_Union
;
2991 if( dest
.eDest
==priorOp
){
2992 /* We can reuse a temporary table generated by a SELECT to our
2995 assert( p
->pLimit
==0 ); /* Not allowed on leftward elements */
2996 unionTab
= dest
.iSDParm
;
2998 /* We will need to create our own temporary table to hold the
2999 ** intermediate results.
3001 unionTab
= pParse
->nTab
++;
3002 assert( p
->pOrderBy
==0 );
3003 addr
= sqlite3VdbeAddOp2(v
, OP_OpenEphemeral
, unionTab
, 0);
3004 assert( p
->addrOpenEphm
[0] == -1 );
3005 p
->addrOpenEphm
[0] = addr
;
3006 findRightmost(p
)->selFlags
|= SF_UsesEphemeral
;
3007 assert( p
->pEList
);
3011 /* Code the SELECT statements to our left
3013 assert( !pPrior
->pOrderBy
);
3014 sqlite3SelectDestInit(&uniondest
, priorOp
, unionTab
);
3015 TREETRACE(0x200, pParse
, p
, ("multiSelect EXCEPT/UNION left...\n"));
3016 rc
= sqlite3Select(pParse
, pPrior
, &uniondest
);
3018 goto multi_select_end
;
3021 /* Code the current SELECT statement
3023 if( p
->op
==TK_EXCEPT
){
3026 assert( p
->op
==TK_UNION
);
3032 uniondest
.eDest
= op
;
3033 ExplainQueryPlan((pParse
, 1, "%s USING TEMP B-TREE",
3034 sqlite3SelectOpName(p
->op
)));
3035 TREETRACE(0x200, pParse
, p
, ("multiSelect EXCEPT/UNION right...\n"));
3036 rc
= sqlite3Select(pParse
, p
, &uniondest
);
3037 testcase( rc
!=SQLITE_OK
);
3038 assert( p
->pOrderBy
==0 );
3039 pDelete
= p
->pPrior
;
3042 if( p
->op
==TK_UNION
){
3043 p
->nSelectRow
= sqlite3LogEstAdd(p
->nSelectRow
, pPrior
->nSelectRow
);
3045 sqlite3ExprDelete(db
, p
->pLimit
);
3050 /* Convert the data in the temporary table into whatever form
3051 ** it is that we currently need.
3053 assert( unionTab
==dest
.iSDParm
|| dest
.eDest
!=priorOp
);
3054 assert( p
->pEList
|| db
->mallocFailed
);
3055 if( dest
.eDest
!=priorOp
&& db
->mallocFailed
==0 ){
3056 int iCont
, iBreak
, iStart
;
3057 iBreak
= sqlite3VdbeMakeLabel(pParse
);
3058 iCont
= sqlite3VdbeMakeLabel(pParse
);
3059 computeLimitRegisters(pParse
, p
, iBreak
);
3060 sqlite3VdbeAddOp2(v
, OP_Rewind
, unionTab
, iBreak
); VdbeCoverage(v
);
3061 iStart
= sqlite3VdbeCurrentAddr(v
);
3062 selectInnerLoop(pParse
, p
, unionTab
,
3063 0, 0, &dest
, iCont
, iBreak
);
3064 sqlite3VdbeResolveLabel(v
, iCont
);
3065 sqlite3VdbeAddOp2(v
, OP_Next
, unionTab
, iStart
); VdbeCoverage(v
);
3066 sqlite3VdbeResolveLabel(v
, iBreak
);
3067 sqlite3VdbeAddOp2(v
, OP_Close
, unionTab
, 0);
3071 default: assert( p
->op
==TK_INTERSECT
); {
3073 int iCont
, iBreak
, iStart
;
3076 SelectDest intersectdest
;
3079 /* INTERSECT is different from the others since it requires
3080 ** two temporary tables. Hence it has its own case. Begin
3081 ** by allocating the tables we will need.
3083 tab1
= pParse
->nTab
++;
3084 tab2
= pParse
->nTab
++;
3085 assert( p
->pOrderBy
==0 );
3087 addr
= sqlite3VdbeAddOp2(v
, OP_OpenEphemeral
, tab1
, 0);
3088 assert( p
->addrOpenEphm
[0] == -1 );
3089 p
->addrOpenEphm
[0] = addr
;
3090 findRightmost(p
)->selFlags
|= SF_UsesEphemeral
;
3091 assert( p
->pEList
);
3093 /* Code the SELECTs to our left into temporary table "tab1".
3095 sqlite3SelectDestInit(&intersectdest
, SRT_Union
, tab1
);
3096 TREETRACE(0x400, pParse
, p
, ("multiSelect INTERSECT left...\n"));
3097 rc
= sqlite3Select(pParse
, pPrior
, &intersectdest
);
3099 goto multi_select_end
;
3102 /* Code the current SELECT into temporary table "tab2"
3104 addr
= sqlite3VdbeAddOp2(v
, OP_OpenEphemeral
, tab2
, 0);
3105 assert( p
->addrOpenEphm
[1] == -1 );
3106 p
->addrOpenEphm
[1] = addr
;
3110 intersectdest
.iSDParm
= tab2
;
3111 ExplainQueryPlan((pParse
, 1, "%s USING TEMP B-TREE",
3112 sqlite3SelectOpName(p
->op
)));
3113 TREETRACE(0x400, pParse
, p
, ("multiSelect INTERSECT right...\n"));
3114 rc
= sqlite3Select(pParse
, p
, &intersectdest
);
3115 testcase( rc
!=SQLITE_OK
);
3116 pDelete
= p
->pPrior
;
3118 if( p
->nSelectRow
>pPrior
->nSelectRow
){
3119 p
->nSelectRow
= pPrior
->nSelectRow
;
3121 sqlite3ExprDelete(db
, p
->pLimit
);
3124 /* Generate code to take the intersection of the two temporary
3128 assert( p
->pEList
);
3129 iBreak
= sqlite3VdbeMakeLabel(pParse
);
3130 iCont
= sqlite3VdbeMakeLabel(pParse
);
3131 computeLimitRegisters(pParse
, p
, iBreak
);
3132 sqlite3VdbeAddOp2(v
, OP_Rewind
, tab1
, iBreak
); VdbeCoverage(v
);
3133 r1
= sqlite3GetTempReg(pParse
);
3134 iStart
= sqlite3VdbeAddOp2(v
, OP_RowData
, tab1
, r1
);
3135 sqlite3VdbeAddOp4Int(v
, OP_NotFound
, tab2
, iCont
, r1
, 0);
3137 sqlite3ReleaseTempReg(pParse
, r1
);
3138 selectInnerLoop(pParse
, p
, tab1
,
3139 0, 0, &dest
, iCont
, iBreak
);
3140 sqlite3VdbeResolveLabel(v
, iCont
);
3141 sqlite3VdbeAddOp2(v
, OP_Next
, tab1
, iStart
); VdbeCoverage(v
);
3142 sqlite3VdbeResolveLabel(v
, iBreak
);
3143 sqlite3VdbeAddOp2(v
, OP_Close
, tab2
, 0);
3144 sqlite3VdbeAddOp2(v
, OP_Close
, tab1
, 0);
3149 #ifndef SQLITE_OMIT_EXPLAIN
3151 ExplainQueryPlanPop(pParse
);
3155 if( pParse
->nErr
) goto multi_select_end
;
3157 /* Compute collating sequences used by
3158 ** temporary tables needed to implement the compound select.
3159 ** Attach the KeyInfo structure to all temporary tables.
3161 ** This section is run by the right-most SELECT statement only.
3162 ** SELECT statements to the left always skip this part. The right-most
3163 ** SELECT might also skip this part if it has no ORDER BY clause and
3164 ** no temp tables are required.
3166 if( p
->selFlags
& SF_UsesEphemeral
){
3167 int i
; /* Loop counter */
3168 KeyInfo
*pKeyInfo
; /* Collating sequence for the result set */
3169 Select
*pLoop
; /* For looping through SELECT statements */
3170 CollSeq
**apColl
; /* For looping through pKeyInfo->aColl[] */
3171 int nCol
; /* Number of columns in result set */
3173 assert( p
->pNext
==0 );
3174 assert( p
->pEList
!=0 );
3175 nCol
= p
->pEList
->nExpr
;
3176 pKeyInfo
= sqlite3KeyInfoAlloc(db
, nCol
, 1);
3178 rc
= SQLITE_NOMEM_BKPT
;
3179 goto multi_select_end
;
3181 for(i
=0, apColl
=pKeyInfo
->aColl
; i
<nCol
; i
++, apColl
++){
3182 *apColl
= multiSelectCollSeq(pParse
, p
, i
);
3184 *apColl
= db
->pDfltColl
;
3188 for(pLoop
=p
; pLoop
; pLoop
=pLoop
->pPrior
){
3190 int addr
= pLoop
->addrOpenEphm
[i
];
3192 /* If [0] is unused then [1] is also unused. So we can
3193 ** always safely abort as soon as the first unused slot is found */
3194 assert( pLoop
->addrOpenEphm
[1]<0 );
3197 sqlite3VdbeChangeP2(v
, addr
, nCol
);
3198 sqlite3VdbeChangeP4(v
, addr
, (char*)sqlite3KeyInfoRef(pKeyInfo
),
3200 pLoop
->addrOpenEphm
[i
] = -1;
3203 sqlite3KeyInfoUnref(pKeyInfo
);
3207 pDest
->iSdst
= dest
.iSdst
;
3208 pDest
->nSdst
= dest
.nSdst
;
3210 sqlite3ParserAddCleanup(pParse
, sqlite3SelectDeleteGeneric
, pDelete
);
3214 #endif /* SQLITE_OMIT_COMPOUND_SELECT */
3217 ** Error message for when two or more terms of a compound select have different
3218 ** size result sets.
3220 void sqlite3SelectWrongNumTermsError(Parse
*pParse
, Select
*p
){
3221 if( p
->selFlags
& SF_Values
){
3222 sqlite3ErrorMsg(pParse
, "all VALUES must have the same number of terms");
3224 sqlite3ErrorMsg(pParse
, "SELECTs to the left and right of %s"
3225 " do not have the same number of result columns",
3226 sqlite3SelectOpName(p
->op
));
3231 ** Code an output subroutine for a coroutine implementation of a
3232 ** SELECT statement.
3234 ** The data to be output is contained in pIn->iSdst. There are
3235 ** pIn->nSdst columns to be output. pDest is where the output should
3238 ** regReturn is the number of the register holding the subroutine
3241 ** If regPrev>0 then it is the first register in a vector that
3242 ** records the previous output. mem[regPrev] is a flag that is false
3243 ** if there has been no previous output. If regPrev>0 then code is
3244 ** generated to suppress duplicates. pKeyInfo is used for comparing
3247 ** If the LIMIT found in p->iLimit is reached, jump immediately to
3250 static int generateOutputSubroutine(
3251 Parse
*pParse
, /* Parsing context */
3252 Select
*p
, /* The SELECT statement */
3253 SelectDest
*pIn
, /* Coroutine supplying data */
3254 SelectDest
*pDest
, /* Where to send the data */
3255 int regReturn
, /* The return address register */
3256 int regPrev
, /* Previous result register. No uniqueness if 0 */
3257 KeyInfo
*pKeyInfo
, /* For comparing with previous entry */
3258 int iBreak
/* Jump here if we hit the LIMIT */
3260 Vdbe
*v
= pParse
->pVdbe
;
3264 addr
= sqlite3VdbeCurrentAddr(v
);
3265 iContinue
= sqlite3VdbeMakeLabel(pParse
);
3267 /* Suppress duplicates for UNION, EXCEPT, and INTERSECT
3271 addr1
= sqlite3VdbeAddOp1(v
, OP_IfNot
, regPrev
); VdbeCoverage(v
);
3272 addr2
= sqlite3VdbeAddOp4(v
, OP_Compare
, pIn
->iSdst
, regPrev
+1, pIn
->nSdst
,
3273 (char*)sqlite3KeyInfoRef(pKeyInfo
), P4_KEYINFO
);
3274 sqlite3VdbeAddOp3(v
, OP_Jump
, addr2
+2, iContinue
, addr2
+2); VdbeCoverage(v
);
3275 sqlite3VdbeJumpHere(v
, addr1
);
3276 sqlite3VdbeAddOp3(v
, OP_Copy
, pIn
->iSdst
, regPrev
+1, pIn
->nSdst
-1);
3277 sqlite3VdbeAddOp2(v
, OP_Integer
, 1, regPrev
);
3279 if( pParse
->db
->mallocFailed
) return 0;
3281 /* Suppress the first OFFSET entries if there is an OFFSET clause
3283 codeOffset(v
, p
->iOffset
, iContinue
);
3285 assert( pDest
->eDest
!=SRT_Exists
);
3286 assert( pDest
->eDest
!=SRT_Table
);
3287 switch( pDest
->eDest
){
3288 /* Store the result as data using a unique key.
3290 case SRT_EphemTab
: {
3291 int r1
= sqlite3GetTempReg(pParse
);
3292 int r2
= sqlite3GetTempReg(pParse
);
3293 sqlite3VdbeAddOp3(v
, OP_MakeRecord
, pIn
->iSdst
, pIn
->nSdst
, r1
);
3294 sqlite3VdbeAddOp2(v
, OP_NewRowid
, pDest
->iSDParm
, r2
);
3295 sqlite3VdbeAddOp3(v
, OP_Insert
, pDest
->iSDParm
, r1
, r2
);
3296 sqlite3VdbeChangeP5(v
, OPFLAG_APPEND
);
3297 sqlite3ReleaseTempReg(pParse
, r2
);
3298 sqlite3ReleaseTempReg(pParse
, r1
);
3302 #ifndef SQLITE_OMIT_SUBQUERY
3303 /* If we are creating a set for an "expr IN (SELECT ...)".
3307 testcase( pIn
->nSdst
>1 );
3308 r1
= sqlite3GetTempReg(pParse
);
3309 sqlite3VdbeAddOp4(v
, OP_MakeRecord
, pIn
->iSdst
, pIn
->nSdst
,
3310 r1
, pDest
->zAffSdst
, pIn
->nSdst
);
3311 sqlite3VdbeAddOp4Int(v
, OP_IdxInsert
, pDest
->iSDParm
, r1
,
3312 pIn
->iSdst
, pIn
->nSdst
);
3313 sqlite3ReleaseTempReg(pParse
, r1
);
3317 /* If this is a scalar select that is part of an expression, then
3318 ** store the results in the appropriate memory cell and break out
3319 ** of the scan loop. Note that the select might return multiple columns
3320 ** if it is the RHS of a row-value IN operator.
3323 testcase( pIn
->nSdst
>1 );
3324 sqlite3ExprCodeMove(pParse
, pIn
->iSdst
, pDest
->iSDParm
, pIn
->nSdst
);
3325 /* The LIMIT clause will jump out of the loop for us */
3328 #endif /* #ifndef SQLITE_OMIT_SUBQUERY */
3330 /* The results are stored in a sequence of registers
3331 ** starting at pDest->iSdst. Then the co-routine yields.
3333 case SRT_Coroutine
: {
3334 if( pDest
->iSdst
==0 ){
3335 pDest
->iSdst
= sqlite3GetTempRange(pParse
, pIn
->nSdst
);
3336 pDest
->nSdst
= pIn
->nSdst
;
3338 sqlite3ExprCodeMove(pParse
, pIn
->iSdst
, pDest
->iSdst
, pIn
->nSdst
);
3339 sqlite3VdbeAddOp1(v
, OP_Yield
, pDest
->iSDParm
);
3343 /* If none of the above, then the result destination must be
3344 ** SRT_Output. This routine is never called with any other
3345 ** destination other than the ones handled above or SRT_Output.
3347 ** For SRT_Output, results are stored in a sequence of registers.
3348 ** Then the OP_ResultRow opcode is used to cause sqlite3_step() to
3349 ** return the next row of result.
3352 assert( pDest
->eDest
==SRT_Output
);
3353 sqlite3VdbeAddOp2(v
, OP_ResultRow
, pIn
->iSdst
, pIn
->nSdst
);
3358 /* Jump to the end of the loop if the LIMIT is reached.
3361 sqlite3VdbeAddOp2(v
, OP_DecrJumpZero
, p
->iLimit
, iBreak
); VdbeCoverage(v
);
3364 /* Generate the subroutine return
3366 sqlite3VdbeResolveLabel(v
, iContinue
);
3367 sqlite3VdbeAddOp1(v
, OP_Return
, regReturn
);
3373 ** Alternative compound select code generator for cases when there
3374 ** is an ORDER BY clause.
3376 ** We assume a query of the following form:
3378 ** <selectA> <operator> <selectB> ORDER BY <orderbylist>
3380 ** <operator> is one of UNION ALL, UNION, EXCEPT, or INTERSECT. The idea
3381 ** is to code both <selectA> and <selectB> with the ORDER BY clause as
3382 ** co-routines. Then run the co-routines in parallel and merge the results
3383 ** into the output. In addition to the two coroutines (called selectA and
3384 ** selectB) there are 7 subroutines:
3386 ** outA: Move the output of the selectA coroutine into the output
3387 ** of the compound query.
3389 ** outB: Move the output of the selectB coroutine into the output
3390 ** of the compound query. (Only generated for UNION and
3391 ** UNION ALL. EXCEPT and INSERTSECT never output a row that
3392 ** appears only in B.)
3394 ** AltB: Called when there is data from both coroutines and A<B.
3396 ** AeqB: Called when there is data from both coroutines and A==B.
3398 ** AgtB: Called when there is data from both coroutines and A>B.
3400 ** EofA: Called when data is exhausted from selectA.
3402 ** EofB: Called when data is exhausted from selectB.
3404 ** The implementation of the latter five subroutines depend on which
3405 ** <operator> is used:
3408 ** UNION ALL UNION EXCEPT INTERSECT
3409 ** ------------- ----------------- -------------- -----------------
3410 ** AltB: outA, nextA outA, nextA outA, nextA nextA
3412 ** AeqB: outA, nextA nextA nextA outA, nextA
3414 ** AgtB: outB, nextB outB, nextB nextB nextB
3416 ** EofA: outB, nextB outB, nextB halt halt
3418 ** EofB: outA, nextA outA, nextA outA, nextA halt
3420 ** In the AltB, AeqB, and AgtB subroutines, an EOF on A following nextA
3421 ** causes an immediate jump to EofA and an EOF on B following nextB causes
3422 ** an immediate jump to EofB. Within EofA and EofB, and EOF on entry or
3423 ** following nextX causes a jump to the end of the select processing.
3425 ** Duplicate removal in the UNION, EXCEPT, and INTERSECT cases is handled
3426 ** within the output subroutine. The regPrev register set holds the previously
3427 ** output value. A comparison is made against this value and the output
3428 ** is skipped if the next results would be the same as the previous.
3430 ** The implementation plan is to implement the two coroutines and seven
3431 ** subroutines first, then put the control logic at the bottom. Like this:
3434 ** coA: coroutine for left query (A)
3435 ** coB: coroutine for right query (B)
3436 ** outA: output one row of A
3437 ** outB: output one row of B (UNION and UNION ALL only)
3443 ** Init: initialize coroutine registers
3445 ** if eof(A) goto EofA
3447 ** if eof(B) goto EofB
3448 ** Cmpr: Compare A, B
3449 ** Jump AltB, AeqB, AgtB
3452 ** We call AltB, AeqB, AgtB, EofA, and EofB "subroutines" but they are not
3453 ** actually called using Gosub and they do not Return. EofA and EofB loop
3454 ** until all data is exhausted then jump to the "end" label. AltB, AeqB,
3455 ** and AgtB jump to either L2 or to one of EofA or EofB.
3457 #ifndef SQLITE_OMIT_COMPOUND_SELECT
3458 static int multiSelectOrderBy(
3459 Parse
*pParse
, /* Parsing context */
3460 Select
*p
, /* The right-most of SELECTs to be coded */
3461 SelectDest
*pDest
/* What to do with query results */
3463 int i
, j
; /* Loop counters */
3464 Select
*pPrior
; /* Another SELECT immediately to our left */
3465 Select
*pSplit
; /* Left-most SELECT in the right-hand group */
3466 int nSelect
; /* Number of SELECT statements in the compound */
3467 Vdbe
*v
; /* Generate code to this VDBE */
3468 SelectDest destA
; /* Destination for coroutine A */
3469 SelectDest destB
; /* Destination for coroutine B */
3470 int regAddrA
; /* Address register for select-A coroutine */
3471 int regAddrB
; /* Address register for select-B coroutine */
3472 int addrSelectA
; /* Address of the select-A coroutine */
3473 int addrSelectB
; /* Address of the select-B coroutine */
3474 int regOutA
; /* Address register for the output-A subroutine */
3475 int regOutB
; /* Address register for the output-B subroutine */
3476 int addrOutA
; /* Address of the output-A subroutine */
3477 int addrOutB
= 0; /* Address of the output-B subroutine */
3478 int addrEofA
; /* Address of the select-A-exhausted subroutine */
3479 int addrEofA_noB
; /* Alternate addrEofA if B is uninitialized */
3480 int addrEofB
; /* Address of the select-B-exhausted subroutine */
3481 int addrAltB
; /* Address of the A<B subroutine */
3482 int addrAeqB
; /* Address of the A==B subroutine */
3483 int addrAgtB
; /* Address of the A>B subroutine */
3484 int regLimitA
; /* Limit register for select-A */
3485 int regLimitB
; /* Limit register for select-A */
3486 int regPrev
; /* A range of registers to hold previous output */
3487 int savedLimit
; /* Saved value of p->iLimit */
3488 int savedOffset
; /* Saved value of p->iOffset */
3489 int labelCmpr
; /* Label for the start of the merge algorithm */
3490 int labelEnd
; /* Label for the end of the overall SELECT stmt */
3491 int addr1
; /* Jump instructions that get retargeted */
3492 int op
; /* One of TK_ALL, TK_UNION, TK_EXCEPT, TK_INTERSECT */
3493 KeyInfo
*pKeyDup
= 0; /* Comparison information for duplicate removal */
3494 KeyInfo
*pKeyMerge
; /* Comparison information for merging rows */
3495 sqlite3
*db
; /* Database connection */
3496 ExprList
*pOrderBy
; /* The ORDER BY clause */
3497 int nOrderBy
; /* Number of terms in the ORDER BY clause */
3498 u32
*aPermute
; /* Mapping from ORDER BY terms to result set columns */
3500 assert( p
->pOrderBy
!=0 );
3501 assert( pKeyDup
==0 ); /* "Managed" code needs this. Ticket #3382. */
3504 assert( v
!=0 ); /* Already thrown the error if VDBE alloc failed */
3505 labelEnd
= sqlite3VdbeMakeLabel(pParse
);
3506 labelCmpr
= sqlite3VdbeMakeLabel(pParse
);
3509 /* Patch up the ORDER BY clause
3512 assert( p
->pPrior
->pOrderBy
==0 );
3513 pOrderBy
= p
->pOrderBy
;
3515 nOrderBy
= pOrderBy
->nExpr
;
3517 /* For operators other than UNION ALL we have to make sure that
3518 ** the ORDER BY clause covers every term of the result set. Add
3519 ** terms to the ORDER BY clause as necessary.
3522 for(i
=1; db
->mallocFailed
==0 && i
<=p
->pEList
->nExpr
; i
++){
3523 struct ExprList_item
*pItem
;
3524 for(j
=0, pItem
=pOrderBy
->a
; j
<nOrderBy
; j
++, pItem
++){
3526 assert( pItem
->u
.x
.iOrderByCol
>0 );
3527 if( pItem
->u
.x
.iOrderByCol
==i
) break;
3530 Expr
*pNew
= sqlite3Expr(db
, TK_INTEGER
, 0);
3531 if( pNew
==0 ) return SQLITE_NOMEM_BKPT
;
3532 pNew
->flags
|= EP_IntValue
;
3534 p
->pOrderBy
= pOrderBy
= sqlite3ExprListAppend(pParse
, pOrderBy
, pNew
);
3535 if( pOrderBy
) pOrderBy
->a
[nOrderBy
++].u
.x
.iOrderByCol
= (u16
)i
;
3540 /* Compute the comparison permutation and keyinfo that is used with
3541 ** the permutation used to determine if the next
3542 ** row of results comes from selectA or selectB. Also add explicit
3543 ** collations to the ORDER BY clause terms so that when the subqueries
3544 ** to the right and the left are evaluated, they use the correct
3547 aPermute
= sqlite3DbMallocRawNN(db
, sizeof(u32
)*(nOrderBy
+ 1));
3549 struct ExprList_item
*pItem
;
3550 aPermute
[0] = nOrderBy
;
3551 for(i
=1, pItem
=pOrderBy
->a
; i
<=nOrderBy
; i
++, pItem
++){
3553 assert( pItem
->u
.x
.iOrderByCol
>0 );
3554 assert( pItem
->u
.x
.iOrderByCol
<=p
->pEList
->nExpr
);
3555 aPermute
[i
] = pItem
->u
.x
.iOrderByCol
- 1;
3557 pKeyMerge
= multiSelectOrderByKeyInfo(pParse
, p
, 1);
3562 /* Allocate a range of temporary registers and the KeyInfo needed
3563 ** for the logic that removes duplicate result rows when the
3564 ** operator is UNION, EXCEPT, or INTERSECT (but not UNION ALL).
3569 int nExpr
= p
->pEList
->nExpr
;
3570 assert( nOrderBy
>=nExpr
|| db
->mallocFailed
);
3571 regPrev
= pParse
->nMem
+1;
3572 pParse
->nMem
+= nExpr
+1;
3573 sqlite3VdbeAddOp2(v
, OP_Integer
, 0, regPrev
);
3574 pKeyDup
= sqlite3KeyInfoAlloc(db
, nExpr
, 1);
3576 assert( sqlite3KeyInfoIsWriteable(pKeyDup
) );
3577 for(i
=0; i
<nExpr
; i
++){
3578 pKeyDup
->aColl
[i
] = multiSelectCollSeq(pParse
, p
, i
);
3579 pKeyDup
->aSortFlags
[i
] = 0;
3584 /* Separate the left and the right query from one another
3587 if( (op
==TK_ALL
|| op
==TK_UNION
)
3588 && OptimizationEnabled(db
, SQLITE_BalancedMerge
)
3590 for(pSplit
=p
; pSplit
->pPrior
!=0 && pSplit
->op
==op
; pSplit
=pSplit
->pPrior
){
3592 assert( pSplit
->pPrior
->pNext
==pSplit
);
3599 for(i
=2; i
<nSelect
; i
+=2){ pSplit
= pSplit
->pPrior
; }
3601 pPrior
= pSplit
->pPrior
;
3602 assert( pPrior
!=0 );
3605 assert( p
->pOrderBy
== pOrderBy
);
3606 assert( pOrderBy
!=0 || db
->mallocFailed
);
3607 pPrior
->pOrderBy
= sqlite3ExprListDup(pParse
->db
, pOrderBy
, 0);
3608 sqlite3ResolveOrderGroupBy(pParse
, p
, p
->pOrderBy
, "ORDER");
3609 sqlite3ResolveOrderGroupBy(pParse
, pPrior
, pPrior
->pOrderBy
, "ORDER");
3611 /* Compute the limit registers */
3612 computeLimitRegisters(pParse
, p
, labelEnd
);
3613 if( p
->iLimit
&& op
==TK_ALL
){
3614 regLimitA
= ++pParse
->nMem
;
3615 regLimitB
= ++pParse
->nMem
;
3616 sqlite3VdbeAddOp2(v
, OP_Copy
, p
->iOffset
? p
->iOffset
+1 : p
->iLimit
,
3618 sqlite3VdbeAddOp2(v
, OP_Copy
, regLimitA
, regLimitB
);
3620 regLimitA
= regLimitB
= 0;
3622 sqlite3ExprDelete(db
, p
->pLimit
);
3625 regAddrA
= ++pParse
->nMem
;
3626 regAddrB
= ++pParse
->nMem
;
3627 regOutA
= ++pParse
->nMem
;
3628 regOutB
= ++pParse
->nMem
;
3629 sqlite3SelectDestInit(&destA
, SRT_Coroutine
, regAddrA
);
3630 sqlite3SelectDestInit(&destB
, SRT_Coroutine
, regAddrB
);
3632 ExplainQueryPlan((pParse
, 1, "MERGE (%s)", sqlite3SelectOpName(p
->op
)));
3634 /* Generate a coroutine to evaluate the SELECT statement to the
3635 ** left of the compound operator - the "A" select.
3637 addrSelectA
= sqlite3VdbeCurrentAddr(v
) + 1;
3638 addr1
= sqlite3VdbeAddOp3(v
, OP_InitCoroutine
, regAddrA
, 0, addrSelectA
);
3639 VdbeComment((v
, "left SELECT"));
3640 pPrior
->iLimit
= regLimitA
;
3641 ExplainQueryPlan((pParse
, 1, "LEFT"));
3642 sqlite3Select(pParse
, pPrior
, &destA
);
3643 sqlite3VdbeEndCoroutine(v
, regAddrA
);
3644 sqlite3VdbeJumpHere(v
, addr1
);
3646 /* Generate a coroutine to evaluate the SELECT statement on
3647 ** the right - the "B" select
3649 addrSelectB
= sqlite3VdbeCurrentAddr(v
) + 1;
3650 addr1
= sqlite3VdbeAddOp3(v
, OP_InitCoroutine
, regAddrB
, 0, addrSelectB
);
3651 VdbeComment((v
, "right SELECT"));
3652 savedLimit
= p
->iLimit
;
3653 savedOffset
= p
->iOffset
;
3654 p
->iLimit
= regLimitB
;
3656 ExplainQueryPlan((pParse
, 1, "RIGHT"));
3657 sqlite3Select(pParse
, p
, &destB
);
3658 p
->iLimit
= savedLimit
;
3659 p
->iOffset
= savedOffset
;
3660 sqlite3VdbeEndCoroutine(v
, regAddrB
);
3662 /* Generate a subroutine that outputs the current row of the A
3663 ** select as the next output row of the compound select.
3665 VdbeNoopComment((v
, "Output routine for A"));
3666 addrOutA
= generateOutputSubroutine(pParse
,
3667 p
, &destA
, pDest
, regOutA
,
3668 regPrev
, pKeyDup
, labelEnd
);
3670 /* Generate a subroutine that outputs the current row of the B
3671 ** select as the next output row of the compound select.
3673 if( op
==TK_ALL
|| op
==TK_UNION
){
3674 VdbeNoopComment((v
, "Output routine for B"));
3675 addrOutB
= generateOutputSubroutine(pParse
,
3676 p
, &destB
, pDest
, regOutB
,
3677 regPrev
, pKeyDup
, labelEnd
);
3679 sqlite3KeyInfoUnref(pKeyDup
);
3681 /* Generate a subroutine to run when the results from select A
3682 ** are exhausted and only data in select B remains.
3684 if( op
==TK_EXCEPT
|| op
==TK_INTERSECT
){
3685 addrEofA_noB
= addrEofA
= labelEnd
;
3687 VdbeNoopComment((v
, "eof-A subroutine"));
3688 addrEofA
= sqlite3VdbeAddOp2(v
, OP_Gosub
, regOutB
, addrOutB
);
3689 addrEofA_noB
= sqlite3VdbeAddOp2(v
, OP_Yield
, regAddrB
, labelEnd
);
3691 sqlite3VdbeGoto(v
, addrEofA
);
3692 p
->nSelectRow
= sqlite3LogEstAdd(p
->nSelectRow
, pPrior
->nSelectRow
);
3695 /* Generate a subroutine to run when the results from select B
3696 ** are exhausted and only data in select A remains.
3698 if( op
==TK_INTERSECT
){
3699 addrEofB
= addrEofA
;
3700 if( p
->nSelectRow
> pPrior
->nSelectRow
) p
->nSelectRow
= pPrior
->nSelectRow
;
3702 VdbeNoopComment((v
, "eof-B subroutine"));
3703 addrEofB
= sqlite3VdbeAddOp2(v
, OP_Gosub
, regOutA
, addrOutA
);
3704 sqlite3VdbeAddOp2(v
, OP_Yield
, regAddrA
, labelEnd
); VdbeCoverage(v
);
3705 sqlite3VdbeGoto(v
, addrEofB
);
3708 /* Generate code to handle the case of A<B
3710 VdbeNoopComment((v
, "A-lt-B subroutine"));
3711 addrAltB
= sqlite3VdbeAddOp2(v
, OP_Gosub
, regOutA
, addrOutA
);
3712 sqlite3VdbeAddOp2(v
, OP_Yield
, regAddrA
, addrEofA
); VdbeCoverage(v
);
3713 sqlite3VdbeGoto(v
, labelCmpr
);
3715 /* Generate code to handle the case of A==B
3718 addrAeqB
= addrAltB
;
3719 }else if( op
==TK_INTERSECT
){
3720 addrAeqB
= addrAltB
;
3723 VdbeNoopComment((v
, "A-eq-B subroutine"));
3725 sqlite3VdbeAddOp2(v
, OP_Yield
, regAddrA
, addrEofA
); VdbeCoverage(v
);
3726 sqlite3VdbeGoto(v
, labelCmpr
);
3729 /* Generate code to handle the case of A>B
3731 VdbeNoopComment((v
, "A-gt-B subroutine"));
3732 addrAgtB
= sqlite3VdbeCurrentAddr(v
);
3733 if( op
==TK_ALL
|| op
==TK_UNION
){
3734 sqlite3VdbeAddOp2(v
, OP_Gosub
, regOutB
, addrOutB
);
3736 sqlite3VdbeAddOp2(v
, OP_Yield
, regAddrB
, addrEofB
); VdbeCoverage(v
);
3737 sqlite3VdbeGoto(v
, labelCmpr
);
3739 /* This code runs once to initialize everything.
3741 sqlite3VdbeJumpHere(v
, addr1
);
3742 sqlite3VdbeAddOp2(v
, OP_Yield
, regAddrA
, addrEofA_noB
); VdbeCoverage(v
);
3743 sqlite3VdbeAddOp2(v
, OP_Yield
, regAddrB
, addrEofB
); VdbeCoverage(v
);
3745 /* Implement the main merge loop
3747 sqlite3VdbeResolveLabel(v
, labelCmpr
);
3748 sqlite3VdbeAddOp4(v
, OP_Permutation
, 0, 0, 0, (char*)aPermute
, P4_INTARRAY
);
3749 sqlite3VdbeAddOp4(v
, OP_Compare
, destA
.iSdst
, destB
.iSdst
, nOrderBy
,
3750 (char*)pKeyMerge
, P4_KEYINFO
);
3751 sqlite3VdbeChangeP5(v
, OPFLAG_PERMUTE
);
3752 sqlite3VdbeAddOp3(v
, OP_Jump
, addrAltB
, addrAeqB
, addrAgtB
); VdbeCoverage(v
);
3754 /* Jump to the this point in order to terminate the query.
3756 sqlite3VdbeResolveLabel(v
, labelEnd
);
3758 /* Make arrangements to free the 2nd and subsequent arms of the compound
3759 ** after the parse has finished */
3760 if( pSplit
->pPrior
){
3761 sqlite3ParserAddCleanup(pParse
, sqlite3SelectDeleteGeneric
, pSplit
->pPrior
);
3763 pSplit
->pPrior
= pPrior
;
3764 pPrior
->pNext
= pSplit
;
3765 sqlite3ExprListDelete(db
, pPrior
->pOrderBy
);
3766 pPrior
->pOrderBy
= 0;
3768 /*** TBD: Insert subroutine calls to close cursors on incomplete
3769 **** subqueries ****/
3770 ExplainQueryPlanPop(pParse
);
3771 return pParse
->nErr
!=0;
3775 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
3777 /* An instance of the SubstContext object describes an substitution edit
3778 ** to be performed on a parse tree.
3780 ** All references to columns in table iTable are to be replaced by corresponding
3781 ** expressions in pEList.
3783 ** ## About "isOuterJoin":
3785 ** The isOuterJoin column indicates that the replacement will occur into a
3786 ** position in the parent that NULL-able due to an OUTER JOIN. Either the
3787 ** target slot in the parent is the right operand of a LEFT JOIN, or one of
3788 ** the left operands of a RIGHT JOIN. In either case, we need to potentially
3789 ** bypass the substituted expression with OP_IfNullRow.
3791 ** Suppose the original expression is an integer constant. Even though the table
3792 ** has the nullRow flag set, because the expression is an integer constant,
3793 ** it will not be NULLed out. So instead, we insert an OP_IfNullRow opcode
3794 ** that checks to see if the nullRow flag is set on the table. If the nullRow
3795 ** flag is set, then the value in the register is set to NULL and the original
3796 ** expression is bypassed. If the nullRow flag is not set, then the original
3797 ** expression runs to populate the register.
3799 ** Example where this is needed:
3801 ** CREATE TABLE t1(a INTEGER PRIMARY KEY, b INT);
3802 ** CREATE TABLE t2(x INT UNIQUE);
3804 ** SELECT a,b,m,x FROM t1 LEFT JOIN (SELECT 59 AS m,x FROM t2) ON b=x;
3806 ** When the subquery on the right side of the LEFT JOIN is flattened, we
3807 ** have to add OP_IfNullRow in front of the OP_Integer that implements the
3808 ** "m" value of the subquery so that a NULL will be loaded instead of 59
3809 ** when processing a non-matched row of the left.
3811 typedef struct SubstContext
{
3812 Parse
*pParse
; /* The parsing context */
3813 int iTable
; /* Replace references to this table */
3814 int iNewTable
; /* New table number */
3815 int isOuterJoin
; /* Add TK_IF_NULL_ROW opcodes on each replacement */
3816 ExprList
*pEList
; /* Replacement expressions */
3817 ExprList
*pCList
; /* Collation sequences for replacement expr */
3820 /* Forward Declarations */
3821 static void substExprList(SubstContext
*, ExprList
*);
3822 static void substSelect(SubstContext
*, Select
*, int);
3825 ** Scan through the expression pExpr. Replace every reference to
3826 ** a column in table number iTable with a copy of the iColumn-th
3827 ** entry in pEList. (But leave references to the ROWID column
3830 ** This routine is part of the flattening procedure. A subquery
3831 ** whose result set is defined by pEList appears as entry in the
3832 ** FROM clause of a SELECT such that the VDBE cursor assigned to that
3833 ** FORM clause entry is iTable. This routine makes the necessary
3834 ** changes to pExpr so that it refers directly to the source table
3835 ** of the subquery rather the result set of the subquery.
3837 static Expr
*substExpr(
3838 SubstContext
*pSubst
, /* Description of the substitution */
3839 Expr
*pExpr
/* Expr in which substitution occurs */
3841 if( pExpr
==0 ) return 0;
3842 if( ExprHasProperty(pExpr
, EP_OuterON
|EP_InnerON
)
3843 && pExpr
->w
.iJoin
==pSubst
->iTable
3845 testcase( ExprHasProperty(pExpr
, EP_InnerON
) );
3846 pExpr
->w
.iJoin
= pSubst
->iNewTable
;
3848 if( pExpr
->op
==TK_COLUMN
3849 && pExpr
->iTable
==pSubst
->iTable
3850 && !ExprHasProperty(pExpr
, EP_FixedCol
)
3852 #ifdef SQLITE_ALLOW_ROWID_IN_VIEW
3853 if( pExpr
->iColumn
<0 ){
3854 pExpr
->op
= TK_NULL
;
3862 iColumn
= pExpr
->iColumn
;
3863 assert( iColumn
>=0 );
3864 assert( pSubst
->pEList
!=0 && iColumn
<pSubst
->pEList
->nExpr
);
3865 assert( pExpr
->pRight
==0 );
3866 pCopy
= pSubst
->pEList
->a
[iColumn
].pExpr
;
3867 if( sqlite3ExprIsVector(pCopy
) ){
3868 sqlite3VectorErrorMsg(pSubst
->pParse
, pCopy
);
3870 sqlite3
*db
= pSubst
->pParse
->db
;
3871 if( pSubst
->isOuterJoin
3872 && (pCopy
->op
!=TK_COLUMN
|| pCopy
->iTable
!=pSubst
->iNewTable
)
3874 memset(&ifNullRow
, 0, sizeof(ifNullRow
));
3875 ifNullRow
.op
= TK_IF_NULL_ROW
;
3876 ifNullRow
.pLeft
= pCopy
;
3877 ifNullRow
.iTable
= pSubst
->iNewTable
;
3878 ifNullRow
.iColumn
= -99;
3879 ifNullRow
.flags
= EP_IfNullRow
;
3882 testcase( ExprHasProperty(pCopy
, EP_Subquery
) );
3883 pNew
= sqlite3ExprDup(db
, pCopy
, 0);
3884 if( db
->mallocFailed
){
3885 sqlite3ExprDelete(db
, pNew
);
3888 if( pSubst
->isOuterJoin
){
3889 ExprSetProperty(pNew
, EP_CanBeNull
);
3891 if( ExprHasProperty(pExpr
,EP_OuterON
|EP_InnerON
) ){
3892 sqlite3SetJoinExpr(pNew
, pExpr
->w
.iJoin
,
3893 pExpr
->flags
& (EP_OuterON
|EP_InnerON
));
3895 sqlite3ExprDelete(db
, pExpr
);
3897 if( pExpr
->op
==TK_TRUEFALSE
){
3898 pExpr
->u
.iValue
= sqlite3ExprTruthValue(pExpr
);
3899 pExpr
->op
= TK_INTEGER
;
3900 ExprSetProperty(pExpr
, EP_IntValue
);
3903 /* Ensure that the expression now has an implicit collation sequence,
3904 ** just as it did when it was a column of a view or sub-query. */
3906 CollSeq
*pNat
= sqlite3ExprCollSeq(pSubst
->pParse
, pExpr
);
3907 CollSeq
*pColl
= sqlite3ExprCollSeq(pSubst
->pParse
,
3908 pSubst
->pCList
->a
[iColumn
].pExpr
3910 if( pNat
!=pColl
|| (pExpr
->op
!=TK_COLUMN
&& pExpr
->op
!=TK_COLLATE
) ){
3911 pExpr
= sqlite3ExprAddCollateString(pSubst
->pParse
, pExpr
,
3912 (pColl
? pColl
->zName
: "BINARY")
3916 ExprClearProperty(pExpr
, EP_Collate
);
3920 if( pExpr
->op
==TK_IF_NULL_ROW
&& pExpr
->iTable
==pSubst
->iTable
){
3921 pExpr
->iTable
= pSubst
->iNewTable
;
3923 pExpr
->pLeft
= substExpr(pSubst
, pExpr
->pLeft
);
3924 pExpr
->pRight
= substExpr(pSubst
, pExpr
->pRight
);
3925 if( ExprUseXSelect(pExpr
) ){
3926 substSelect(pSubst
, pExpr
->x
.pSelect
, 1);
3928 substExprList(pSubst
, pExpr
->x
.pList
);
3930 #ifndef SQLITE_OMIT_WINDOWFUNC
3931 if( ExprHasProperty(pExpr
, EP_WinFunc
) ){
3932 Window
*pWin
= pExpr
->y
.pWin
;
3933 pWin
->pFilter
= substExpr(pSubst
, pWin
->pFilter
);
3934 substExprList(pSubst
, pWin
->pPartition
);
3935 substExprList(pSubst
, pWin
->pOrderBy
);
3941 static void substExprList(
3942 SubstContext
*pSubst
, /* Description of the substitution */
3943 ExprList
*pList
/* List to scan and in which to make substitutes */
3946 if( pList
==0 ) return;
3947 for(i
=0; i
<pList
->nExpr
; i
++){
3948 pList
->a
[i
].pExpr
= substExpr(pSubst
, pList
->a
[i
].pExpr
);
3951 static void substSelect(
3952 SubstContext
*pSubst
, /* Description of the substitution */
3953 Select
*p
, /* SELECT statement in which to make substitutions */
3954 int doPrior
/* Do substitutes on p->pPrior too */
3961 substExprList(pSubst
, p
->pEList
);
3962 substExprList(pSubst
, p
->pGroupBy
);
3963 substExprList(pSubst
, p
->pOrderBy
);
3964 p
->pHaving
= substExpr(pSubst
, p
->pHaving
);
3965 p
->pWhere
= substExpr(pSubst
, p
->pWhere
);
3968 for(i
=pSrc
->nSrc
, pItem
=pSrc
->a
; i
>0; i
--, pItem
++){
3969 substSelect(pSubst
, pItem
->pSelect
, 1);
3970 if( pItem
->fg
.isTabFunc
){
3971 substExprList(pSubst
, pItem
->u1
.pFuncArg
);
3974 }while( doPrior
&& (p
= p
->pPrior
)!=0 );
3976 #endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
3978 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
3980 ** pSelect is a SELECT statement and pSrcItem is one item in the FROM
3981 ** clause of that SELECT.
3983 ** This routine scans the entire SELECT statement and recomputes the
3984 ** pSrcItem->colUsed mask.
3986 static int recomputeColumnsUsedExpr(Walker
*pWalker
, Expr
*pExpr
){
3988 if( pExpr
->op
!=TK_COLUMN
) return WRC_Continue
;
3989 pItem
= pWalker
->u
.pSrcItem
;
3990 if( pItem
->iCursor
!=pExpr
->iTable
) return WRC_Continue
;
3991 if( pExpr
->iColumn
<0 ) return WRC_Continue
;
3992 pItem
->colUsed
|= sqlite3ExprColUsed(pExpr
);
3993 return WRC_Continue
;
3995 static void recomputeColumnsUsed(
3996 Select
*pSelect
, /* The complete SELECT statement */
3997 SrcItem
*pSrcItem
/* Which FROM clause item to recompute */
4000 if( NEVER(pSrcItem
->pTab
==0) ) return;
4001 memset(&w
, 0, sizeof(w
));
4002 w
.xExprCallback
= recomputeColumnsUsedExpr
;
4003 w
.xSelectCallback
= sqlite3SelectWalkNoop
;
4004 w
.u
.pSrcItem
= pSrcItem
;
4005 pSrcItem
->colUsed
= 0;
4006 sqlite3WalkSelect(&w
, pSelect
);
4008 #endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
4010 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
4012 ** Assign new cursor numbers to each of the items in pSrc. For each
4013 ** new cursor number assigned, set an entry in the aCsrMap[] array
4014 ** to map the old cursor number to the new:
4016 ** aCsrMap[iOld+1] = iNew;
4018 ** The array is guaranteed by the caller to be large enough for all
4019 ** existing cursor numbers in pSrc. aCsrMap[0] is the array size.
4021 ** If pSrc contains any sub-selects, call this routine recursively
4022 ** on the FROM clause of each such sub-select, with iExcept set to -1.
4024 static void srclistRenumberCursors(
4025 Parse
*pParse
, /* Parse context */
4026 int *aCsrMap
, /* Array to store cursor mappings in */
4027 SrcList
*pSrc
, /* FROM clause to renumber */
4028 int iExcept
/* FROM clause item to skip */
4032 for(i
=0, pItem
=pSrc
->a
; i
<pSrc
->nSrc
; i
++, pItem
++){
4035 assert( pItem
->iCursor
< aCsrMap
[0] );
4036 if( !pItem
->fg
.isRecursive
|| aCsrMap
[pItem
->iCursor
+1]==0 ){
4037 aCsrMap
[pItem
->iCursor
+1] = pParse
->nTab
++;
4039 pItem
->iCursor
= aCsrMap
[pItem
->iCursor
+1];
4040 for(p
=pItem
->pSelect
; p
; p
=p
->pPrior
){
4041 srclistRenumberCursors(pParse
, aCsrMap
, p
->pSrc
, -1);
4048 ** *piCursor is a cursor number. Change it if it needs to be mapped.
4050 static void renumberCursorDoMapping(Walker
*pWalker
, int *piCursor
){
4051 int *aCsrMap
= pWalker
->u
.aiCol
;
4052 int iCsr
= *piCursor
;
4053 if( iCsr
< aCsrMap
[0] && aCsrMap
[iCsr
+1]>0 ){
4054 *piCursor
= aCsrMap
[iCsr
+1];
4059 ** Expression walker callback used by renumberCursors() to update
4060 ** Expr objects to match newly assigned cursor numbers.
4062 static int renumberCursorsCb(Walker
*pWalker
, Expr
*pExpr
){
4064 if( op
==TK_COLUMN
|| op
==TK_IF_NULL_ROW
){
4065 renumberCursorDoMapping(pWalker
, &pExpr
->iTable
);
4067 if( ExprHasProperty(pExpr
, EP_OuterON
) ){
4068 renumberCursorDoMapping(pWalker
, &pExpr
->w
.iJoin
);
4070 return WRC_Continue
;
4074 ** Assign a new cursor number to each cursor in the FROM clause (Select.pSrc)
4075 ** of the SELECT statement passed as the second argument, and to each
4076 ** cursor in the FROM clause of any FROM clause sub-selects, recursively.
4077 ** Except, do not assign a new cursor number to the iExcept'th element in
4078 ** the FROM clause of (*p). Update all expressions and other references
4079 ** to refer to the new cursor numbers.
4081 ** Argument aCsrMap is an array that may be used for temporary working
4082 ** space. Two guarantees are made by the caller:
4084 ** * the array is larger than the largest cursor number used within the
4085 ** select statement passed as an argument, and
4087 ** * the array entries for all cursor numbers that do *not* appear in
4088 ** FROM clauses of the select statement as described above are
4089 ** initialized to zero.
4091 static void renumberCursors(
4092 Parse
*pParse
, /* Parse context */
4093 Select
*p
, /* Select to renumber cursors within */
4094 int iExcept
, /* FROM clause item to skip */
4095 int *aCsrMap
/* Working space */
4098 srclistRenumberCursors(pParse
, aCsrMap
, p
->pSrc
, iExcept
);
4099 memset(&w
, 0, sizeof(w
));
4100 w
.u
.aiCol
= aCsrMap
;
4101 w
.xExprCallback
= renumberCursorsCb
;
4102 w
.xSelectCallback
= sqlite3SelectWalkNoop
;
4103 sqlite3WalkSelect(&w
, p
);
4105 #endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
4108 ** If pSel is not part of a compound SELECT, return a pointer to its
4109 ** expression list. Otherwise, return a pointer to the expression list
4110 ** of the leftmost SELECT in the compound.
4112 static ExprList
*findLeftmostExprlist(Select
*pSel
){
4113 while( pSel
->pPrior
){
4114 pSel
= pSel
->pPrior
;
4116 return pSel
->pEList
;
4120 ** Return true if any of the result-set columns in the compound query
4121 ** have incompatible affinities on one or more arms of the compound.
4123 static int compoundHasDifferentAffinities(Select
*p
){
4127 assert( p
->pEList
!=0 );
4128 assert( p
->pPrior
!=0 );
4130 for(ii
=0; ii
<pList
->nExpr
; ii
++){
4133 assert( pList
->a
[ii
].pExpr
!=0 );
4134 aff
= sqlite3ExprAffinity(pList
->a
[ii
].pExpr
);
4135 for(pSub1
=p
->pPrior
; pSub1
; pSub1
=pSub1
->pPrior
){
4136 assert( pSub1
->pEList
!=0 );
4137 assert( pSub1
->pEList
->nExpr
>ii
);
4138 assert( pSub1
->pEList
->a
[ii
].pExpr
!=0 );
4139 if( sqlite3ExprAffinity(pSub1
->pEList
->a
[ii
].pExpr
)!=aff
){
4147 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
4149 ** This routine attempts to flatten subqueries as a performance optimization.
4150 ** This routine returns 1 if it makes changes and 0 if no flattening occurs.
4152 ** To understand the concept of flattening, consider the following
4155 ** SELECT a FROM (SELECT x+y AS a FROM t1 WHERE z<100) WHERE a>5
4157 ** The default way of implementing this query is to execute the
4158 ** subquery first and store the results in a temporary table, then
4159 ** run the outer query on that temporary table. This requires two
4160 ** passes over the data. Furthermore, because the temporary table
4161 ** has no indices, the WHERE clause on the outer query cannot be
4164 ** This routine attempts to rewrite queries such as the above into
4165 ** a single flat select, like this:
4167 ** SELECT x+y AS a FROM t1 WHERE z<100 AND a>5
4169 ** The code generated for this simplification gives the same result
4170 ** but only has to scan the data once. And because indices might
4171 ** exist on the table t1, a complete scan of the data might be
4174 ** Flattening is subject to the following constraints:
4176 ** (**) We no longer attempt to flatten aggregate subqueries. Was:
4177 ** The subquery and the outer query cannot both be aggregates.
4179 ** (**) We no longer attempt to flatten aggregate subqueries. Was:
4180 ** (2) If the subquery is an aggregate then
4181 ** (2a) the outer query must not be a join and
4182 ** (2b) the outer query must not use subqueries
4183 ** other than the one FROM-clause subquery that is a candidate
4184 ** for flattening. (This is due to ticket [2f7170d73bf9abf80]
4185 ** from 2015-02-09.)
4187 ** (3) If the subquery is the right operand of a LEFT JOIN then
4188 ** (3a) the subquery may not be a join and
4189 ** (3b) the FROM clause of the subquery may not contain a virtual
4191 ** (**) Was: "The outer query may not have a GROUP BY." This case
4192 ** is now managed correctly
4193 ** (3d) the outer query may not be DISTINCT.
4194 ** See also (26) for restrictions on RIGHT JOIN.
4196 ** (4) The subquery can not be DISTINCT.
4198 ** (**) At one point restrictions (4) and (5) defined a subset of DISTINCT
4199 ** sub-queries that were excluded from this optimization. Restriction
4200 ** (4) has since been expanded to exclude all DISTINCT subqueries.
4202 ** (**) We no longer attempt to flatten aggregate subqueries. Was:
4203 ** If the subquery is aggregate, the outer query may not be DISTINCT.
4205 ** (7) The subquery must have a FROM clause. TODO: For subqueries without
4206 ** A FROM clause, consider adding a FROM clause with the special
4207 ** table sqlite_once that consists of a single row containing a
4210 ** (8) If the subquery uses LIMIT then the outer query may not be a join.
4212 ** (9) If the subquery uses LIMIT then the outer query may not be aggregate.
4214 ** (**) Restriction (10) was removed from the code on 2005-02-05 but we
4215 ** accidentally carried the comment forward until 2014-09-15. Original
4216 ** constraint: "If the subquery is aggregate then the outer query
4217 ** may not use LIMIT."
4219 ** (11) The subquery and the outer query may not both have ORDER BY clauses.
4221 ** (**) Not implemented. Subsumed into restriction (3). Was previously
4222 ** a separate restriction deriving from ticket #350.
4224 ** (13) The subquery and outer query may not both use LIMIT.
4226 ** (14) The subquery may not use OFFSET.
4228 ** (15) If the outer query is part of a compound select, then the
4229 ** subquery may not use LIMIT.
4230 ** (See ticket #2339 and ticket [02a8e81d44]).
4232 ** (16) If the outer query is aggregate, then the subquery may not
4233 ** use ORDER BY. (Ticket #2942) This used to not matter
4234 ** until we introduced the group_concat() function.
4236 ** (17) If the subquery is a compound select, then
4237 ** (17a) all compound operators must be a UNION ALL, and
4238 ** (17b) no terms within the subquery compound may be aggregate
4240 ** (17c) every term within the subquery compound must have a FROM clause
4241 ** (17d) the outer query may not be
4242 ** (17d1) aggregate, or
4244 ** (17e) the subquery may not contain window functions, and
4245 ** (17f) the subquery must not be the RHS of a LEFT JOIN.
4246 ** (17g) either the subquery is the first element of the outer
4247 ** query or there are no RIGHT or FULL JOINs in any arm
4248 ** of the subquery. (This is a duplicate of condition (27b).)
4249 ** (17h) The corresponding result set expressions in all arms of the
4250 ** compound must have the same affinity.
4252 ** The parent and sub-query may contain WHERE clauses. Subject to
4253 ** rules (11), (13) and (14), they may also contain ORDER BY,
4254 ** LIMIT and OFFSET clauses. The subquery cannot use any compound
4255 ** operator other than UNION ALL because all the other compound
4256 ** operators have an implied DISTINCT which is disallowed by
4259 ** Also, each component of the sub-query must return the same number
4260 ** of result columns. This is actually a requirement for any compound
4261 ** SELECT statement, but all the code here does is make sure that no
4262 ** such (illegal) sub-query is flattened. The caller will detect the
4263 ** syntax error and return a detailed message.
4265 ** (18) If the sub-query is a compound select, then all terms of the
4266 ** ORDER BY clause of the parent must be copies of a term returned
4267 ** by the parent query.
4269 ** (19) If the subquery uses LIMIT then the outer query may not
4270 ** have a WHERE clause.
4272 ** (20) If the sub-query is a compound select, then it must not use
4273 ** an ORDER BY clause. Ticket #3773. We could relax this constraint
4274 ** somewhat by saying that the terms of the ORDER BY clause must
4275 ** appear as unmodified result columns in the outer query. But we
4276 ** have other optimizations in mind to deal with that case.
4278 ** (21) If the subquery uses LIMIT then the outer query may not be
4279 ** DISTINCT. (See ticket [752e1646fc]).
4281 ** (22) The subquery may not be a recursive CTE.
4283 ** (23) If the outer query is a recursive CTE, then the sub-query may not be
4284 ** a compound query. This restriction is because transforming the
4285 ** parent to a compound query confuses the code that handles
4286 ** recursive queries in multiSelect().
4288 ** (**) We no longer attempt to flatten aggregate subqueries. Was:
4289 ** The subquery may not be an aggregate that uses the built-in min() or
4290 ** or max() functions. (Without this restriction, a query like:
4291 ** "SELECT x FROM (SELECT max(y), x FROM t1)" would not necessarily
4292 ** return the value X for which Y was maximal.)
4294 ** (25) If either the subquery or the parent query contains a window
4295 ** function in the select list or ORDER BY clause, flattening
4296 ** is not attempted.
4298 ** (26) The subquery may not be the right operand of a RIGHT JOIN.
4299 ** See also (3) for restrictions on LEFT JOIN.
4301 ** (27) The subquery may not contain a FULL or RIGHT JOIN unless it
4302 ** is the first element of the parent query. Two subcases:
4303 ** (27a) the subquery is not a compound query.
4304 ** (27b) the subquery is a compound query and the RIGHT JOIN occurs
4305 ** in any arm of the compound query. (See also (17g).)
4307 ** (28) The subquery is not a MATERIALIZED CTE. (This is handled
4308 ** in the caller before ever reaching this routine.)
4311 ** In this routine, the "p" parameter is a pointer to the outer query.
4312 ** The subquery is p->pSrc->a[iFrom]. isAgg is true if the outer query
4315 ** If flattening is not attempted, this routine is a no-op and returns 0.
4316 ** If flattening is attempted this routine returns 1.
4318 ** All of the expression analysis must occur on both the outer query and
4319 ** the subquery before this routine runs.
4321 static int flattenSubquery(
4322 Parse
*pParse
, /* Parsing context */
4323 Select
*p
, /* The parent or outer SELECT statement */
4324 int iFrom
, /* Index in p->pSrc->a[] of the inner subquery */
4325 int isAgg
/* True if outer SELECT uses aggregate functions */
4327 const char *zSavedAuthContext
= pParse
->zAuthContext
;
4328 Select
*pParent
; /* Current UNION ALL term of the other query */
4329 Select
*pSub
; /* The inner query or "subquery" */
4330 Select
*pSub1
; /* Pointer to the rightmost select in sub-query */
4331 SrcList
*pSrc
; /* The FROM clause of the outer query */
4332 SrcList
*pSubSrc
; /* The FROM clause of the subquery */
4333 int iParent
; /* VDBE cursor number of the pSub result set temp table */
4334 int iNewParent
= -1;/* Replacement table for iParent */
4335 int isOuterJoin
= 0; /* True if pSub is the right side of a LEFT JOIN */
4336 int i
; /* Loop counter */
4337 Expr
*pWhere
; /* The WHERE clause */
4338 SrcItem
*pSubitem
; /* The subquery */
4339 sqlite3
*db
= pParse
->db
;
4340 Walker w
; /* Walker to persist agginfo data */
4343 /* Check to see if flattening is permitted. Return 0 if not.
4346 assert( p
->pPrior
==0 );
4347 if( OptimizationDisabled(db
, SQLITE_QueryFlattener
) ) return 0;
4349 assert( pSrc
&& iFrom
>=0 && iFrom
<pSrc
->nSrc
);
4350 pSubitem
= &pSrc
->a
[iFrom
];
4351 iParent
= pSubitem
->iCursor
;
4352 pSub
= pSubitem
->pSelect
;
4355 #ifndef SQLITE_OMIT_WINDOWFUNC
4356 if( p
->pWin
|| pSub
->pWin
) return 0; /* Restriction (25) */
4359 pSubSrc
= pSub
->pSrc
;
4361 /* Prior to version 3.1.2, when LIMIT and OFFSET had to be simple constants,
4362 ** not arbitrary expressions, we allowed some combining of LIMIT and OFFSET
4363 ** because they could be computed at compile-time. But when LIMIT and OFFSET
4364 ** became arbitrary expressions, we were forced to add restrictions (13)
4366 if( pSub
->pLimit
&& p
->pLimit
) return 0; /* Restriction (13) */
4367 if( pSub
->pLimit
&& pSub
->pLimit
->pRight
) return 0; /* Restriction (14) */
4368 if( (p
->selFlags
& SF_Compound
)!=0 && pSub
->pLimit
){
4369 return 0; /* Restriction (15) */
4371 if( pSubSrc
->nSrc
==0 ) return 0; /* Restriction (7) */
4372 if( pSub
->selFlags
& SF_Distinct
) return 0; /* Restriction (4) */
4373 if( pSub
->pLimit
&& (pSrc
->nSrc
>1 || isAgg
) ){
4374 return 0; /* Restrictions (8)(9) */
4376 if( p
->pOrderBy
&& pSub
->pOrderBy
){
4377 return 0; /* Restriction (11) */
4379 if( isAgg
&& pSub
->pOrderBy
) return 0; /* Restriction (16) */
4380 if( pSub
->pLimit
&& p
->pWhere
) return 0; /* Restriction (19) */
4381 if( pSub
->pLimit
&& (p
->selFlags
& SF_Distinct
)!=0 ){
4382 return 0; /* Restriction (21) */
4384 if( pSub
->selFlags
& (SF_Recursive
) ){
4385 return 0; /* Restrictions (22) */
4389 ** If the subquery is the right operand of a LEFT JOIN, then the
4390 ** subquery may not be a join itself (3a). Example of why this is not
4393 ** t1 LEFT OUTER JOIN (t2 JOIN t3)
4395 ** If we flatten the above, we would get
4397 ** (t1 LEFT OUTER JOIN t2) JOIN t3
4399 ** which is not at all the same thing.
4401 ** See also tickets #306, #350, and #3300.
4403 if( (pSubitem
->fg
.jointype
& (JT_OUTER
|JT_LTORJ
))!=0 ){
4404 if( pSubSrc
->nSrc
>1 /* (3a) */
4405 || IsVirtual(pSubSrc
->a
[0].pTab
) /* (3b) */
4406 || (p
->selFlags
& SF_Distinct
)!=0 /* (3d) */
4407 || (pSubitem
->fg
.jointype
& JT_RIGHT
)!=0 /* (26) */
4414 assert( pSubSrc
->nSrc
>0 ); /* True by restriction (7) */
4415 if( iFrom
>0 && (pSubSrc
->a
[0].fg
.jointype
& JT_LTORJ
)!=0 ){
4416 return 0; /* Restriction (27a) */
4419 /* Condition (28) is blocked by the caller */
4420 assert( !pSubitem
->fg
.isCte
|| pSubitem
->u2
.pCteUse
->eM10d
!=M10d_Yes
);
4422 /* Restriction (17): If the sub-query is a compound SELECT, then it must
4423 ** use only the UNION ALL operator. And none of the simple select queries
4424 ** that make up the compound SELECT are allowed to be aggregate or distinct
4429 if( pSub
->pOrderBy
){
4430 return 0; /* Restriction (20) */
4432 if( isAgg
|| (p
->selFlags
& SF_Distinct
)!=0 || isOuterJoin
>0 ){
4433 return 0; /* (17d1), (17d2), or (17f) */
4435 for(pSub1
=pSub
; pSub1
; pSub1
=pSub1
->pPrior
){
4436 testcase( (pSub1
->selFlags
& (SF_Distinct
|SF_Aggregate
))==SF_Distinct
);
4437 testcase( (pSub1
->selFlags
& (SF_Distinct
|SF_Aggregate
))==SF_Aggregate
);
4438 assert( pSub
->pSrc
!=0 );
4439 assert( (pSub
->selFlags
& SF_Recursive
)==0 );
4440 assert( pSub
->pEList
->nExpr
==pSub1
->pEList
->nExpr
);
4441 if( (pSub1
->selFlags
& (SF_Distinct
|SF_Aggregate
))!=0 /* (17b) */
4442 || (pSub1
->pPrior
&& pSub1
->op
!=TK_ALL
) /* (17a) */
4443 || pSub1
->pSrc
->nSrc
<1 /* (17c) */
4444 #ifndef SQLITE_OMIT_WINDOWFUNC
4445 || pSub1
->pWin
/* (17e) */
4450 if( iFrom
>0 && (pSub1
->pSrc
->a
[0].fg
.jointype
& JT_LTORJ
)!=0 ){
4451 /* Without this restriction, the JT_LTORJ flag would end up being
4452 ** omitted on left-hand tables of the right join that is being
4454 return 0; /* Restrictions (17g), (27b) */
4456 testcase( pSub1
->pSrc
->nSrc
>1 );
4459 /* Restriction (18). */
4461 for(ii
=0; ii
<p
->pOrderBy
->nExpr
; ii
++){
4462 if( p
->pOrderBy
->a
[ii
].u
.x
.iOrderByCol
==0 ) return 0;
4466 /* Restriction (23) */
4467 if( (p
->selFlags
& SF_Recursive
) ) return 0;
4469 /* Restriction (17h) */
4470 if( compoundHasDifferentAffinities(pSub
) ) return 0;
4473 if( pParse
->nSelect
>500 ) return 0;
4474 if( OptimizationDisabled(db
, SQLITE_FlttnUnionAll
) ) return 0;
4475 aCsrMap
= sqlite3DbMallocZero(db
, ((i64
)pParse
->nTab
+1)*sizeof(int));
4476 if( aCsrMap
) aCsrMap
[0] = pParse
->nTab
;
4480 /***** If we reach this point, flattening is permitted. *****/
4481 TREETRACE(0x4,pParse
,p
,("flatten %u.%p from term %d\n",
4482 pSub
->selId
, pSub
, iFrom
));
4484 /* Authorize the subquery */
4485 pParse
->zAuthContext
= pSubitem
->zName
;
4486 TESTONLY(i
=) sqlite3AuthCheck(pParse
, SQLITE_SELECT
, 0, 0, 0);
4487 testcase( i
==SQLITE_DENY
);
4488 pParse
->zAuthContext
= zSavedAuthContext
;
4490 /* Delete the transient structures associated with the subquery */
4491 pSub1
= pSubitem
->pSelect
;
4492 sqlite3DbFree(db
, pSubitem
->zDatabase
);
4493 sqlite3DbFree(db
, pSubitem
->zName
);
4494 sqlite3DbFree(db
, pSubitem
->zAlias
);
4495 pSubitem
->zDatabase
= 0;
4496 pSubitem
->zName
= 0;
4497 pSubitem
->zAlias
= 0;
4498 pSubitem
->pSelect
= 0;
4499 assert( pSubitem
->fg
.isUsing
!=0 || pSubitem
->u3
.pOn
==0 );
4501 /* If the sub-query is a compound SELECT statement, then (by restrictions
4502 ** 17 and 18 above) it must be a UNION ALL and the parent query must
4505 ** SELECT <expr-list> FROM (<sub-query>) <where-clause>
4507 ** followed by any ORDER BY, LIMIT and/or OFFSET clauses. This block
4508 ** creates N-1 copies of the parent query without any ORDER BY, LIMIT or
4509 ** OFFSET clauses and joins them to the left-hand-side of the original
4510 ** using UNION ALL operators. In this case N is the number of simple
4511 ** select statements in the compound sub-query.
4515 ** SELECT a+1 FROM (
4516 ** SELECT x FROM tab
4518 ** SELECT y FROM tab
4520 ** SELECT abs(z*2) FROM tab2
4521 ** ) WHERE a!=5 ORDER BY 1
4523 ** Transformed into:
4525 ** SELECT x+1 FROM tab WHERE x+1!=5
4527 ** SELECT y+1 FROM tab WHERE y+1!=5
4529 ** SELECT abs(z*2)+1 FROM tab2 WHERE abs(z*2)+1!=5
4532 ** We call this the "compound-subquery flattening".
4534 for(pSub
=pSub
->pPrior
; pSub
; pSub
=pSub
->pPrior
){
4536 ExprList
*pOrderBy
= p
->pOrderBy
;
4537 Expr
*pLimit
= p
->pLimit
;
4538 Select
*pPrior
= p
->pPrior
;
4539 Table
*pItemTab
= pSubitem
->pTab
;
4544 pNew
= sqlite3SelectDup(db
, p
, 0);
4546 p
->pOrderBy
= pOrderBy
;
4548 pSubitem
->pTab
= pItemTab
;
4552 pNew
->selId
= ++pParse
->nSelect
;
4553 if( aCsrMap
&& ALWAYS(db
->mallocFailed
==0) ){
4554 renumberCursors(pParse
, pNew
, iFrom
, aCsrMap
);
4556 pNew
->pPrior
= pPrior
;
4557 if( pPrior
) pPrior
->pNext
= pNew
;
4560 TREETRACE(0x4,pParse
,p
,("compound-subquery flattener"
4561 " creates %u as peer\n",pNew
->selId
));
4563 assert( pSubitem
->pSelect
==0 );
4565 sqlite3DbFree(db
, aCsrMap
);
4566 if( db
->mallocFailed
){
4567 pSubitem
->pSelect
= pSub1
;
4571 /* Defer deleting the Table object associated with the
4572 ** subquery until code generation is
4573 ** complete, since there may still exist Expr.pTab entries that
4574 ** refer to the subquery even after flattening. Ticket #3346.
4576 ** pSubitem->pTab is always non-NULL by test restrictions and tests above.
4578 if( ALWAYS(pSubitem
->pTab
!=0) ){
4579 Table
*pTabToDel
= pSubitem
->pTab
;
4580 if( pTabToDel
->nTabRef
==1 ){
4581 Parse
*pToplevel
= sqlite3ParseToplevel(pParse
);
4582 sqlite3ParserAddCleanup(pToplevel
, sqlite3DeleteTableGeneric
, pTabToDel
);
4583 testcase( pToplevel
->earlyCleanup
);
4585 pTabToDel
->nTabRef
--;
4590 /* The following loop runs once for each term in a compound-subquery
4591 ** flattening (as described above). If we are doing a different kind
4592 ** of flattening - a flattening other than a compound-subquery flattening -
4593 ** then this loop only runs once.
4595 ** This loop moves all of the FROM elements of the subquery into the
4596 ** the FROM clause of the outer query. Before doing this, remember
4597 ** the cursor number for the original outer query FROM element in
4598 ** iParent. The iParent cursor will never be used. Subsequent code
4599 ** will scan expressions looking for iParent references and replace
4600 ** those references with expressions that resolve to the subquery FROM
4601 ** elements we are now copying in.
4604 for(pParent
=p
; pParent
; pParent
=pParent
->pPrior
, pSub
=pSub
->pPrior
){
4607 u8 ltorj
= pSrc
->a
[iFrom
].fg
.jointype
& JT_LTORJ
;
4609 pSubSrc
= pSub
->pSrc
; /* FROM clause of subquery */
4610 nSubSrc
= pSubSrc
->nSrc
; /* Number of terms in subquery FROM clause */
4611 pSrc
= pParent
->pSrc
; /* FROM clause of the outer query */
4614 jointype
= pSubitem
->fg
.jointype
; /* First time through the loop */
4617 /* The subquery uses a single slot of the FROM clause of the outer
4618 ** query. If the subquery has more than one element in its FROM clause,
4619 ** then expand the outer query to make space for it to hold all elements
4624 ** SELECT * FROM tabA, (SELECT * FROM sub1, sub2), tabB;
4626 ** The outer query has 3 slots in its FROM clause. One slot of the
4627 ** outer query (the middle slot) is used by the subquery. The next
4628 ** block of code will expand the outer query FROM clause to 4 slots.
4629 ** The middle slot is expanded to two slots in order to make space
4630 ** for the two elements in the FROM clause of the subquery.
4633 pSrc
= sqlite3SrcListEnlarge(pParse
, pSrc
, nSubSrc
-1,iFrom
+1);
4634 if( pSrc
==0 ) break;
4635 pParent
->pSrc
= pSrc
;
4638 /* Transfer the FROM clause terms from the subquery into the
4641 for(i
=0; i
<nSubSrc
; i
++){
4642 SrcItem
*pItem
= &pSrc
->a
[i
+iFrom
];
4643 if( pItem
->fg
.isUsing
) sqlite3IdListDelete(db
, pItem
->u3
.pUsing
);
4644 assert( pItem
->fg
.isTabFunc
==0 );
4645 *pItem
= pSubSrc
->a
[i
];
4646 pItem
->fg
.jointype
|= ltorj
;
4647 iNewParent
= pSubSrc
->a
[i
].iCursor
;
4648 memset(&pSubSrc
->a
[i
], 0, sizeof(pSubSrc
->a
[i
]));
4650 pSrc
->a
[iFrom
].fg
.jointype
&= JT_LTORJ
;
4651 pSrc
->a
[iFrom
].fg
.jointype
|= jointype
| ltorj
;
4653 /* Now begin substituting subquery result set expressions for
4654 ** references to the iParent in the outer query.
4658 ** SELECT a+5, b*10 FROM (SELECT x*3 AS a, y+10 AS b FROM t1) WHERE a>b;
4659 ** \ \_____________ subquery __________/ /
4660 ** \_____________________ outer query ______________________________/
4662 ** We look at every expression in the outer query and every place we see
4663 ** "a" we substitute "x*3" and every place we see "b" we substitute "y+10".
4665 if( pSub
->pOrderBy
&& (pParent
->selFlags
& SF_NoopOrderBy
)==0 ){
4666 /* At this point, any non-zero iOrderByCol values indicate that the
4667 ** ORDER BY column expression is identical to the iOrderByCol'th
4668 ** expression returned by SELECT statement pSub. Since these values
4669 ** do not necessarily correspond to columns in SELECT statement pParent,
4670 ** zero them before transferring the ORDER BY clause.
4672 ** Not doing this may cause an error if a subsequent call to this
4673 ** function attempts to flatten a compound sub-query into pParent
4674 ** (the only way this can happen is if the compound sub-query is
4675 ** currently part of pSub->pSrc). See ticket [d11a6e908f]. */
4676 ExprList
*pOrderBy
= pSub
->pOrderBy
;
4677 for(i
=0; i
<pOrderBy
->nExpr
; i
++){
4678 pOrderBy
->a
[i
].u
.x
.iOrderByCol
= 0;
4680 assert( pParent
->pOrderBy
==0 );
4681 pParent
->pOrderBy
= pOrderBy
;
4684 pWhere
= pSub
->pWhere
;
4686 if( isOuterJoin
>0 ){
4687 sqlite3SetJoinExpr(pWhere
, iNewParent
, EP_OuterON
);
4690 if( pParent
->pWhere
){
4691 pParent
->pWhere
= sqlite3PExpr(pParse
, TK_AND
, pWhere
, pParent
->pWhere
);
4693 pParent
->pWhere
= pWhere
;
4696 if( db
->mallocFailed
==0 ){
4700 x
.iNewTable
= iNewParent
;
4701 x
.isOuterJoin
= isOuterJoin
;
4702 x
.pEList
= pSub
->pEList
;
4703 x
.pCList
= findLeftmostExprlist(pSub
);
4704 substSelect(&x
, pParent
, 0);
4707 /* The flattened query is a compound if either the inner or the
4708 ** outer query is a compound. */
4709 pParent
->selFlags
|= pSub
->selFlags
& SF_Compound
;
4710 assert( (pSub
->selFlags
& SF_Distinct
)==0 ); /* restriction (17b) */
4713 ** SELECT ... FROM (SELECT ... LIMIT a OFFSET b) LIMIT x OFFSET y;
4715 ** One is tempted to try to add a and b to combine the limits. But this
4716 ** does not work if either limit is negative.
4719 pParent
->pLimit
= pSub
->pLimit
;
4723 /* Recompute the SrcItem.colUsed masks for the flattened
4725 for(i
=0; i
<nSubSrc
; i
++){
4726 recomputeColumnsUsed(pParent
, &pSrc
->a
[i
+iFrom
]);
4730 /* Finally, delete what is left of the subquery and return success.
4732 sqlite3AggInfoPersistWalkerInit(&w
, pParse
);
4733 sqlite3WalkSelect(&w
,pSub1
);
4734 sqlite3SelectDelete(db
, pSub1
);
4736 #if TREETRACE_ENABLED
4737 if( sqlite3TreeTrace
& 0x4 ){
4738 TREETRACE(0x4,pParse
,p
,("After flattening:\n"));
4739 sqlite3TreeViewSelect(0, p
, 0);
4745 #endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
4748 ** A structure to keep track of all of the column values that are fixed to
4749 ** a known value due to WHERE clause constraints of the form COLUMN=VALUE.
4751 typedef struct WhereConst WhereConst
;
4753 Parse
*pParse
; /* Parsing context */
4754 u8
*pOomFault
; /* Pointer to pParse->db->mallocFailed */
4755 int nConst
; /* Number for COLUMN=CONSTANT terms */
4756 int nChng
; /* Number of times a constant is propagated */
4757 int bHasAffBlob
; /* At least one column in apExpr[] as affinity BLOB */
4758 u32 mExcludeOn
; /* Which ON expressions to exclude from considertion.
4759 ** Either EP_OuterON or EP_InnerON|EP_OuterON */
4760 Expr
**apExpr
; /* [i*2] is COLUMN and [i*2+1] is VALUE */
4764 ** Add a new entry to the pConst object. Except, do not add duplicate
4765 ** pColumn entries. Also, do not add if doing so would not be appropriate.
4767 ** The caller guarantees the pColumn is a column and pValue is a constant.
4768 ** This routine has to do some additional checks before completing the
4771 static void constInsert(
4772 WhereConst
*pConst
, /* The WhereConst into which we are inserting */
4773 Expr
*pColumn
, /* The COLUMN part of the constraint */
4774 Expr
*pValue
, /* The VALUE part of the constraint */
4775 Expr
*pExpr
/* Overall expression: COLUMN=VALUE or VALUE=COLUMN */
4778 assert( pColumn
->op
==TK_COLUMN
);
4779 assert( sqlite3ExprIsConstant(pValue
) );
4781 if( ExprHasProperty(pColumn
, EP_FixedCol
) ) return;
4782 if( sqlite3ExprAffinity(pValue
)!=0 ) return;
4783 if( !sqlite3IsBinary(sqlite3ExprCompareCollSeq(pConst
->pParse
,pExpr
)) ){
4787 /* 2018-10-25 ticket [cf5ed20f]
4788 ** Make sure the same pColumn is not inserted more than once */
4789 for(i
=0; i
<pConst
->nConst
; i
++){
4790 const Expr
*pE2
= pConst
->apExpr
[i
*2];
4791 assert( pE2
->op
==TK_COLUMN
);
4792 if( pE2
->iTable
==pColumn
->iTable
4793 && pE2
->iColumn
==pColumn
->iColumn
4795 return; /* Already present. Return without doing anything. */
4798 if( sqlite3ExprAffinity(pColumn
)==SQLITE_AFF_BLOB
){
4799 pConst
->bHasAffBlob
= 1;
4803 pConst
->apExpr
= sqlite3DbReallocOrFree(pConst
->pParse
->db
, pConst
->apExpr
,
4804 pConst
->nConst
*2*sizeof(Expr
*));
4805 if( pConst
->apExpr
==0 ){
4808 pConst
->apExpr
[pConst
->nConst
*2-2] = pColumn
;
4809 pConst
->apExpr
[pConst
->nConst
*2-1] = pValue
;
4814 ** Find all terms of COLUMN=VALUE or VALUE=COLUMN in pExpr where VALUE
4815 ** is a constant expression and where the term must be true because it
4816 ** is part of the AND-connected terms of the expression. For each term
4817 ** found, add it to the pConst structure.
4819 static void findConstInWhere(WhereConst
*pConst
, Expr
*pExpr
){
4820 Expr
*pRight
, *pLeft
;
4821 if( NEVER(pExpr
==0) ) return;
4822 if( ExprHasProperty(pExpr
, pConst
->mExcludeOn
) ){
4823 testcase( ExprHasProperty(pExpr
, EP_OuterON
) );
4824 testcase( ExprHasProperty(pExpr
, EP_InnerON
) );
4827 if( pExpr
->op
==TK_AND
){
4828 findConstInWhere(pConst
, pExpr
->pRight
);
4829 findConstInWhere(pConst
, pExpr
->pLeft
);
4832 if( pExpr
->op
!=TK_EQ
) return;
4833 pRight
= pExpr
->pRight
;
4834 pLeft
= pExpr
->pLeft
;
4835 assert( pRight
!=0 );
4837 if( pRight
->op
==TK_COLUMN
&& sqlite3ExprIsConstant(pLeft
) ){
4838 constInsert(pConst
,pRight
,pLeft
,pExpr
);
4840 if( pLeft
->op
==TK_COLUMN
&& sqlite3ExprIsConstant(pRight
) ){
4841 constInsert(pConst
,pLeft
,pRight
,pExpr
);
4846 ** This is a helper function for Walker callback propagateConstantExprRewrite().
4848 ** Argument pExpr is a candidate expression to be replaced by a value. If
4849 ** pExpr is equivalent to one of the columns named in pWalker->u.pConst,
4850 ** then overwrite it with the corresponding value. Except, do not do so
4851 ** if argument bIgnoreAffBlob is non-zero and the affinity of pExpr
4852 ** is SQLITE_AFF_BLOB.
4854 static int propagateConstantExprRewriteOne(
4860 if( pConst
->pOomFault
[0] ) return WRC_Prune
;
4861 if( pExpr
->op
!=TK_COLUMN
) return WRC_Continue
;
4862 if( ExprHasProperty(pExpr
, EP_FixedCol
|pConst
->mExcludeOn
) ){
4863 testcase( ExprHasProperty(pExpr
, EP_FixedCol
) );
4864 testcase( ExprHasProperty(pExpr
, EP_OuterON
) );
4865 testcase( ExprHasProperty(pExpr
, EP_InnerON
) );
4866 return WRC_Continue
;
4868 for(i
=0; i
<pConst
->nConst
; i
++){
4869 Expr
*pColumn
= pConst
->apExpr
[i
*2];
4870 if( pColumn
==pExpr
) continue;
4871 if( pColumn
->iTable
!=pExpr
->iTable
) continue;
4872 if( pColumn
->iColumn
!=pExpr
->iColumn
) continue;
4873 if( bIgnoreAffBlob
&& sqlite3ExprAffinity(pColumn
)==SQLITE_AFF_BLOB
){
4876 /* A match is found. Add the EP_FixedCol property */
4878 ExprClearProperty(pExpr
, EP_Leaf
);
4879 ExprSetProperty(pExpr
, EP_FixedCol
);
4880 assert( pExpr
->pLeft
==0 );
4881 pExpr
->pLeft
= sqlite3ExprDup(pConst
->pParse
->db
, pConst
->apExpr
[i
*2+1], 0);
4882 if( pConst
->pParse
->db
->mallocFailed
) return WRC_Prune
;
4889 ** This is a Walker expression callback. pExpr is a node from the WHERE
4890 ** clause of a SELECT statement. This function examines pExpr to see if
4891 ** any substitutions based on the contents of pWalker->u.pConst should
4892 ** be made to pExpr or its immediate children.
4894 ** A substitution is made if:
4896 ** + pExpr is a column with an affinity other than BLOB that matches
4897 ** one of the columns in pWalker->u.pConst, or
4899 ** + pExpr is a binary comparison operator (=, <=, >=, <, >) that
4900 ** uses an affinity other than TEXT and one of its immediate
4901 ** children is a column that matches one of the columns in
4902 ** pWalker->u.pConst.
4904 static int propagateConstantExprRewrite(Walker
*pWalker
, Expr
*pExpr
){
4905 WhereConst
*pConst
= pWalker
->u
.pConst
;
4906 assert( TK_GT
==TK_EQ
+1 );
4907 assert( TK_LE
==TK_EQ
+2 );
4908 assert( TK_LT
==TK_EQ
+3 );
4909 assert( TK_GE
==TK_EQ
+4 );
4910 if( pConst
->bHasAffBlob
){
4911 if( (pExpr
->op
>=TK_EQ
&& pExpr
->op
<=TK_GE
)
4914 propagateConstantExprRewriteOne(pConst
, pExpr
->pLeft
, 0);
4915 if( pConst
->pOomFault
[0] ) return WRC_Prune
;
4916 if( sqlite3ExprAffinity(pExpr
->pLeft
)!=SQLITE_AFF_TEXT
){
4917 propagateConstantExprRewriteOne(pConst
, pExpr
->pRight
, 0);
4921 return propagateConstantExprRewriteOne(pConst
, pExpr
, pConst
->bHasAffBlob
);
4925 ** The WHERE-clause constant propagation optimization.
4927 ** If the WHERE clause contains terms of the form COLUMN=CONSTANT or
4928 ** CONSTANT=COLUMN that are top-level AND-connected terms that are not
4929 ** part of a ON clause from a LEFT JOIN, then throughout the query
4930 ** replace all other occurrences of COLUMN with CONSTANT.
4932 ** For example, the query:
4934 ** SELECT * FROM t1, t2, t3 WHERE t1.a=39 AND t2.b=t1.a AND t3.c=t2.b
4936 ** Is transformed into
4938 ** SELECT * FROM t1, t2, t3 WHERE t1.a=39 AND t2.b=39 AND t3.c=39
4940 ** Return true if any transformations where made and false if not.
4942 ** Implementation note: Constant propagation is tricky due to affinity
4943 ** and collating sequence interactions. Consider this example:
4945 ** CREATE TABLE t1(a INT,b TEXT);
4946 ** INSERT INTO t1 VALUES(123,'0123');
4947 ** SELECT * FROM t1 WHERE a=123 AND b=a;
4948 ** SELECT * FROM t1 WHERE a=123 AND b=123;
4950 ** The two SELECT statements above should return different answers. b=a
4951 ** is always true because the comparison uses numeric affinity, but b=123
4952 ** is false because it uses text affinity and '0123' is not the same as '123'.
4953 ** To work around this, the expression tree is not actually changed from
4954 ** "b=a" to "b=123" but rather the "a" in "b=a" is tagged with EP_FixedCol
4955 ** and the "123" value is hung off of the pLeft pointer. Code generator
4956 ** routines know to generate the constant "123" instead of looking up the
4957 ** column value. Also, to avoid collation problems, this optimization is
4958 ** only attempted if the "a=123" term uses the default BINARY collation.
4960 ** 2021-05-25 forum post 6a06202608: Another troublesome case is...
4962 ** CREATE TABLE t1(x);
4963 ** INSERT INTO t1 VALUES(10.0);
4964 ** SELECT 1 FROM t1 WHERE x=10 AND x LIKE 10;
4966 ** The query should return no rows, because the t1.x value is '10.0' not '10'
4967 ** and '10.0' is not LIKE '10'. But if we are not careful, the first WHERE
4968 ** term "x=10" will cause the second WHERE term to become "10 LIKE 10",
4969 ** resulting in a false positive. To avoid this, constant propagation for
4970 ** columns with BLOB affinity is only allowed if the constant is used with
4971 ** operators ==, <=, <, >=, >, or IS in a way that will cause the correct
4972 ** type conversions to occur. See logic associated with the bHasAffBlob flag
4975 static int propagateConstants(
4976 Parse
*pParse
, /* The parsing context */
4977 Select
*p
/* The query in which to propagate constants */
4983 x
.pOomFault
= &pParse
->db
->mallocFailed
;
4989 if( ALWAYS(p
->pSrc
!=0)
4991 && (p
->pSrc
->a
[0].fg
.jointype
& JT_LTORJ
)!=0
4993 /* Do not propagate constants on any ON clause if there is a
4994 ** RIGHT JOIN anywhere in the query */
4995 x
.mExcludeOn
= EP_InnerON
| EP_OuterON
;
4997 /* Do not propagate constants through the ON clause of a LEFT JOIN */
4998 x
.mExcludeOn
= EP_OuterON
;
5000 findConstInWhere(&x
, p
->pWhere
);
5002 memset(&w
, 0, sizeof(w
));
5004 w
.xExprCallback
= propagateConstantExprRewrite
;
5005 w
.xSelectCallback
= sqlite3SelectWalkNoop
;
5006 w
.xSelectCallback2
= 0;
5009 sqlite3WalkExpr(&w
, p
->pWhere
);
5010 sqlite3DbFree(x
.pParse
->db
, x
.apExpr
);
5017 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
5018 # if !defined(SQLITE_OMIT_WINDOWFUNC)
5020 ** This function is called to determine whether or not it is safe to
5021 ** push WHERE clause expression pExpr down to FROM clause sub-query
5022 ** pSubq, which contains at least one window function. Return 1
5023 ** if it is safe and the expression should be pushed down, or 0
5026 ** It is only safe to push the expression down if it consists only
5027 ** of constants and copies of expressions that appear in the PARTITION
5028 ** BY clause of all window function used by the sub-query. It is safe
5029 ** to filter out entire partitions, but not rows within partitions, as
5030 ** this may change the results of the window functions.
5032 ** At the time this function is called it is guaranteed that
5034 ** * the sub-query uses only one distinct window frame, and
5035 ** * that the window frame has a PARTITION BY clause.
5037 static int pushDownWindowCheck(Parse
*pParse
, Select
*pSubq
, Expr
*pExpr
){
5038 assert( pSubq
->pWin
->pPartition
);
5039 assert( (pSubq
->selFlags
& SF_MultiPart
)==0 );
5040 assert( pSubq
->pPrior
==0 );
5041 return sqlite3ExprIsConstantOrGroupBy(pParse
, pExpr
, pSubq
->pWin
->pPartition
);
5043 # endif /* SQLITE_OMIT_WINDOWFUNC */
5044 #endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
5046 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
5048 ** Make copies of relevant WHERE clause terms of the outer query into
5049 ** the WHERE clause of subquery. Example:
5051 ** SELECT * FROM (SELECT a AS x, c-d AS y FROM t1) WHERE x=5 AND y=10;
5053 ** Transformed into:
5055 ** SELECT * FROM (SELECT a AS x, c-d AS y FROM t1 WHERE a=5 AND c-d=10)
5056 ** WHERE x=5 AND y=10;
5058 ** The hope is that the terms added to the inner query will make it more
5061 ** Do not attempt this optimization if:
5063 ** (1) (** This restriction was removed on 2017-09-29. We used to
5064 ** disallow this optimization for aggregate subqueries, but now
5065 ** it is allowed by putting the extra terms on the HAVING clause.
5066 ** The added HAVING clause is pointless if the subquery lacks
5067 ** a GROUP BY clause. But such a HAVING clause is also harmless
5068 ** so there does not appear to be any reason to add extra logic
5069 ** to suppress it. **)
5071 ** (2) The inner query is the recursive part of a common table expression.
5073 ** (3) The inner query has a LIMIT clause (since the changes to the WHERE
5074 ** clause would change the meaning of the LIMIT).
5076 ** (4) The inner query is the right operand of a LEFT JOIN and the
5077 ** expression to be pushed down does not come from the ON clause
5078 ** on that LEFT JOIN.
5080 ** (5) The WHERE clause expression originates in the ON or USING clause
5081 ** of a LEFT JOIN where iCursor is not the right-hand table of that
5082 ** left join. An example:
5085 ** FROM (SELECT 1 AS a1 UNION ALL SELECT 2) AS aa
5086 ** JOIN (SELECT 1 AS b2 UNION ALL SELECT 2) AS bb ON (a1=b2)
5087 ** LEFT JOIN (SELECT 8 AS c3 UNION ALL SELECT 9) AS cc ON (b2=2);
5089 ** The correct answer is three rows: (1,1,NULL),(2,2,8),(2,2,9).
5090 ** But if the (b2=2) term were to be pushed down into the bb subquery,
5091 ** then the (1,1,NULL) row would be suppressed.
5093 ** (6) Window functions make things tricky as changes to the WHERE clause
5094 ** of the inner query could change the window over which window
5095 ** functions are calculated. Therefore, do not attempt the optimization
5098 ** (6a) The inner query uses multiple incompatible window partitions.
5100 ** (6b) The inner query is a compound and uses window-functions.
5102 ** (6c) The WHERE clause does not consist entirely of constants and
5103 ** copies of expressions found in the PARTITION BY clause of
5104 ** all window-functions used by the sub-query. It is safe to
5105 ** filter out entire partitions, as this does not change the
5106 ** window over which any window-function is calculated.
5108 ** (7) The inner query is a Common Table Expression (CTE) that should
5109 ** be materialized. (This restriction is implemented in the calling
5112 ** (8) If the subquery is a compound that uses UNION, INTERSECT,
5113 ** or EXCEPT, then all of the result set columns for all arms of
5114 ** the compound must use the BINARY collating sequence.
5116 ** (9) All three of the following are true:
5118 ** (9a) The WHERE clause expression originates in the ON or USING clause
5119 ** of a join (either an INNER or an OUTER join), and
5121 ** (9b) The subquery is to the right of the ON/USING clause
5123 ** (9c) There is a RIGHT JOIN (or FULL JOIN) in between the ON/USING
5124 ** clause and the subquery.
5126 ** Without this restriction, the push-down optimization might move
5127 ** the ON/USING filter expression from the left side of a RIGHT JOIN
5128 ** over to the right side, which leads to incorrect answers. See
5129 ** also restriction (6) in sqlite3ExprIsSingleTableConstraint().
5131 ** (10) The inner query is not the right-hand table of a RIGHT JOIN.
5133 ** (11) The subquery is not a VALUES clause
5135 ** Return 0 if no changes are made and non-zero if one or more WHERE clause
5136 ** terms are duplicated into the subquery.
5138 static int pushDownWhereTerms(
5139 Parse
*pParse
, /* Parse context (for malloc() and error reporting) */
5140 Select
*pSubq
, /* The subquery whose WHERE clause is to be augmented */
5141 Expr
*pWhere
, /* The WHERE clause of the outer query */
5142 SrcList
*pSrcList
, /* The complete from clause of the outer query */
5143 int iSrc
/* Which FROM clause term to try to push into */
5146 SrcItem
*pSrc
; /* The subquery FROM term into which WHERE is pushed */
5148 pSrc
= &pSrcList
->a
[iSrc
];
5149 if( pWhere
==0 ) return 0;
5150 if( pSubq
->selFlags
& (SF_Recursive
|SF_MultiPart
) ){
5151 return 0; /* restrictions (2) and (11) */
5153 if( pSrc
->fg
.jointype
& (JT_LTORJ
|JT_RIGHT
) ){
5154 return 0; /* restrictions (10) */
5157 if( pSubq
->pPrior
){
5159 int notUnionAll
= 0;
5160 for(pSel
=pSubq
; pSel
; pSel
=pSel
->pPrior
){
5162 assert( op
==TK_ALL
|| op
==TK_SELECT
5163 || op
==TK_UNION
|| op
==TK_INTERSECT
|| op
==TK_EXCEPT
);
5164 if( op
!=TK_ALL
&& op
!=TK_SELECT
){
5167 #ifndef SQLITE_OMIT_WINDOWFUNC
5168 if( pSel
->pWin
) return 0; /* restriction (6b) */
5172 /* If any of the compound arms are connected using UNION, INTERSECT,
5173 ** or EXCEPT, then we must ensure that none of the columns use a
5174 ** non-BINARY collating sequence. */
5175 for(pSel
=pSubq
; pSel
; pSel
=pSel
->pPrior
){
5177 const ExprList
*pList
= pSel
->pEList
;
5179 for(ii
=0; ii
<pList
->nExpr
; ii
++){
5180 CollSeq
*pColl
= sqlite3ExprCollSeq(pParse
, pList
->a
[ii
].pExpr
);
5181 if( !sqlite3IsBinary(pColl
) ){
5182 return 0; /* Restriction (8) */
5188 #ifndef SQLITE_OMIT_WINDOWFUNC
5189 if( pSubq
->pWin
&& pSubq
->pWin
->pPartition
==0 ) return 0;
5194 /* Only the first term of a compound can have a WITH clause. But make
5195 ** sure no other terms are marked SF_Recursive in case something changes
5200 for(pX
=pSubq
; pX
; pX
=pX
->pPrior
){
5201 assert( (pX
->selFlags
& (SF_Recursive
))==0 );
5206 if( pSubq
->pLimit
!=0 ){
5207 return 0; /* restriction (3) */
5209 while( pWhere
->op
==TK_AND
){
5210 nChng
+= pushDownWhereTerms(pParse
, pSubq
, pWhere
->pRight
, pSrcList
, iSrc
);
5211 pWhere
= pWhere
->pLeft
;
5214 #if 0 /* These checks now done by sqlite3ExprIsSingleTableConstraint() */
5215 if( ExprHasProperty(pWhere
, EP_OuterON
|EP_InnerON
) /* (9a) */
5216 && (pSrcList
->a
[0].fg
.jointype
& JT_LTORJ
)!=0 /* Fast pre-test of (9c) */
5219 for(jj
=0; jj
<iSrc
; jj
++){
5220 if( pWhere
->w
.iJoin
==pSrcList
->a
[jj
].iCursor
){
5221 /* If we reach this point, both (9a) and (9b) are satisfied.
5222 ** The following loop checks (9c):
5224 for(jj
++; jj
<iSrc
; jj
++){
5225 if( (pSrcList
->a
[jj
].fg
.jointype
& JT_RIGHT
)!=0 ){
5226 return 0; /* restriction (9) */
5233 && (ExprHasProperty(pWhere
,EP_OuterON
)==0
5234 || pWhere
->w
.iJoin
!=iCursor
)
5236 return 0; /* restriction (4) */
5238 if( ExprHasProperty(pWhere
,EP_OuterON
)
5239 && pWhere
->w
.iJoin
!=iCursor
5241 return 0; /* restriction (5) */
5245 if( sqlite3ExprIsSingleTableConstraint(pWhere
, pSrcList
, iSrc
) ){
5247 pSubq
->selFlags
|= SF_PushDown
;
5250 pNew
= sqlite3ExprDup(pParse
->db
, pWhere
, 0);
5251 unsetJoinExpr(pNew
, -1, 1);
5253 x
.iTable
= pSrc
->iCursor
;
5254 x
.iNewTable
= pSrc
->iCursor
;
5256 x
.pEList
= pSubq
->pEList
;
5257 x
.pCList
= findLeftmostExprlist(pSubq
);
5258 pNew
= substExpr(&x
, pNew
);
5259 #ifndef SQLITE_OMIT_WINDOWFUNC
5260 if( pSubq
->pWin
&& 0==pushDownWindowCheck(pParse
, pSubq
, pNew
) ){
5261 /* Restriction 6c has prevented push-down in this case */
5262 sqlite3ExprDelete(pParse
->db
, pNew
);
5267 if( pSubq
->selFlags
& SF_Aggregate
){
5268 pSubq
->pHaving
= sqlite3ExprAnd(pParse
, pSubq
->pHaving
, pNew
);
5270 pSubq
->pWhere
= sqlite3ExprAnd(pParse
, pSubq
->pWhere
, pNew
);
5272 pSubq
= pSubq
->pPrior
;
5277 #endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
5280 ** Check to see if a subquery contains result-set columns that are
5281 ** never used. If it does, change the value of those result-set columns
5282 ** to NULL so that they do not cause unnecessary work to compute.
5284 ** Return the number of column that were changed to NULL.
5286 static int disableUnusedSubqueryResultColumns(SrcItem
*pItem
){
5288 Select
*pSub
; /* The subquery to be simplified */
5289 Select
*pX
; /* For looping over compound elements of pSub */
5290 Table
*pTab
; /* The table that describes the subquery */
5291 int j
; /* Column number */
5292 int nChng
= 0; /* Number of columns converted to NULL */
5293 Bitmask colUsed
; /* Columns that may not be NULLed out */
5296 if( pItem
->fg
.isCorrelated
|| pItem
->fg
.isCte
){
5299 assert( pItem
->pTab
!=0 );
5301 assert( pItem
->pSelect
!=0 );
5302 pSub
= pItem
->pSelect
;
5303 assert( pSub
->pEList
->nExpr
==pTab
->nCol
);
5304 for(pX
=pSub
; pX
; pX
=pX
->pPrior
){
5305 if( (pX
->selFlags
& (SF_Distinct
|SF_Aggregate
))!=0 ){
5306 testcase( pX
->selFlags
& SF_Distinct
);
5307 testcase( pX
->selFlags
& SF_Aggregate
);
5310 if( pX
->pPrior
&& pX
->op
!=TK_ALL
){
5311 /* This optimization does not work for compound subqueries that
5312 ** use UNION, INTERSECT, or EXCEPT. Only UNION ALL is allowed. */
5315 #ifndef SQLITE_OMIT_WINDOWFUNC
5317 /* This optimization does not work for subqueries that use window
5323 colUsed
= pItem
->colUsed
;
5324 if( pSub
->pOrderBy
){
5325 ExprList
*pList
= pSub
->pOrderBy
;
5326 for(j
=0; j
<pList
->nExpr
; j
++){
5327 u16 iCol
= pList
->a
[j
].u
.x
.iOrderByCol
;
5330 colUsed
|= ((Bitmask
)1)<<(iCol
>=BMS
? BMS
-1 : iCol
);
5335 for(j
=0; j
<nCol
; j
++){
5336 Bitmask m
= j
<BMS
-1 ? MASKBIT(j
) : TOPBIT
;
5337 if( (m
& colUsed
)!=0 ) continue;
5338 for(pX
=pSub
; pX
; pX
=pX
->pPrior
) {
5339 Expr
*pY
= pX
->pEList
->a
[j
].pExpr
;
5340 if( pY
->op
==TK_NULL
) continue;
5342 ExprClearProperty(pY
, EP_Skip
|EP_Unlikely
);
5343 pX
->selFlags
|= SF_PushDown
;
5352 ** The pFunc is the only aggregate function in the query. Check to see
5353 ** if the query is a candidate for the min/max optimization.
5355 ** If the query is a candidate for the min/max optimization, then set
5356 ** *ppMinMax to be an ORDER BY clause to be used for the optimization
5357 ** and return either WHERE_ORDERBY_MIN or WHERE_ORDERBY_MAX depending on
5358 ** whether pFunc is a min() or max() function.
5360 ** If the query is not a candidate for the min/max optimization, return
5361 ** WHERE_ORDERBY_NORMAL (which must be zero).
5363 ** This routine must be called after aggregate functions have been
5364 ** located but before their arguments have been subjected to aggregate
5367 static u8
minMaxQuery(sqlite3
*db
, Expr
*pFunc
, ExprList
**ppMinMax
){
5368 int eRet
= WHERE_ORDERBY_NORMAL
; /* Return value */
5369 ExprList
*pEList
; /* Arguments to agg function */
5370 const char *zFunc
; /* Name of aggregate function pFunc */
5374 assert( *ppMinMax
==0 );
5375 assert( pFunc
->op
==TK_AGG_FUNCTION
);
5376 assert( !IsWindowFunc(pFunc
) );
5377 assert( ExprUseXList(pFunc
) );
5378 pEList
= pFunc
->x
.pList
;
5381 || ExprHasProperty(pFunc
, EP_WinFunc
)
5382 || OptimizationDisabled(db
, SQLITE_MinMaxOpt
)
5386 assert( !ExprHasProperty(pFunc
, EP_IntValue
) );
5387 zFunc
= pFunc
->u
.zToken
;
5388 if( sqlite3StrICmp(zFunc
, "min")==0 ){
5389 eRet
= WHERE_ORDERBY_MIN
;
5390 if( sqlite3ExprCanBeNull(pEList
->a
[0].pExpr
) ){
5391 sortFlags
= KEYINFO_ORDER_BIGNULL
;
5393 }else if( sqlite3StrICmp(zFunc
, "max")==0 ){
5394 eRet
= WHERE_ORDERBY_MAX
;
5395 sortFlags
= KEYINFO_ORDER_DESC
;
5399 *ppMinMax
= pOrderBy
= sqlite3ExprListDup(db
, pEList
, 0);
5400 assert( pOrderBy
!=0 || db
->mallocFailed
);
5401 if( pOrderBy
) pOrderBy
->a
[0].fg
.sortFlags
= sortFlags
;
5406 ** The select statement passed as the first argument is an aggregate query.
5407 ** The second argument is the associated aggregate-info object. This
5408 ** function tests if the SELECT is of the form:
5410 ** SELECT count(*) FROM <tbl>
5412 ** where table is a database table, not a sub-select or view. If the query
5413 ** does match this pattern, then a pointer to the Table object representing
5414 ** <tbl> is returned. Otherwise, NULL is returned.
5416 ** This routine checks to see if it is safe to use the count optimization.
5417 ** A correct answer is still obtained (though perhaps more slowly) if
5418 ** this routine returns NULL when it could have returned a table pointer.
5419 ** But returning the pointer when NULL should have been returned can
5420 ** result in incorrect answers and/or crashes. So, when in doubt, return NULL.
5422 static Table
*isSimpleCount(Select
*p
, AggInfo
*pAggInfo
){
5426 assert( !p
->pGroupBy
);
5429 || p
->pEList
->nExpr
!=1
5431 || p
->pSrc
->a
[0].pSelect
5432 || pAggInfo
->nFunc
!=1
5437 pTab
= p
->pSrc
->a
[0].pTab
;
5439 assert( !IsView(pTab
) );
5440 if( !IsOrdinaryTable(pTab
) ) return 0;
5441 pExpr
= p
->pEList
->a
[0].pExpr
;
5443 if( pExpr
->op
!=TK_AGG_FUNCTION
) return 0;
5444 if( pExpr
->pAggInfo
!=pAggInfo
) return 0;
5445 if( (pAggInfo
->aFunc
[0].pFunc
->funcFlags
&SQLITE_FUNC_COUNT
)==0 ) return 0;
5446 assert( pAggInfo
->aFunc
[0].pFExpr
==pExpr
);
5447 testcase( ExprHasProperty(pExpr
, EP_Distinct
) );
5448 testcase( ExprHasProperty(pExpr
, EP_WinFunc
) );
5449 if( ExprHasProperty(pExpr
, EP_Distinct
|EP_WinFunc
) ) return 0;
5455 ** If the source-list item passed as an argument was augmented with an
5456 ** INDEXED BY clause, then try to locate the specified index. If there
5457 ** was such a clause and the named index cannot be found, return
5458 ** SQLITE_ERROR and leave an error in pParse. Otherwise, populate
5459 ** pFrom->pIndex and return SQLITE_OK.
5461 int sqlite3IndexedByLookup(Parse
*pParse
, SrcItem
*pFrom
){
5462 Table
*pTab
= pFrom
->pTab
;
5463 char *zIndexedBy
= pFrom
->u1
.zIndexedBy
;
5466 assert( pFrom
->fg
.isIndexedBy
!=0 );
5468 for(pIdx
=pTab
->pIndex
;
5469 pIdx
&& sqlite3StrICmp(pIdx
->zName
, zIndexedBy
);
5473 sqlite3ErrorMsg(pParse
, "no such index: %s", zIndexedBy
, 0);
5474 pParse
->checkSchema
= 1;
5475 return SQLITE_ERROR
;
5477 assert( pFrom
->fg
.isCte
==0 );
5478 pFrom
->u2
.pIBIndex
= pIdx
;
5483 ** Detect compound SELECT statements that use an ORDER BY clause with
5484 ** an alternative collating sequence.
5486 ** SELECT ... FROM t1 EXCEPT SELECT ... FROM t2 ORDER BY .. COLLATE ...
5488 ** These are rewritten as a subquery:
5490 ** SELECT * FROM (SELECT ... FROM t1 EXCEPT SELECT ... FROM t2)
5491 ** ORDER BY ... COLLATE ...
5493 ** This transformation is necessary because the multiSelectOrderBy() routine
5494 ** above that generates the code for a compound SELECT with an ORDER BY clause
5495 ** uses a merge algorithm that requires the same collating sequence on the
5496 ** result columns as on the ORDER BY clause. See ticket
5497 ** http://www.sqlite.org/src/info/6709574d2a
5499 ** This transformation is only needed for EXCEPT, INTERSECT, and UNION.
5500 ** The UNION ALL operator works fine with multiSelectOrderBy() even when
5501 ** there are COLLATE terms in the ORDER BY.
5503 static int convertCompoundSelectToSubquery(Walker
*pWalker
, Select
*p
){
5508 struct ExprList_item
*a
;
5513 if( p
->pPrior
==0 ) return WRC_Continue
;
5514 if( p
->pOrderBy
==0 ) return WRC_Continue
;
5515 for(pX
=p
; pX
&& (pX
->op
==TK_ALL
|| pX
->op
==TK_SELECT
); pX
=pX
->pPrior
){}
5516 if( pX
==0 ) return WRC_Continue
;
5518 #ifndef SQLITE_OMIT_WINDOWFUNC
5519 /* If iOrderByCol is already non-zero, then it has already been matched
5520 ** to a result column of the SELECT statement. This occurs when the
5521 ** SELECT is rewritten for window-functions processing and then passed
5522 ** to sqlite3SelectPrep() and similar a second time. The rewriting done
5523 ** by this function is not required in this case. */
5524 if( a
[0].u
.x
.iOrderByCol
) return WRC_Continue
;
5526 for(i
=p
->pOrderBy
->nExpr
-1; i
>=0; i
--){
5527 if( a
[i
].pExpr
->flags
& EP_Collate
) break;
5529 if( i
<0 ) return WRC_Continue
;
5531 /* If we reach this point, that means the transformation is required. */
5533 pParse
= pWalker
->pParse
;
5535 pNew
= sqlite3DbMallocZero(db
, sizeof(*pNew
) );
5536 if( pNew
==0 ) return WRC_Abort
;
5537 memset(&dummy
, 0, sizeof(dummy
));
5538 pNewSrc
= sqlite3SrcListAppendFromTerm(pParse
,0,0,0,&dummy
,pNew
,0);
5539 if( pNewSrc
==0 ) return WRC_Abort
;
5542 p
->pEList
= sqlite3ExprListAppend(pParse
, 0, sqlite3Expr(db
, TK_ASTERISK
, 0));
5551 #ifndef SQLITE_OMIT_WINDOWFUNC
5554 p
->selFlags
&= ~SF_Compound
;
5555 assert( (p
->selFlags
& SF_Converted
)==0 );
5556 p
->selFlags
|= SF_Converted
;
5557 assert( pNew
->pPrior
!=0 );
5558 pNew
->pPrior
->pNext
= pNew
;
5560 return WRC_Continue
;
5564 ** Check to see if the FROM clause term pFrom has table-valued function
5565 ** arguments. If it does, leave an error message in pParse and return
5566 ** non-zero, since pFrom is not allowed to be a table-valued function.
5568 static int cannotBeFunction(Parse
*pParse
, SrcItem
*pFrom
){
5569 if( pFrom
->fg
.isTabFunc
){
5570 sqlite3ErrorMsg(pParse
, "'%s' is not a function", pFrom
->zName
);
5576 #ifndef SQLITE_OMIT_CTE
5578 ** Argument pWith (which may be NULL) points to a linked list of nested
5579 ** WITH contexts, from inner to outermost. If the table identified by
5580 ** FROM clause element pItem is really a common-table-expression (CTE)
5581 ** then return a pointer to the CTE definition for that table. Otherwise
5584 ** If a non-NULL value is returned, set *ppContext to point to the With
5585 ** object that the returned CTE belongs to.
5587 static struct Cte
*searchWith(
5588 With
*pWith
, /* Current innermost WITH clause */
5589 SrcItem
*pItem
, /* FROM clause element to resolve */
5590 With
**ppContext
/* OUT: WITH clause return value belongs to */
5592 const char *zName
= pItem
->zName
;
5594 assert( pItem
->zDatabase
==0 );
5596 for(p
=pWith
; p
; p
=p
->pOuter
){
5598 for(i
=0; i
<p
->nCte
; i
++){
5599 if( sqlite3StrICmp(zName
, p
->a
[i
].zName
)==0 ){
5604 if( p
->bView
) break;
5609 /* The code generator maintains a stack of active WITH clauses
5610 ** with the inner-most WITH clause being at the top of the stack.
5612 ** This routine pushes the WITH clause passed as the second argument
5613 ** onto the top of the stack. If argument bFree is true, then this
5614 ** WITH clause will never be popped from the stack but should instead
5615 ** be freed along with the Parse object. In other cases, when
5616 ** bFree==0, the With object will be freed along with the SELECT
5617 ** statement with which it is associated.
5619 ** This routine returns a copy of pWith. Or, if bFree is true and
5620 ** the pWith object is destroyed immediately due to an OOM condition,
5621 ** then this routine return NULL.
5623 ** If bFree is true, do not continue to use the pWith pointer after
5624 ** calling this routine, Instead, use only the return value.
5626 With
*sqlite3WithPush(Parse
*pParse
, With
*pWith
, u8 bFree
){
5629 pWith
= (With
*)sqlite3ParserAddCleanup(pParse
, sqlite3WithDeleteGeneric
,
5631 if( pWith
==0 ) return 0;
5633 if( pParse
->nErr
==0 ){
5634 assert( pParse
->pWith
!=pWith
);
5635 pWith
->pOuter
= pParse
->pWith
;
5636 pParse
->pWith
= pWith
;
5643 ** This function checks if argument pFrom refers to a CTE declared by
5644 ** a WITH clause on the stack currently maintained by the parser (on the
5645 ** pParse->pWith linked list). And if currently processing a CTE
5646 ** CTE expression, through routine checks to see if the reference is
5647 ** a recursive reference to the CTE.
5649 ** If pFrom matches a CTE according to either of these two above, pFrom->pTab
5650 ** and other fields are populated accordingly.
5652 ** Return 0 if no match is found.
5653 ** Return 1 if a match is found.
5654 ** Return 2 if an error condition is detected.
5656 static int resolveFromTermToCte(
5657 Parse
*pParse
, /* The parsing context */
5658 Walker
*pWalker
, /* Current tree walker */
5659 SrcItem
*pFrom
/* The FROM clause term to check */
5661 Cte
*pCte
; /* Matched CTE (or NULL if no match) */
5662 With
*pWith
; /* The matching WITH */
5664 assert( pFrom
->pTab
==0 );
5665 if( pParse
->pWith
==0 ){
5666 /* There are no WITH clauses in the stack. No match is possible */
5670 /* Prior errors might have left pParse->pWith in a goofy state, so
5671 ** go no further. */
5674 if( pFrom
->zDatabase
!=0 ){
5675 /* The FROM term contains a schema qualifier (ex: main.t1) and so
5676 ** it cannot possibly be a CTE reference. */
5679 if( pFrom
->fg
.notCte
){
5680 /* The FROM term is specifically excluded from matching a CTE.
5681 ** (1) It is part of a trigger that used to have zDatabase but had
5682 ** zDatabase removed by sqlite3FixTriggerStep().
5683 ** (2) This is the first term in the FROM clause of an UPDATE.
5687 pCte
= searchWith(pParse
->pWith
, pFrom
, &pWith
);
5689 sqlite3
*db
= pParse
->db
;
5693 Select
*pLeft
; /* Left-most SELECT statement */
5694 Select
*pRecTerm
; /* Left-most recursive term */
5695 int bMayRecursive
; /* True if compound joined by UNION [ALL] */
5696 With
*pSavedWith
; /* Initial value of pParse->pWith */
5697 int iRecTab
= -1; /* Cursor for recursive table */
5700 /* If pCte->zCteErr is non-NULL at this point, then this is an illegal
5701 ** recursive reference to CTE pCte. Leave an error in pParse and return
5702 ** early. If pCte->zCteErr is NULL, then this is not a recursive reference.
5703 ** In this case, proceed. */
5704 if( pCte
->zCteErr
){
5705 sqlite3ErrorMsg(pParse
, pCte
->zCteErr
, pCte
->zName
);
5708 if( cannotBeFunction(pParse
, pFrom
) ) return 2;
5710 assert( pFrom
->pTab
==0 );
5711 pTab
= sqlite3DbMallocZero(db
, sizeof(Table
));
5712 if( pTab
==0 ) return 2;
5713 pCteUse
= pCte
->pUse
;
5715 pCte
->pUse
= pCteUse
= sqlite3DbMallocZero(db
, sizeof(pCteUse
[0]));
5717 || sqlite3ParserAddCleanup(pParse
,sqlite3DbFree
,pCteUse
)==0
5719 sqlite3DbFree(db
, pTab
);
5722 pCteUse
->eM10d
= pCte
->eM10d
;
5726 pTab
->zName
= sqlite3DbStrDup(db
, pCte
->zName
);
5728 pTab
->nRowLogEst
= 200; assert( 200==sqlite3LogEst(1048576) );
5729 pTab
->tabFlags
|= TF_Ephemeral
| TF_NoVisibleRowid
;
5730 pFrom
->pSelect
= sqlite3SelectDup(db
, pCte
->pSelect
, 0);
5731 if( db
->mallocFailed
) return 2;
5732 pFrom
->pSelect
->selFlags
|= SF_CopyCte
;
5733 assert( pFrom
->pSelect
);
5734 if( pFrom
->fg
.isIndexedBy
){
5735 sqlite3ErrorMsg(pParse
, "no such index: \"%s\"", pFrom
->u1
.zIndexedBy
);
5738 pFrom
->fg
.isCte
= 1;
5739 pFrom
->u2
.pCteUse
= pCteUse
;
5742 /* Check if this is a recursive CTE. */
5743 pRecTerm
= pSel
= pFrom
->pSelect
;
5744 bMayRecursive
= ( pSel
->op
==TK_ALL
|| pSel
->op
==TK_UNION
);
5745 while( bMayRecursive
&& pRecTerm
->op
==pSel
->op
){
5747 SrcList
*pSrc
= pRecTerm
->pSrc
;
5748 assert( pRecTerm
->pPrior
!=0 );
5749 for(i
=0; i
<pSrc
->nSrc
; i
++){
5750 SrcItem
*pItem
= &pSrc
->a
[i
];
5751 if( pItem
->zDatabase
==0
5753 && 0==sqlite3StrICmp(pItem
->zName
, pCte
->zName
)
5757 pItem
->fg
.isRecursive
= 1;
5758 if( pRecTerm
->selFlags
& SF_Recursive
){
5759 sqlite3ErrorMsg(pParse
,
5760 "multiple references to recursive table: %s", pCte
->zName
5764 pRecTerm
->selFlags
|= SF_Recursive
;
5765 if( iRecTab
<0 ) iRecTab
= pParse
->nTab
++;
5766 pItem
->iCursor
= iRecTab
;
5769 if( (pRecTerm
->selFlags
& SF_Recursive
)==0 ) break;
5770 pRecTerm
= pRecTerm
->pPrior
;
5773 pCte
->zCteErr
= "circular reference: %s";
5774 pSavedWith
= pParse
->pWith
;
5775 pParse
->pWith
= pWith
;
5776 if( pSel
->selFlags
& SF_Recursive
){
5778 assert( pRecTerm
!=0 );
5779 assert( (pRecTerm
->selFlags
& SF_Recursive
)==0 );
5780 assert( pRecTerm
->pNext
!=0 );
5781 assert( (pRecTerm
->pNext
->selFlags
& SF_Recursive
)!=0 );
5782 assert( pRecTerm
->pWith
==0 );
5783 pRecTerm
->pWith
= pSel
->pWith
;
5784 rc
= sqlite3WalkSelect(pWalker
, pRecTerm
);
5785 pRecTerm
->pWith
= 0;
5787 pParse
->pWith
= pSavedWith
;
5791 if( sqlite3WalkSelect(pWalker
, pSel
) ){
5792 pParse
->pWith
= pSavedWith
;
5796 pParse
->pWith
= pWith
;
5798 for(pLeft
=pSel
; pLeft
->pPrior
; pLeft
=pLeft
->pPrior
);
5799 pEList
= pLeft
->pEList
;
5801 if( pEList
&& pEList
->nExpr
!=pCte
->pCols
->nExpr
){
5802 sqlite3ErrorMsg(pParse
, "table %s has %d values for %d columns",
5803 pCte
->zName
, pEList
->nExpr
, pCte
->pCols
->nExpr
5805 pParse
->pWith
= pSavedWith
;
5808 pEList
= pCte
->pCols
;
5811 sqlite3ColumnsFromExprList(pParse
, pEList
, &pTab
->nCol
, &pTab
->aCol
);
5812 if( bMayRecursive
){
5813 if( pSel
->selFlags
& SF_Recursive
){
5814 pCte
->zCteErr
= "multiple recursive references: %s";
5816 pCte
->zCteErr
= "recursive reference in a subquery: %s";
5818 sqlite3WalkSelect(pWalker
, pSel
);
5821 pParse
->pWith
= pSavedWith
;
5822 return 1; /* Success */
5824 return 0; /* No match */
5828 #ifndef SQLITE_OMIT_CTE
5830 ** If the SELECT passed as the second argument has an associated WITH
5831 ** clause, pop it from the stack stored as part of the Parse object.
5833 ** This function is used as the xSelectCallback2() callback by
5834 ** sqlite3SelectExpand() when walking a SELECT tree to resolve table
5835 ** names and other FROM clause elements.
5837 void sqlite3SelectPopWith(Walker
*pWalker
, Select
*p
){
5838 Parse
*pParse
= pWalker
->pParse
;
5839 if( OK_IF_ALWAYS_TRUE(pParse
->pWith
) && p
->pPrior
==0 ){
5840 With
*pWith
= findRightmost(p
)->pWith
;
5842 assert( pParse
->pWith
==pWith
|| pParse
->nErr
);
5843 pParse
->pWith
= pWith
->pOuter
;
5850 ** The SrcItem structure passed as the second argument represents a
5851 ** sub-query in the FROM clause of a SELECT statement. This function
5852 ** allocates and populates the SrcItem.pTab object. If successful,
5853 ** SQLITE_OK is returned. Otherwise, if an OOM error is encountered,
5856 int sqlite3ExpandSubquery(Parse
*pParse
, SrcItem
*pFrom
){
5857 Select
*pSel
= pFrom
->pSelect
;
5861 pFrom
->pTab
= pTab
= sqlite3DbMallocZero(pParse
->db
, sizeof(Table
));
5862 if( pTab
==0 ) return SQLITE_NOMEM
;
5864 if( pFrom
->zAlias
){
5865 pTab
->zName
= sqlite3DbStrDup(pParse
->db
, pFrom
->zAlias
);
5867 pTab
->zName
= sqlite3MPrintf(pParse
->db
, "%!S", pFrom
);
5869 while( pSel
->pPrior
){ pSel
= pSel
->pPrior
; }
5870 sqlite3ColumnsFromExprList(pParse
, pSel
->pEList
,&pTab
->nCol
,&pTab
->aCol
);
5872 pTab
->nRowLogEst
= 200; assert( 200==sqlite3LogEst(1048576) );
5873 #ifndef SQLITE_ALLOW_ROWID_IN_VIEW
5874 /* The usual case - do not allow ROWID on a subquery */
5875 pTab
->tabFlags
|= TF_Ephemeral
| TF_NoVisibleRowid
;
5877 pTab
->tabFlags
|= TF_Ephemeral
; /* Legacy compatibility mode */
5879 return pParse
->nErr
? SQLITE_ERROR
: SQLITE_OK
;
5884 ** Check the N SrcItem objects to the right of pBase. (N might be zero!)
5885 ** If any of those SrcItem objects have a USING clause containing zName
5886 ** then return true.
5888 ** If N is zero, or none of the N SrcItem objects to the right of pBase
5889 ** contains a USING clause, or if none of the USING clauses contain zName,
5890 ** then return false.
5892 static int inAnyUsingClause(
5893 const char *zName
, /* Name we are looking for */
5894 SrcItem
*pBase
, /* The base SrcItem. Looking at pBase[1] and following */
5895 int N
/* How many SrcItems to check */
5900 if( pBase
->fg
.isUsing
==0 ) continue;
5901 if( NEVER(pBase
->u3
.pUsing
==0) ) continue;
5902 if( sqlite3IdListIndex(pBase
->u3
.pUsing
, zName
)>=0 ) return 1;
5909 ** This routine is a Walker callback for "expanding" a SELECT statement.
5910 ** "Expanding" means to do the following:
5912 ** (1) Make sure VDBE cursor numbers have been assigned to every
5913 ** element of the FROM clause.
5915 ** (2) Fill in the pTabList->a[].pTab fields in the SrcList that
5916 ** defines FROM clause. When views appear in the FROM clause,
5917 ** fill pTabList->a[].pSelect with a copy of the SELECT statement
5918 ** that implements the view. A copy is made of the view's SELECT
5919 ** statement so that we can freely modify or delete that statement
5920 ** without worrying about messing up the persistent representation
5923 ** (3) Add terms to the WHERE clause to accommodate the NATURAL keyword
5924 ** on joins and the ON and USING clause of joins.
5926 ** (4) Scan the list of columns in the result set (pEList) looking
5927 ** for instances of the "*" operator or the TABLE.* operator.
5928 ** If found, expand each "*" to be every column in every table
5929 ** and TABLE.* to be every column in TABLE.
5932 static int selectExpander(Walker
*pWalker
, Select
*p
){
5933 Parse
*pParse
= pWalker
->pParse
;
5938 sqlite3
*db
= pParse
->db
;
5939 Expr
*pE
, *pRight
, *pExpr
;
5940 u16 selFlags
= p
->selFlags
;
5943 p
->selFlags
|= SF_Expanded
;
5944 if( db
->mallocFailed
){
5947 assert( p
->pSrc
!=0 );
5948 if( (selFlags
& SF_Expanded
)!=0 ){
5951 if( pWalker
->eCode
){
5952 /* Renumber selId because it has been copied from a view */
5953 p
->selId
= ++pParse
->nSelect
;
5957 if( pParse
->pWith
&& (p
->selFlags
& SF_View
) ){
5959 p
->pWith
= (With
*)sqlite3DbMallocZero(db
, sizeof(With
));
5964 p
->pWith
->bView
= 1;
5966 sqlite3WithPush(pParse
, p
->pWith
, 0);
5968 /* Make sure cursor numbers have been assigned to all entries in
5969 ** the FROM clause of the SELECT statement.
5971 sqlite3SrcListAssignCursors(pParse
, pTabList
);
5973 /* Look up every table named in the FROM clause of the select. If
5974 ** an entry of the FROM clause is a subquery instead of a table or view,
5975 ** then create a transient table structure to describe the subquery.
5977 for(i
=0, pFrom
=pTabList
->a
; i
<pTabList
->nSrc
; i
++, pFrom
++){
5979 assert( pFrom
->fg
.isRecursive
==0 || pFrom
->pTab
!=0 );
5980 if( pFrom
->pTab
) continue;
5981 assert( pFrom
->fg
.isRecursive
==0 );
5982 if( pFrom
->zName
==0 ){
5983 #ifndef SQLITE_OMIT_SUBQUERY
5984 Select
*pSel
= pFrom
->pSelect
;
5985 /* A sub-query in the FROM clause of a SELECT */
5987 assert( pFrom
->pTab
==0 );
5988 if( sqlite3WalkSelect(pWalker
, pSel
) ) return WRC_Abort
;
5989 if( sqlite3ExpandSubquery(pParse
, pFrom
) ) return WRC_Abort
;
5991 #ifndef SQLITE_OMIT_CTE
5992 }else if( (rc
= resolveFromTermToCte(pParse
, pWalker
, pFrom
))!=0 ){
5993 if( rc
>1 ) return WRC_Abort
;
5998 /* An ordinary table or view name in the FROM clause */
5999 assert( pFrom
->pTab
==0 );
6000 pFrom
->pTab
= pTab
= sqlite3LocateTableItem(pParse
, 0, pFrom
);
6001 if( pTab
==0 ) return WRC_Abort
;
6002 if( pTab
->nTabRef
>=0xffff ){
6003 sqlite3ErrorMsg(pParse
, "too many references to \"%s\": max 65535",
6009 if( !IsVirtual(pTab
) && cannotBeFunction(pParse
, pFrom
) ){
6012 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
6013 if( !IsOrdinaryTable(pTab
) ){
6015 u8 eCodeOrig
= pWalker
->eCode
;
6016 if( sqlite3ViewGetColumnNames(pParse
, pTab
) ) return WRC_Abort
;
6017 assert( pFrom
->pSelect
==0 );
6019 if( (db
->flags
& SQLITE_EnableView
)==0
6020 && pTab
->pSchema
!=db
->aDb
[1].pSchema
6022 sqlite3ErrorMsg(pParse
, "access to view \"%s\" prohibited",
6025 pFrom
->pSelect
= sqlite3SelectDup(db
, pTab
->u
.view
.pSelect
, 0);
6027 #ifndef SQLITE_OMIT_VIRTUALTABLE
6028 else if( ALWAYS(IsVirtual(pTab
))
6029 && pFrom
->fg
.fromDDL
6030 && ALWAYS(pTab
->u
.vtab
.p
!=0)
6031 && pTab
->u
.vtab
.p
->eVtabRisk
> ((db
->flags
& SQLITE_TrustedSchema
)!=0)
6033 sqlite3ErrorMsg(pParse
, "unsafe use of virtual table \"%s\"",
6036 assert( SQLITE_VTABRISK_Normal
==1 && SQLITE_VTABRISK_High
==2 );
6040 pWalker
->eCode
= 1; /* Turn on Select.selId renumbering */
6041 sqlite3WalkSelect(pWalker
, pFrom
->pSelect
);
6042 pWalker
->eCode
= eCodeOrig
;
6048 /* Locate the index named by the INDEXED BY clause, if any. */
6049 if( pFrom
->fg
.isIndexedBy
&& sqlite3IndexedByLookup(pParse
, pFrom
) ){
6054 /* Process NATURAL keywords, and ON and USING clauses of joins.
6056 assert( db
->mallocFailed
==0 || pParse
->nErr
!=0 );
6057 if( pParse
->nErr
|| sqlite3ProcessJoin(pParse
, p
) ){
6061 /* For every "*" that occurs in the column list, insert the names of
6062 ** all columns in all tables. And for every TABLE.* insert the names
6063 ** of all columns in TABLE. The parser inserted a special expression
6064 ** with the TK_ASTERISK operator for each "*" that it found in the column
6065 ** list. The following code just has to locate the TK_ASTERISK
6066 ** expressions and expand each one to the list of all columns in
6069 ** The first loop just checks to see if there are any "*" operators
6070 ** that need expanding.
6072 for(k
=0; k
<pEList
->nExpr
; k
++){
6073 pE
= pEList
->a
[k
].pExpr
;
6074 if( pE
->op
==TK_ASTERISK
) break;
6075 assert( pE
->op
!=TK_DOT
|| pE
->pRight
!=0 );
6076 assert( pE
->op
!=TK_DOT
|| (pE
->pLeft
!=0 && pE
->pLeft
->op
==TK_ID
) );
6077 if( pE
->op
==TK_DOT
&& pE
->pRight
->op
==TK_ASTERISK
) break;
6078 elistFlags
|= pE
->flags
;
6080 if( k
<pEList
->nExpr
){
6082 ** If we get here it means the result set contains one or more "*"
6083 ** operators that need to be expanded. Loop through each expression
6084 ** in the result set and expand them one by one.
6086 struct ExprList_item
*a
= pEList
->a
;
6088 int flags
= pParse
->db
->flags
;
6089 int longNames
= (flags
& SQLITE_FullColNames
)!=0
6090 && (flags
& SQLITE_ShortColNames
)==0;
6092 for(k
=0; k
<pEList
->nExpr
; k
++){
6094 elistFlags
|= pE
->flags
;
6095 pRight
= pE
->pRight
;
6096 assert( pE
->op
!=TK_DOT
|| pRight
!=0 );
6097 if( pE
->op
!=TK_ASTERISK
6098 && (pE
->op
!=TK_DOT
|| pRight
->op
!=TK_ASTERISK
)
6100 /* This particular expression does not need to be expanded.
6102 pNew
= sqlite3ExprListAppend(pParse
, pNew
, a
[k
].pExpr
);
6104 pNew
->a
[pNew
->nExpr
-1].zEName
= a
[k
].zEName
;
6105 pNew
->a
[pNew
->nExpr
-1].fg
.eEName
= a
[k
].fg
.eEName
;
6110 /* This expression is a "*" or a "TABLE.*" and needs to be
6112 int tableSeen
= 0; /* Set to 1 when TABLE matches */
6113 char *zTName
= 0; /* text of name of TABLE */
6115 if( pE
->op
==TK_DOT
){
6116 assert( (selFlags
& SF_NestedFrom
)==0 );
6117 assert( pE
->pLeft
!=0 );
6118 assert( !ExprHasProperty(pE
->pLeft
, EP_IntValue
) );
6119 zTName
= pE
->pLeft
->u
.zToken
;
6120 assert( ExprUseWOfst(pE
->pLeft
) );
6121 iErrOfst
= pE
->pRight
->w
.iOfst
;
6123 assert( ExprUseWOfst(pE
) );
6124 iErrOfst
= pE
->w
.iOfst
;
6126 for(i
=0, pFrom
=pTabList
->a
; i
<pTabList
->nSrc
; i
++, pFrom
++){
6127 int nAdd
; /* Number of cols including rowid */
6128 Table
*pTab
= pFrom
->pTab
; /* Table for this data source */
6129 ExprList
*pNestedFrom
; /* Result-set of a nested FROM clause */
6130 char *zTabName
; /* AS name for this data source */
6131 const char *zSchemaName
= 0; /* Schema name for this data source */
6132 int iDb
; /* Schema index for this data src */
6133 IdList
*pUsing
; /* USING clause for pFrom[1] */
6135 if( (zTabName
= pFrom
->zAlias
)==0 ){
6136 zTabName
= pTab
->zName
;
6138 if( db
->mallocFailed
) break;
6139 assert( (int)pFrom
->fg
.isNestedFrom
== IsNestedFrom(pFrom
->pSelect
) );
6140 if( pFrom
->fg
.isNestedFrom
){
6141 assert( pFrom
->pSelect
!=0 );
6142 pNestedFrom
= pFrom
->pSelect
->pEList
;
6143 assert( pNestedFrom
!=0 );
6144 assert( pNestedFrom
->nExpr
==pTab
->nCol
);
6145 assert( VisibleRowid(pTab
)==0 );
6147 if( zTName
&& sqlite3StrICmp(zTName
, zTabName
)!=0 ){
6151 iDb
= sqlite3SchemaToIndex(db
, pTab
->pSchema
);
6152 zSchemaName
= iDb
>=0 ? db
->aDb
[iDb
].zDbSName
: "*";
6154 if( i
+1<pTabList
->nSrc
6155 && pFrom
[1].fg
.isUsing
6156 && (selFlags
& SF_NestedFrom
)!=0
6159 pUsing
= pFrom
[1].u3
.pUsing
;
6160 for(ii
=0; ii
<pUsing
->nId
; ii
++){
6161 const char *zUName
= pUsing
->a
[ii
].zName
;
6162 pRight
= sqlite3Expr(db
, TK_ID
, zUName
);
6163 sqlite3ExprSetErrorOffset(pRight
, iErrOfst
);
6164 pNew
= sqlite3ExprListAppend(pParse
, pNew
, pRight
);
6166 struct ExprList_item
*pX
= &pNew
->a
[pNew
->nExpr
-1];
6167 assert( pX
->zEName
==0 );
6168 pX
->zEName
= sqlite3MPrintf(db
,"..%s", zUName
);
6169 pX
->fg
.eEName
= ENAME_TAB
;
6170 pX
->fg
.bUsingTerm
= 1;
6177 nAdd
= pTab
->nCol
+ (VisibleRowid(pTab
) && (selFlags
&SF_NestedFrom
));
6178 for(j
=0; j
<nAdd
; j
++){
6180 struct ExprList_item
*pX
; /* Newly added ExprList term */
6182 if( j
==pTab
->nCol
){
6183 zName
= sqlite3RowidAlias(pTab
);
6184 if( zName
==0 ) continue;
6186 zName
= pTab
->aCol
[j
].zCnName
;
6188 /* If pTab is actually an SF_NestedFrom sub-select, do not
6189 ** expand any ENAME_ROWID columns. */
6190 if( pNestedFrom
&& pNestedFrom
->a
[j
].fg
.eEName
==ENAME_ROWID
){
6196 && sqlite3MatchEName(&pNestedFrom
->a
[j
], 0, zTName
, 0, 0)==0
6201 /* If a column is marked as 'hidden', omit it from the expanded
6202 ** result-set list unless the SELECT has the SF_IncludeHidden
6205 if( (p
->selFlags
& SF_IncludeHidden
)==0
6206 && IsHiddenColumn(&pTab
->aCol
[j
])
6210 if( (pTab
->aCol
[j
].colFlags
& COLFLAG_NOEXPAND
)!=0
6212 && (selFlags
& (SF_NestedFrom
))==0
6220 if( i
>0 && zTName
==0 && (selFlags
& SF_NestedFrom
)==0 ){
6221 if( pFrom
->fg
.isUsing
6222 && sqlite3IdListIndex(pFrom
->u3
.pUsing
, zName
)>=0
6224 /* In a join with a USING clause, omit columns in the
6225 ** using clause from the table on the right. */
6229 pRight
= sqlite3Expr(db
, TK_ID
, zName
);
6230 if( (pTabList
->nSrc
>1
6231 && ( (pFrom
->fg
.jointype
& JT_LTORJ
)==0
6232 || (selFlags
& SF_NestedFrom
)!=0
6233 || !inAnyUsingClause(zName
,pFrom
,pTabList
->nSrc
-i
-1)
6239 pLeft
= sqlite3Expr(db
, TK_ID
, zTabName
);
6240 pExpr
= sqlite3PExpr(pParse
, TK_DOT
, pLeft
, pRight
);
6241 if( IN_RENAME_OBJECT
&& pE
->pLeft
){
6242 sqlite3RenameTokenRemap(pParse
, pLeft
, pE
->pLeft
);
6245 pLeft
= sqlite3Expr(db
, TK_ID
, zSchemaName
);
6246 pExpr
= sqlite3PExpr(pParse
, TK_DOT
, pLeft
, pExpr
);
6251 sqlite3ExprSetErrorOffset(pExpr
, iErrOfst
);
6252 pNew
= sqlite3ExprListAppend(pParse
, pNew
, pExpr
);
6256 pX
= &pNew
->a
[pNew
->nExpr
-1];
6257 assert( pX
->zEName
==0 );
6258 if( (selFlags
& SF_NestedFrom
)!=0 && !IN_RENAME_OBJECT
){
6260 pX
->zEName
= sqlite3DbStrDup(db
, pNestedFrom
->a
[j
].zEName
);
6261 testcase( pX
->zEName
==0 );
6263 pX
->zEName
= sqlite3MPrintf(db
, "%s.%s.%s",
6264 zSchemaName
, zTabName
, zName
);
6265 testcase( pX
->zEName
==0 );
6267 pX
->fg
.eEName
= (j
==pTab
->nCol
? ENAME_ROWID
: ENAME_TAB
);
6268 if( (pFrom
->fg
.isUsing
6269 && sqlite3IdListIndex(pFrom
->u3
.pUsing
, zName
)>=0)
6270 || (pUsing
&& sqlite3IdListIndex(pUsing
, zName
)>=0)
6271 || (j
<pTab
->nCol
&& (pTab
->aCol
[j
].colFlags
& COLFLAG_NOEXPAND
))
6273 pX
->fg
.bNoExpand
= 1;
6275 }else if( longNames
){
6276 pX
->zEName
= sqlite3MPrintf(db
, "%s.%s", zTabName
, zName
);
6277 pX
->fg
.eEName
= ENAME_NAME
;
6279 pX
->zEName
= sqlite3DbStrDup(db
, zName
);
6280 pX
->fg
.eEName
= ENAME_NAME
;
6286 sqlite3ErrorMsg(pParse
, "no such table: %s", zTName
);
6288 sqlite3ErrorMsg(pParse
, "no tables specified");
6293 sqlite3ExprListDelete(db
, pEList
);
6297 if( p
->pEList
->nExpr
>db
->aLimit
[SQLITE_LIMIT_COLUMN
] ){
6298 sqlite3ErrorMsg(pParse
, "too many columns in result set");
6301 if( (elistFlags
& (EP_HasFunc
|EP_Subquery
))!=0 ){
6302 p
->selFlags
|= SF_ComplexResult
;
6305 #if TREETRACE_ENABLED
6306 if( sqlite3TreeTrace
& 0x8 ){
6307 TREETRACE(0x8,pParse
,p
,("After result-set wildcard expansion:\n"));
6308 sqlite3TreeViewSelect(0, p
, 0);
6311 return WRC_Continue
;
6316 ** Always assert. This xSelectCallback2 implementation proves that the
6317 ** xSelectCallback2 is never invoked.
6319 void sqlite3SelectWalkAssert2(Walker
*NotUsed
, Select
*NotUsed2
){
6320 UNUSED_PARAMETER2(NotUsed
, NotUsed2
);
6325 ** This routine "expands" a SELECT statement and all of its subqueries.
6326 ** For additional information on what it means to "expand" a SELECT
6327 ** statement, see the comment on the selectExpand worker callback above.
6329 ** Expanding a SELECT statement is the first step in processing a
6330 ** SELECT statement. The SELECT statement must be expanded before
6331 ** name resolution is performed.
6333 ** If anything goes wrong, an error message is written into pParse.
6334 ** The calling function can detect the problem by looking at pParse->nErr
6335 ** and/or pParse->db->mallocFailed.
6337 static void sqlite3SelectExpand(Parse
*pParse
, Select
*pSelect
){
6339 w
.xExprCallback
= sqlite3ExprWalkNoop
;
6341 if( OK_IF_ALWAYS_TRUE(pParse
->hasCompound
) ){
6342 w
.xSelectCallback
= convertCompoundSelectToSubquery
;
6343 w
.xSelectCallback2
= 0;
6344 sqlite3WalkSelect(&w
, pSelect
);
6346 w
.xSelectCallback
= selectExpander
;
6347 w
.xSelectCallback2
= sqlite3SelectPopWith
;
6349 sqlite3WalkSelect(&w
, pSelect
);
6353 #ifndef SQLITE_OMIT_SUBQUERY
6355 ** This is a Walker.xSelectCallback callback for the sqlite3SelectTypeInfo()
6358 ** For each FROM-clause subquery, add Column.zType, Column.zColl, and
6359 ** Column.affinity information to the Table structure that represents
6360 ** the result set of that subquery.
6362 ** The Table structure that represents the result set was constructed
6363 ** by selectExpander() but the type and collation and affinity information
6364 ** was omitted at that point because identifiers had not yet been resolved.
6365 ** This routine is called after identifier resolution.
6367 static void selectAddSubqueryTypeInfo(Walker
*pWalker
, Select
*p
){
6373 if( p
->selFlags
& SF_HasTypeInfo
) return;
6374 p
->selFlags
|= SF_HasTypeInfo
;
6375 pParse
= pWalker
->pParse
;
6376 testcase( (p
->selFlags
& SF_Resolved
)==0 );
6377 assert( (p
->selFlags
& SF_Resolved
) || IN_RENAME_OBJECT
);
6379 for(i
=0, pFrom
=pTabList
->a
; i
<pTabList
->nSrc
; i
++, pFrom
++){
6380 Table
*pTab
= pFrom
->pTab
;
6382 if( (pTab
->tabFlags
& TF_Ephemeral
)!=0 ){
6383 /* A sub-query in the FROM clause of a SELECT */
6384 Select
*pSel
= pFrom
->pSelect
;
6386 sqlite3SubqueryColumnTypes(pParse
, pTab
, pSel
, SQLITE_AFF_NONE
);
6395 ** This routine adds datatype and collating sequence information to
6396 ** the Table structures of all FROM-clause subqueries in a
6397 ** SELECT statement.
6399 ** Use this routine after name resolution.
6401 static void sqlite3SelectAddTypeInfo(Parse
*pParse
, Select
*pSelect
){
6402 #ifndef SQLITE_OMIT_SUBQUERY
6404 w
.xSelectCallback
= sqlite3SelectWalkNoop
;
6405 w
.xSelectCallback2
= selectAddSubqueryTypeInfo
;
6406 w
.xExprCallback
= sqlite3ExprWalkNoop
;
6408 sqlite3WalkSelect(&w
, pSelect
);
6414 ** This routine sets up a SELECT statement for processing. The
6415 ** following is accomplished:
6417 ** * VDBE Cursor numbers are assigned to all FROM-clause terms.
6418 ** * Ephemeral Table objects are created for all FROM-clause subqueries.
6419 ** * ON and USING clauses are shifted into WHERE statements
6420 ** * Wildcards "*" and "TABLE.*" in result sets are expanded.
6421 ** * Identifiers in expression are matched to tables.
6423 ** This routine acts recursively on all subqueries within the SELECT.
6425 void sqlite3SelectPrep(
6426 Parse
*pParse
, /* The parser context */
6427 Select
*p
, /* The SELECT statement being coded. */
6428 NameContext
*pOuterNC
/* Name context for container */
6430 assert( p
!=0 || pParse
->db
->mallocFailed
);
6431 assert( pParse
->db
->pParse
==pParse
);
6432 if( pParse
->db
->mallocFailed
) return;
6433 if( p
->selFlags
& SF_HasTypeInfo
) return;
6434 sqlite3SelectExpand(pParse
, p
);
6435 if( pParse
->nErr
) return;
6436 sqlite3ResolveSelectNames(pParse
, p
, pOuterNC
);
6437 if( pParse
->nErr
) return;
6438 sqlite3SelectAddTypeInfo(pParse
, p
);
6441 #if TREETRACE_ENABLED
6443 ** Display all information about an AggInfo object
6445 static void printAggInfo(AggInfo
*pAggInfo
){
6447 sqlite3DebugPrintf("AggInfo %d/%p:\n",
6448 pAggInfo
->selId
, pAggInfo
);
6449 for(ii
=0; ii
<pAggInfo
->nColumn
; ii
++){
6450 struct AggInfo_col
*pCol
= &pAggInfo
->aCol
[ii
];
6452 "agg-column[%d] pTab=%s iTable=%d iColumn=%d iMem=%d"
6453 " iSorterColumn=%d %s\n",
6454 ii
, pCol
->pTab
? pCol
->pTab
->zName
: "NULL",
6455 pCol
->iTable
, pCol
->iColumn
, pAggInfo
->iFirstReg
+ii
,
6456 pCol
->iSorterColumn
,
6457 ii
>=pAggInfo
->nAccumulator
? "" : " Accumulator");
6458 sqlite3TreeViewExpr(0, pAggInfo
->aCol
[ii
].pCExpr
, 0);
6460 for(ii
=0; ii
<pAggInfo
->nFunc
; ii
++){
6461 sqlite3DebugPrintf("agg-func[%d]: iMem=%d\n",
6462 ii
, pAggInfo
->iFirstReg
+pAggInfo
->nColumn
+ii
);
6463 sqlite3TreeViewExpr(0, pAggInfo
->aFunc
[ii
].pFExpr
, 0);
6466 #endif /* TREETRACE_ENABLED */
6469 ** Analyze the arguments to aggregate functions. Create new pAggInfo->aCol[]
6470 ** entries for columns that are arguments to aggregate functions but which
6471 ** are not otherwise used.
6473 ** The aCol[] entries in AggInfo prior to nAccumulator are columns that
6474 ** are referenced outside of aggregate functions. These might be columns
6475 ** that are part of the GROUP by clause, for example. Other database engines
6476 ** would throw an error if there is a column reference that is not in the
6477 ** GROUP BY clause and that is not part of an aggregate function argument.
6478 ** But SQLite allows this.
6480 ** The aCol[] entries beginning with the aCol[nAccumulator] and following
6481 ** are column references that are used exclusively as arguments to
6482 ** aggregate functions. This routine is responsible for computing
6483 ** (or recomputing) those aCol[] entries.
6485 static void analyzeAggFuncArgs(
6490 assert( pAggInfo
!=0 );
6491 assert( pAggInfo
->iFirstReg
==0 );
6492 pNC
->ncFlags
|= NC_InAggFunc
;
6493 for(i
=0; i
<pAggInfo
->nFunc
; i
++){
6494 Expr
*pExpr
= pAggInfo
->aFunc
[i
].pFExpr
;
6495 assert( pExpr
->op
==TK_FUNCTION
|| pExpr
->op
==TK_AGG_FUNCTION
);
6496 assert( ExprUseXList(pExpr
) );
6497 sqlite3ExprAnalyzeAggList(pNC
, pExpr
->x
.pList
);
6499 assert( pExpr
->pLeft
->op
==TK_ORDER
);
6500 assert( ExprUseXList(pExpr
->pLeft
) );
6501 sqlite3ExprAnalyzeAggList(pNC
, pExpr
->pLeft
->x
.pList
);
6503 #ifndef SQLITE_OMIT_WINDOWFUNC
6504 assert( !IsWindowFunc(pExpr
) );
6505 if( ExprHasProperty(pExpr
, EP_WinFunc
) ){
6506 sqlite3ExprAnalyzeAggregates(pNC
, pExpr
->y
.pWin
->pFilter
);
6510 pNC
->ncFlags
&= ~NC_InAggFunc
;
6514 ** An index on expressions is being used in the inner loop of an
6515 ** aggregate query with a GROUP BY clause. This routine attempts
6516 ** to adjust the AggInfo object to take advantage of index and to
6517 ** perhaps use the index as a covering index.
6520 static void optimizeAggregateUseOfIndexedExpr(
6521 Parse
*pParse
, /* Parsing context */
6522 Select
*pSelect
, /* The SELECT statement being processed */
6523 AggInfo
*pAggInfo
, /* The aggregate info */
6524 NameContext
*pNC
/* Name context used to resolve agg-func args */
6526 assert( pAggInfo
->iFirstReg
==0 );
6527 assert( pSelect
!=0 );
6528 assert( pSelect
->pGroupBy
!=0 );
6529 pAggInfo
->nColumn
= pAggInfo
->nAccumulator
;
6530 if( ALWAYS(pAggInfo
->nSortingColumn
>0) ){
6531 int mx
= pSelect
->pGroupBy
->nExpr
- 1;
6533 for(j
=0; j
<pAggInfo
->nColumn
; j
++){
6534 k
= pAggInfo
->aCol
[j
].iSorterColumn
;
6537 pAggInfo
->nSortingColumn
= mx
+1;
6539 analyzeAggFuncArgs(pAggInfo
, pNC
);
6540 #if TREETRACE_ENABLED
6541 if( sqlite3TreeTrace
& 0x20 ){
6543 TREETRACE(0x20, pParse
, pSelect
,
6544 ("AggInfo (possibly) adjusted for Indexed Exprs\n"));
6545 sqlite3TreeViewSelect(0, pSelect
, 0);
6546 for(pIEpr
=pParse
->pIdxEpr
; pIEpr
; pIEpr
=pIEpr
->pIENext
){
6547 printf("data-cursor=%d index={%d,%d}\n",
6548 pIEpr
->iDataCur
, pIEpr
->iIdxCur
, pIEpr
->iIdxCol
);
6549 sqlite3TreeViewExpr(0, pIEpr
->pExpr
, 0);
6551 printAggInfo(pAggInfo
);
6554 UNUSED_PARAMETER(pSelect
);
6555 UNUSED_PARAMETER(pParse
);
6560 ** Walker callback for aggregateConvertIndexedExprRefToColumn().
6562 static int aggregateIdxEprRefToColCallback(Walker
*pWalker
, Expr
*pExpr
){
6564 struct AggInfo_col
*pCol
;
6565 UNUSED_PARAMETER(pWalker
);
6566 if( pExpr
->pAggInfo
==0 ) return WRC_Continue
;
6567 if( pExpr
->op
==TK_AGG_COLUMN
) return WRC_Continue
;
6568 if( pExpr
->op
==TK_AGG_FUNCTION
) return WRC_Continue
;
6569 if( pExpr
->op
==TK_IF_NULL_ROW
) return WRC_Continue
;
6570 pAggInfo
= pExpr
->pAggInfo
;
6571 if( NEVER(pExpr
->iAgg
>=pAggInfo
->nColumn
) ) return WRC_Continue
;
6572 assert( pExpr
->iAgg
>=0 );
6573 pCol
= &pAggInfo
->aCol
[pExpr
->iAgg
];
6574 pExpr
->op
= TK_AGG_COLUMN
;
6575 pExpr
->iTable
= pCol
->iTable
;
6576 pExpr
->iColumn
= pCol
->iColumn
;
6577 ExprClearProperty(pExpr
, EP_Skip
|EP_Collate
|EP_Unlikely
);
6582 ** Convert every pAggInfo->aFunc[].pExpr such that any node within
6583 ** those expressions that has pAppInfo set is changed into a TK_AGG_COLUMN
6586 static void aggregateConvertIndexedExprRefToColumn(AggInfo
*pAggInfo
){
6589 memset(&w
, 0, sizeof(w
));
6590 w
.xExprCallback
= aggregateIdxEprRefToColCallback
;
6591 for(i
=0; i
<pAggInfo
->nFunc
; i
++){
6592 sqlite3WalkExpr(&w
, pAggInfo
->aFunc
[i
].pFExpr
);
6598 ** Allocate a block of registers so that there is one register for each
6599 ** pAggInfo->aCol[] and pAggInfo->aFunc[] entry in pAggInfo. The first
6600 ** register in this block is stored in pAggInfo->iFirstReg.
6602 ** This routine may only be called once for each AggInfo object. Prior
6603 ** to calling this routine:
6605 ** * The aCol[] and aFunc[] arrays may be modified
6606 ** * The AggInfoColumnReg() and AggInfoFuncReg() macros may not be used
6608 ** After calling this routine:
6610 ** * The aCol[] and aFunc[] arrays are fixed
6611 ** * The AggInfoColumnReg() and AggInfoFuncReg() macros may be used
6614 static void assignAggregateRegisters(Parse
*pParse
, AggInfo
*pAggInfo
){
6615 assert( pAggInfo
!=0 );
6616 assert( pAggInfo
->iFirstReg
==0 );
6617 pAggInfo
->iFirstReg
= pParse
->nMem
+ 1;
6618 pParse
->nMem
+= pAggInfo
->nColumn
+ pAggInfo
->nFunc
;
6622 ** Reset the aggregate accumulator.
6624 ** The aggregate accumulator is a set of memory cells that hold
6625 ** intermediate results while calculating an aggregate. This
6626 ** routine generates code that stores NULLs in all of those memory
6629 static void resetAccumulator(Parse
*pParse
, AggInfo
*pAggInfo
){
6630 Vdbe
*v
= pParse
->pVdbe
;
6632 struct AggInfo_func
*pFunc
;
6633 int nReg
= pAggInfo
->nFunc
+ pAggInfo
->nColumn
;
6634 assert( pAggInfo
->iFirstReg
>0 );
6635 assert( pParse
->db
->pParse
==pParse
);
6636 assert( pParse
->db
->mallocFailed
==0 || pParse
->nErr
!=0 );
6637 if( nReg
==0 ) return;
6638 if( pParse
->nErr
) return;
6639 sqlite3VdbeAddOp3(v
, OP_Null
, 0, pAggInfo
->iFirstReg
,
6640 pAggInfo
->iFirstReg
+nReg
-1);
6641 for(pFunc
=pAggInfo
->aFunc
, i
=0; i
<pAggInfo
->nFunc
; i
++, pFunc
++){
6642 if( pFunc
->iDistinct
>=0 ){
6643 Expr
*pE
= pFunc
->pFExpr
;
6644 assert( ExprUseXList(pE
) );
6645 if( pE
->x
.pList
==0 || pE
->x
.pList
->nExpr
!=1 ){
6646 sqlite3ErrorMsg(pParse
, "DISTINCT aggregates must have exactly one "
6648 pFunc
->iDistinct
= -1;
6650 KeyInfo
*pKeyInfo
= sqlite3KeyInfoFromExprList(pParse
, pE
->x
.pList
,0,0);
6651 pFunc
->iDistAddr
= sqlite3VdbeAddOp4(v
, OP_OpenEphemeral
,
6652 pFunc
->iDistinct
, 0, 0, (char*)pKeyInfo
, P4_KEYINFO
);
6653 ExplainQueryPlan((pParse
, 0, "USE TEMP B-TREE FOR %s(DISTINCT)",
6654 pFunc
->pFunc
->zName
));
6657 if( pFunc
->iOBTab
>=0 ){
6661 assert( pFunc
->pFExpr
->pLeft
!=0 );
6662 assert( pFunc
->pFExpr
->pLeft
->op
==TK_ORDER
);
6663 assert( ExprUseXList(pFunc
->pFExpr
->pLeft
) );
6664 assert( pFunc
->pFunc
!=0 );
6665 pOBList
= pFunc
->pFExpr
->pLeft
->x
.pList
;
6666 if( !pFunc
->bOBUnique
){
6667 nExtra
++; /* One extra column for the OP_Sequence */
6669 if( pFunc
->bOBPayload
){
6670 /* extra columns for the function arguments */
6671 assert( ExprUseXList(pFunc
->pFExpr
) );
6672 nExtra
+= pFunc
->pFExpr
->x
.pList
->nExpr
;
6674 if( pFunc
->bUseSubtype
){
6675 nExtra
+= pFunc
->pFExpr
->x
.pList
->nExpr
;
6677 pKeyInfo
= sqlite3KeyInfoFromExprList(pParse
, pOBList
, 0, nExtra
);
6678 if( !pFunc
->bOBUnique
&& pParse
->nErr
==0 ){
6679 pKeyInfo
->nKeyField
++;
6681 sqlite3VdbeAddOp4(v
, OP_OpenEphemeral
,
6682 pFunc
->iOBTab
, pOBList
->nExpr
+nExtra
, 0,
6683 (char*)pKeyInfo
, P4_KEYINFO
);
6684 ExplainQueryPlan((pParse
, 0, "USE TEMP B-TREE FOR %s(ORDER BY)",
6685 pFunc
->pFunc
->zName
));
6691 ** Invoke the OP_AggFinalize opcode for every aggregate function
6692 ** in the AggInfo structure.
6694 static void finalizeAggFunctions(Parse
*pParse
, AggInfo
*pAggInfo
){
6695 Vdbe
*v
= pParse
->pVdbe
;
6697 struct AggInfo_func
*pF
;
6698 for(i
=0, pF
=pAggInfo
->aFunc
; i
<pAggInfo
->nFunc
; i
++, pF
++){
6700 assert( ExprUseXList(pF
->pFExpr
) );
6701 pList
= pF
->pFExpr
->x
.pList
;
6702 if( pF
->iOBTab
>=0 ){
6703 /* For an ORDER BY aggregate, calls to OP_AggStep were deferred. Inputs
6704 ** were stored in emphermal table pF->iOBTab. Here, we extract those
6705 ** inputs (in ORDER BY order) and make all calls to OP_AggStep
6706 ** before doing the OP_AggFinal call. */
6707 int iTop
; /* Start of loop for extracting columns */
6708 int nArg
; /* Number of columns to extract */
6709 int nKey
; /* Key columns to be skipped */
6710 int regAgg
; /* Extract into this array */
6711 int j
; /* Loop counter */
6713 assert( pF
->pFunc
!=0 );
6714 nArg
= pList
->nExpr
;
6715 regAgg
= sqlite3GetTempRange(pParse
, nArg
);
6717 if( pF
->bOBPayload
==0 ){
6720 assert( pF
->pFExpr
->pLeft
!=0 );
6721 assert( ExprUseXList(pF
->pFExpr
->pLeft
) );
6722 assert( pF
->pFExpr
->pLeft
->x
.pList
!=0 );
6723 nKey
= pF
->pFExpr
->pLeft
->x
.pList
->nExpr
;
6724 if( ALWAYS(!pF
->bOBUnique
) ) nKey
++;
6726 iTop
= sqlite3VdbeAddOp1(v
, OP_Rewind
, pF
->iOBTab
); VdbeCoverage(v
);
6727 for(j
=nArg
-1; j
>=0; j
--){
6728 sqlite3VdbeAddOp3(v
, OP_Column
, pF
->iOBTab
, nKey
+j
, regAgg
+j
);
6730 if( pF
->bUseSubtype
){
6731 int regSubtype
= sqlite3GetTempReg(pParse
);
6732 int iBaseCol
= nKey
+ nArg
+ (pF
->bOBPayload
==0 && pF
->bOBUnique
==0);
6733 for(j
=nArg
-1; j
>=0; j
--){
6734 sqlite3VdbeAddOp3(v
, OP_Column
, pF
->iOBTab
, iBaseCol
+j
, regSubtype
);
6735 sqlite3VdbeAddOp2(v
, OP_SetSubtype
, regSubtype
, regAgg
+j
);
6737 sqlite3ReleaseTempReg(pParse
, regSubtype
);
6739 sqlite3VdbeAddOp3(v
, OP_AggStep
, 0, regAgg
, AggInfoFuncReg(pAggInfo
,i
));
6740 sqlite3VdbeAppendP4(v
, pF
->pFunc
, P4_FUNCDEF
);
6741 sqlite3VdbeChangeP5(v
, (u8
)nArg
);
6742 sqlite3VdbeAddOp2(v
, OP_Next
, pF
->iOBTab
, iTop
+1); VdbeCoverage(v
);
6743 sqlite3VdbeJumpHere(v
, iTop
);
6744 sqlite3ReleaseTempRange(pParse
, regAgg
, nArg
);
6746 sqlite3VdbeAddOp2(v
, OP_AggFinal
, AggInfoFuncReg(pAggInfo
,i
),
6747 pList
? pList
->nExpr
: 0);
6748 sqlite3VdbeAppendP4(v
, pF
->pFunc
, P4_FUNCDEF
);
6753 ** Generate code that will update the accumulator memory cells for an
6754 ** aggregate based on the current cursor position.
6756 ** If regAcc is non-zero and there are no min() or max() aggregates
6757 ** in pAggInfo, then only populate the pAggInfo->nAccumulator accumulator
6758 ** registers if register regAcc contains 0. The caller will take care
6759 ** of setting and clearing regAcc.
6761 ** For an ORDER BY aggregate, the actual accumulator memory cell update
6762 ** is deferred until after all input rows have been received, so that they
6763 ** can be run in the requested order. In that case, instead of invoking
6764 ** OP_AggStep to update the accumulator, just add the arguments that would
6765 ** have been passed into OP_AggStep into the sorting ephemeral table
6766 ** (along with the appropriate sort key).
6768 static void updateAccumulator(
6774 Vdbe
*v
= pParse
->pVdbe
;
6777 int addrHitTest
= 0;
6778 struct AggInfo_func
*pF
;
6779 struct AggInfo_col
*pC
;
6781 assert( pAggInfo
->iFirstReg
>0 );
6782 if( pParse
->nErr
) return;
6783 pAggInfo
->directMode
= 1;
6784 for(i
=0, pF
=pAggInfo
->aFunc
; i
<pAggInfo
->nFunc
; i
++, pF
++){
6789 int regDistinct
= 0;
6791 assert( ExprUseXList(pF
->pFExpr
) );
6792 assert( !IsWindowFunc(pF
->pFExpr
) );
6793 assert( pF
->pFunc
!=0 );
6794 pList
= pF
->pFExpr
->x
.pList
;
6795 if( ExprHasProperty(pF
->pFExpr
, EP_WinFunc
) ){
6796 Expr
*pFilter
= pF
->pFExpr
->y
.pWin
->pFilter
;
6797 if( pAggInfo
->nAccumulator
6798 && (pF
->pFunc
->funcFlags
& SQLITE_FUNC_NEEDCOLL
)
6801 /* If regAcc==0, there there exists some min() or max() function
6802 ** without a FILTER clause that will ensure the magnet registers
6803 ** are populated. */
6804 if( regHit
==0 ) regHit
= ++pParse
->nMem
;
6805 /* If this is the first row of the group (regAcc contains 0), clear the
6806 ** "magnet" register regHit so that the accumulator registers
6807 ** are populated if the FILTER clause jumps over the the
6808 ** invocation of min() or max() altogether. Or, if this is not
6809 ** the first row (regAcc contains 1), set the magnet register so that
6810 ** the accumulators are not populated unless the min()/max() is invoked
6811 ** and indicates that they should be. */
6812 sqlite3VdbeAddOp2(v
, OP_Copy
, regAcc
, regHit
);
6814 addrNext
= sqlite3VdbeMakeLabel(pParse
);
6815 sqlite3ExprIfFalse(pParse
, pFilter
, addrNext
, SQLITE_JUMPIFNULL
);
6817 if( pF
->iOBTab
>=0 ){
6818 /* Instead of invoking AggStep, we must push the arguments that would
6819 ** have been passed to AggStep onto the sorting table. */
6820 int jj
; /* Registered used so far in building the record */
6821 ExprList
*pOBList
; /* The ORDER BY clause */
6823 nArg
= pList
->nExpr
;
6825 assert( pF
->pFExpr
->pLeft
!=0 );
6826 assert( pF
->pFExpr
->pLeft
->op
==TK_ORDER
);
6827 assert( ExprUseXList(pF
->pFExpr
->pLeft
) );
6828 pOBList
= pF
->pFExpr
->pLeft
->x
.pList
;
6829 assert( pOBList
!=0 );
6830 assert( pOBList
->nExpr
>0 );
6831 regAggSz
= pOBList
->nExpr
;
6832 if( !pF
->bOBUnique
){
6833 regAggSz
++; /* One register for OP_Sequence */
6835 if( pF
->bOBPayload
){
6838 if( pF
->bUseSubtype
){
6841 regAggSz
++; /* One extra register to hold result of MakeRecord */
6842 regAgg
= sqlite3GetTempRange(pParse
, regAggSz
);
6843 regDistinct
= regAgg
;
6844 sqlite3ExprCodeExprList(pParse
, pOBList
, regAgg
, 0, SQLITE_ECEL_DUP
);
6845 jj
= pOBList
->nExpr
;
6846 if( !pF
->bOBUnique
){
6847 sqlite3VdbeAddOp2(v
, OP_Sequence
, pF
->iOBTab
, regAgg
+jj
);
6850 if( pF
->bOBPayload
){
6851 regDistinct
= regAgg
+jj
;
6852 sqlite3ExprCodeExprList(pParse
, pList
, regDistinct
, 0, SQLITE_ECEL_DUP
);
6855 if( pF
->bUseSubtype
){
6857 int regBase
= pF
->bOBPayload
? regDistinct
: regAgg
;
6858 for(kk
=0; kk
<nArg
; kk
++, jj
++){
6859 sqlite3VdbeAddOp2(v
, OP_GetSubtype
, regBase
+kk
, regAgg
+jj
);
6863 nArg
= pList
->nExpr
;
6864 regAgg
= sqlite3GetTempRange(pParse
, nArg
);
6865 regDistinct
= regAgg
;
6866 sqlite3ExprCodeExprList(pParse
, pList
, regAgg
, 0, SQLITE_ECEL_DUP
);
6871 if( pF
->iDistinct
>=0 && pList
){
6873 addrNext
= sqlite3VdbeMakeLabel(pParse
);
6875 pF
->iDistinct
= codeDistinct(pParse
, eDistinctType
,
6876 pF
->iDistinct
, addrNext
, pList
, regDistinct
);
6878 if( pF
->iOBTab
>=0 ){
6879 /* Insert a new record into the ORDER BY table */
6880 sqlite3VdbeAddOp3(v
, OP_MakeRecord
, regAgg
, regAggSz
-1,
6882 sqlite3VdbeAddOp4Int(v
, OP_IdxInsert
, pF
->iOBTab
, regAgg
+regAggSz
-1,
6883 regAgg
, regAggSz
-1);
6884 sqlite3ReleaseTempRange(pParse
, regAgg
, regAggSz
);
6886 /* Invoke the AggStep function */
6887 if( pF
->pFunc
->funcFlags
& SQLITE_FUNC_NEEDCOLL
){
6889 struct ExprList_item
*pItem
;
6891 assert( pList
!=0 ); /* pList!=0 if pF->pFunc has NEEDCOLL */
6892 for(j
=0, pItem
=pList
->a
; !pColl
&& j
<nArg
; j
++, pItem
++){
6893 pColl
= sqlite3ExprCollSeq(pParse
, pItem
->pExpr
);
6896 pColl
= pParse
->db
->pDfltColl
;
6898 if( regHit
==0 && pAggInfo
->nAccumulator
) regHit
= ++pParse
->nMem
;
6899 sqlite3VdbeAddOp4(v
, OP_CollSeq
, regHit
, 0, 0,
6900 (char *)pColl
, P4_COLLSEQ
);
6902 sqlite3VdbeAddOp3(v
, OP_AggStep
, 0, regAgg
, AggInfoFuncReg(pAggInfo
,i
));
6903 sqlite3VdbeAppendP4(v
, pF
->pFunc
, P4_FUNCDEF
);
6904 sqlite3VdbeChangeP5(v
, (u8
)nArg
);
6905 sqlite3ReleaseTempRange(pParse
, regAgg
, nArg
);
6908 sqlite3VdbeResolveLabel(v
, addrNext
);
6911 if( regHit
==0 && pAggInfo
->nAccumulator
){
6915 addrHitTest
= sqlite3VdbeAddOp1(v
, OP_If
, regHit
); VdbeCoverage(v
);
6917 for(i
=0, pC
=pAggInfo
->aCol
; i
<pAggInfo
->nAccumulator
; i
++, pC
++){
6918 sqlite3ExprCode(pParse
, pC
->pCExpr
, AggInfoColumnReg(pAggInfo
,i
));
6921 pAggInfo
->directMode
= 0;
6923 sqlite3VdbeJumpHereOrPopInst(v
, addrHitTest
);
6928 ** Add a single OP_Explain instruction to the VDBE to explain a simple
6929 ** count(*) query ("SELECT count(*) FROM pTab").
6931 #ifndef SQLITE_OMIT_EXPLAIN
6932 static void explainSimpleCount(
6933 Parse
*pParse
, /* Parse context */
6934 Table
*pTab
, /* Table being queried */
6935 Index
*pIdx
/* Index used to optimize scan, or NULL */
6937 if( pParse
->explain
==2 ){
6938 int bCover
= (pIdx
!=0 && (HasRowid(pTab
) || !IsPrimaryKeyIndex(pIdx
)));
6939 sqlite3VdbeExplain(pParse
, 0, "SCAN %s%s%s",
6941 bCover
? " USING COVERING INDEX " : "",
6942 bCover
? pIdx
->zName
: ""
6947 # define explainSimpleCount(a,b,c)
6951 ** sqlite3WalkExpr() callback used by havingToWhere().
6953 ** If the node passed to the callback is a TK_AND node, return
6954 ** WRC_Continue to tell sqlite3WalkExpr() to iterate through child nodes.
6956 ** Otherwise, return WRC_Prune. In this case, also check if the
6957 ** sub-expression matches the criteria for being moved to the WHERE
6958 ** clause. If so, add it to the WHERE clause and replace the sub-expression
6959 ** within the HAVING expression with a constant "1".
6961 static int havingToWhereExprCb(Walker
*pWalker
, Expr
*pExpr
){
6962 if( pExpr
->op
!=TK_AND
){
6963 Select
*pS
= pWalker
->u
.pSelect
;
6964 /* This routine is called before the HAVING clause of the current
6965 ** SELECT is analyzed for aggregates. So if pExpr->pAggInfo is set
6966 ** here, it indicates that the expression is a correlated reference to a
6967 ** column from an outer aggregate query, or an aggregate function that
6968 ** belongs to an outer query. Do not move the expression to the WHERE
6969 ** clause in this obscure case, as doing so may corrupt the outer Select
6970 ** statements AggInfo structure. */
6971 if( sqlite3ExprIsConstantOrGroupBy(pWalker
->pParse
, pExpr
, pS
->pGroupBy
)
6972 && ExprAlwaysFalse(pExpr
)==0
6973 && pExpr
->pAggInfo
==0
6975 sqlite3
*db
= pWalker
->pParse
->db
;
6976 Expr
*pNew
= sqlite3Expr(db
, TK_INTEGER
, "1");
6978 Expr
*pWhere
= pS
->pWhere
;
6979 SWAP(Expr
, *pNew
, *pExpr
);
6980 pNew
= sqlite3ExprAnd(pWalker
->pParse
, pWhere
, pNew
);
6987 return WRC_Continue
;
6991 ** Transfer eligible terms from the HAVING clause of a query, which is
6992 ** processed after grouping, to the WHERE clause, which is processed before
6993 ** grouping. For example, the query:
6995 ** SELECT * FROM <tables> WHERE a=? GROUP BY b HAVING b=? AND c=?
6997 ** can be rewritten as:
6999 ** SELECT * FROM <tables> WHERE a=? AND b=? GROUP BY b HAVING c=?
7001 ** A term of the HAVING expression is eligible for transfer if it consists
7002 ** entirely of constants and expressions that are also GROUP BY terms that
7003 ** use the "BINARY" collation sequence.
7005 static void havingToWhere(Parse
*pParse
, Select
*p
){
7007 memset(&sWalker
, 0, sizeof(sWalker
));
7008 sWalker
.pParse
= pParse
;
7009 sWalker
.xExprCallback
= havingToWhereExprCb
;
7010 sWalker
.u
.pSelect
= p
;
7011 sqlite3WalkExpr(&sWalker
, p
->pHaving
);
7012 #if TREETRACE_ENABLED
7013 if( sWalker
.eCode
&& (sqlite3TreeTrace
& 0x100)!=0 ){
7014 TREETRACE(0x100,pParse
,p
,("Move HAVING terms into WHERE:\n"));
7015 sqlite3TreeViewSelect(0, p
, 0);
7021 ** Check to see if the pThis entry of pTabList is a self-join of another view.
7022 ** Search FROM-clause entries in the range of iFirst..iEnd, including iFirst
7023 ** but stopping before iEnd.
7025 ** If pThis is a self-join, then return the SrcItem for the first other
7026 ** instance of that view found. If pThis is not a self-join then return 0.
7028 static SrcItem
*isSelfJoinView(
7029 SrcList
*pTabList
, /* Search for self-joins in this FROM clause */
7030 SrcItem
*pThis
, /* Search for prior reference to this subquery */
7031 int iFirst
, int iEnd
/* Range of FROM-clause entries to search. */
7034 assert( pThis
->pSelect
!=0 );
7035 if( pThis
->pSelect
->selFlags
& SF_PushDown
) return 0;
7036 while( iFirst
<iEnd
){
7038 pItem
= &pTabList
->a
[iFirst
++];
7039 if( pItem
->pSelect
==0 ) continue;
7040 if( pItem
->fg
.viaCoroutine
) continue;
7041 if( pItem
->zName
==0 ) continue;
7042 assert( pItem
->pTab
!=0 );
7043 assert( pThis
->pTab
!=0 );
7044 if( pItem
->pTab
->pSchema
!=pThis
->pTab
->pSchema
) continue;
7045 if( sqlite3_stricmp(pItem
->zName
, pThis
->zName
)!=0 ) continue;
7046 pS1
= pItem
->pSelect
;
7047 if( pItem
->pTab
->pSchema
==0 && pThis
->pSelect
->selId
!=pS1
->selId
){
7048 /* The query flattener left two different CTE tables with identical
7049 ** names in the same FROM clause. */
7052 if( pItem
->pSelect
->selFlags
& SF_PushDown
){
7053 /* The view was modified by some other optimization such as
7054 ** pushDownWhereTerms() */
7063 ** Deallocate a single AggInfo object
7065 static void agginfoFree(sqlite3
*db
, void *pArg
){
7066 AggInfo
*p
= (AggInfo
*)pArg
;
7067 sqlite3DbFree(db
, p
->aCol
);
7068 sqlite3DbFree(db
, p
->aFunc
);
7069 sqlite3DbFreeNN(db
, p
);
7073 ** Attempt to transform a query of the form
7075 ** SELECT count(*) FROM (SELECT x FROM t1 UNION ALL SELECT y FROM t2)
7079 ** SELECT (SELECT count(*) FROM t1)+(SELECT count(*) FROM t2)
7081 ** The transformation only works if all of the following are true:
7083 ** * The subquery is a UNION ALL of two or more terms
7084 ** * The subquery does not have a LIMIT clause
7085 ** * There is no WHERE or GROUP BY or HAVING clauses on the subqueries
7086 ** * The outer query is a simple count(*) with no WHERE clause or other
7087 ** extraneous syntax.
7089 ** Return TRUE if the optimization is undertaken.
7091 static int countOfViewOptimization(Parse
*pParse
, Select
*p
){
7092 Select
*pSub
, *pPrior
;
7096 if( (p
->selFlags
& SF_Aggregate
)==0 ) return 0; /* This is an aggregate */
7097 if( p
->pEList
->nExpr
!=1 ) return 0; /* Single result column */
7098 if( p
->pWhere
) return 0;
7099 if( p
->pHaving
) return 0;
7100 if( p
->pGroupBy
) return 0;
7101 if( p
->pOrderBy
) return 0;
7102 pExpr
= p
->pEList
->a
[0].pExpr
;
7103 if( pExpr
->op
!=TK_AGG_FUNCTION
) return 0; /* Result is an aggregate */
7104 assert( ExprUseUToken(pExpr
) );
7105 if( sqlite3_stricmp(pExpr
->u
.zToken
,"count") ) return 0; /* Is count() */
7106 assert( ExprUseXList(pExpr
) );
7107 if( pExpr
->x
.pList
!=0 ) return 0; /* Must be count(*) */
7108 if( p
->pSrc
->nSrc
!=1 ) return 0; /* One table in FROM */
7109 if( ExprHasProperty(pExpr
, EP_WinFunc
) ) return 0;/* Not a window function */
7110 pSub
= p
->pSrc
->a
[0].pSelect
;
7111 if( pSub
==0 ) return 0; /* The FROM is a subquery */
7112 if( pSub
->pPrior
==0 ) return 0; /* Must be a compound */
7113 if( pSub
->selFlags
& SF_CopyCte
) return 0; /* Not a CTE */
7115 if( pSub
->op
!=TK_ALL
&& pSub
->pPrior
) return 0; /* Must be UNION ALL */
7116 if( pSub
->pWhere
) return 0; /* No WHERE clause */
7117 if( pSub
->pLimit
) return 0; /* No LIMIT clause */
7118 if( pSub
->selFlags
& SF_Aggregate
) return 0; /* Not an aggregate */
7119 assert( pSub
->pHaving
==0 ); /* Due to the previous */
7120 pSub
= pSub
->pPrior
; /* Repeat over compound */
7123 /* If we reach this point then it is OK to perform the transformation */
7128 pSub
= p
->pSrc
->a
[0].pSelect
;
7129 p
->pSrc
->a
[0].pSelect
= 0;
7130 sqlite3SrcListDelete(db
, p
->pSrc
);
7131 p
->pSrc
= sqlite3DbMallocZero(pParse
->db
, sizeof(*p
->pSrc
));
7134 pPrior
= pSub
->pPrior
;
7137 pSub
->selFlags
|= SF_Aggregate
;
7138 pSub
->selFlags
&= ~SF_Compound
;
7139 pSub
->nSelectRow
= 0;
7140 sqlite3ParserAddCleanup(pParse
, sqlite3ExprListDeleteGeneric
, pSub
->pEList
);
7141 pTerm
= pPrior
? sqlite3ExprDup(db
, pCount
, 0) : pCount
;
7142 pSub
->pEList
= sqlite3ExprListAppend(pParse
, 0, pTerm
);
7143 pTerm
= sqlite3PExpr(pParse
, TK_SELECT
, 0, 0);
7144 sqlite3PExprAddSelect(pParse
, pTerm
, pSub
);
7148 pExpr
= sqlite3PExpr(pParse
, TK_PLUS
, pTerm
, pExpr
);
7152 p
->pEList
->a
[0].pExpr
= pExpr
;
7153 p
->selFlags
&= ~SF_Aggregate
;
7155 #if TREETRACE_ENABLED
7156 if( sqlite3TreeTrace
& 0x200 ){
7157 TREETRACE(0x200,pParse
,p
,("After count-of-view optimization:\n"));
7158 sqlite3TreeViewSelect(0, p
, 0);
7165 ** If any term of pSrc, or any SF_NestedFrom sub-query, is not the same
7166 ** as pSrcItem but has the same alias as p0, then return true.
7167 ** Otherwise return false.
7169 static int sameSrcAlias(SrcItem
*p0
, SrcList
*pSrc
){
7171 for(i
=0; i
<pSrc
->nSrc
; i
++){
7172 SrcItem
*p1
= &pSrc
->a
[i
];
7173 if( p1
==p0
) continue;
7174 if( p0
->pTab
==p1
->pTab
&& 0==sqlite3_stricmp(p0
->zAlias
, p1
->zAlias
) ){
7178 && (p1
->pSelect
->selFlags
& SF_NestedFrom
)!=0
7179 && sameSrcAlias(p0
, p1
->pSelect
->pSrc
)
7188 ** Return TRUE (non-zero) if the i-th entry in the pTabList SrcList can
7189 ** be implemented as a co-routine. The i-th entry is guaranteed to be
7192 ** The subquery is implemented as a co-routine if all of the following are
7195 ** (1) The subquery will likely be implemented in the outer loop of
7196 ** the query. This will be the case if any one of the following
7198 ** (a) The subquery is the only term in the FROM clause
7199 ** (b) The subquery is the left-most term and a CROSS JOIN or similar
7200 ** requires it to be the outer loop
7201 ** (c) All of the following are true:
7202 ** (i) The subquery is the left-most subquery in the FROM clause
7203 ** (ii) There is nothing that would prevent the subquery from
7204 ** being used as the outer loop if the sqlite3WhereBegin()
7205 ** routine nominates it to that position.
7206 ** (iii) The query is not a UPDATE ... FROM
7207 ** (2) The subquery is not a CTE that should be materialized because
7208 ** (a) the AS MATERIALIZED keyword is used, or
7209 ** (b) the CTE is used multiple times and does not have the
7210 ** NOT MATERIALIZED keyword
7211 ** (3) The subquery is not part of a left operand for a RIGHT JOIN
7212 ** (4) The SQLITE_Coroutine optimization disable flag is not set
7213 ** (5) The subquery is not self-joined
7215 static int fromClauseTermCanBeCoroutine(
7216 Parse
*pParse
, /* Parsing context */
7217 SrcList
*pTabList
, /* FROM clause */
7218 int i
, /* Which term of the FROM clause holds the subquery */
7219 int selFlags
/* Flags on the SELECT statement */
7221 SrcItem
*pItem
= &pTabList
->a
[i
];
7222 if( pItem
->fg
.isCte
){
7223 const CteUse
*pCteUse
= pItem
->u2
.pCteUse
;
7224 if( pCteUse
->eM10d
==M10d_Yes
) return 0; /* (2a) */
7225 if( pCteUse
->nUse
>=2 && pCteUse
->eM10d
!=M10d_No
) return 0; /* (2b) */
7227 if( pTabList
->a
[0].fg
.jointype
& JT_LTORJ
) return 0; /* (3) */
7228 if( OptimizationDisabled(pParse
->db
, SQLITE_Coroutines
) ) return 0; /* (4) */
7229 if( isSelfJoinView(pTabList
, pItem
, i
+1, pTabList
->nSrc
)!=0 ){
7233 if( pTabList
->nSrc
==1 ) return 1; /* (1a) */
7234 if( pTabList
->a
[1].fg
.jointype
& JT_CROSS
) return 1; /* (1b) */
7235 if( selFlags
& SF_UpdateFrom
) return 0; /* (1c-iii) */
7238 if( selFlags
& SF_UpdateFrom
) return 0; /* (1c-iii) */
7239 while( 1 /*exit-by-break*/ ){
7240 if( pItem
->fg
.jointype
& (JT_OUTER
|JT_CROSS
) ) return 0; /* (1c-ii) */
7244 if( pItem
->pSelect
!=0 ) return 0; /* (1c-i) */
7250 ** Generate code for the SELECT statement given in the p argument.
7252 ** The results are returned according to the SelectDest structure.
7253 ** See comments in sqliteInt.h for further information.
7255 ** This routine returns the number of errors. If any errors are
7256 ** encountered, then an appropriate error message is left in
7259 ** This routine does NOT free the Select structure passed in. The
7260 ** calling function needs to do that.
7263 Parse
*pParse
, /* The parser context */
7264 Select
*p
, /* The SELECT statement being coded. */
7265 SelectDest
*pDest
/* What to do with the query results */
7267 int i
, j
; /* Loop counters */
7268 WhereInfo
*pWInfo
; /* Return from sqlite3WhereBegin() */
7269 Vdbe
*v
; /* The virtual machine under construction */
7270 int isAgg
; /* True for select lists like "count(*)" */
7271 ExprList
*pEList
= 0; /* List of columns to extract. */
7272 SrcList
*pTabList
; /* List of tables to select from */
7273 Expr
*pWhere
; /* The WHERE clause. May be NULL */
7274 ExprList
*pGroupBy
; /* The GROUP BY clause. May be NULL */
7275 Expr
*pHaving
; /* The HAVING clause. May be NULL */
7276 AggInfo
*pAggInfo
= 0; /* Aggregate information */
7277 int rc
= 1; /* Value to return from this function */
7278 DistinctCtx sDistinct
; /* Info on how to code the DISTINCT keyword */
7279 SortCtx sSort
; /* Info on how to code the ORDER BY clause */
7280 int iEnd
; /* Address of the end of the query */
7281 sqlite3
*db
; /* The database connection */
7282 ExprList
*pMinMaxOrderBy
= 0; /* Added ORDER BY for min/max queries */
7283 u8 minMaxFlag
; /* Flag for min/max queries */
7286 assert( pParse
==db
->pParse
);
7287 v
= sqlite3GetVdbe(pParse
);
7288 if( p
==0 || pParse
->nErr
){
7291 assert( db
->mallocFailed
==0 );
7292 if( sqlite3AuthCheck(pParse
, SQLITE_SELECT
, 0, 0, 0) ) return 1;
7293 #if TREETRACE_ENABLED
7294 TREETRACE(0x1,pParse
,p
, ("begin processing:\n", pParse
->addrExplain
));
7295 if( sqlite3TreeTrace
& 0x10000 ){
7296 if( (sqlite3TreeTrace
& 0x10001)==0x10000 ){
7297 sqlite3TreeViewLine(0, "In sqlite3Select() at %s:%d",
7298 __FILE__
, __LINE__
);
7300 sqlite3ShowSelect(p
);
7304 assert( p
->pOrderBy
==0 || pDest
->eDest
!=SRT_DistFifo
);
7305 assert( p
->pOrderBy
==0 || pDest
->eDest
!=SRT_Fifo
);
7306 assert( p
->pOrderBy
==0 || pDest
->eDest
!=SRT_DistQueue
);
7307 assert( p
->pOrderBy
==0 || pDest
->eDest
!=SRT_Queue
);
7308 if( IgnorableDistinct(pDest
) ){
7309 assert(pDest
->eDest
==SRT_Exists
|| pDest
->eDest
==SRT_Union
||
7310 pDest
->eDest
==SRT_Except
|| pDest
->eDest
==SRT_Discard
||
7311 pDest
->eDest
==SRT_DistQueue
|| pDest
->eDest
==SRT_DistFifo
);
7312 /* All of these destinations are also able to ignore the ORDER BY clause */
7314 #if TREETRACE_ENABLED
7315 TREETRACE(0x800,pParse
,p
, ("dropping superfluous ORDER BY:\n"));
7316 if( sqlite3TreeTrace
& 0x800 ){
7317 sqlite3TreeViewExprList(0, p
->pOrderBy
, 0, "ORDERBY");
7320 sqlite3ParserAddCleanup(pParse
, sqlite3ExprListDeleteGeneric
,
7322 testcase( pParse
->earlyCleanup
);
7325 p
->selFlags
&= ~SF_Distinct
;
7326 p
->selFlags
|= SF_NoopOrderBy
;
7328 sqlite3SelectPrep(pParse
, p
, 0);
7332 assert( db
->mallocFailed
==0 );
7333 assert( p
->pEList
!=0 );
7334 #if TREETRACE_ENABLED
7335 if( sqlite3TreeTrace
& 0x10 ){
7336 TREETRACE(0x10,pParse
,p
, ("after name resolution:\n"));
7337 sqlite3TreeViewSelect(0, p
, 0);
7341 /* If the SF_UFSrcCheck flag is set, then this function is being called
7342 ** as part of populating the temp table for an UPDATE...FROM statement.
7343 ** In this case, it is an error if the target object (pSrc->a[0]) name
7344 ** or alias is duplicated within FROM clause (pSrc->a[1..n]).
7346 ** Postgres disallows this case too. The reason is that some other
7347 ** systems handle this case differently, and not all the same way,
7348 ** which is just confusing. To avoid this, we follow PG's lead and
7349 ** disallow it altogether. */
7350 if( p
->selFlags
& SF_UFSrcCheck
){
7351 SrcItem
*p0
= &p
->pSrc
->a
[0];
7352 if( sameSrcAlias(p0
, p
->pSrc
) ){
7353 sqlite3ErrorMsg(pParse
,
7354 "target object/alias may not appear in FROM clause: %s",
7355 p0
->zAlias
? p0
->zAlias
: p0
->pTab
->zName
7360 /* Clear the SF_UFSrcCheck flag. The check has already been performed,
7361 ** and leaving this flag set can cause errors if a compound sub-query
7362 ** in p->pSrc is flattened into this query and this function called
7363 ** again as part of compound SELECT processing. */
7364 p
->selFlags
&= ~SF_UFSrcCheck
;
7367 if( pDest
->eDest
==SRT_Output
){
7368 sqlite3GenerateColumnNames(pParse
, p
);
7371 #ifndef SQLITE_OMIT_WINDOWFUNC
7372 if( sqlite3WindowRewrite(pParse
, p
) ){
7373 assert( pParse
->nErr
);
7376 #if TREETRACE_ENABLED
7377 if( p
->pWin
&& (sqlite3TreeTrace
& 0x40)!=0 ){
7378 TREETRACE(0x40,pParse
,p
, ("after window rewrite:\n"));
7379 sqlite3TreeViewSelect(0, p
, 0);
7382 #endif /* SQLITE_OMIT_WINDOWFUNC */
7384 isAgg
= (p
->selFlags
& SF_Aggregate
)!=0;
7385 memset(&sSort
, 0, sizeof(sSort
));
7386 sSort
.pOrderBy
= p
->pOrderBy
;
7388 /* Try to do various optimizations (flattening subqueries, and strength
7389 ** reduction of join operators) in the FROM clause up into the main query
7391 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
7392 for(i
=0; !p
->pPrior
&& i
<pTabList
->nSrc
; i
++){
7393 SrcItem
*pItem
= &pTabList
->a
[i
];
7394 Select
*pSub
= pItem
->pSelect
;
7395 Table
*pTab
= pItem
->pTab
;
7397 /* The expander should have already created transient Table objects
7398 ** even for FROM clause elements such as subqueries that do not correspond
7399 ** to a real table */
7402 /* Try to simplify joins:
7404 ** LEFT JOIN -> JOIN
7405 ** RIGHT JOIN -> JOIN
7406 ** FULL JOIN -> RIGHT JOIN
7408 ** If terms of the i-th table are used in the WHERE clause in such a
7409 ** way that the i-th table cannot be the NULL row of a join, then
7410 ** perform the appropriate simplification. This is called
7411 ** "OUTER JOIN strength reduction" in the SQLite documentation.
7413 if( (pItem
->fg
.jointype
& (JT_LEFT
|JT_LTORJ
))!=0
7414 && sqlite3ExprImpliesNonNullRow(p
->pWhere
, pItem
->iCursor
,
7415 pItem
->fg
.jointype
& JT_LTORJ
)
7416 && OptimizationEnabled(db
, SQLITE_SimplifyJoin
)
7418 if( pItem
->fg
.jointype
& JT_LEFT
){
7419 if( pItem
->fg
.jointype
& JT_RIGHT
){
7420 TREETRACE(0x1000,pParse
,p
,
7421 ("FULL-JOIN simplifies to RIGHT-JOIN on term %d\n",i
));
7422 pItem
->fg
.jointype
&= ~JT_LEFT
;
7424 TREETRACE(0x1000,pParse
,p
,
7425 ("LEFT-JOIN simplifies to JOIN on term %d\n",i
));
7426 pItem
->fg
.jointype
&= ~(JT_LEFT
|JT_OUTER
);
7427 unsetJoinExpr(p
->pWhere
, pItem
->iCursor
, 0);
7430 if( pItem
->fg
.jointype
& JT_LTORJ
){
7431 for(j
=i
+1; j
<pTabList
->nSrc
; j
++){
7432 SrcItem
*pI2
= &pTabList
->a
[j
];
7433 if( pI2
->fg
.jointype
& JT_RIGHT
){
7434 if( pI2
->fg
.jointype
& JT_LEFT
){
7435 TREETRACE(0x1000,pParse
,p
,
7436 ("FULL-JOIN simplifies to LEFT-JOIN on term %d\n",j
));
7437 pI2
->fg
.jointype
&= ~JT_RIGHT
;
7439 TREETRACE(0x1000,pParse
,p
,
7440 ("RIGHT-JOIN simplifies to JOIN on term %d\n",j
));
7441 pI2
->fg
.jointype
&= ~(JT_RIGHT
|JT_OUTER
);
7442 unsetJoinExpr(p
->pWhere
, pI2
->iCursor
, 1);
7446 for(j
=pTabList
->nSrc
-1; j
>=0; j
--){
7447 pTabList
->a
[j
].fg
.jointype
&= ~JT_LTORJ
;
7448 if( pTabList
->a
[j
].fg
.jointype
& JT_RIGHT
) break;
7453 /* No further action if this term of the FROM clause is not a subquery */
7454 if( pSub
==0 ) continue;
7456 /* Catch mismatch in the declared columns of a view and the number of
7457 ** columns in the SELECT on the RHS */
7458 if( pTab
->nCol
!=pSub
->pEList
->nExpr
){
7459 sqlite3ErrorMsg(pParse
, "expected %d columns for '%s' but got %d",
7460 pTab
->nCol
, pTab
->zName
, pSub
->pEList
->nExpr
);
7464 /* Do not attempt the usual optimizations (flattening and ORDER BY
7465 ** elimination) on a MATERIALIZED common table expression because
7466 ** a MATERIALIZED common table expression is an optimization fence.
7468 if( pItem
->fg
.isCte
&& pItem
->u2
.pCteUse
->eM10d
==M10d_Yes
){
7472 /* Do not try to flatten an aggregate subquery.
7474 ** Flattening an aggregate subquery is only possible if the outer query
7475 ** is not a join. But if the outer query is not a join, then the subquery
7476 ** will be implemented as a co-routine and there is no advantage to
7477 ** flattening in that case.
7479 if( (pSub
->selFlags
& SF_Aggregate
)!=0 ) continue;
7480 assert( pSub
->pGroupBy
==0 );
7482 /* If a FROM-clause subquery has an ORDER BY clause that is not
7483 ** really doing anything, then delete it now so that it does not
7484 ** interfere with query flattening. See the discussion at
7485 ** https://sqlite.org/forum/forumpost/2d76f2bcf65d256a
7487 ** Beware of these cases where the ORDER BY clause may not be safely
7490 ** (1) There is also a LIMIT clause
7491 ** (2) The subquery was added to help with window-function
7493 ** (3) The subquery is in the FROM clause of an UPDATE
7494 ** (4) The outer query uses an aggregate function other than
7495 ** the built-in count(), min(), or max().
7496 ** (5) The ORDER BY isn't going to accomplish anything because
7498 ** (a) The outer query has a different ORDER BY clause
7499 ** (b) The subquery is part of a join
7500 ** See forum post 062d576715d277c8
7502 ** Also retain the ORDER BY if the OmitOrderBy optimization is disabled.
7504 if( pSub
->pOrderBy
!=0
7505 && (p
->pOrderBy
!=0 || pTabList
->nSrc
>1) /* Condition (5) */
7506 && pSub
->pLimit
==0 /* Condition (1) */
7507 && (pSub
->selFlags
& SF_OrderByReqd
)==0 /* Condition (2) */
7508 && (p
->selFlags
& SF_OrderByReqd
)==0 /* Condition (3) and (4) */
7509 && OptimizationEnabled(db
, SQLITE_OmitOrderBy
)
7511 TREETRACE(0x800,pParse
,p
,
7512 ("omit superfluous ORDER BY on %r FROM-clause subquery\n",i
+1));
7513 sqlite3ParserAddCleanup(pParse
, sqlite3ExprListDeleteGeneric
,
7518 /* If the outer query contains a "complex" result set (that is,
7519 ** if the result set of the outer query uses functions or subqueries)
7520 ** and if the subquery contains an ORDER BY clause and if
7521 ** it will be implemented as a co-routine, then do not flatten. This
7522 ** restriction allows SQL constructs like this:
7524 ** SELECT expensive_function(x)
7525 ** FROM (SELECT x FROM tab ORDER BY y LIMIT 10);
7527 ** The expensive_function() is only computed on the 10 rows that
7528 ** are output, rather than every row of the table.
7530 ** The requirement that the outer query have a complex result set
7531 ** means that flattening does occur on simpler SQL constraints without
7532 ** the expensive_function() like:
7534 ** SELECT x FROM (SELECT x FROM tab ORDER BY y LIMIT 10);
7536 if( pSub
->pOrderBy
!=0
7538 && (p
->selFlags
& SF_ComplexResult
)!=0
7539 && (pTabList
->nSrc
==1
7540 || (pTabList
->a
[1].fg
.jointype
&(JT_OUTER
|JT_CROSS
))!=0)
7545 if( flattenSubquery(pParse
, p
, i
, isAgg
) ){
7546 if( pParse
->nErr
) goto select_end
;
7547 /* This subquery can be absorbed into its parent. */
7551 if( db
->mallocFailed
) goto select_end
;
7552 if( !IgnorableOrderby(pDest
) ){
7553 sSort
.pOrderBy
= p
->pOrderBy
;
7558 #ifndef SQLITE_OMIT_COMPOUND_SELECT
7559 /* Handle compound SELECT statements using the separate multiSelect()
7563 rc
= multiSelect(pParse
, p
, pDest
);
7564 #if TREETRACE_ENABLED
7565 TREETRACE(0x400,pParse
,p
,("end compound-select processing\n"));
7566 if( (sqlite3TreeTrace
& 0x400)!=0 && ExplainQueryPlanParent(pParse
)==0 ){
7567 sqlite3TreeViewSelect(0, p
, 0);
7570 if( p
->pNext
==0 ) ExplainQueryPlanPop(pParse
);
7575 /* Do the WHERE-clause constant propagation optimization if this is
7576 ** a join. No need to speed time on this operation for non-join queries
7577 ** as the equivalent optimization will be handled by query planner in
7578 ** sqlite3WhereBegin().
7581 && p
->pWhere
->op
==TK_AND
7582 && OptimizationEnabled(db
, SQLITE_PropagateConst
)
7583 && propagateConstants(pParse
, p
)
7585 #if TREETRACE_ENABLED
7586 if( sqlite3TreeTrace
& 0x2000 ){
7587 TREETRACE(0x2000,pParse
,p
,("After constant propagation:\n"));
7588 sqlite3TreeViewSelect(0, p
, 0);
7592 TREETRACE(0x2000,pParse
,p
,("Constant propagation not helpful\n"));
7595 if( OptimizationEnabled(db
, SQLITE_QueryFlattener
|SQLITE_CountOfView
)
7596 && countOfViewOptimization(pParse
, p
)
7598 if( db
->mallocFailed
) goto select_end
;
7602 /* For each term in the FROM clause, do two things:
7603 ** (1) Authorized unreferenced tables
7604 ** (2) Generate code for all sub-queries
7606 for(i
=0; i
<pTabList
->nSrc
; i
++){
7607 SrcItem
*pItem
= &pTabList
->a
[i
];
7611 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
7612 const char *zSavedAuthContext
;
7615 /* Issue SQLITE_READ authorizations with a fake column name for any
7616 ** tables that are referenced but from which no values are extracted.
7617 ** Examples of where these kinds of null SQLITE_READ authorizations
7620 ** SELECT count(*) FROM t1; -- SQLITE_READ t1.""
7621 ** SELECT t1.* FROM t1, t2; -- SQLITE_READ t2.""
7623 ** The fake column name is an empty string. It is possible for a table to
7624 ** have a column named by the empty string, in which case there is no way to
7625 ** distinguish between an unreferenced table and an actual reference to the
7626 ** "" column. The original design was for the fake column name to be a NULL,
7627 ** which would be unambiguous. But legacy authorization callbacks might
7628 ** assume the column name is non-NULL and segfault. The use of an empty
7629 ** string for the fake column name seems safer.
7631 if( pItem
->colUsed
==0 && pItem
->zName
!=0 ){
7632 sqlite3AuthCheck(pParse
, SQLITE_READ
, pItem
->zName
, "", pItem
->zDatabase
);
7635 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
7636 /* Generate code for all sub-queries in the FROM clause
7638 pSub
= pItem
->pSelect
;
7639 if( pSub
==0 ) continue;
7641 /* The code for a subquery should only be generated once. */
7642 assert( pItem
->addrFillSub
==0 );
7644 /* Increment Parse.nHeight by the height of the largest expression
7645 ** tree referred to by this, the parent select. The child select
7646 ** may contain expression trees of at most
7647 ** (SQLITE_MAX_EXPR_DEPTH-Parse.nHeight) height. This is a bit
7648 ** more conservative than necessary, but much easier than enforcing
7651 pParse
->nHeight
+= sqlite3SelectExprHeight(p
);
7653 /* Make copies of constant WHERE-clause terms in the outer query down
7654 ** inside the subquery. This can help the subquery to run more efficiently.
7656 if( OptimizationEnabled(db
, SQLITE_PushDown
)
7657 && (pItem
->fg
.isCte
==0
7658 || (pItem
->u2
.pCteUse
->eM10d
!=M10d_Yes
&& pItem
->u2
.pCteUse
->nUse
<2))
7659 && pushDownWhereTerms(pParse
, pSub
, p
->pWhere
, pTabList
, i
)
7661 #if TREETRACE_ENABLED
7662 if( sqlite3TreeTrace
& 0x4000 ){
7663 TREETRACE(0x4000,pParse
,p
,
7664 ("After WHERE-clause push-down into subquery %d:\n", pSub
->selId
));
7665 sqlite3TreeViewSelect(0, p
, 0);
7668 assert( pItem
->pSelect
&& (pItem
->pSelect
->selFlags
& SF_PushDown
)!=0 );
7670 TREETRACE(0x4000,pParse
,p
,("Push-down not possible\n"));
7673 /* Convert unused result columns of the subquery into simple NULL
7674 ** expressions, to avoid unneeded searching and computation.
7676 if( OptimizationEnabled(db
, SQLITE_NullUnusedCols
)
7677 && disableUnusedSubqueryResultColumns(pItem
)
7679 #if TREETRACE_ENABLED
7680 if( sqlite3TreeTrace
& 0x4000 ){
7681 TREETRACE(0x4000,pParse
,p
,
7682 ("Change unused result columns to NULL for subquery %d:\n",
7684 sqlite3TreeViewSelect(0, p
, 0);
7689 zSavedAuthContext
= pParse
->zAuthContext
;
7690 pParse
->zAuthContext
= pItem
->zName
;
7692 /* Generate code to implement the subquery
7694 if( fromClauseTermCanBeCoroutine(pParse
, pTabList
, i
, p
->selFlags
) ){
7695 /* Implement a co-routine that will return a single row of the result
7696 ** set on each invocation.
7698 int addrTop
= sqlite3VdbeCurrentAddr(v
)+1;
7700 pItem
->regReturn
= ++pParse
->nMem
;
7701 sqlite3VdbeAddOp3(v
, OP_InitCoroutine
, pItem
->regReturn
, 0, addrTop
);
7702 VdbeComment((v
, "%!S", pItem
));
7703 pItem
->addrFillSub
= addrTop
;
7704 sqlite3SelectDestInit(&dest
, SRT_Coroutine
, pItem
->regReturn
);
7705 ExplainQueryPlan((pParse
, 1, "CO-ROUTINE %!S", pItem
));
7706 sqlite3Select(pParse
, pSub
, &dest
);
7707 pItem
->pTab
->nRowLogEst
= pSub
->nSelectRow
;
7708 pItem
->fg
.viaCoroutine
= 1;
7709 pItem
->regResult
= dest
.iSdst
;
7710 sqlite3VdbeEndCoroutine(v
, pItem
->regReturn
);
7711 sqlite3VdbeJumpHere(v
, addrTop
-1);
7712 sqlite3ClearTempRegCache(pParse
);
7713 }else if( pItem
->fg
.isCte
&& pItem
->u2
.pCteUse
->addrM9e
>0 ){
7714 /* This is a CTE for which materialization code has already been
7715 ** generated. Invoke the subroutine to compute the materialization,
7716 ** the make the pItem->iCursor be a copy of the ephemeral table that
7717 ** holds the result of the materialization. */
7718 CteUse
*pCteUse
= pItem
->u2
.pCteUse
;
7719 sqlite3VdbeAddOp2(v
, OP_Gosub
, pCteUse
->regRtn
, pCteUse
->addrM9e
);
7720 if( pItem
->iCursor
!=pCteUse
->iCur
){
7721 sqlite3VdbeAddOp2(v
, OP_OpenDup
, pItem
->iCursor
, pCteUse
->iCur
);
7722 VdbeComment((v
, "%!S", pItem
));
7724 pSub
->nSelectRow
= pCteUse
->nRowEst
;
7725 }else if( (pPrior
= isSelfJoinView(pTabList
, pItem
, 0, i
))!=0 ){
7726 /* This view has already been materialized by a prior entry in
7727 ** this same FROM clause. Reuse it. */
7728 if( pPrior
->addrFillSub
){
7729 sqlite3VdbeAddOp2(v
, OP_Gosub
, pPrior
->regReturn
, pPrior
->addrFillSub
);
7731 sqlite3VdbeAddOp2(v
, OP_OpenDup
, pItem
->iCursor
, pPrior
->iCursor
);
7732 pSub
->nSelectRow
= pPrior
->pSelect
->nSelectRow
;
7734 /* Materialize the view. If the view is not correlated, generate a
7735 ** subroutine to do the materialization so that subsequent uses of
7736 ** the same view can reuse the materialization. */
7739 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
7743 pItem
->regReturn
= ++pParse
->nMem
;
7744 topAddr
= sqlite3VdbeAddOp0(v
, OP_Goto
);
7745 pItem
->addrFillSub
= topAddr
+1;
7746 pItem
->fg
.isMaterialized
= 1;
7747 if( pItem
->fg
.isCorrelated
==0 ){
7748 /* If the subquery is not correlated and if we are not inside of
7749 ** a trigger, then we only need to compute the value of the subquery
7751 onceAddr
= sqlite3VdbeAddOp0(v
, OP_Once
); VdbeCoverage(v
);
7752 VdbeComment((v
, "materialize %!S", pItem
));
7754 VdbeNoopComment((v
, "materialize %!S", pItem
));
7756 sqlite3SelectDestInit(&dest
, SRT_EphemTab
, pItem
->iCursor
);
7758 ExplainQueryPlan2(addrExplain
, (pParse
, 1, "MATERIALIZE %!S", pItem
));
7759 sqlite3Select(pParse
, pSub
, &dest
);
7760 pItem
->pTab
->nRowLogEst
= pSub
->nSelectRow
;
7761 if( onceAddr
) sqlite3VdbeJumpHere(v
, onceAddr
);
7762 sqlite3VdbeAddOp2(v
, OP_Return
, pItem
->regReturn
, topAddr
+1);
7763 VdbeComment((v
, "end %!S", pItem
));
7764 sqlite3VdbeScanStatusRange(v
, addrExplain
, addrExplain
, -1);
7765 sqlite3VdbeJumpHere(v
, topAddr
);
7766 sqlite3ClearTempRegCache(pParse
);
7767 if( pItem
->fg
.isCte
&& pItem
->fg
.isCorrelated
==0 ){
7768 CteUse
*pCteUse
= pItem
->u2
.pCteUse
;
7769 pCteUse
->addrM9e
= pItem
->addrFillSub
;
7770 pCteUse
->regRtn
= pItem
->regReturn
;
7771 pCteUse
->iCur
= pItem
->iCursor
;
7772 pCteUse
->nRowEst
= pSub
->nSelectRow
;
7775 if( db
->mallocFailed
) goto select_end
;
7776 pParse
->nHeight
-= sqlite3SelectExprHeight(p
);
7777 pParse
->zAuthContext
= zSavedAuthContext
;
7781 /* Various elements of the SELECT copied into local variables for
7785 pGroupBy
= p
->pGroupBy
;
7786 pHaving
= p
->pHaving
;
7787 sDistinct
.isTnct
= (p
->selFlags
& SF_Distinct
)!=0;
7789 #if TREETRACE_ENABLED
7790 if( sqlite3TreeTrace
& 0x8000 ){
7791 TREETRACE(0x8000,pParse
,p
,("After all FROM-clause analysis:\n"));
7792 sqlite3TreeViewSelect(0, p
, 0);
7796 /* If the query is DISTINCT with an ORDER BY but is not an aggregate, and
7797 ** if the select-list is the same as the ORDER BY list, then this query
7798 ** can be rewritten as a GROUP BY. In other words, this:
7800 ** SELECT DISTINCT xyz FROM ... ORDER BY xyz
7802 ** is transformed to:
7804 ** SELECT xyz FROM ... GROUP BY xyz ORDER BY xyz
7806 ** The second form is preferred as a single index (or temp-table) may be
7807 ** used for both the ORDER BY and DISTINCT processing. As originally
7808 ** written the query must use a temp-table for at least one of the ORDER
7809 ** BY and DISTINCT, and an index or separate temp-table for the other.
7811 if( (p
->selFlags
& (SF_Distinct
|SF_Aggregate
))==SF_Distinct
7812 && sqlite3ExprListCompare(sSort
.pOrderBy
, pEList
, -1)==0
7813 #ifndef SQLITE_OMIT_WINDOWFUNC
7817 p
->selFlags
&= ~SF_Distinct
;
7818 pGroupBy
= p
->pGroupBy
= sqlite3ExprListDup(db
, pEList
, 0);
7819 p
->selFlags
|= SF_Aggregate
;
7820 /* Notice that even thought SF_Distinct has been cleared from p->selFlags,
7821 ** the sDistinct.isTnct is still set. Hence, isTnct represents the
7822 ** original setting of the SF_Distinct flag, not the current setting */
7823 assert( sDistinct
.isTnct
);
7824 sDistinct
.isTnct
= 2;
7826 #if TREETRACE_ENABLED
7827 if( sqlite3TreeTrace
& 0x20000 ){
7828 TREETRACE(0x20000,pParse
,p
,("Transform DISTINCT into GROUP BY:\n"));
7829 sqlite3TreeViewSelect(0, p
, 0);
7834 /* If there is an ORDER BY clause, then create an ephemeral index to
7835 ** do the sorting. But this sorting ephemeral index might end up
7836 ** being unused if the data can be extracted in pre-sorted order.
7837 ** If that is the case, then the OP_OpenEphemeral instruction will be
7838 ** changed to an OP_Noop once we figure out that the sorting index is
7839 ** not needed. The sSort.addrSortIndex variable is used to facilitate
7842 if( sSort
.pOrderBy
){
7844 pKeyInfo
= sqlite3KeyInfoFromExprList(
7845 pParse
, sSort
.pOrderBy
, 0, pEList
->nExpr
);
7846 sSort
.iECursor
= pParse
->nTab
++;
7847 sSort
.addrSortIndex
=
7848 sqlite3VdbeAddOp4(v
, OP_OpenEphemeral
,
7849 sSort
.iECursor
, sSort
.pOrderBy
->nExpr
+1+pEList
->nExpr
, 0,
7850 (char*)pKeyInfo
, P4_KEYINFO
7853 sSort
.addrSortIndex
= -1;
7856 /* If the output is destined for a temporary table, open that table.
7858 if( pDest
->eDest
==SRT_EphemTab
){
7859 sqlite3VdbeAddOp2(v
, OP_OpenEphemeral
, pDest
->iSDParm
, pEList
->nExpr
);
7860 if( p
->selFlags
& SF_NestedFrom
){
7861 /* Delete or NULL-out result columns that will never be used */
7863 for(ii
=pEList
->nExpr
-1; ii
>0 && pEList
->a
[ii
].fg
.bUsed
==0; ii
--){
7864 sqlite3ExprDelete(db
, pEList
->a
[ii
].pExpr
);
7865 sqlite3DbFree(db
, pEList
->a
[ii
].zEName
);
7868 for(ii
=0; ii
<pEList
->nExpr
; ii
++){
7869 if( pEList
->a
[ii
].fg
.bUsed
==0 ) pEList
->a
[ii
].pExpr
->op
= TK_NULL
;
7876 iEnd
= sqlite3VdbeMakeLabel(pParse
);
7877 if( (p
->selFlags
& SF_FixedLimit
)==0 ){
7878 p
->nSelectRow
= 320; /* 4 billion rows */
7880 if( p
->pLimit
) computeLimitRegisters(pParse
, p
, iEnd
);
7881 if( p
->iLimit
==0 && sSort
.addrSortIndex
>=0 ){
7882 sqlite3VdbeChangeOpcode(v
, sSort
.addrSortIndex
, OP_SorterOpen
);
7883 sSort
.sortFlags
|= SORTFLAG_UseSorter
;
7886 /* Open an ephemeral index to use for the distinct set.
7888 if( p
->selFlags
& SF_Distinct
){
7889 sDistinct
.tabTnct
= pParse
->nTab
++;
7890 sDistinct
.addrTnct
= sqlite3VdbeAddOp4(v
, OP_OpenEphemeral
,
7891 sDistinct
.tabTnct
, 0, 0,
7892 (char*)sqlite3KeyInfoFromExprList(pParse
, p
->pEList
,0,0),
7894 sqlite3VdbeChangeP5(v
, BTREE_UNORDERED
);
7895 sDistinct
.eTnctType
= WHERE_DISTINCT_UNORDERED
;
7897 sDistinct
.eTnctType
= WHERE_DISTINCT_NOOP
;
7900 if( !isAgg
&& pGroupBy
==0 ){
7901 /* No aggregate functions and no GROUP BY clause */
7902 u16 wctrlFlags
= (sDistinct
.isTnct
? WHERE_WANT_DISTINCT
: 0)
7903 | (p
->selFlags
& SF_FixedLimit
);
7904 #ifndef SQLITE_OMIT_WINDOWFUNC
7905 Window
*pWin
= p
->pWin
; /* Main window object (or NULL) */
7907 sqlite3WindowCodeInit(pParse
, p
);
7910 assert( WHERE_USE_LIMIT
==SF_FixedLimit
);
7913 /* Begin the database scan. */
7914 TREETRACE(0x2,pParse
,p
,("WhereBegin\n"));
7915 pWInfo
= sqlite3WhereBegin(pParse
, pTabList
, pWhere
, sSort
.pOrderBy
,
7916 p
->pEList
, p
, wctrlFlags
, p
->nSelectRow
);
7917 if( pWInfo
==0 ) goto select_end
;
7918 if( sqlite3WhereOutputRowCount(pWInfo
) < p
->nSelectRow
){
7919 p
->nSelectRow
= sqlite3WhereOutputRowCount(pWInfo
);
7921 if( sDistinct
.isTnct
&& sqlite3WhereIsDistinct(pWInfo
) ){
7922 sDistinct
.eTnctType
= sqlite3WhereIsDistinct(pWInfo
);
7924 if( sSort
.pOrderBy
){
7925 sSort
.nOBSat
= sqlite3WhereIsOrdered(pWInfo
);
7926 sSort
.labelOBLopt
= sqlite3WhereOrderByLimitOptLabel(pWInfo
);
7927 if( sSort
.nOBSat
==sSort
.pOrderBy
->nExpr
){
7931 TREETRACE(0x2,pParse
,p
,("WhereBegin returns\n"));
7933 /* If sorting index that was created by a prior OP_OpenEphemeral
7934 ** instruction ended up not being needed, then change the OP_OpenEphemeral
7937 if( sSort
.addrSortIndex
>=0 && sSort
.pOrderBy
==0 ){
7938 sqlite3VdbeChangeToNoop(v
, sSort
.addrSortIndex
);
7941 assert( p
->pEList
==pEList
);
7942 #ifndef SQLITE_OMIT_WINDOWFUNC
7944 int addrGosub
= sqlite3VdbeMakeLabel(pParse
);
7945 int iCont
= sqlite3VdbeMakeLabel(pParse
);
7946 int iBreak
= sqlite3VdbeMakeLabel(pParse
);
7947 int regGosub
= ++pParse
->nMem
;
7949 sqlite3WindowCodeStep(pParse
, p
, pWInfo
, regGosub
, addrGosub
);
7951 sqlite3VdbeAddOp2(v
, OP_Goto
, 0, iBreak
);
7952 sqlite3VdbeResolveLabel(v
, addrGosub
);
7953 VdbeNoopComment((v
, "inner-loop subroutine"));
7954 sSort
.labelOBLopt
= 0;
7955 selectInnerLoop(pParse
, p
, -1, &sSort
, &sDistinct
, pDest
, iCont
, iBreak
);
7956 sqlite3VdbeResolveLabel(v
, iCont
);
7957 sqlite3VdbeAddOp1(v
, OP_Return
, regGosub
);
7958 VdbeComment((v
, "end inner-loop subroutine"));
7959 sqlite3VdbeResolveLabel(v
, iBreak
);
7961 #endif /* SQLITE_OMIT_WINDOWFUNC */
7963 /* Use the standard inner loop. */
7964 selectInnerLoop(pParse
, p
, -1, &sSort
, &sDistinct
, pDest
,
7965 sqlite3WhereContinueLabel(pWInfo
),
7966 sqlite3WhereBreakLabel(pWInfo
));
7968 /* End the database scan loop.
7970 TREETRACE(0x2,pParse
,p
,("WhereEnd\n"));
7971 sqlite3WhereEnd(pWInfo
);
7974 /* This case when there exist aggregate functions or a GROUP BY clause
7976 NameContext sNC
; /* Name context for processing aggregate information */
7977 int iAMem
; /* First Mem address for storing current GROUP BY */
7978 int iBMem
; /* First Mem address for previous GROUP BY */
7979 int iUseFlag
; /* Mem address holding flag indicating that at least
7980 ** one row of the input to the aggregator has been
7982 int iAbortFlag
; /* Mem address which causes query abort if positive */
7983 int groupBySort
; /* Rows come from source in GROUP BY order */
7984 int addrEnd
; /* End of processing for this SELECT */
7985 int sortPTab
= 0; /* Pseudotable used to decode sorting results */
7986 int sortOut
= 0; /* Output register from the sorter */
7987 int orderByGrp
= 0; /* True if the GROUP BY and ORDER BY are the same */
7989 /* Remove any and all aliases between the result set and the
7993 int k
; /* Loop counter */
7994 struct ExprList_item
*pItem
; /* For looping over expression in a list */
7996 for(k
=p
->pEList
->nExpr
, pItem
=p
->pEList
->a
; k
>0; k
--, pItem
++){
7997 pItem
->u
.x
.iAlias
= 0;
7999 for(k
=pGroupBy
->nExpr
, pItem
=pGroupBy
->a
; k
>0; k
--, pItem
++){
8000 pItem
->u
.x
.iAlias
= 0;
8002 assert( 66==sqlite3LogEst(100) );
8003 if( p
->nSelectRow
>66 ) p
->nSelectRow
= 66;
8005 /* If there is both a GROUP BY and an ORDER BY clause and they are
8006 ** identical, then it may be possible to disable the ORDER BY clause
8007 ** on the grounds that the GROUP BY will cause elements to come out
8008 ** in the correct order. It also may not - the GROUP BY might use a
8009 ** database index that causes rows to be grouped together as required
8010 ** but not actually sorted. Either way, record the fact that the
8011 ** ORDER BY and GROUP BY clauses are the same by setting the orderByGrp
8013 if( sSort
.pOrderBy
&& pGroupBy
->nExpr
==sSort
.pOrderBy
->nExpr
){
8015 /* The GROUP BY processing doesn't care whether rows are delivered in
8016 ** ASC or DESC order - only that each group is returned contiguously.
8017 ** So set the ASC/DESC flags in the GROUP BY to match those in the
8018 ** ORDER BY to maximize the chances of rows being delivered in an
8019 ** order that makes the ORDER BY redundant. */
8020 for(ii
=0; ii
<pGroupBy
->nExpr
; ii
++){
8022 sortFlags
= sSort
.pOrderBy
->a
[ii
].fg
.sortFlags
& KEYINFO_ORDER_DESC
;
8023 pGroupBy
->a
[ii
].fg
.sortFlags
= sortFlags
;
8025 if( sqlite3ExprListCompare(pGroupBy
, sSort
.pOrderBy
, -1)==0 ){
8030 assert( 0==sqlite3LogEst(1) );
8034 /* Create a label to jump to when we want to abort the query */
8035 addrEnd
= sqlite3VdbeMakeLabel(pParse
);
8037 /* Convert TK_COLUMN nodes into TK_AGG_COLUMN and make entries in
8038 ** sAggInfo for all TK_AGG_FUNCTION nodes in expressions of the
8039 ** SELECT statement.
8041 pAggInfo
= sqlite3DbMallocZero(db
, sizeof(*pAggInfo
) );
8043 sqlite3ParserAddCleanup(pParse
, agginfoFree
, pAggInfo
);
8044 testcase( pParse
->earlyCleanup
);
8046 if( db
->mallocFailed
){
8049 pAggInfo
->selId
= p
->selId
;
8051 pAggInfo
->pSelect
= p
;
8053 memset(&sNC
, 0, sizeof(sNC
));
8054 sNC
.pParse
= pParse
;
8055 sNC
.pSrcList
= pTabList
;
8056 sNC
.uNC
.pAggInfo
= pAggInfo
;
8057 VVA_ONLY( sNC
.ncFlags
= NC_UAggInfo
; )
8058 pAggInfo
->nSortingColumn
= pGroupBy
? pGroupBy
->nExpr
: 0;
8059 pAggInfo
->pGroupBy
= pGroupBy
;
8060 sqlite3ExprAnalyzeAggList(&sNC
, pEList
);
8061 sqlite3ExprAnalyzeAggList(&sNC
, sSort
.pOrderBy
);
8064 assert( pWhere
==p
->pWhere
);
8065 assert( pHaving
==p
->pHaving
);
8066 assert( pGroupBy
==p
->pGroupBy
);
8067 havingToWhere(pParse
, p
);
8070 sqlite3ExprAnalyzeAggregates(&sNC
, pHaving
);
8072 pAggInfo
->nAccumulator
= pAggInfo
->nColumn
;
8073 if( p
->pGroupBy
==0 && p
->pHaving
==0 && pAggInfo
->nFunc
==1 ){
8074 minMaxFlag
= minMaxQuery(db
, pAggInfo
->aFunc
[0].pFExpr
, &pMinMaxOrderBy
);
8076 minMaxFlag
= WHERE_ORDERBY_NORMAL
;
8078 analyzeAggFuncArgs(pAggInfo
, &sNC
);
8079 if( db
->mallocFailed
) goto select_end
;
8080 #if TREETRACE_ENABLED
8081 if( sqlite3TreeTrace
& 0x20 ){
8082 TREETRACE(0x20,pParse
,p
,("After aggregate analysis %p:\n", pAggInfo
));
8083 sqlite3TreeViewSelect(0, p
, 0);
8085 sqlite3DebugPrintf("MIN/MAX Optimization (0x%02x) adds:\n", minMaxFlag
);
8086 sqlite3TreeViewExprList(0, pMinMaxOrderBy
, 0, "ORDERBY");
8088 printAggInfo(pAggInfo
);
8093 /* Processing for aggregates with GROUP BY is very different and
8094 ** much more complex than aggregates without a GROUP BY.
8097 KeyInfo
*pKeyInfo
; /* Keying information for the group by clause */
8098 int addr1
; /* A-vs-B comparison jump */
8099 int addrOutputRow
; /* Start of subroutine that outputs a result row */
8100 int regOutputRow
; /* Return address register for output subroutine */
8101 int addrSetAbort
; /* Set the abort flag and return */
8102 int addrTopOfLoop
; /* Top of the input loop */
8103 int addrSortingIdx
; /* The OP_OpenEphemeral for the sorting index */
8104 int addrReset
; /* Subroutine for resetting the accumulator */
8105 int regReset
; /* Return address register for reset subroutine */
8106 ExprList
*pDistinct
= 0;
8108 int eDist
= WHERE_DISTINCT_NOOP
;
8110 if( pAggInfo
->nFunc
==1
8111 && pAggInfo
->aFunc
[0].iDistinct
>=0
8112 && ALWAYS(pAggInfo
->aFunc
[0].pFExpr
!=0)
8113 && ALWAYS(ExprUseXList(pAggInfo
->aFunc
[0].pFExpr
))
8114 && pAggInfo
->aFunc
[0].pFExpr
->x
.pList
!=0
8116 Expr
*pExpr
= pAggInfo
->aFunc
[0].pFExpr
->x
.pList
->a
[0].pExpr
;
8117 pExpr
= sqlite3ExprDup(db
, pExpr
, 0);
8118 pDistinct
= sqlite3ExprListDup(db
, pGroupBy
, 0);
8119 pDistinct
= sqlite3ExprListAppend(pParse
, pDistinct
, pExpr
);
8120 distFlag
= pDistinct
? (WHERE_WANT_DISTINCT
|WHERE_AGG_DISTINCT
) : 0;
8123 /* If there is a GROUP BY clause we might need a sorting index to
8124 ** implement it. Allocate that sorting index now. If it turns out
8125 ** that we do not need it after all, the OP_SorterOpen instruction
8126 ** will be converted into a Noop.
8128 pAggInfo
->sortingIdx
= pParse
->nTab
++;
8129 pKeyInfo
= sqlite3KeyInfoFromExprList(pParse
, pGroupBy
,
8130 0, pAggInfo
->nColumn
);
8131 addrSortingIdx
= sqlite3VdbeAddOp4(v
, OP_SorterOpen
,
8132 pAggInfo
->sortingIdx
, pAggInfo
->nSortingColumn
,
8133 0, (char*)pKeyInfo
, P4_KEYINFO
);
8135 /* Initialize memory locations used by GROUP BY aggregate processing
8137 iUseFlag
= ++pParse
->nMem
;
8138 iAbortFlag
= ++pParse
->nMem
;
8139 regOutputRow
= ++pParse
->nMem
;
8140 addrOutputRow
= sqlite3VdbeMakeLabel(pParse
);
8141 regReset
= ++pParse
->nMem
;
8142 addrReset
= sqlite3VdbeMakeLabel(pParse
);
8143 iAMem
= pParse
->nMem
+ 1;
8144 pParse
->nMem
+= pGroupBy
->nExpr
;
8145 iBMem
= pParse
->nMem
+ 1;
8146 pParse
->nMem
+= pGroupBy
->nExpr
;
8147 sqlite3VdbeAddOp2(v
, OP_Integer
, 0, iAbortFlag
);
8148 VdbeComment((v
, "clear abort flag"));
8149 sqlite3VdbeAddOp3(v
, OP_Null
, 0, iAMem
, iAMem
+pGroupBy
->nExpr
-1);
8151 /* Begin a loop that will extract all source rows in GROUP BY order.
8152 ** This might involve two separate loops with an OP_Sort in between, or
8153 ** it might be a single loop that uses an index to extract information
8154 ** in the right order to begin with.
8156 sqlite3VdbeAddOp2(v
, OP_Gosub
, regReset
, addrReset
);
8157 TREETRACE(0x2,pParse
,p
,("WhereBegin\n"));
8158 pWInfo
= sqlite3WhereBegin(pParse
, pTabList
, pWhere
, pGroupBy
, pDistinct
,
8159 p
, (sDistinct
.isTnct
==2 ? WHERE_DISTINCTBY
: WHERE_GROUPBY
)
8160 | (orderByGrp
? WHERE_SORTBYGROUP
: 0) | distFlag
, 0
8163 sqlite3ExprListDelete(db
, pDistinct
);
8166 if( pParse
->pIdxEpr
){
8167 optimizeAggregateUseOfIndexedExpr(pParse
, p
, pAggInfo
, &sNC
);
8169 assignAggregateRegisters(pParse
, pAggInfo
);
8170 eDist
= sqlite3WhereIsDistinct(pWInfo
);
8171 TREETRACE(0x2,pParse
,p
,("WhereBegin returns\n"));
8172 if( sqlite3WhereIsOrdered(pWInfo
)==pGroupBy
->nExpr
){
8173 /* The optimizer is able to deliver rows in group by order so
8174 ** we do not have to sort. The OP_OpenEphemeral table will be
8175 ** cancelled later because we still need to use the pKeyInfo
8179 /* Rows are coming out in undetermined order. We have to push
8180 ** each row into a sorting index, terminate the first loop,
8181 ** then loop over the sorting index in order to get the output
8189 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
8190 int addrExp
; /* Address of OP_Explain instruction */
8192 ExplainQueryPlan2(addrExp
, (pParse
, 0, "USE TEMP B-TREE FOR %s",
8193 (sDistinct
.isTnct
&& (p
->selFlags
&SF_Distinct
)==0) ?
8194 "DISTINCT" : "GROUP BY"
8198 nGroupBy
= pGroupBy
->nExpr
;
8201 for(i
=0; i
<pAggInfo
->nColumn
; i
++){
8202 if( pAggInfo
->aCol
[i
].iSorterColumn
>=j
){
8207 regBase
= sqlite3GetTempRange(pParse
, nCol
);
8208 sqlite3ExprCodeExprList(pParse
, pGroupBy
, regBase
, 0, 0);
8210 pAggInfo
->directMode
= 1;
8211 for(i
=0; i
<pAggInfo
->nColumn
; i
++){
8212 struct AggInfo_col
*pCol
= &pAggInfo
->aCol
[i
];
8213 if( pCol
->iSorterColumn
>=j
){
8214 sqlite3ExprCode(pParse
, pCol
->pCExpr
, j
+ regBase
);
8218 pAggInfo
->directMode
= 0;
8219 regRecord
= sqlite3GetTempReg(pParse
);
8220 sqlite3VdbeScanStatusCounters(v
, addrExp
, 0, sqlite3VdbeCurrentAddr(v
));
8221 sqlite3VdbeAddOp3(v
, OP_MakeRecord
, regBase
, nCol
, regRecord
);
8222 sqlite3VdbeAddOp2(v
, OP_SorterInsert
, pAggInfo
->sortingIdx
, regRecord
);
8223 sqlite3VdbeScanStatusRange(v
, addrExp
, sqlite3VdbeCurrentAddr(v
)-2, -1);
8224 sqlite3ReleaseTempReg(pParse
, regRecord
);
8225 sqlite3ReleaseTempRange(pParse
, regBase
, nCol
);
8226 TREETRACE(0x2,pParse
,p
,("WhereEnd\n"));
8227 sqlite3WhereEnd(pWInfo
);
8228 pAggInfo
->sortingIdxPTab
= sortPTab
= pParse
->nTab
++;
8229 sortOut
= sqlite3GetTempReg(pParse
);
8230 sqlite3VdbeScanStatusCounters(v
, addrExp
, sqlite3VdbeCurrentAddr(v
), 0);
8231 sqlite3VdbeAddOp3(v
, OP_OpenPseudo
, sortPTab
, sortOut
, nCol
);
8232 sqlite3VdbeAddOp2(v
, OP_SorterSort
, pAggInfo
->sortingIdx
, addrEnd
);
8233 VdbeComment((v
, "GROUP BY sort")); VdbeCoverage(v
);
8234 pAggInfo
->useSortingIdx
= 1;
8235 sqlite3VdbeScanStatusRange(v
, addrExp
, -1, sortPTab
);
8236 sqlite3VdbeScanStatusRange(v
, addrExp
, -1, pAggInfo
->sortingIdx
);
8239 /* If there are entries in pAgggInfo->aFunc[] that contain subexpressions
8240 ** that are indexed (and that were previously identified and tagged
8241 ** in optimizeAggregateUseOfIndexedExpr()) then those subexpressions
8242 ** must now be converted into a TK_AGG_COLUMN node so that the value
8243 ** is correctly pulled from the index rather than being recomputed. */
8244 if( pParse
->pIdxEpr
){
8245 aggregateConvertIndexedExprRefToColumn(pAggInfo
);
8246 #if TREETRACE_ENABLED
8247 if( sqlite3TreeTrace
& 0x20 ){
8248 TREETRACE(0x20, pParse
, p
,
8249 ("AggInfo function expressions converted to reference index\n"));
8250 sqlite3TreeViewSelect(0, p
, 0);
8251 printAggInfo(pAggInfo
);
8256 /* If the index or temporary table used by the GROUP BY sort
8257 ** will naturally deliver rows in the order required by the ORDER BY
8258 ** clause, cancel the ephemeral table open coded earlier.
8260 ** This is an optimization - the correct answer should result regardless.
8261 ** Use the SQLITE_GroupByOrder flag with SQLITE_TESTCTRL_OPTIMIZER to
8262 ** disable this optimization for testing purposes. */
8263 if( orderByGrp
&& OptimizationEnabled(db
, SQLITE_GroupByOrder
)
8264 && (groupBySort
|| sqlite3WhereIsSorted(pWInfo
))
8267 sqlite3VdbeChangeToNoop(v
, sSort
.addrSortIndex
);
8270 /* Evaluate the current GROUP BY terms and store in b0, b1, b2...
8271 ** (b0 is memory location iBMem+0, b1 is iBMem+1, and so forth)
8272 ** Then compare the current GROUP BY terms against the GROUP BY terms
8273 ** from the previous row currently stored in a0, a1, a2...
8275 addrTopOfLoop
= sqlite3VdbeCurrentAddr(v
);
8277 sqlite3VdbeAddOp3(v
, OP_SorterData
, pAggInfo
->sortingIdx
,
8280 for(j
=0; j
<pGroupBy
->nExpr
; j
++){
8282 sqlite3VdbeAddOp3(v
, OP_Column
, sortPTab
, j
, iBMem
+j
);
8284 pAggInfo
->directMode
= 1;
8285 sqlite3ExprCode(pParse
, pGroupBy
->a
[j
].pExpr
, iBMem
+j
);
8288 sqlite3VdbeAddOp4(v
, OP_Compare
, iAMem
, iBMem
, pGroupBy
->nExpr
,
8289 (char*)sqlite3KeyInfoRef(pKeyInfo
), P4_KEYINFO
);
8290 addr1
= sqlite3VdbeCurrentAddr(v
);
8291 sqlite3VdbeAddOp3(v
, OP_Jump
, addr1
+1, 0, addr1
+1); VdbeCoverage(v
);
8293 /* Generate code that runs whenever the GROUP BY changes.
8294 ** Changes in the GROUP BY are detected by the previous code
8295 ** block. If there were no changes, this block is skipped.
8297 ** This code copies current group by terms in b0,b1,b2,...
8298 ** over to a0,a1,a2. It then calls the output subroutine
8299 ** and resets the aggregate accumulator registers in preparation
8300 ** for the next GROUP BY batch.
8302 sqlite3ExprCodeMove(pParse
, iBMem
, iAMem
, pGroupBy
->nExpr
);
8303 sqlite3VdbeAddOp2(v
, OP_Gosub
, regOutputRow
, addrOutputRow
);
8304 VdbeComment((v
, "output one row"));
8305 sqlite3VdbeAddOp2(v
, OP_IfPos
, iAbortFlag
, addrEnd
); VdbeCoverage(v
);
8306 VdbeComment((v
, "check abort flag"));
8307 sqlite3VdbeAddOp2(v
, OP_Gosub
, regReset
, addrReset
);
8308 VdbeComment((v
, "reset accumulator"));
8310 /* Update the aggregate accumulators based on the content of
8313 sqlite3VdbeJumpHere(v
, addr1
);
8314 updateAccumulator(pParse
, iUseFlag
, pAggInfo
, eDist
);
8315 sqlite3VdbeAddOp2(v
, OP_Integer
, 1, iUseFlag
);
8316 VdbeComment((v
, "indicate data in accumulator"));
8321 sqlite3VdbeAddOp2(v
, OP_SorterNext
, pAggInfo
->sortingIdx
,addrTopOfLoop
);
8324 TREETRACE(0x2,pParse
,p
,("WhereEnd\n"));
8325 sqlite3WhereEnd(pWInfo
);
8326 sqlite3VdbeChangeToNoop(v
, addrSortingIdx
);
8328 sqlite3ExprListDelete(db
, pDistinct
);
8330 /* Output the final row of result
8332 sqlite3VdbeAddOp2(v
, OP_Gosub
, regOutputRow
, addrOutputRow
);
8333 VdbeComment((v
, "output final row"));
8335 /* Jump over the subroutines
8337 sqlite3VdbeGoto(v
, addrEnd
);
8339 /* Generate a subroutine that outputs a single row of the result
8340 ** set. This subroutine first looks at the iUseFlag. If iUseFlag
8341 ** is less than or equal to zero, the subroutine is a no-op. If
8342 ** the processing calls for the query to abort, this subroutine
8343 ** increments the iAbortFlag memory location before returning in
8344 ** order to signal the caller to abort.
8346 addrSetAbort
= sqlite3VdbeCurrentAddr(v
);
8347 sqlite3VdbeAddOp2(v
, OP_Integer
, 1, iAbortFlag
);
8348 VdbeComment((v
, "set abort flag"));
8349 sqlite3VdbeAddOp1(v
, OP_Return
, regOutputRow
);
8350 sqlite3VdbeResolveLabel(v
, addrOutputRow
);
8351 addrOutputRow
= sqlite3VdbeCurrentAddr(v
);
8352 sqlite3VdbeAddOp2(v
, OP_IfPos
, iUseFlag
, addrOutputRow
+2);
8354 VdbeComment((v
, "Groupby result generator entry point"));
8355 sqlite3VdbeAddOp1(v
, OP_Return
, regOutputRow
);
8356 finalizeAggFunctions(pParse
, pAggInfo
);
8357 sqlite3ExprIfFalse(pParse
, pHaving
, addrOutputRow
+1, SQLITE_JUMPIFNULL
);
8358 selectInnerLoop(pParse
, p
, -1, &sSort
,
8360 addrOutputRow
+1, addrSetAbort
);
8361 sqlite3VdbeAddOp1(v
, OP_Return
, regOutputRow
);
8362 VdbeComment((v
, "end groupby result generator"));
8364 /* Generate a subroutine that will reset the group-by accumulator
8366 sqlite3VdbeResolveLabel(v
, addrReset
);
8367 resetAccumulator(pParse
, pAggInfo
);
8368 sqlite3VdbeAddOp2(v
, OP_Integer
, 0, iUseFlag
);
8369 VdbeComment((v
, "indicate accumulator empty"));
8370 sqlite3VdbeAddOp1(v
, OP_Return
, regReset
);
8372 if( distFlag
!=0 && eDist
!=WHERE_DISTINCT_NOOP
){
8373 struct AggInfo_func
*pF
= &pAggInfo
->aFunc
[0];
8374 fixDistinctOpenEph(pParse
, eDist
, pF
->iDistinct
, pF
->iDistAddr
);
8376 } /* endif pGroupBy. Begin aggregate queries without GROUP BY: */
8379 if( (pTab
= isSimpleCount(p
, pAggInfo
))!=0 ){
8380 /* If isSimpleCount() returns a pointer to a Table structure, then
8381 ** the SQL statement is of the form:
8383 ** SELECT count(*) FROM <tbl>
8385 ** where the Table structure returned represents table <tbl>.
8387 ** This statement is so common that it is optimized specially. The
8388 ** OP_Count instruction is executed either on the intkey table that
8389 ** contains the data for table <tbl> or on one of its indexes. It
8390 ** is better to execute the op on an index, as indexes are almost
8391 ** always spread across less pages than their corresponding tables.
8393 const int iDb
= sqlite3SchemaToIndex(pParse
->db
, pTab
->pSchema
);
8394 const int iCsr
= pParse
->nTab
++; /* Cursor to scan b-tree */
8395 Index
*pIdx
; /* Iterator variable */
8396 KeyInfo
*pKeyInfo
= 0; /* Keyinfo for scanned index */
8397 Index
*pBest
= 0; /* Best index found so far */
8398 Pgno iRoot
= pTab
->tnum
; /* Root page of scanned b-tree */
8400 sqlite3CodeVerifySchema(pParse
, iDb
);
8401 sqlite3TableLock(pParse
, iDb
, pTab
->tnum
, 0, pTab
->zName
);
8403 /* Search for the index that has the lowest scan cost.
8405 ** (2011-04-15) Do not do a full scan of an unordered index.
8407 ** (2013-10-03) Do not count the entries in a partial index.
8409 ** In practice the KeyInfo structure will not be used. It is only
8410 ** passed to keep OP_OpenRead happy.
8412 if( !HasRowid(pTab
) ) pBest
= sqlite3PrimaryKeyIndex(pTab
);
8413 if( !p
->pSrc
->a
[0].fg
.notIndexed
){
8414 for(pIdx
=pTab
->pIndex
; pIdx
; pIdx
=pIdx
->pNext
){
8415 if( pIdx
->bUnordered
==0
8416 && pIdx
->szIdxRow
<pTab
->szTabRow
8417 && pIdx
->pPartIdxWhere
==0
8418 && (!pBest
|| pIdx
->szIdxRow
<pBest
->szIdxRow
)
8425 iRoot
= pBest
->tnum
;
8426 pKeyInfo
= sqlite3KeyInfoOfIndex(pParse
, pBest
);
8429 /* Open a read-only cursor, execute the OP_Count, close the cursor. */
8430 sqlite3VdbeAddOp4Int(v
, OP_OpenRead
, iCsr
, (int)iRoot
, iDb
, 1);
8432 sqlite3VdbeChangeP4(v
, -1, (char *)pKeyInfo
, P4_KEYINFO
);
8434 assignAggregateRegisters(pParse
, pAggInfo
);
8435 sqlite3VdbeAddOp2(v
, OP_Count
, iCsr
, AggInfoFuncReg(pAggInfo
,0));
8436 sqlite3VdbeAddOp1(v
, OP_Close
, iCsr
);
8437 explainSimpleCount(pParse
, pTab
, pBest
);
8439 int regAcc
= 0; /* "populate accumulators" flag */
8440 ExprList
*pDistinct
= 0;
8444 /* If there are accumulator registers but no min() or max() functions
8445 ** without FILTER clauses, allocate register regAcc. Register regAcc
8446 ** will contain 0 the first time the inner loop runs, and 1 thereafter.
8447 ** The code generated by updateAccumulator() uses this to ensure
8448 ** that the accumulator registers are (a) updated only once if
8449 ** there are no min() or max functions or (b) always updated for the
8450 ** first row visited by the aggregate, so that they are updated at
8451 ** least once even if the FILTER clause means the min() or max()
8452 ** function visits zero rows. */
8453 if( pAggInfo
->nAccumulator
){
8454 for(i
=0; i
<pAggInfo
->nFunc
; i
++){
8455 if( ExprHasProperty(pAggInfo
->aFunc
[i
].pFExpr
, EP_WinFunc
) ){
8458 if( pAggInfo
->aFunc
[i
].pFunc
->funcFlags
&SQLITE_FUNC_NEEDCOLL
){
8462 if( i
==pAggInfo
->nFunc
){
8463 regAcc
= ++pParse
->nMem
;
8464 sqlite3VdbeAddOp2(v
, OP_Integer
, 0, regAcc
);
8466 }else if( pAggInfo
->nFunc
==1 && pAggInfo
->aFunc
[0].iDistinct
>=0 ){
8467 assert( ExprUseXList(pAggInfo
->aFunc
[0].pFExpr
) );
8468 pDistinct
= pAggInfo
->aFunc
[0].pFExpr
->x
.pList
;
8469 distFlag
= pDistinct
? (WHERE_WANT_DISTINCT
|WHERE_AGG_DISTINCT
) : 0;
8471 assignAggregateRegisters(pParse
, pAggInfo
);
8473 /* This case runs if the aggregate has no GROUP BY clause. The
8474 ** processing is much simpler since there is only a single row
8477 assert( p
->pGroupBy
==0 );
8478 resetAccumulator(pParse
, pAggInfo
);
8480 /* If this query is a candidate for the min/max optimization, then
8481 ** minMaxFlag will have been previously set to either
8482 ** WHERE_ORDERBY_MIN or WHERE_ORDERBY_MAX and pMinMaxOrderBy will
8483 ** be an appropriate ORDER BY expression for the optimization.
8485 assert( minMaxFlag
==WHERE_ORDERBY_NORMAL
|| pMinMaxOrderBy
!=0 );
8486 assert( pMinMaxOrderBy
==0 || pMinMaxOrderBy
->nExpr
==1 );
8488 TREETRACE(0x2,pParse
,p
,("WhereBegin\n"));
8489 pWInfo
= sqlite3WhereBegin(pParse
, pTabList
, pWhere
, pMinMaxOrderBy
,
8490 pDistinct
, p
, minMaxFlag
|distFlag
, 0);
8494 TREETRACE(0x2,pParse
,p
,("WhereBegin returns\n"));
8495 eDist
= sqlite3WhereIsDistinct(pWInfo
);
8496 updateAccumulator(pParse
, regAcc
, pAggInfo
, eDist
);
8497 if( eDist
!=WHERE_DISTINCT_NOOP
){
8498 struct AggInfo_func
*pF
= pAggInfo
->aFunc
;
8500 fixDistinctOpenEph(pParse
, eDist
, pF
->iDistinct
, pF
->iDistAddr
);
8504 if( regAcc
) sqlite3VdbeAddOp2(v
, OP_Integer
, 1, regAcc
);
8506 sqlite3WhereMinMaxOptEarlyOut(v
, pWInfo
);
8508 TREETRACE(0x2,pParse
,p
,("WhereEnd\n"));
8509 sqlite3WhereEnd(pWInfo
);
8510 finalizeAggFunctions(pParse
, pAggInfo
);
8514 sqlite3ExprIfFalse(pParse
, pHaving
, addrEnd
, SQLITE_JUMPIFNULL
);
8515 selectInnerLoop(pParse
, p
, -1, 0, 0,
8516 pDest
, addrEnd
, addrEnd
);
8518 sqlite3VdbeResolveLabel(v
, addrEnd
);
8520 } /* endif aggregate query */
8522 if( sDistinct
.eTnctType
==WHERE_DISTINCT_UNORDERED
){
8523 explainTempTable(pParse
, "DISTINCT");
8526 /* If there is an ORDER BY clause, then we need to sort the results
8527 ** and send them to the callback one by one.
8529 if( sSort
.pOrderBy
){
8530 assert( p
->pEList
==pEList
);
8531 generateSortTail(pParse
, p
, &sSort
, pEList
->nExpr
, pDest
);
8534 /* Jump here to skip this query
8536 sqlite3VdbeResolveLabel(v
, iEnd
);
8538 /* The SELECT has been coded. If there is an error in the Parse structure,
8539 ** set the return code to 1. Otherwise 0. */
8540 rc
= (pParse
->nErr
>0);
8542 /* Control jumps to here if an error is encountered above, or upon
8543 ** successful coding of the SELECT.
8546 assert( db
->mallocFailed
==0 || db
->mallocFailed
==1 );
8547 assert( db
->mallocFailed
==0 || pParse
->nErr
!=0 );
8548 sqlite3ExprListDelete(db
, pMinMaxOrderBy
);
8550 if( pAggInfo
&& !db
->mallocFailed
){
8551 #if TREETRACE_ENABLED
8552 if( sqlite3TreeTrace
& 0x20 ){
8553 TREETRACE(0x20,pParse
,p
,("Finished with AggInfo\n"));
8554 printAggInfo(pAggInfo
);
8557 for(i
=0; i
<pAggInfo
->nColumn
; i
++){
8558 Expr
*pExpr
= pAggInfo
->aCol
[i
].pCExpr
;
8559 if( pExpr
==0 ) continue;
8560 assert( pExpr
->pAggInfo
==pAggInfo
);
8561 assert( pExpr
->iAgg
==i
);
8563 for(i
=0; i
<pAggInfo
->nFunc
; i
++){
8564 Expr
*pExpr
= pAggInfo
->aFunc
[i
].pFExpr
;
8566 assert( pExpr
->pAggInfo
==pAggInfo
);
8567 assert( pExpr
->iAgg
==i
);
8572 #if TREETRACE_ENABLED
8573 TREETRACE(0x1,pParse
,p
,("end processing\n"));
8574 if( (sqlite3TreeTrace
& 0x40000)!=0 && ExplainQueryPlanParent(pParse
)==0 ){
8575 sqlite3TreeViewSelect(0, p
, 0);
8578 ExplainQueryPlanPop(pParse
);