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
);
1380 pDest
->iSDParm2
= 0; /* Signal that any Bloom filter is unpopulated */
1382 int r1
= sqlite3GetTempReg(pParse
);
1383 assert( sqlite3Strlen30(pDest
->zAffSdst
)==nResultCol
);
1384 sqlite3VdbeAddOp4(v
, OP_MakeRecord
, regResult
, nResultCol
,
1385 r1
, pDest
->zAffSdst
, nResultCol
);
1386 sqlite3VdbeAddOp4Int(v
, OP_IdxInsert
, iParm
, r1
, regResult
, nResultCol
);
1387 if( pDest
->iSDParm2
){
1388 sqlite3VdbeAddOp4Int(v
, OP_FilterAdd
, pDest
->iSDParm2
, 0,
1389 regResult
, nResultCol
);
1390 ExplainQueryPlan((pParse
, 0, "CREATE BLOOM FILTER"));
1392 sqlite3ReleaseTempReg(pParse
, r1
);
1398 /* If any row exist in the result set, record that fact and abort.
1401 sqlite3VdbeAddOp2(v
, OP_Integer
, 1, iParm
);
1402 /* The LIMIT clause will terminate the loop for us */
1406 /* If this is a scalar select that is part of an expression, then
1407 ** store the results in the appropriate memory cell or array of
1408 ** memory cells and break out of the scan loop.
1412 assert( nResultCol
<=pDest
->nSdst
);
1414 pParse
, pSort
, p
, regResult
, regOrig
, nResultCol
, nPrefixReg
);
1416 assert( nResultCol
==pDest
->nSdst
);
1417 assert( regResult
==iParm
);
1418 /* The LIMIT clause will jump out of the loop for us */
1422 #endif /* #ifndef SQLITE_OMIT_SUBQUERY */
1424 case SRT_Coroutine
: /* Send data to a co-routine */
1425 case SRT_Output
: { /* Return the results */
1426 testcase( eDest
==SRT_Coroutine
);
1427 testcase( eDest
==SRT_Output
);
1429 pushOntoSorter(pParse
, pSort
, p
, regResult
, regOrig
, nResultCol
,
1431 }else if( eDest
==SRT_Coroutine
){
1432 sqlite3VdbeAddOp1(v
, OP_Yield
, pDest
->iSDParm
);
1434 sqlite3VdbeAddOp2(v
, OP_ResultRow
, regResult
, nResultCol
);
1439 #ifndef SQLITE_OMIT_CTE
1440 /* Write the results into a priority queue that is order according to
1441 ** pDest->pOrderBy (in pSO). pDest->iSDParm (in iParm) is the cursor for an
1442 ** index with pSO->nExpr+2 columns. Build a key using pSO for the first
1443 ** pSO->nExpr columns, then make sure all keys are unique by adding a
1444 ** final OP_Sequence column. The last column is the record as a blob.
1452 pSO
= pDest
->pOrderBy
;
1455 r1
= sqlite3GetTempReg(pParse
);
1456 r2
= sqlite3GetTempRange(pParse
, nKey
+2);
1458 if( eDest
==SRT_DistQueue
){
1459 /* If the destination is DistQueue, then cursor (iParm+1) is open
1460 ** on a second ephemeral index that holds all values every previously
1461 ** added to the queue. */
1462 addrTest
= sqlite3VdbeAddOp4Int(v
, OP_Found
, iParm
+1, 0,
1463 regResult
, nResultCol
);
1466 sqlite3VdbeAddOp3(v
, OP_MakeRecord
, regResult
, nResultCol
, r3
);
1467 if( eDest
==SRT_DistQueue
){
1468 sqlite3VdbeAddOp2(v
, OP_IdxInsert
, iParm
+1, r3
);
1469 sqlite3VdbeChangeP5(v
, OPFLAG_USESEEKRESULT
);
1471 for(i
=0; i
<nKey
; i
++){
1472 sqlite3VdbeAddOp2(v
, OP_SCopy
,
1473 regResult
+ pSO
->a
[i
].u
.x
.iOrderByCol
- 1,
1476 sqlite3VdbeAddOp2(v
, OP_Sequence
, iParm
, r2
+nKey
);
1477 sqlite3VdbeAddOp3(v
, OP_MakeRecord
, r2
, nKey
+2, r1
);
1478 sqlite3VdbeAddOp4Int(v
, OP_IdxInsert
, iParm
, r1
, r2
, nKey
+2);
1479 if( addrTest
) sqlite3VdbeJumpHere(v
, addrTest
);
1480 sqlite3ReleaseTempReg(pParse
, r1
);
1481 sqlite3ReleaseTempRange(pParse
, r2
, nKey
+2);
1484 #endif /* SQLITE_OMIT_CTE */
1488 #if !defined(SQLITE_OMIT_TRIGGER)
1489 /* Discard the results. This is used for SELECT statements inside
1490 ** the body of a TRIGGER. The purpose of such selects is to call
1491 ** user-defined functions that have side effects. We do not care
1492 ** about the actual results of the select.
1495 assert( eDest
==SRT_Discard
);
1501 /* Jump to the end of the loop if the LIMIT is reached. Except, if
1502 ** there is a sorter, in which case the sorter has already limited
1503 ** the output for us.
1505 if( pSort
==0 && p
->iLimit
){
1506 sqlite3VdbeAddOp2(v
, OP_DecrJumpZero
, p
->iLimit
, iBreak
); VdbeCoverage(v
);
1511 ** Allocate a KeyInfo object sufficient for an index of N key columns and
1514 KeyInfo
*sqlite3KeyInfoAlloc(sqlite3
*db
, int N
, int X
){
1515 int nExtra
= (N
+X
)*(sizeof(CollSeq
*)+1) - sizeof(CollSeq
*);
1516 KeyInfo
*p
= sqlite3DbMallocRawNN(db
, sizeof(KeyInfo
) + nExtra
);
1518 p
->aSortFlags
= (u8
*)&p
->aColl
[N
+X
];
1519 p
->nKeyField
= (u16
)N
;
1520 p
->nAllField
= (u16
)(N
+X
);
1524 memset(&p
[1], 0, nExtra
);
1526 return (KeyInfo
*)sqlite3OomFault(db
);
1532 ** Deallocate a KeyInfo object
1534 void sqlite3KeyInfoUnref(KeyInfo
*p
){
1537 assert( p
->nRef
>0 );
1539 if( p
->nRef
==0 ) sqlite3DbNNFreeNN(p
->db
, p
);
1544 ** Make a new pointer to a KeyInfo object
1546 KeyInfo
*sqlite3KeyInfoRef(KeyInfo
*p
){
1548 assert( p
->nRef
>0 );
1556 ** Return TRUE if a KeyInfo object can be change. The KeyInfo object
1557 ** can only be changed if this is just a single reference to the object.
1559 ** This routine is used only inside of assert() statements.
1561 int sqlite3KeyInfoIsWriteable(KeyInfo
*p
){ return p
->nRef
==1; }
1562 #endif /* SQLITE_DEBUG */
1565 ** Given an expression list, generate a KeyInfo structure that records
1566 ** the collating sequence for each expression in that expression list.
1568 ** If the ExprList is an ORDER BY or GROUP BY clause then the resulting
1569 ** KeyInfo structure is appropriate for initializing a virtual index to
1570 ** implement that clause. If the ExprList is the result set of a SELECT
1571 ** then the KeyInfo structure is appropriate for initializing a virtual
1572 ** index to implement a DISTINCT test.
1574 ** Space to hold the KeyInfo structure is obtained from malloc. The calling
1575 ** function is responsible for seeing that this structure is eventually
1578 KeyInfo
*sqlite3KeyInfoFromExprList(
1579 Parse
*pParse
, /* Parsing context */
1580 ExprList
*pList
, /* Form the KeyInfo object from this ExprList */
1581 int iStart
, /* Begin with this column of pList */
1582 int nExtra
/* Add this many extra columns to the end */
1586 struct ExprList_item
*pItem
;
1587 sqlite3
*db
= pParse
->db
;
1590 nExpr
= pList
->nExpr
;
1591 pInfo
= sqlite3KeyInfoAlloc(db
, nExpr
-iStart
, nExtra
+1);
1593 assert( sqlite3KeyInfoIsWriteable(pInfo
) );
1594 for(i
=iStart
, pItem
=pList
->a
+iStart
; i
<nExpr
; i
++, pItem
++){
1595 pInfo
->aColl
[i
-iStart
] = sqlite3ExprNNCollSeq(pParse
, pItem
->pExpr
);
1596 pInfo
->aSortFlags
[i
-iStart
] = pItem
->fg
.sortFlags
;
1603 ** Name of the connection operator, used for error messages.
1605 const char *sqlite3SelectOpName(int id
){
1608 case TK_ALL
: z
= "UNION ALL"; break;
1609 case TK_INTERSECT
: z
= "INTERSECT"; break;
1610 case TK_EXCEPT
: z
= "EXCEPT"; break;
1611 default: z
= "UNION"; break;
1616 #ifndef SQLITE_OMIT_EXPLAIN
1618 ** Unless an "EXPLAIN QUERY PLAN" command is being processed, this function
1619 ** is a no-op. Otherwise, it adds a single row of output to the EQP result,
1620 ** where the caption is of the form:
1622 ** "USE TEMP B-TREE FOR xxx"
1624 ** where xxx is one of "DISTINCT", "ORDER BY" or "GROUP BY". Exactly which
1625 ** is determined by the zUsage argument.
1627 static void explainTempTable(Parse
*pParse
, const char *zUsage
){
1628 ExplainQueryPlan((pParse
, 0, "USE TEMP B-TREE FOR %s", zUsage
));
1632 ** Assign expression b to lvalue a. A second, no-op, version of this macro
1633 ** is provided when SQLITE_OMIT_EXPLAIN is defined. This allows the code
1634 ** in sqlite3Select() to assign values to structure member variables that
1635 ** only exist if SQLITE_OMIT_EXPLAIN is not defined without polluting the
1636 ** code with #ifndef directives.
1638 # define explainSetInteger(a, b) a = b
1641 /* No-op versions of the explainXXX() functions and macros. */
1642 # define explainTempTable(y,z)
1643 # define explainSetInteger(y,z)
1648 ** If the inner loop was generated using a non-null pOrderBy argument,
1649 ** then the results were placed in a sorter. After the loop is terminated
1650 ** we need to run the sorter and output the results. The following
1651 ** routine generates the code needed to do that.
1653 static void generateSortTail(
1654 Parse
*pParse
, /* Parsing context */
1655 Select
*p
, /* The SELECT statement */
1656 SortCtx
*pSort
, /* Information on the ORDER BY clause */
1657 int nColumn
, /* Number of columns of data */
1658 SelectDest
*pDest
/* Write the sorted results here */
1660 Vdbe
*v
= pParse
->pVdbe
; /* The prepared statement */
1661 int addrBreak
= pSort
->labelDone
; /* Jump here to exit loop */
1662 int addrContinue
= sqlite3VdbeMakeLabel(pParse
);/* Jump here for next cycle */
1663 int addr
; /* Top of output loop. Jump for Next. */
1666 ExprList
*pOrderBy
= pSort
->pOrderBy
;
1667 int eDest
= pDest
->eDest
;
1668 int iParm
= pDest
->iSDParm
;
1672 int nKey
; /* Number of key columns in sorter record */
1673 int iSortTab
; /* Sorter cursor to read from */
1675 int bSeq
; /* True if sorter record includes seq. no. */
1677 struct ExprList_item
*aOutEx
= p
->pEList
->a
;
1678 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
1679 int addrExplain
; /* Address of OP_Explain instruction */
1682 nKey
= pOrderBy
->nExpr
- pSort
->nOBSat
;
1683 if( pSort
->nOBSat
==0 || nKey
==1 ){
1684 ExplainQueryPlan2(addrExplain
, (pParse
, 0,
1685 "USE TEMP B-TREE FOR %sORDER BY", pSort
->nOBSat
?"LAST TERM OF ":""
1688 ExplainQueryPlan2(addrExplain
, (pParse
, 0,
1689 "USE TEMP B-TREE FOR LAST %d TERMS OF ORDER BY", nKey
1692 sqlite3VdbeScanStatusRange(v
, addrExplain
,pSort
->addrPush
,pSort
->addrPushEnd
);
1693 sqlite3VdbeScanStatusCounters(v
, addrExplain
, addrExplain
, pSort
->addrPush
);
1696 assert( addrBreak
<0 );
1697 if( pSort
->labelBkOut
){
1698 sqlite3VdbeAddOp2(v
, OP_Gosub
, pSort
->regReturn
, pSort
->labelBkOut
);
1699 sqlite3VdbeGoto(v
, addrBreak
);
1700 sqlite3VdbeResolveLabel(v
, pSort
->labelBkOut
);
1703 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
1704 /* Open any cursors needed for sorter-reference expressions */
1705 for(i
=0; i
<pSort
->nDefer
; i
++){
1706 Table
*pTab
= pSort
->aDefer
[i
].pTab
;
1707 int iDb
= sqlite3SchemaToIndex(pParse
->db
, pTab
->pSchema
);
1708 sqlite3OpenTable(pParse
, pSort
->aDefer
[i
].iCsr
, iDb
, pTab
, OP_OpenRead
);
1709 nRefKey
= MAX(nRefKey
, pSort
->aDefer
[i
].nKey
);
1713 iTab
= pSort
->iECursor
;
1714 if( eDest
==SRT_Output
|| eDest
==SRT_Coroutine
|| eDest
==SRT_Mem
){
1715 if( eDest
==SRT_Mem
&& p
->iOffset
){
1716 sqlite3VdbeAddOp2(v
, OP_Null
, 0, pDest
->iSdst
);
1719 regRow
= pDest
->iSdst
;
1721 regRowid
= sqlite3GetTempReg(pParse
);
1722 if( eDest
==SRT_EphemTab
|| eDest
==SRT_Table
){
1723 regRow
= sqlite3GetTempReg(pParse
);
1726 regRow
= sqlite3GetTempRange(pParse
, nColumn
);
1729 if( pSort
->sortFlags
& SORTFLAG_UseSorter
){
1730 int regSortOut
= ++pParse
->nMem
;
1731 iSortTab
= pParse
->nTab
++;
1732 if( pSort
->labelBkOut
){
1733 addrOnce
= sqlite3VdbeAddOp0(v
, OP_Once
); VdbeCoverage(v
);
1735 sqlite3VdbeAddOp3(v
, OP_OpenPseudo
, iSortTab
, regSortOut
,
1736 nKey
+1+nColumn
+nRefKey
);
1737 if( addrOnce
) sqlite3VdbeJumpHere(v
, addrOnce
);
1738 addr
= 1 + sqlite3VdbeAddOp2(v
, OP_SorterSort
, iTab
, addrBreak
);
1740 assert( p
->iLimit
==0 && p
->iOffset
==0 );
1741 sqlite3VdbeAddOp3(v
, OP_SorterData
, iTab
, regSortOut
, iSortTab
);
1744 addr
= 1 + sqlite3VdbeAddOp2(v
, OP_Sort
, iTab
, addrBreak
); VdbeCoverage(v
);
1745 codeOffset(v
, p
->iOffset
, addrContinue
);
1749 sqlite3VdbeAddOp2(v
, OP_AddImm
, p
->iLimit
, -1);
1752 for(i
=0, iCol
=nKey
+bSeq
-1; i
<nColumn
; i
++){
1753 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
1754 if( aOutEx
[i
].fg
.bSorterRef
) continue;
1756 if( aOutEx
[i
].u
.x
.iOrderByCol
==0 ) iCol
++;
1758 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
1759 if( pSort
->nDefer
){
1761 int regKey
= sqlite3GetTempRange(pParse
, nRefKey
);
1763 for(i
=0; i
<pSort
->nDefer
; i
++){
1764 int iCsr
= pSort
->aDefer
[i
].iCsr
;
1765 Table
*pTab
= pSort
->aDefer
[i
].pTab
;
1766 int nKey
= pSort
->aDefer
[i
].nKey
;
1768 sqlite3VdbeAddOp1(v
, OP_NullRow
, iCsr
);
1769 if( HasRowid(pTab
) ){
1770 sqlite3VdbeAddOp3(v
, OP_Column
, iSortTab
, iKey
++, regKey
);
1771 sqlite3VdbeAddOp3(v
, OP_SeekRowid
, iCsr
,
1772 sqlite3VdbeCurrentAddr(v
)+1, regKey
);
1776 assert( sqlite3PrimaryKeyIndex(pTab
)->nKeyCol
==nKey
);
1777 for(k
=0; k
<nKey
; k
++){
1778 sqlite3VdbeAddOp3(v
, OP_Column
, iSortTab
, iKey
++, regKey
+k
);
1780 iJmp
= sqlite3VdbeCurrentAddr(v
);
1781 sqlite3VdbeAddOp4Int(v
, OP_SeekGE
, iCsr
, iJmp
+2, regKey
, nKey
);
1782 sqlite3VdbeAddOp4Int(v
, OP_IdxLE
, iCsr
, iJmp
+3, regKey
, nKey
);
1783 sqlite3VdbeAddOp1(v
, OP_NullRow
, iCsr
);
1786 sqlite3ReleaseTempRange(pParse
, regKey
, nRefKey
);
1789 for(i
=nColumn
-1; i
>=0; i
--){
1790 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
1791 if( aOutEx
[i
].fg
.bSorterRef
){
1792 sqlite3ExprCode(pParse
, aOutEx
[i
].pExpr
, regRow
+i
);
1797 if( aOutEx
[i
].u
.x
.iOrderByCol
){
1798 iRead
= aOutEx
[i
].u
.x
.iOrderByCol
-1;
1802 sqlite3VdbeAddOp3(v
, OP_Column
, iSortTab
, iRead
, regRow
+i
);
1803 VdbeComment((v
, "%s", aOutEx
[i
].zEName
));
1806 sqlite3VdbeScanStatusRange(v
, addrExplain
, addrExplain
, -1);
1809 case SRT_EphemTab
: {
1810 sqlite3VdbeAddOp3(v
, OP_Column
, iSortTab
, nKey
+bSeq
, regRow
);
1811 sqlite3VdbeAddOp2(v
, OP_NewRowid
, iParm
, regRowid
);
1812 sqlite3VdbeAddOp3(v
, OP_Insert
, iParm
, regRow
, regRowid
);
1813 sqlite3VdbeChangeP5(v
, OPFLAG_APPEND
);
1816 #ifndef SQLITE_OMIT_SUBQUERY
1818 assert( nColumn
==sqlite3Strlen30(pDest
->zAffSdst
) );
1819 sqlite3VdbeAddOp4(v
, OP_MakeRecord
, regRow
, nColumn
, regRowid
,
1820 pDest
->zAffSdst
, nColumn
);
1821 sqlite3VdbeAddOp4Int(v
, OP_IdxInsert
, iParm
, regRowid
, regRow
, nColumn
);
1825 /* The LIMIT clause will terminate the loop for us */
1830 int i2
= pDest
->iSDParm2
;
1831 int r1
= sqlite3GetTempReg(pParse
);
1832 sqlite3VdbeAddOp3(v
, OP_MakeRecord
,regRow
+(i2
<0),nColumn
-(i2
<0),r1
);
1834 sqlite3VdbeAddOp3(v
, OP_Insert
, iParm
, r1
, regRow
);
1836 sqlite3VdbeAddOp4Int(v
, OP_IdxInsert
, iParm
, r1
, regRow
, i2
);
1841 assert( eDest
==SRT_Output
|| eDest
==SRT_Coroutine
);
1842 testcase( eDest
==SRT_Output
);
1843 testcase( eDest
==SRT_Coroutine
);
1844 if( eDest
==SRT_Output
){
1845 sqlite3VdbeAddOp2(v
, OP_ResultRow
, pDest
->iSdst
, nColumn
);
1847 sqlite3VdbeAddOp1(v
, OP_Yield
, pDest
->iSDParm
);
1853 if( eDest
==SRT_Set
){
1854 sqlite3ReleaseTempRange(pParse
, regRow
, nColumn
);
1856 sqlite3ReleaseTempReg(pParse
, regRow
);
1858 sqlite3ReleaseTempReg(pParse
, regRowid
);
1860 /* The bottom of the loop
1862 sqlite3VdbeResolveLabel(v
, addrContinue
);
1863 if( pSort
->sortFlags
& SORTFLAG_UseSorter
){
1864 sqlite3VdbeAddOp2(v
, OP_SorterNext
, iTab
, addr
); VdbeCoverage(v
);
1866 sqlite3VdbeAddOp2(v
, OP_Next
, iTab
, addr
); VdbeCoverage(v
);
1868 sqlite3VdbeScanStatusRange(v
, addrExplain
, sqlite3VdbeCurrentAddr(v
)-1, -1);
1869 if( pSort
->regReturn
) sqlite3VdbeAddOp1(v
, OP_Return
, pSort
->regReturn
);
1870 sqlite3VdbeResolveLabel(v
, addrBreak
);
1874 ** Return a pointer to a string containing the 'declaration type' of the
1875 ** expression pExpr. The string may be treated as static by the caller.
1877 ** The declaration type is the exact datatype definition extracted from the
1878 ** original CREATE TABLE statement if the expression is a column. The
1879 ** declaration type for a ROWID field is INTEGER. Exactly when an expression
1880 ** is considered a column can be complex in the presence of subqueries. The
1881 ** result-set expression in all of the following SELECT statements is
1882 ** considered a column by this function.
1884 ** SELECT col FROM tbl;
1885 ** SELECT (SELECT col FROM tbl;
1886 ** SELECT (SELECT col FROM tbl);
1887 ** SELECT abc FROM (SELECT col AS abc FROM tbl);
1889 ** The declaration type for any expression other than a column is NULL.
1891 ** This routine has either 3 or 6 parameters depending on whether or not
1892 ** the SQLITE_ENABLE_COLUMN_METADATA compile-time option is used.
1894 #ifdef SQLITE_ENABLE_COLUMN_METADATA
1895 # define columnType(A,B,C,D,E) columnTypeImpl(A,B,C,D,E)
1896 #else /* if !defined(SQLITE_ENABLE_COLUMN_METADATA) */
1897 # define columnType(A,B,C,D,E) columnTypeImpl(A,B)
1899 static const char *columnTypeImpl(
1901 #ifndef SQLITE_ENABLE_COLUMN_METADATA
1905 const char **pzOrigDb
,
1906 const char **pzOrigTab
,
1907 const char **pzOrigCol
1910 char const *zType
= 0;
1912 #ifdef SQLITE_ENABLE_COLUMN_METADATA
1913 char const *zOrigDb
= 0;
1914 char const *zOrigTab
= 0;
1915 char const *zOrigCol
= 0;
1919 assert( pNC
->pSrcList
!=0 );
1920 switch( pExpr
->op
){
1922 /* The expression is a column. Locate the table the column is being
1923 ** extracted from in NameContext.pSrcList. This table may be real
1924 ** database table or a subquery.
1926 Table
*pTab
= 0; /* Table structure column is extracted from */
1927 Select
*pS
= 0; /* Select the column is extracted from */
1928 int iCol
= pExpr
->iColumn
; /* Index of column in pTab */
1929 while( pNC
&& !pTab
){
1930 SrcList
*pTabList
= pNC
->pSrcList
;
1931 for(j
=0;j
<pTabList
->nSrc
&& pTabList
->a
[j
].iCursor
!=pExpr
->iTable
;j
++);
1932 if( j
<pTabList
->nSrc
){
1933 pTab
= pTabList
->a
[j
].pTab
;
1934 pS
= pTabList
->a
[j
].pSelect
;
1941 /* At one time, code such as "SELECT new.x" within a trigger would
1942 ** cause this condition to run. Since then, we have restructured how
1943 ** trigger code is generated and so this condition is no longer
1944 ** possible. However, it can still be true for statements like
1947 ** CREATE TABLE t1(col INTEGER);
1948 ** SELECT (SELECT t1.col) FROM FROM t1;
1950 ** when columnType() is called on the expression "t1.col" in the
1951 ** sub-select. In this case, set the column type to NULL, even
1952 ** though it should really be "INTEGER".
1954 ** This is not a problem, as the column type of "t1.col" is never
1955 ** used. When columnType() is called on the expression
1956 ** "(SELECT t1.col)", the correct type is returned (see the TK_SELECT
1961 assert( pTab
&& ExprUseYTab(pExpr
) && pExpr
->y
.pTab
==pTab
);
1963 /* The "table" is actually a sub-select or a view in the FROM clause
1964 ** of the SELECT statement. Return the declaration type and origin
1965 ** data for the result-set column of the sub-select.
1967 if( iCol
<pS
->pEList
->nExpr
1968 && (!ViewCanHaveRowid
|| iCol
>=0)
1970 /* If iCol is less than zero, then the expression requests the
1971 ** rowid of the sub-select or view. This expression is legal (see
1972 ** test case misc2.2.2) - it always evaluates to NULL.
1975 Expr
*p
= pS
->pEList
->a
[iCol
].pExpr
;
1976 sNC
.pSrcList
= pS
->pSrc
;
1978 sNC
.pParse
= pNC
->pParse
;
1979 zType
= columnType(&sNC
, p
,&zOrigDb
,&zOrigTab
,&zOrigCol
);
1982 /* A real table or a CTE table */
1984 #ifdef SQLITE_ENABLE_COLUMN_METADATA
1985 if( iCol
<0 ) iCol
= pTab
->iPKey
;
1986 assert( iCol
==XN_ROWID
|| (iCol
>=0 && iCol
<pTab
->nCol
) );
1991 zOrigCol
= pTab
->aCol
[iCol
].zCnName
;
1992 zType
= sqlite3ColumnType(&pTab
->aCol
[iCol
],0);
1994 zOrigTab
= pTab
->zName
;
1995 if( pNC
->pParse
&& pTab
->pSchema
){
1996 int iDb
= sqlite3SchemaToIndex(pNC
->pParse
->db
, pTab
->pSchema
);
1997 zOrigDb
= pNC
->pParse
->db
->aDb
[iDb
].zDbSName
;
2000 assert( iCol
==XN_ROWID
|| (iCol
>=0 && iCol
<pTab
->nCol
) );
2004 zType
= sqlite3ColumnType(&pTab
->aCol
[iCol
],0);
2010 #ifndef SQLITE_OMIT_SUBQUERY
2012 /* The expression is a sub-select. Return the declaration type and
2013 ** origin info for the single column in the result set of the SELECT
2019 assert( ExprUseXSelect(pExpr
) );
2020 pS
= pExpr
->x
.pSelect
;
2021 p
= pS
->pEList
->a
[0].pExpr
;
2022 sNC
.pSrcList
= pS
->pSrc
;
2024 sNC
.pParse
= pNC
->pParse
;
2025 zType
= columnType(&sNC
, p
, &zOrigDb
, &zOrigTab
, &zOrigCol
);
2031 #ifdef SQLITE_ENABLE_COLUMN_METADATA
2033 assert( pzOrigTab
&& pzOrigCol
);
2034 *pzOrigDb
= zOrigDb
;
2035 *pzOrigTab
= zOrigTab
;
2036 *pzOrigCol
= zOrigCol
;
2043 ** Generate code that will tell the VDBE the declaration types of columns
2044 ** in the result set.
2046 static void generateColumnTypes(
2047 Parse
*pParse
, /* Parser context */
2048 SrcList
*pTabList
, /* List of tables */
2049 ExprList
*pEList
/* Expressions defining the result set */
2051 #ifndef SQLITE_OMIT_DECLTYPE
2052 Vdbe
*v
= pParse
->pVdbe
;
2055 sNC
.pSrcList
= pTabList
;
2056 sNC
.pParse
= pParse
;
2058 for(i
=0; i
<pEList
->nExpr
; i
++){
2059 Expr
*p
= pEList
->a
[i
].pExpr
;
2061 #ifdef SQLITE_ENABLE_COLUMN_METADATA
2062 const char *zOrigDb
= 0;
2063 const char *zOrigTab
= 0;
2064 const char *zOrigCol
= 0;
2065 zType
= columnType(&sNC
, p
, &zOrigDb
, &zOrigTab
, &zOrigCol
);
2067 /* The vdbe must make its own copy of the column-type and other
2068 ** column specific strings, in case the schema is reset before this
2069 ** virtual machine is deleted.
2071 sqlite3VdbeSetColName(v
, i
, COLNAME_DATABASE
, zOrigDb
, SQLITE_TRANSIENT
);
2072 sqlite3VdbeSetColName(v
, i
, COLNAME_TABLE
, zOrigTab
, SQLITE_TRANSIENT
);
2073 sqlite3VdbeSetColName(v
, i
, COLNAME_COLUMN
, zOrigCol
, SQLITE_TRANSIENT
);
2075 zType
= columnType(&sNC
, p
, 0, 0, 0);
2077 sqlite3VdbeSetColName(v
, i
, COLNAME_DECLTYPE
, zType
, SQLITE_TRANSIENT
);
2079 #endif /* !defined(SQLITE_OMIT_DECLTYPE) */
2084 ** Compute the column names for a SELECT statement.
2086 ** The only guarantee that SQLite makes about column names is that if the
2087 ** column has an AS clause assigning it a name, that will be the name used.
2088 ** That is the only documented guarantee. However, countless applications
2089 ** developed over the years have made baseless assumptions about column names
2090 ** and will break if those assumptions changes. Hence, use extreme caution
2091 ** when modifying this routine to avoid breaking legacy.
2093 ** See Also: sqlite3ColumnsFromExprList()
2095 ** The PRAGMA short_column_names and PRAGMA full_column_names settings are
2096 ** deprecated. The default setting is short=ON, full=OFF. 99.9% of all
2097 ** applications should operate this way. Nevertheless, we need to support the
2098 ** other modes for legacy:
2100 ** short=OFF, full=OFF: Column name is the text of the expression has it
2101 ** originally appears in the SELECT statement. In
2102 ** other words, the zSpan of the result expression.
2104 ** short=ON, full=OFF: (This is the default setting). If the result
2105 ** refers directly to a table column, then the
2106 ** result column name is just the table column
2107 ** name: COLUMN. Otherwise use zSpan.
2109 ** full=ON, short=ANY: If the result refers directly to a table column,
2110 ** then the result column name with the table name
2111 ** prefix, ex: TABLE.COLUMN. Otherwise use zSpan.
2113 void sqlite3GenerateColumnNames(
2114 Parse
*pParse
, /* Parser context */
2115 Select
*pSelect
/* Generate column names for this SELECT statement */
2117 Vdbe
*v
= pParse
->pVdbe
;
2122 sqlite3
*db
= pParse
->db
;
2123 int fullName
; /* TABLE.COLUMN if no AS clause and is a direct table ref */
2124 int srcName
; /* COLUMN or TABLE.COLUMN if no AS clause and is direct */
2126 if( pParse
->colNamesSet
) return;
2127 /* Column names are determined by the left-most term of a compound select */
2128 while( pSelect
->pPrior
) pSelect
= pSelect
->pPrior
;
2129 TREETRACE(0x80,pParse
,pSelect
,("generating column names\n"));
2130 pTabList
= pSelect
->pSrc
;
2131 pEList
= pSelect
->pEList
;
2133 assert( pTabList
!=0 );
2134 pParse
->colNamesSet
= 1;
2135 fullName
= (db
->flags
& SQLITE_FullColNames
)!=0;
2136 srcName
= (db
->flags
& SQLITE_ShortColNames
)!=0 || fullName
;
2137 sqlite3VdbeSetNumCols(v
, pEList
->nExpr
);
2138 for(i
=0; i
<pEList
->nExpr
; i
++){
2139 Expr
*p
= pEList
->a
[i
].pExpr
;
2142 assert( p
->op
!=TK_AGG_COLUMN
); /* Agg processing has not run yet */
2143 assert( p
->op
!=TK_COLUMN
2144 || (ExprUseYTab(p
) && p
->y
.pTab
!=0) ); /* Covering idx not yet coded */
2145 if( pEList
->a
[i
].zEName
&& pEList
->a
[i
].fg
.eEName
==ENAME_NAME
){
2146 /* An AS clause always takes first priority */
2147 char *zName
= pEList
->a
[i
].zEName
;
2148 sqlite3VdbeSetColName(v
, i
, COLNAME_NAME
, zName
, SQLITE_TRANSIENT
);
2149 }else if( srcName
&& p
->op
==TK_COLUMN
){
2151 int iCol
= p
->iColumn
;
2154 if( iCol
<0 ) iCol
= pTab
->iPKey
;
2155 assert( iCol
==-1 || (iCol
>=0 && iCol
<pTab
->nCol
) );
2159 zCol
= pTab
->aCol
[iCol
].zCnName
;
2163 zName
= sqlite3MPrintf(db
, "%s.%s", pTab
->zName
, zCol
);
2164 sqlite3VdbeSetColName(v
, i
, COLNAME_NAME
, zName
, SQLITE_DYNAMIC
);
2166 sqlite3VdbeSetColName(v
, i
, COLNAME_NAME
, zCol
, SQLITE_TRANSIENT
);
2169 const char *z
= pEList
->a
[i
].zEName
;
2170 z
= z
==0 ? sqlite3MPrintf(db
, "column%d", i
+1) : sqlite3DbStrDup(db
, z
);
2171 sqlite3VdbeSetColName(v
, i
, COLNAME_NAME
, z
, SQLITE_DYNAMIC
);
2174 generateColumnTypes(pParse
, pTabList
, pEList
);
2178 ** Given an expression list (which is really the list of expressions
2179 ** that form the result set of a SELECT statement) compute appropriate
2180 ** column names for a table that would hold the expression list.
2182 ** All column names will be unique.
2184 ** Only the column names are computed. Column.zType, Column.zColl,
2185 ** and other fields of Column are zeroed.
2187 ** Return SQLITE_OK on success. If a memory allocation error occurs,
2188 ** store NULL in *paCol and 0 in *pnCol and return SQLITE_NOMEM.
2190 ** The only guarantee that SQLite makes about column names is that if the
2191 ** column has an AS clause assigning it a name, that will be the name used.
2192 ** That is the only documented guarantee. However, countless applications
2193 ** developed over the years have made baseless assumptions about column names
2194 ** and will break if those assumptions changes. Hence, use extreme caution
2195 ** when modifying this routine to avoid breaking legacy.
2197 ** See Also: sqlite3GenerateColumnNames()
2199 int sqlite3ColumnsFromExprList(
2200 Parse
*pParse
, /* Parsing context */
2201 ExprList
*pEList
, /* Expr list from which to derive column names */
2202 i16
*pnCol
, /* Write the number of columns here */
2203 Column
**paCol
/* Write the new column list here */
2205 sqlite3
*db
= pParse
->db
; /* Database connection */
2206 int i
, j
; /* Loop counters */
2207 u32 cnt
; /* Index added to make the name unique */
2208 Column
*aCol
, *pCol
; /* For looping over result columns */
2209 int nCol
; /* Number of columns in the result set */
2210 char *zName
; /* Column name */
2211 int nName
; /* Size of name in zName[] */
2212 Hash ht
; /* Hash table of column names */
2215 sqlite3HashInit(&ht
);
2217 nCol
= pEList
->nExpr
;
2218 aCol
= sqlite3DbMallocZero(db
, sizeof(aCol
[0])*nCol
);
2219 testcase( aCol
==0 );
2220 if( NEVER(nCol
>32767) ) nCol
= 32767;
2225 assert( nCol
==(i16
)nCol
);
2229 for(i
=0, pCol
=aCol
; i
<nCol
&& !pParse
->nErr
; i
++, pCol
++){
2230 struct ExprList_item
*pX
= &pEList
->a
[i
];
2231 struct ExprList_item
*pCollide
;
2232 /* Get an appropriate name for the column
2234 if( (zName
= pX
->zEName
)!=0 && pX
->fg
.eEName
==ENAME_NAME
){
2235 /* If the column contains an "AS <name>" phrase, use <name> as the name */
2237 Expr
*pColExpr
= sqlite3ExprSkipCollateAndLikely(pX
->pExpr
);
2238 while( ALWAYS(pColExpr
!=0) && pColExpr
->op
==TK_DOT
){
2239 pColExpr
= pColExpr
->pRight
;
2240 assert( pColExpr
!=0 );
2242 if( pColExpr
->op
==TK_COLUMN
2243 && ALWAYS( ExprUseYTab(pColExpr
) )
2244 && ALWAYS( pColExpr
->y
.pTab
!=0 )
2246 /* For columns use the column name name */
2247 int iCol
= pColExpr
->iColumn
;
2248 pTab
= pColExpr
->y
.pTab
;
2249 if( iCol
<0 ) iCol
= pTab
->iPKey
;
2250 zName
= iCol
>=0 ? pTab
->aCol
[iCol
].zCnName
: "rowid";
2251 }else if( pColExpr
->op
==TK_ID
){
2252 assert( !ExprHasProperty(pColExpr
, EP_IntValue
) );
2253 zName
= pColExpr
->u
.zToken
;
2255 /* Use the original text of the column expression as its name */
2256 assert( zName
==pX
->zEName
); /* pointer comparison intended */
2259 if( zName
&& !sqlite3IsTrueOrFalse(zName
) ){
2260 zName
= sqlite3DbStrDup(db
, zName
);
2262 zName
= sqlite3MPrintf(db
,"column%d",i
+1);
2265 /* Make sure the column name is unique. If the name is not unique,
2266 ** append an integer to the name so that it becomes unique.
2269 while( zName
&& (pCollide
= sqlite3HashFind(&ht
, zName
))!=0 ){
2270 if( pCollide
->fg
.bUsingTerm
){
2271 pCol
->colFlags
|= COLFLAG_NOEXPAND
;
2273 nName
= sqlite3Strlen30(zName
);
2275 for(j
=nName
-1; j
>0 && sqlite3Isdigit(zName
[j
]); j
--){}
2276 if( zName
[j
]==':' ) nName
= j
;
2278 zName
= sqlite3MPrintf(db
, "%.*z:%u", nName
, zName
, ++cnt
);
2279 sqlite3ProgressCheck(pParse
);
2281 sqlite3_randomness(sizeof(cnt
), &cnt
);
2284 pCol
->zCnName
= zName
;
2285 pCol
->hName
= sqlite3StrIHash(zName
);
2286 if( pX
->fg
.bNoExpand
){
2287 pCol
->colFlags
|= COLFLAG_NOEXPAND
;
2289 sqlite3ColumnPropertiesFromName(0, pCol
);
2290 if( zName
&& sqlite3HashInsert(&ht
, zName
, pX
)==pX
){
2291 sqlite3OomFault(db
);
2294 sqlite3HashClear(&ht
);
2297 sqlite3DbFree(db
, aCol
[j
].zCnName
);
2299 sqlite3DbFree(db
, aCol
);
2308 ** pTab is a transient Table object that represents a subquery of some
2309 ** kind (maybe a parenthesized subquery in the FROM clause of a larger
2310 ** query, or a VIEW, or a CTE). This routine computes type information
2311 ** for that Table object based on the Select object that implements the
2312 ** subquery. For the purposes of this routine, "type information" means:
2314 ** * The datatype name, as it might appear in a CREATE TABLE statement
2315 ** * Which collating sequence to use for the column
2316 ** * The affinity of the column
2318 void sqlite3SubqueryColumnTypes(
2319 Parse
*pParse
, /* Parsing contexts */
2320 Table
*pTab
, /* Add column type information to this table */
2321 Select
*pSelect
, /* SELECT used to determine types and collations */
2322 char aff
/* Default affinity. */
2324 sqlite3
*db
= pParse
->db
;
2329 struct ExprList_item
*a
;
2332 assert( pSelect
!=0 );
2333 assert( (pSelect
->selFlags
& SF_Resolved
)!=0 );
2334 assert( pTab
->nCol
==pSelect
->pEList
->nExpr
|| pParse
->nErr
>0 );
2335 assert( aff
==SQLITE_AFF_NONE
|| aff
==SQLITE_AFF_BLOB
);
2336 if( db
->mallocFailed
|| IN_RENAME_OBJECT
) return;
2337 while( pSelect
->pPrior
) pSelect
= pSelect
->pPrior
;
2338 a
= pSelect
->pEList
->a
;
2339 memset(&sNC
, 0, sizeof(sNC
));
2340 sNC
.pSrcList
= pSelect
->pSrc
;
2341 for(i
=0, pCol
=pTab
->aCol
; i
<pTab
->nCol
; i
++, pCol
++){
2345 Select
*pS2
= pSelect
;
2346 pTab
->tabFlags
|= (pCol
->colFlags
& COLFLAG_NOINSERT
);
2348 /* pCol->szEst = ... // Column size est for SELECT tables never used */
2349 pCol
->affinity
= sqlite3ExprAffinity(p
);
2350 while( pCol
->affinity
<=SQLITE_AFF_NONE
&& pS2
->pNext
!=0 ){
2351 m
|= sqlite3ExprDataType(pS2
->pEList
->a
[i
].pExpr
);
2353 pCol
->affinity
= sqlite3ExprAffinity(pS2
->pEList
->a
[i
].pExpr
);
2355 if( pCol
->affinity
<=SQLITE_AFF_NONE
){
2356 pCol
->affinity
= aff
;
2358 if( pCol
->affinity
>=SQLITE_AFF_TEXT
&& (pS2
->pNext
|| pS2
!=pSelect
) ){
2359 for(pS2
=pS2
->pNext
; pS2
; pS2
=pS2
->pNext
){
2360 m
|= sqlite3ExprDataType(pS2
->pEList
->a
[i
].pExpr
);
2362 if( pCol
->affinity
==SQLITE_AFF_TEXT
&& (m
&0x01)!=0 ){
2363 pCol
->affinity
= SQLITE_AFF_BLOB
;
2365 if( pCol
->affinity
>=SQLITE_AFF_NUMERIC
&& (m
&0x02)!=0 ){
2366 pCol
->affinity
= SQLITE_AFF_BLOB
;
2368 if( pCol
->affinity
>=SQLITE_AFF_NUMERIC
&& p
->op
==TK_CAST
){
2369 pCol
->affinity
= SQLITE_AFF_FLEXNUM
;
2372 zType
= columnType(&sNC
, p
, 0, 0, 0);
2373 if( zType
==0 || pCol
->affinity
!=sqlite3AffinityType(zType
, 0) ){
2374 if( pCol
->affinity
==SQLITE_AFF_NUMERIC
2375 || pCol
->affinity
==SQLITE_AFF_FLEXNUM
2380 for(j
=1; j
<SQLITE_N_STDTYPE
; j
++){
2381 if( sqlite3StdTypeAffinity
[j
]==pCol
->affinity
){
2382 zType
= sqlite3StdType
[j
];
2389 const i64 k
= sqlite3Strlen30(zType
);
2390 n
= sqlite3Strlen30(pCol
->zCnName
);
2391 pCol
->zCnName
= sqlite3DbReallocOrFree(db
, pCol
->zCnName
, n
+k
+2);
2392 pCol
->colFlags
&= ~(COLFLAG_HASTYPE
|COLFLAG_HASCOLL
);
2393 if( pCol
->zCnName
){
2394 memcpy(&pCol
->zCnName
[n
+1], zType
, k
+1);
2395 pCol
->colFlags
|= COLFLAG_HASTYPE
;
2398 pColl
= sqlite3ExprCollSeq(pParse
, p
);
2400 assert( pTab
->pIndex
==0 );
2401 sqlite3ColumnSetColl(db
, pCol
, pColl
->zName
);
2404 pTab
->szTabRow
= 1; /* Any non-zero value works */
2408 ** Given a SELECT statement, generate a Table structure that describes
2409 ** the result set of that SELECT.
2411 Table
*sqlite3ResultSetOfSelect(Parse
*pParse
, Select
*pSelect
, char aff
){
2413 sqlite3
*db
= pParse
->db
;
2416 savedFlags
= db
->flags
;
2417 db
->flags
&= ~(u64
)SQLITE_FullColNames
;
2418 db
->flags
|= SQLITE_ShortColNames
;
2419 sqlite3SelectPrep(pParse
, pSelect
, 0);
2420 db
->flags
= savedFlags
;
2421 if( pParse
->nErr
) return 0;
2422 while( pSelect
->pPrior
) pSelect
= pSelect
->pPrior
;
2423 pTab
= sqlite3DbMallocZero(db
, sizeof(Table
) );
2429 pTab
->nRowLogEst
= 200; assert( 200==sqlite3LogEst(1048576) );
2430 sqlite3ColumnsFromExprList(pParse
, pSelect
->pEList
, &pTab
->nCol
, &pTab
->aCol
);
2431 sqlite3SubqueryColumnTypes(pParse
, pTab
, pSelect
, aff
);
2433 if( db
->mallocFailed
){
2434 sqlite3DeleteTable(db
, pTab
);
2441 ** Get a VDBE for the given parser context. Create a new one if necessary.
2442 ** If an error occurs, return NULL and leave a message in pParse.
2444 Vdbe
*sqlite3GetVdbe(Parse
*pParse
){
2445 if( pParse
->pVdbe
){
2446 return pParse
->pVdbe
;
2448 if( pParse
->pToplevel
==0
2449 && OptimizationEnabled(pParse
->db
,SQLITE_FactorOutConst
)
2451 pParse
->okConstFactor
= 1;
2453 return sqlite3VdbeCreate(pParse
);
2458 ** Compute the iLimit and iOffset fields of the SELECT based on the
2459 ** pLimit expressions. pLimit->pLeft and pLimit->pRight hold the expressions
2460 ** that appear in the original SQL statement after the LIMIT and OFFSET
2461 ** keywords. Or NULL if those keywords are omitted. iLimit and iOffset
2462 ** are the integer memory register numbers for counters used to compute
2463 ** the limit and offset. If there is no limit and/or offset, then
2464 ** iLimit and iOffset are negative.
2466 ** This routine changes the values of iLimit and iOffset only if
2467 ** a limit or offset is defined by pLimit->pLeft and pLimit->pRight. iLimit
2468 ** and iOffset should have been preset to appropriate default values (zero)
2469 ** prior to calling this routine.
2471 ** The iOffset register (if it exists) is initialized to the value
2472 ** of the OFFSET. The iLimit register is initialized to LIMIT. Register
2473 ** iOffset+1 is initialized to LIMIT+OFFSET.
2475 ** Only if pLimit->pLeft!=0 do the limit registers get
2476 ** redefined. The UNION ALL operator uses this property to force
2477 ** the reuse of the same limit and offset registers across multiple
2478 ** SELECT statements.
2480 static void computeLimitRegisters(Parse
*pParse
, Select
*p
, int iBreak
){
2485 Expr
*pLimit
= p
->pLimit
;
2487 if( p
->iLimit
) return;
2490 ** "LIMIT -1" always shows all rows. There is some
2491 ** controversy about what the correct behavior should be.
2492 ** The current implementation interprets "LIMIT 0" to mean
2496 assert( pLimit
->op
==TK_LIMIT
);
2497 assert( pLimit
->pLeft
!=0 );
2498 p
->iLimit
= iLimit
= ++pParse
->nMem
;
2499 v
= sqlite3GetVdbe(pParse
);
2501 if( sqlite3ExprIsInteger(pLimit
->pLeft
, &n
, pParse
) ){
2502 sqlite3VdbeAddOp2(v
, OP_Integer
, n
, iLimit
);
2503 VdbeComment((v
, "LIMIT counter"));
2505 sqlite3VdbeGoto(v
, iBreak
);
2506 }else if( n
>=0 && p
->nSelectRow
>sqlite3LogEst((u64
)n
) ){
2507 p
->nSelectRow
= sqlite3LogEst((u64
)n
);
2508 p
->selFlags
|= SF_FixedLimit
;
2511 sqlite3ExprCode(pParse
, pLimit
->pLeft
, iLimit
);
2512 sqlite3VdbeAddOp1(v
, OP_MustBeInt
, iLimit
); VdbeCoverage(v
);
2513 VdbeComment((v
, "LIMIT counter"));
2514 sqlite3VdbeAddOp2(v
, OP_IfNot
, iLimit
, iBreak
); VdbeCoverage(v
);
2516 if( pLimit
->pRight
){
2517 p
->iOffset
= iOffset
= ++pParse
->nMem
;
2518 pParse
->nMem
++; /* Allocate an extra register for limit+offset */
2519 sqlite3ExprCode(pParse
, pLimit
->pRight
, iOffset
);
2520 sqlite3VdbeAddOp1(v
, OP_MustBeInt
, iOffset
); VdbeCoverage(v
);
2521 VdbeComment((v
, "OFFSET counter"));
2522 sqlite3VdbeAddOp3(v
, OP_OffsetLimit
, iLimit
, iOffset
+1, iOffset
);
2523 VdbeComment((v
, "LIMIT+OFFSET"));
2528 #ifndef SQLITE_OMIT_COMPOUND_SELECT
2530 ** Return the appropriate collating sequence for the iCol-th column of
2531 ** the result set for the compound-select statement "p". Return NULL if
2532 ** the column has no default collating sequence.
2534 ** The collating sequence for the compound select is taken from the
2535 ** left-most term of the select that has a collating sequence.
2537 static CollSeq
*multiSelectCollSeq(Parse
*pParse
, Select
*p
, int iCol
){
2540 pRet
= multiSelectCollSeq(pParse
, p
->pPrior
, iCol
);
2545 /* iCol must be less than p->pEList->nExpr. Otherwise an error would
2546 ** have been thrown during name resolution and we would not have gotten
2548 if( pRet
==0 && ALWAYS(iCol
<p
->pEList
->nExpr
) ){
2549 pRet
= sqlite3ExprCollSeq(pParse
, p
->pEList
->a
[iCol
].pExpr
);
2555 ** The select statement passed as the second parameter is a compound SELECT
2556 ** with an ORDER BY clause. This function allocates and returns a KeyInfo
2557 ** structure suitable for implementing the ORDER BY.
2559 ** Space to hold the KeyInfo structure is obtained from malloc. The calling
2560 ** function is responsible for ensuring that this structure is eventually
2563 static KeyInfo
*multiSelectOrderByKeyInfo(Parse
*pParse
, Select
*p
, int nExtra
){
2564 ExprList
*pOrderBy
= p
->pOrderBy
;
2565 int nOrderBy
= ALWAYS(pOrderBy
!=0) ? pOrderBy
->nExpr
: 0;
2566 sqlite3
*db
= pParse
->db
;
2567 KeyInfo
*pRet
= sqlite3KeyInfoAlloc(db
, nOrderBy
+nExtra
, 1);
2570 for(i
=0; i
<nOrderBy
; i
++){
2571 struct ExprList_item
*pItem
= &pOrderBy
->a
[i
];
2572 Expr
*pTerm
= pItem
->pExpr
;
2575 if( pTerm
->flags
& EP_Collate
){
2576 pColl
= sqlite3ExprCollSeq(pParse
, pTerm
);
2578 pColl
= multiSelectCollSeq(pParse
, p
, pItem
->u
.x
.iOrderByCol
-1);
2579 if( pColl
==0 ) pColl
= db
->pDfltColl
;
2580 pOrderBy
->a
[i
].pExpr
=
2581 sqlite3ExprAddCollateString(pParse
, pTerm
, pColl
->zName
);
2583 assert( sqlite3KeyInfoIsWriteable(pRet
) );
2584 pRet
->aColl
[i
] = pColl
;
2585 pRet
->aSortFlags
[i
] = pOrderBy
->a
[i
].fg
.sortFlags
;
2592 #ifndef SQLITE_OMIT_CTE
2594 ** This routine generates VDBE code to compute the content of a WITH RECURSIVE
2595 ** query of the form:
2597 ** <recursive-table> AS (<setup-query> UNION [ALL] <recursive-query>)
2598 ** \___________/ \_______________/
2602 ** There is exactly one reference to the recursive-table in the FROM clause
2603 ** of recursive-query, marked with the SrcList->a[].fg.isRecursive flag.
2605 ** The setup-query runs once to generate an initial set of rows that go
2606 ** into a Queue table. Rows are extracted from the Queue table one by
2607 ** one. Each row extracted from Queue is output to pDest. Then the single
2608 ** extracted row (now in the iCurrent table) becomes the content of the
2609 ** recursive-table for a recursive-query run. The output of the recursive-query
2610 ** is added back into the Queue table. Then another row is extracted from Queue
2611 ** and the iteration continues until the Queue table is empty.
2613 ** If the compound query operator is UNION then no duplicate rows are ever
2614 ** inserted into the Queue table. The iDistinct table keeps a copy of all rows
2615 ** that have ever been inserted into Queue and causes duplicates to be
2616 ** discarded. If the operator is UNION ALL, then duplicates are allowed.
2618 ** If the query has an ORDER BY, then entries in the Queue table are kept in
2619 ** ORDER BY order and the first entry is extracted for each cycle. Without
2620 ** an ORDER BY, the Queue table is just a FIFO.
2622 ** If a LIMIT clause is provided, then the iteration stops after LIMIT rows
2623 ** have been output to pDest. A LIMIT of zero means to output no rows and a
2624 ** negative LIMIT means to output all rows. If there is also an OFFSET clause
2625 ** with a positive value, then the first OFFSET outputs are discarded rather
2626 ** than being sent to pDest. The LIMIT count does not begin until after OFFSET
2627 ** rows have been skipped.
2629 static void generateWithRecursiveQuery(
2630 Parse
*pParse
, /* Parsing context */
2631 Select
*p
, /* The recursive SELECT to be coded */
2632 SelectDest
*pDest
/* What to do with query results */
2634 SrcList
*pSrc
= p
->pSrc
; /* The FROM clause of the recursive query */
2635 int nCol
= p
->pEList
->nExpr
; /* Number of columns in the recursive table */
2636 Vdbe
*v
= pParse
->pVdbe
; /* The prepared statement under construction */
2637 Select
*pSetup
; /* The setup query */
2638 Select
*pFirstRec
; /* Left-most recursive term */
2639 int addrTop
; /* Top of the loop */
2640 int addrCont
, addrBreak
; /* CONTINUE and BREAK addresses */
2641 int iCurrent
= 0; /* The Current table */
2642 int regCurrent
; /* Register holding Current table */
2643 int iQueue
; /* The Queue table */
2644 int iDistinct
= 0; /* To ensure unique results if UNION */
2645 int eDest
= SRT_Fifo
; /* How to write to Queue */
2646 SelectDest destQueue
; /* SelectDest targeting the Queue table */
2647 int i
; /* Loop counter */
2648 int rc
; /* Result code */
2649 ExprList
*pOrderBy
; /* The ORDER BY clause */
2650 Expr
*pLimit
; /* Saved LIMIT and OFFSET */
2651 int regLimit
, regOffset
; /* Registers used by LIMIT and OFFSET */
2653 #ifndef SQLITE_OMIT_WINDOWFUNC
2655 sqlite3ErrorMsg(pParse
, "cannot use window functions in recursive queries");
2660 /* Obtain authorization to do a recursive query */
2661 if( sqlite3AuthCheck(pParse
, SQLITE_RECURSIVE
, 0, 0, 0) ) return;
2663 /* Process the LIMIT and OFFSET clauses, if they exist */
2664 addrBreak
= sqlite3VdbeMakeLabel(pParse
);
2665 p
->nSelectRow
= 320; /* 4 billion rows */
2666 computeLimitRegisters(pParse
, p
, addrBreak
);
2668 regLimit
= p
->iLimit
;
2669 regOffset
= p
->iOffset
;
2671 p
->iLimit
= p
->iOffset
= 0;
2672 pOrderBy
= p
->pOrderBy
;
2674 /* Locate the cursor number of the Current table */
2675 for(i
=0; ALWAYS(i
<pSrc
->nSrc
); i
++){
2676 if( pSrc
->a
[i
].fg
.isRecursive
){
2677 iCurrent
= pSrc
->a
[i
].iCursor
;
2682 /* Allocate cursors numbers for Queue and Distinct. The cursor number for
2683 ** the Distinct table must be exactly one greater than Queue in order
2684 ** for the SRT_DistFifo and SRT_DistQueue destinations to work. */
2685 iQueue
= pParse
->nTab
++;
2686 if( p
->op
==TK_UNION
){
2687 eDest
= pOrderBy
? SRT_DistQueue
: SRT_DistFifo
;
2688 iDistinct
= pParse
->nTab
++;
2690 eDest
= pOrderBy
? SRT_Queue
: SRT_Fifo
;
2692 sqlite3SelectDestInit(&destQueue
, eDest
, iQueue
);
2694 /* Allocate cursors for Current, Queue, and Distinct. */
2695 regCurrent
= ++pParse
->nMem
;
2696 sqlite3VdbeAddOp3(v
, OP_OpenPseudo
, iCurrent
, regCurrent
, nCol
);
2698 KeyInfo
*pKeyInfo
= multiSelectOrderByKeyInfo(pParse
, p
, 1);
2699 sqlite3VdbeAddOp4(v
, OP_OpenEphemeral
, iQueue
, pOrderBy
->nExpr
+2, 0,
2700 (char*)pKeyInfo
, P4_KEYINFO
);
2701 destQueue
.pOrderBy
= pOrderBy
;
2703 sqlite3VdbeAddOp2(v
, OP_OpenEphemeral
, iQueue
, nCol
);
2705 VdbeComment((v
, "Queue table"));
2707 p
->addrOpenEphm
[0] = sqlite3VdbeAddOp2(v
, OP_OpenEphemeral
, iDistinct
, 0);
2708 p
->selFlags
|= SF_UsesEphemeral
;
2711 /* Detach the ORDER BY clause from the compound SELECT */
2714 /* Figure out how many elements of the compound SELECT are part of the
2715 ** recursive query. Make sure no recursive elements use aggregate
2716 ** functions. Mark the recursive elements as UNION ALL even if they
2717 ** are really UNION because the distinctness will be enforced by the
2718 ** iDistinct table. pFirstRec is left pointing to the left-most
2719 ** recursive term of the CTE.
2721 for(pFirstRec
=p
; ALWAYS(pFirstRec
!=0); pFirstRec
=pFirstRec
->pPrior
){
2722 if( pFirstRec
->selFlags
& SF_Aggregate
){
2723 sqlite3ErrorMsg(pParse
, "recursive aggregate queries not supported");
2724 goto end_of_recursive_query
;
2726 pFirstRec
->op
= TK_ALL
;
2727 if( (pFirstRec
->pPrior
->selFlags
& SF_Recursive
)==0 ) break;
2730 /* Store the results of the setup-query in Queue. */
2731 pSetup
= pFirstRec
->pPrior
;
2733 ExplainQueryPlan((pParse
, 1, "SETUP"));
2734 rc
= sqlite3Select(pParse
, pSetup
, &destQueue
);
2736 if( rc
) goto end_of_recursive_query
;
2738 /* Find the next row in the Queue and output that row */
2739 addrTop
= sqlite3VdbeAddOp2(v
, OP_Rewind
, iQueue
, addrBreak
); VdbeCoverage(v
);
2741 /* Transfer the next row in Queue over to Current */
2742 sqlite3VdbeAddOp1(v
, OP_NullRow
, iCurrent
); /* To reset column cache */
2744 sqlite3VdbeAddOp3(v
, OP_Column
, iQueue
, pOrderBy
->nExpr
+1, regCurrent
);
2746 sqlite3VdbeAddOp2(v
, OP_RowData
, iQueue
, regCurrent
);
2748 sqlite3VdbeAddOp1(v
, OP_Delete
, iQueue
);
2750 /* Output the single row in Current */
2751 addrCont
= sqlite3VdbeMakeLabel(pParse
);
2752 codeOffset(v
, regOffset
, addrCont
);
2753 selectInnerLoop(pParse
, p
, iCurrent
,
2754 0, 0, pDest
, addrCont
, addrBreak
);
2756 sqlite3VdbeAddOp2(v
, OP_DecrJumpZero
, regLimit
, addrBreak
);
2759 sqlite3VdbeResolveLabel(v
, addrCont
);
2761 /* Execute the recursive SELECT taking the single row in Current as
2762 ** the value for the recursive-table. Store the results in the Queue.
2764 pFirstRec
->pPrior
= 0;
2765 ExplainQueryPlan((pParse
, 1, "RECURSIVE STEP"));
2766 sqlite3Select(pParse
, p
, &destQueue
);
2767 assert( pFirstRec
->pPrior
==0 );
2768 pFirstRec
->pPrior
= pSetup
;
2770 /* Keep running the loop until the Queue is empty */
2771 sqlite3VdbeGoto(v
, addrTop
);
2772 sqlite3VdbeResolveLabel(v
, addrBreak
);
2774 end_of_recursive_query
:
2775 sqlite3ExprListDelete(pParse
->db
, p
->pOrderBy
);
2776 p
->pOrderBy
= pOrderBy
;
2780 #endif /* SQLITE_OMIT_CTE */
2782 /* Forward references */
2783 static int multiSelectOrderBy(
2784 Parse
*pParse
, /* Parsing context */
2785 Select
*p
, /* The right-most of SELECTs to be coded */
2786 SelectDest
*pDest
/* What to do with query results */
2790 ** Handle the special case of a compound-select that originates from a
2791 ** VALUES clause. By handling this as a special case, we avoid deep
2792 ** recursion, and thus do not need to enforce the SQLITE_LIMIT_COMPOUND_SELECT
2793 ** on a VALUES clause.
2795 ** Because the Select object originates from a VALUES clause:
2796 ** (1) There is no LIMIT or OFFSET or else there is a LIMIT of exactly 1
2797 ** (2) All terms are UNION ALL
2798 ** (3) There is no ORDER BY clause
2800 ** The "LIMIT of exactly 1" case of condition (1) comes about when a VALUES
2801 ** clause occurs within scalar expression (ex: "SELECT (VALUES(1),(2),(3))").
2802 ** The sqlite3CodeSubselect will have added the LIMIT 1 clause in tht case.
2803 ** Since the limit is exactly 1, we only need to evaluate the left-most VALUES.
2805 static int multiSelectValues(
2806 Parse
*pParse
, /* Parsing context */
2807 Select
*p
, /* The right-most of SELECTs to be coded */
2808 SelectDest
*pDest
/* What to do with query results */
2812 int bShowAll
= p
->pLimit
==0;
2813 assert( p
->selFlags
& SF_MultiValue
);
2815 assert( p
->selFlags
& SF_Values
);
2816 assert( p
->op
==TK_ALL
|| (p
->op
==TK_SELECT
&& p
->pPrior
==0) );
2817 assert( p
->pNext
==0 || p
->pEList
->nExpr
==p
->pNext
->pEList
->nExpr
);
2818 #ifndef SQLITE_OMIT_WINDOWFUNC
2819 if( p
->pWin
) return -1;
2821 if( p
->pPrior
==0 ) break;
2822 assert( p
->pPrior
->pNext
==p
);
2826 ExplainQueryPlan((pParse
, 0, "SCAN %d CONSTANT ROW%s", nRow
,
2827 nRow
==1 ? "" : "S"));
2829 selectInnerLoop(pParse
, p
, -1, 0, 0, pDest
, 1, 1);
2830 if( !bShowAll
) break;
2831 p
->nSelectRow
= nRow
;
2838 ** Return true if the SELECT statement which is known to be the recursive
2839 ** part of a recursive CTE still has its anchor terms attached. If the
2840 ** anchor terms have already been removed, then return false.
2842 static int hasAnchor(Select
*p
){
2843 while( p
&& (p
->selFlags
& SF_Recursive
)!=0 ){ p
= p
->pPrior
; }
2848 ** This routine is called to process a compound query form from
2849 ** two or more separate queries using UNION, UNION ALL, EXCEPT, or
2852 ** "p" points to the right-most of the two queries. the query on the
2853 ** left is p->pPrior. The left query could also be a compound query
2854 ** in which case this routine will be called recursively.
2856 ** The results of the total query are to be written into a destination
2857 ** of type eDest with parameter iParm.
2859 ** Example 1: Consider a three-way compound SQL statement.
2861 ** SELECT a FROM t1 UNION SELECT b FROM t2 UNION SELECT c FROM t3
2863 ** This statement is parsed up as follows:
2867 ** `-----> SELECT b FROM t2
2869 ** `------> SELECT a FROM t1
2871 ** The arrows in the diagram above represent the Select.pPrior pointer.
2872 ** So if this routine is called with p equal to the t3 query, then
2873 ** pPrior will be the t2 query. p->op will be TK_UNION in this case.
2875 ** Notice that because of the way SQLite parses compound SELECTs, the
2876 ** individual selects always group from left to right.
2878 static int multiSelect(
2879 Parse
*pParse
, /* Parsing context */
2880 Select
*p
, /* The right-most of SELECTs to be coded */
2881 SelectDest
*pDest
/* What to do with query results */
2883 int rc
= SQLITE_OK
; /* Success code from a subroutine */
2884 Select
*pPrior
; /* Another SELECT immediately to our left */
2885 Vdbe
*v
; /* Generate code to this VDBE */
2886 SelectDest dest
; /* Alternative data destination */
2887 Select
*pDelete
= 0; /* Chain of simple selects to delete */
2888 sqlite3
*db
; /* Database connection */
2890 /* Make sure there is no ORDER BY or LIMIT clause on prior SELECTs. Only
2891 ** the last (right-most) SELECT in the series may have an ORDER BY or LIMIT.
2893 assert( p
&& p
->pPrior
); /* Calling function guarantees this much */
2894 assert( (p
->selFlags
& SF_Recursive
)==0 || p
->op
==TK_ALL
|| p
->op
==TK_UNION
);
2895 assert( p
->selFlags
& SF_Compound
);
2899 assert( pPrior
->pOrderBy
==0 );
2900 assert( pPrior
->pLimit
==0 );
2902 v
= sqlite3GetVdbe(pParse
);
2903 assert( v
!=0 ); /* The VDBE already created by calling function */
2905 /* Create the destination temporary table if necessary
2907 if( dest
.eDest
==SRT_EphemTab
){
2908 assert( p
->pEList
);
2909 sqlite3VdbeAddOp2(v
, OP_OpenEphemeral
, dest
.iSDParm
, p
->pEList
->nExpr
);
2910 dest
.eDest
= SRT_Table
;
2913 /* Special handling for a compound-select that originates as a VALUES clause.
2915 if( p
->selFlags
& SF_MultiValue
){
2916 rc
= multiSelectValues(pParse
, p
, &dest
);
2917 if( rc
>=0 ) goto multi_select_end
;
2921 /* Make sure all SELECTs in the statement have the same number of elements
2922 ** in their result sets.
2924 assert( p
->pEList
&& pPrior
->pEList
);
2925 assert( p
->pEList
->nExpr
==pPrior
->pEList
->nExpr
);
2927 #ifndef SQLITE_OMIT_CTE
2928 if( (p
->selFlags
& SF_Recursive
)!=0 && hasAnchor(p
) ){
2929 generateWithRecursiveQuery(pParse
, p
, &dest
);
2933 /* Compound SELECTs that have an ORDER BY clause are handled separately.
2936 return multiSelectOrderBy(pParse
, p
, pDest
);
2939 #ifndef SQLITE_OMIT_EXPLAIN
2940 if( pPrior
->pPrior
==0 ){
2941 ExplainQueryPlan((pParse
, 1, "COMPOUND QUERY"));
2942 ExplainQueryPlan((pParse
, 1, "LEFT-MOST SUBQUERY"));
2946 /* Generate code for the left and right SELECT statements.
2951 int nLimit
= 0; /* Initialize to suppress harmless compiler warning */
2952 assert( !pPrior
->pLimit
);
2953 pPrior
->iLimit
= p
->iLimit
;
2954 pPrior
->iOffset
= p
->iOffset
;
2955 pPrior
->pLimit
= p
->pLimit
;
2956 TREETRACE(0x200, pParse
, p
, ("multiSelect UNION ALL left...\n"));
2957 rc
= sqlite3Select(pParse
, pPrior
, &dest
);
2960 goto multi_select_end
;
2963 p
->iLimit
= pPrior
->iLimit
;
2964 p
->iOffset
= pPrior
->iOffset
;
2966 addr
= sqlite3VdbeAddOp1(v
, OP_IfNot
, p
->iLimit
); VdbeCoverage(v
);
2967 VdbeComment((v
, "Jump ahead if LIMIT reached"));
2969 sqlite3VdbeAddOp3(v
, OP_OffsetLimit
,
2970 p
->iLimit
, p
->iOffset
+1, p
->iOffset
);
2973 ExplainQueryPlan((pParse
, 1, "UNION ALL"));
2974 TREETRACE(0x200, pParse
, p
, ("multiSelect UNION ALL right...\n"));
2975 rc
= sqlite3Select(pParse
, p
, &dest
);
2976 testcase( rc
!=SQLITE_OK
);
2977 pDelete
= p
->pPrior
;
2979 p
->nSelectRow
= sqlite3LogEstAdd(p
->nSelectRow
, pPrior
->nSelectRow
);
2981 && sqlite3ExprIsInteger(p
->pLimit
->pLeft
, &nLimit
, pParse
)
2982 && nLimit
>0 && p
->nSelectRow
> sqlite3LogEst((u64
)nLimit
)
2984 p
->nSelectRow
= sqlite3LogEst((u64
)nLimit
);
2987 sqlite3VdbeJumpHere(v
, addr
);
2993 int unionTab
; /* Cursor number of the temp table holding result */
2994 u8 op
= 0; /* One of the SRT_ operations to apply to self */
2995 int priorOp
; /* The SRT_ operation to apply to prior selects */
2996 Expr
*pLimit
; /* Saved values of p->nLimit */
2998 SelectDest uniondest
;
3000 testcase( p
->op
==TK_EXCEPT
);
3001 testcase( p
->op
==TK_UNION
);
3002 priorOp
= SRT_Union
;
3003 if( dest
.eDest
==priorOp
){
3004 /* We can reuse a temporary table generated by a SELECT to our
3007 assert( p
->pLimit
==0 ); /* Not allowed on leftward elements */
3008 unionTab
= dest
.iSDParm
;
3010 /* We will need to create our own temporary table to hold the
3011 ** intermediate results.
3013 unionTab
= pParse
->nTab
++;
3014 assert( p
->pOrderBy
==0 );
3015 addr
= sqlite3VdbeAddOp2(v
, OP_OpenEphemeral
, unionTab
, 0);
3016 assert( p
->addrOpenEphm
[0] == -1 );
3017 p
->addrOpenEphm
[0] = addr
;
3018 findRightmost(p
)->selFlags
|= SF_UsesEphemeral
;
3019 assert( p
->pEList
);
3023 /* Code the SELECT statements to our left
3025 assert( !pPrior
->pOrderBy
);
3026 sqlite3SelectDestInit(&uniondest
, priorOp
, unionTab
);
3027 TREETRACE(0x200, pParse
, p
, ("multiSelect EXCEPT/UNION left...\n"));
3028 rc
= sqlite3Select(pParse
, pPrior
, &uniondest
);
3030 goto multi_select_end
;
3033 /* Code the current SELECT statement
3035 if( p
->op
==TK_EXCEPT
){
3038 assert( p
->op
==TK_UNION
);
3044 uniondest
.eDest
= op
;
3045 ExplainQueryPlan((pParse
, 1, "%s USING TEMP B-TREE",
3046 sqlite3SelectOpName(p
->op
)));
3047 TREETRACE(0x200, pParse
, p
, ("multiSelect EXCEPT/UNION right...\n"));
3048 rc
= sqlite3Select(pParse
, p
, &uniondest
);
3049 testcase( rc
!=SQLITE_OK
);
3050 assert( p
->pOrderBy
==0 );
3051 pDelete
= p
->pPrior
;
3054 if( p
->op
==TK_UNION
){
3055 p
->nSelectRow
= sqlite3LogEstAdd(p
->nSelectRow
, pPrior
->nSelectRow
);
3057 sqlite3ExprDelete(db
, p
->pLimit
);
3062 /* Convert the data in the temporary table into whatever form
3063 ** it is that we currently need.
3065 assert( unionTab
==dest
.iSDParm
|| dest
.eDest
!=priorOp
);
3066 assert( p
->pEList
|| db
->mallocFailed
);
3067 if( dest
.eDest
!=priorOp
&& db
->mallocFailed
==0 ){
3068 int iCont
, iBreak
, iStart
;
3069 iBreak
= sqlite3VdbeMakeLabel(pParse
);
3070 iCont
= sqlite3VdbeMakeLabel(pParse
);
3071 computeLimitRegisters(pParse
, p
, iBreak
);
3072 sqlite3VdbeAddOp2(v
, OP_Rewind
, unionTab
, iBreak
); VdbeCoverage(v
);
3073 iStart
= sqlite3VdbeCurrentAddr(v
);
3074 selectInnerLoop(pParse
, p
, unionTab
,
3075 0, 0, &dest
, iCont
, iBreak
);
3076 sqlite3VdbeResolveLabel(v
, iCont
);
3077 sqlite3VdbeAddOp2(v
, OP_Next
, unionTab
, iStart
); VdbeCoverage(v
);
3078 sqlite3VdbeResolveLabel(v
, iBreak
);
3079 sqlite3VdbeAddOp2(v
, OP_Close
, unionTab
, 0);
3083 default: assert( p
->op
==TK_INTERSECT
); {
3085 int iCont
, iBreak
, iStart
;
3088 SelectDest intersectdest
;
3091 /* INTERSECT is different from the others since it requires
3092 ** two temporary tables. Hence it has its own case. Begin
3093 ** by allocating the tables we will need.
3095 tab1
= pParse
->nTab
++;
3096 tab2
= pParse
->nTab
++;
3097 assert( p
->pOrderBy
==0 );
3099 addr
= sqlite3VdbeAddOp2(v
, OP_OpenEphemeral
, tab1
, 0);
3100 assert( p
->addrOpenEphm
[0] == -1 );
3101 p
->addrOpenEphm
[0] = addr
;
3102 findRightmost(p
)->selFlags
|= SF_UsesEphemeral
;
3103 assert( p
->pEList
);
3105 /* Code the SELECTs to our left into temporary table "tab1".
3107 sqlite3SelectDestInit(&intersectdest
, SRT_Union
, tab1
);
3108 TREETRACE(0x400, pParse
, p
, ("multiSelect INTERSECT left...\n"));
3109 rc
= sqlite3Select(pParse
, pPrior
, &intersectdest
);
3111 goto multi_select_end
;
3114 /* Code the current SELECT into temporary table "tab2"
3116 addr
= sqlite3VdbeAddOp2(v
, OP_OpenEphemeral
, tab2
, 0);
3117 assert( p
->addrOpenEphm
[1] == -1 );
3118 p
->addrOpenEphm
[1] = addr
;
3122 intersectdest
.iSDParm
= tab2
;
3123 ExplainQueryPlan((pParse
, 1, "%s USING TEMP B-TREE",
3124 sqlite3SelectOpName(p
->op
)));
3125 TREETRACE(0x400, pParse
, p
, ("multiSelect INTERSECT right...\n"));
3126 rc
= sqlite3Select(pParse
, p
, &intersectdest
);
3127 testcase( rc
!=SQLITE_OK
);
3128 pDelete
= p
->pPrior
;
3130 if( p
->nSelectRow
>pPrior
->nSelectRow
){
3131 p
->nSelectRow
= pPrior
->nSelectRow
;
3133 sqlite3ExprDelete(db
, p
->pLimit
);
3136 /* Generate code to take the intersection of the two temporary
3140 assert( p
->pEList
);
3141 iBreak
= sqlite3VdbeMakeLabel(pParse
);
3142 iCont
= sqlite3VdbeMakeLabel(pParse
);
3143 computeLimitRegisters(pParse
, p
, iBreak
);
3144 sqlite3VdbeAddOp2(v
, OP_Rewind
, tab1
, iBreak
); VdbeCoverage(v
);
3145 r1
= sqlite3GetTempReg(pParse
);
3146 iStart
= sqlite3VdbeAddOp2(v
, OP_RowData
, tab1
, r1
);
3147 sqlite3VdbeAddOp4Int(v
, OP_NotFound
, tab2
, iCont
, r1
, 0);
3149 sqlite3ReleaseTempReg(pParse
, r1
);
3150 selectInnerLoop(pParse
, p
, tab1
,
3151 0, 0, &dest
, iCont
, iBreak
);
3152 sqlite3VdbeResolveLabel(v
, iCont
);
3153 sqlite3VdbeAddOp2(v
, OP_Next
, tab1
, iStart
); VdbeCoverage(v
);
3154 sqlite3VdbeResolveLabel(v
, iBreak
);
3155 sqlite3VdbeAddOp2(v
, OP_Close
, tab2
, 0);
3156 sqlite3VdbeAddOp2(v
, OP_Close
, tab1
, 0);
3161 #ifndef SQLITE_OMIT_EXPLAIN
3163 ExplainQueryPlanPop(pParse
);
3167 if( pParse
->nErr
) goto multi_select_end
;
3169 /* Compute collating sequences used by
3170 ** temporary tables needed to implement the compound select.
3171 ** Attach the KeyInfo structure to all temporary tables.
3173 ** This section is run by the right-most SELECT statement only.
3174 ** SELECT statements to the left always skip this part. The right-most
3175 ** SELECT might also skip this part if it has no ORDER BY clause and
3176 ** no temp tables are required.
3178 if( p
->selFlags
& SF_UsesEphemeral
){
3179 int i
; /* Loop counter */
3180 KeyInfo
*pKeyInfo
; /* Collating sequence for the result set */
3181 Select
*pLoop
; /* For looping through SELECT statements */
3182 CollSeq
**apColl
; /* For looping through pKeyInfo->aColl[] */
3183 int nCol
; /* Number of columns in result set */
3185 assert( p
->pNext
==0 );
3186 assert( p
->pEList
!=0 );
3187 nCol
= p
->pEList
->nExpr
;
3188 pKeyInfo
= sqlite3KeyInfoAlloc(db
, nCol
, 1);
3190 rc
= SQLITE_NOMEM_BKPT
;
3191 goto multi_select_end
;
3193 for(i
=0, apColl
=pKeyInfo
->aColl
; i
<nCol
; i
++, apColl
++){
3194 *apColl
= multiSelectCollSeq(pParse
, p
, i
);
3196 *apColl
= db
->pDfltColl
;
3200 for(pLoop
=p
; pLoop
; pLoop
=pLoop
->pPrior
){
3202 int addr
= pLoop
->addrOpenEphm
[i
];
3204 /* If [0] is unused then [1] is also unused. So we can
3205 ** always safely abort as soon as the first unused slot is found */
3206 assert( pLoop
->addrOpenEphm
[1]<0 );
3209 sqlite3VdbeChangeP2(v
, addr
, nCol
);
3210 sqlite3VdbeChangeP4(v
, addr
, (char*)sqlite3KeyInfoRef(pKeyInfo
),
3212 pLoop
->addrOpenEphm
[i
] = -1;
3215 sqlite3KeyInfoUnref(pKeyInfo
);
3219 pDest
->iSdst
= dest
.iSdst
;
3220 pDest
->nSdst
= dest
.nSdst
;
3222 sqlite3ParserAddCleanup(pParse
, sqlite3SelectDeleteGeneric
, pDelete
);
3226 #endif /* SQLITE_OMIT_COMPOUND_SELECT */
3229 ** Error message for when two or more terms of a compound select have different
3230 ** size result sets.
3232 void sqlite3SelectWrongNumTermsError(Parse
*pParse
, Select
*p
){
3233 if( p
->selFlags
& SF_Values
){
3234 sqlite3ErrorMsg(pParse
, "all VALUES must have the same number of terms");
3236 sqlite3ErrorMsg(pParse
, "SELECTs to the left and right of %s"
3237 " do not have the same number of result columns",
3238 sqlite3SelectOpName(p
->op
));
3243 ** Code an output subroutine for a coroutine implementation of a
3244 ** SELECT statement.
3246 ** The data to be output is contained in pIn->iSdst. There are
3247 ** pIn->nSdst columns to be output. pDest is where the output should
3250 ** regReturn is the number of the register holding the subroutine
3253 ** If regPrev>0 then it is the first register in a vector that
3254 ** records the previous output. mem[regPrev] is a flag that is false
3255 ** if there has been no previous output. If regPrev>0 then code is
3256 ** generated to suppress duplicates. pKeyInfo is used for comparing
3259 ** If the LIMIT found in p->iLimit is reached, jump immediately to
3262 static int generateOutputSubroutine(
3263 Parse
*pParse
, /* Parsing context */
3264 Select
*p
, /* The SELECT statement */
3265 SelectDest
*pIn
, /* Coroutine supplying data */
3266 SelectDest
*pDest
, /* Where to send the data */
3267 int regReturn
, /* The return address register */
3268 int regPrev
, /* Previous result register. No uniqueness if 0 */
3269 KeyInfo
*pKeyInfo
, /* For comparing with previous entry */
3270 int iBreak
/* Jump here if we hit the LIMIT */
3272 Vdbe
*v
= pParse
->pVdbe
;
3276 addr
= sqlite3VdbeCurrentAddr(v
);
3277 iContinue
= sqlite3VdbeMakeLabel(pParse
);
3279 /* Suppress duplicates for UNION, EXCEPT, and INTERSECT
3283 addr1
= sqlite3VdbeAddOp1(v
, OP_IfNot
, regPrev
); VdbeCoverage(v
);
3284 addr2
= sqlite3VdbeAddOp4(v
, OP_Compare
, pIn
->iSdst
, regPrev
+1, pIn
->nSdst
,
3285 (char*)sqlite3KeyInfoRef(pKeyInfo
), P4_KEYINFO
);
3286 sqlite3VdbeAddOp3(v
, OP_Jump
, addr2
+2, iContinue
, addr2
+2); VdbeCoverage(v
);
3287 sqlite3VdbeJumpHere(v
, addr1
);
3288 sqlite3VdbeAddOp3(v
, OP_Copy
, pIn
->iSdst
, regPrev
+1, pIn
->nSdst
-1);
3289 sqlite3VdbeAddOp2(v
, OP_Integer
, 1, regPrev
);
3291 if( pParse
->db
->mallocFailed
) return 0;
3293 /* Suppress the first OFFSET entries if there is an OFFSET clause
3295 codeOffset(v
, p
->iOffset
, iContinue
);
3297 assert( pDest
->eDest
!=SRT_Exists
);
3298 assert( pDest
->eDest
!=SRT_Table
);
3299 switch( pDest
->eDest
){
3300 /* Store the result as data using a unique key.
3302 case SRT_EphemTab
: {
3303 int r1
= sqlite3GetTempReg(pParse
);
3304 int r2
= sqlite3GetTempReg(pParse
);
3305 sqlite3VdbeAddOp3(v
, OP_MakeRecord
, pIn
->iSdst
, pIn
->nSdst
, r1
);
3306 sqlite3VdbeAddOp2(v
, OP_NewRowid
, pDest
->iSDParm
, r2
);
3307 sqlite3VdbeAddOp3(v
, OP_Insert
, pDest
->iSDParm
, r1
, r2
);
3308 sqlite3VdbeChangeP5(v
, OPFLAG_APPEND
);
3309 sqlite3ReleaseTempReg(pParse
, r2
);
3310 sqlite3ReleaseTempReg(pParse
, r1
);
3314 #ifndef SQLITE_OMIT_SUBQUERY
3315 /* If we are creating a set for an "expr IN (SELECT ...)".
3319 testcase( pIn
->nSdst
>1 );
3320 r1
= sqlite3GetTempReg(pParse
);
3321 sqlite3VdbeAddOp4(v
, OP_MakeRecord
, pIn
->iSdst
, pIn
->nSdst
,
3322 r1
, pDest
->zAffSdst
, pIn
->nSdst
);
3323 sqlite3VdbeAddOp4Int(v
, OP_IdxInsert
, pDest
->iSDParm
, r1
,
3324 pIn
->iSdst
, pIn
->nSdst
);
3325 if( pDest
->iSDParm2
>0 ){
3326 sqlite3VdbeAddOp4Int(v
, OP_FilterAdd
, pDest
->iSDParm2
, 0,
3327 pIn
->iSdst
, pIn
->nSdst
);
3328 ExplainQueryPlan((pParse
, 0, "CREATE BLOOM FILTER"));
3330 sqlite3ReleaseTempReg(pParse
, r1
);
3334 /* If this is a scalar select that is part of an expression, then
3335 ** store the results in the appropriate memory cell and break out
3336 ** of the scan loop. Note that the select might return multiple columns
3337 ** if it is the RHS of a row-value IN operator.
3340 testcase( pIn
->nSdst
>1 );
3341 sqlite3ExprCodeMove(pParse
, pIn
->iSdst
, pDest
->iSDParm
, pIn
->nSdst
);
3342 /* The LIMIT clause will jump out of the loop for us */
3345 #endif /* #ifndef SQLITE_OMIT_SUBQUERY */
3347 /* The results are stored in a sequence of registers
3348 ** starting at pDest->iSdst. Then the co-routine yields.
3350 case SRT_Coroutine
: {
3351 if( pDest
->iSdst
==0 ){
3352 pDest
->iSdst
= sqlite3GetTempRange(pParse
, pIn
->nSdst
);
3353 pDest
->nSdst
= pIn
->nSdst
;
3355 sqlite3ExprCodeMove(pParse
, pIn
->iSdst
, pDest
->iSdst
, pIn
->nSdst
);
3356 sqlite3VdbeAddOp1(v
, OP_Yield
, pDest
->iSDParm
);
3360 /* If none of the above, then the result destination must be
3361 ** SRT_Output. This routine is never called with any other
3362 ** destination other than the ones handled above or SRT_Output.
3364 ** For SRT_Output, results are stored in a sequence of registers.
3365 ** Then the OP_ResultRow opcode is used to cause sqlite3_step() to
3366 ** return the next row of result.
3369 assert( pDest
->eDest
==SRT_Output
);
3370 sqlite3VdbeAddOp2(v
, OP_ResultRow
, pIn
->iSdst
, pIn
->nSdst
);
3375 /* Jump to the end of the loop if the LIMIT is reached.
3378 sqlite3VdbeAddOp2(v
, OP_DecrJumpZero
, p
->iLimit
, iBreak
); VdbeCoverage(v
);
3381 /* Generate the subroutine return
3383 sqlite3VdbeResolveLabel(v
, iContinue
);
3384 sqlite3VdbeAddOp1(v
, OP_Return
, regReturn
);
3390 ** Alternative compound select code generator for cases when there
3391 ** is an ORDER BY clause.
3393 ** We assume a query of the following form:
3395 ** <selectA> <operator> <selectB> ORDER BY <orderbylist>
3397 ** <operator> is one of UNION ALL, UNION, EXCEPT, or INTERSECT. The idea
3398 ** is to code both <selectA> and <selectB> with the ORDER BY clause as
3399 ** co-routines. Then run the co-routines in parallel and merge the results
3400 ** into the output. In addition to the two coroutines (called selectA and
3401 ** selectB) there are 7 subroutines:
3403 ** outA: Move the output of the selectA coroutine into the output
3404 ** of the compound query.
3406 ** outB: Move the output of the selectB coroutine into the output
3407 ** of the compound query. (Only generated for UNION and
3408 ** UNION ALL. EXCEPT and INSERTSECT never output a row that
3409 ** appears only in B.)
3411 ** AltB: Called when there is data from both coroutines and A<B.
3413 ** AeqB: Called when there is data from both coroutines and A==B.
3415 ** AgtB: Called when there is data from both coroutines and A>B.
3417 ** EofA: Called when data is exhausted from selectA.
3419 ** EofB: Called when data is exhausted from selectB.
3421 ** The implementation of the latter five subroutines depend on which
3422 ** <operator> is used:
3425 ** UNION ALL UNION EXCEPT INTERSECT
3426 ** ------------- ----------------- -------------- -----------------
3427 ** AltB: outA, nextA outA, nextA outA, nextA nextA
3429 ** AeqB: outA, nextA nextA nextA outA, nextA
3431 ** AgtB: outB, nextB outB, nextB nextB nextB
3433 ** EofA: outB, nextB outB, nextB halt halt
3435 ** EofB: outA, nextA outA, nextA outA, nextA halt
3437 ** In the AltB, AeqB, and AgtB subroutines, an EOF on A following nextA
3438 ** causes an immediate jump to EofA and an EOF on B following nextB causes
3439 ** an immediate jump to EofB. Within EofA and EofB, and EOF on entry or
3440 ** following nextX causes a jump to the end of the select processing.
3442 ** Duplicate removal in the UNION, EXCEPT, and INTERSECT cases is handled
3443 ** within the output subroutine. The regPrev register set holds the previously
3444 ** output value. A comparison is made against this value and the output
3445 ** is skipped if the next results would be the same as the previous.
3447 ** The implementation plan is to implement the two coroutines and seven
3448 ** subroutines first, then put the control logic at the bottom. Like this:
3451 ** coA: coroutine for left query (A)
3452 ** coB: coroutine for right query (B)
3453 ** outA: output one row of A
3454 ** outB: output one row of B (UNION and UNION ALL only)
3460 ** Init: initialize coroutine registers
3462 ** if eof(A) goto EofA
3464 ** if eof(B) goto EofB
3465 ** Cmpr: Compare A, B
3466 ** Jump AltB, AeqB, AgtB
3469 ** We call AltB, AeqB, AgtB, EofA, and EofB "subroutines" but they are not
3470 ** actually called using Gosub and they do not Return. EofA and EofB loop
3471 ** until all data is exhausted then jump to the "end" label. AltB, AeqB,
3472 ** and AgtB jump to either L2 or to one of EofA or EofB.
3474 #ifndef SQLITE_OMIT_COMPOUND_SELECT
3475 static int multiSelectOrderBy(
3476 Parse
*pParse
, /* Parsing context */
3477 Select
*p
, /* The right-most of SELECTs to be coded */
3478 SelectDest
*pDest
/* What to do with query results */
3480 int i
, j
; /* Loop counters */
3481 Select
*pPrior
; /* Another SELECT immediately to our left */
3482 Select
*pSplit
; /* Left-most SELECT in the right-hand group */
3483 int nSelect
; /* Number of SELECT statements in the compound */
3484 Vdbe
*v
; /* Generate code to this VDBE */
3485 SelectDest destA
; /* Destination for coroutine A */
3486 SelectDest destB
; /* Destination for coroutine B */
3487 int regAddrA
; /* Address register for select-A coroutine */
3488 int regAddrB
; /* Address register for select-B coroutine */
3489 int addrSelectA
; /* Address of the select-A coroutine */
3490 int addrSelectB
; /* Address of the select-B coroutine */
3491 int regOutA
; /* Address register for the output-A subroutine */
3492 int regOutB
; /* Address register for the output-B subroutine */
3493 int addrOutA
; /* Address of the output-A subroutine */
3494 int addrOutB
= 0; /* Address of the output-B subroutine */
3495 int addrEofA
; /* Address of the select-A-exhausted subroutine */
3496 int addrEofA_noB
; /* Alternate addrEofA if B is uninitialized */
3497 int addrEofB
; /* Address of the select-B-exhausted subroutine */
3498 int addrAltB
; /* Address of the A<B subroutine */
3499 int addrAeqB
; /* Address of the A==B subroutine */
3500 int addrAgtB
; /* Address of the A>B subroutine */
3501 int regLimitA
; /* Limit register for select-A */
3502 int regLimitB
; /* Limit register for select-A */
3503 int regPrev
; /* A range of registers to hold previous output */
3504 int savedLimit
; /* Saved value of p->iLimit */
3505 int savedOffset
; /* Saved value of p->iOffset */
3506 int labelCmpr
; /* Label for the start of the merge algorithm */
3507 int labelEnd
; /* Label for the end of the overall SELECT stmt */
3508 int addr1
; /* Jump instructions that get retargeted */
3509 int op
; /* One of TK_ALL, TK_UNION, TK_EXCEPT, TK_INTERSECT */
3510 KeyInfo
*pKeyDup
= 0; /* Comparison information for duplicate removal */
3511 KeyInfo
*pKeyMerge
; /* Comparison information for merging rows */
3512 sqlite3
*db
; /* Database connection */
3513 ExprList
*pOrderBy
; /* The ORDER BY clause */
3514 int nOrderBy
; /* Number of terms in the ORDER BY clause */
3515 u32
*aPermute
; /* Mapping from ORDER BY terms to result set columns */
3517 assert( p
->pOrderBy
!=0 );
3518 assert( pKeyDup
==0 ); /* "Managed" code needs this. Ticket #3382. */
3521 assert( v
!=0 ); /* Already thrown the error if VDBE alloc failed */
3522 labelEnd
= sqlite3VdbeMakeLabel(pParse
);
3523 labelCmpr
= sqlite3VdbeMakeLabel(pParse
);
3526 /* Patch up the ORDER BY clause
3529 assert( p
->pPrior
->pOrderBy
==0 );
3530 pOrderBy
= p
->pOrderBy
;
3532 nOrderBy
= pOrderBy
->nExpr
;
3534 /* For operators other than UNION ALL we have to make sure that
3535 ** the ORDER BY clause covers every term of the result set. Add
3536 ** terms to the ORDER BY clause as necessary.
3539 for(i
=1; db
->mallocFailed
==0 && i
<=p
->pEList
->nExpr
; i
++){
3540 struct ExprList_item
*pItem
;
3541 for(j
=0, pItem
=pOrderBy
->a
; j
<nOrderBy
; j
++, pItem
++){
3543 assert( pItem
->u
.x
.iOrderByCol
>0 );
3544 if( pItem
->u
.x
.iOrderByCol
==i
) break;
3547 Expr
*pNew
= sqlite3Expr(db
, TK_INTEGER
, 0);
3548 if( pNew
==0 ) return SQLITE_NOMEM_BKPT
;
3549 pNew
->flags
|= EP_IntValue
;
3551 p
->pOrderBy
= pOrderBy
= sqlite3ExprListAppend(pParse
, pOrderBy
, pNew
);
3552 if( pOrderBy
) pOrderBy
->a
[nOrderBy
++].u
.x
.iOrderByCol
= (u16
)i
;
3557 /* Compute the comparison permutation and keyinfo that is used with
3558 ** the permutation used to determine if the next
3559 ** row of results comes from selectA or selectB. Also add explicit
3560 ** collations to the ORDER BY clause terms so that when the subqueries
3561 ** to the right and the left are evaluated, they use the correct
3564 aPermute
= sqlite3DbMallocRawNN(db
, sizeof(u32
)*(nOrderBy
+ 1));
3566 struct ExprList_item
*pItem
;
3567 aPermute
[0] = nOrderBy
;
3568 for(i
=1, pItem
=pOrderBy
->a
; i
<=nOrderBy
; i
++, pItem
++){
3570 assert( pItem
->u
.x
.iOrderByCol
>0 );
3571 assert( pItem
->u
.x
.iOrderByCol
<=p
->pEList
->nExpr
);
3572 aPermute
[i
] = pItem
->u
.x
.iOrderByCol
- 1;
3574 pKeyMerge
= multiSelectOrderByKeyInfo(pParse
, p
, 1);
3579 /* Allocate a range of temporary registers and the KeyInfo needed
3580 ** for the logic that removes duplicate result rows when the
3581 ** operator is UNION, EXCEPT, or INTERSECT (but not UNION ALL).
3586 int nExpr
= p
->pEList
->nExpr
;
3587 assert( nOrderBy
>=nExpr
|| db
->mallocFailed
);
3588 regPrev
= pParse
->nMem
+1;
3589 pParse
->nMem
+= nExpr
+1;
3590 sqlite3VdbeAddOp2(v
, OP_Integer
, 0, regPrev
);
3591 pKeyDup
= sqlite3KeyInfoAlloc(db
, nExpr
, 1);
3593 assert( sqlite3KeyInfoIsWriteable(pKeyDup
) );
3594 for(i
=0; i
<nExpr
; i
++){
3595 pKeyDup
->aColl
[i
] = multiSelectCollSeq(pParse
, p
, i
);
3596 pKeyDup
->aSortFlags
[i
] = 0;
3601 /* Separate the left and the right query from one another
3604 if( (op
==TK_ALL
|| op
==TK_UNION
)
3605 && OptimizationEnabled(db
, SQLITE_BalancedMerge
)
3607 for(pSplit
=p
; pSplit
->pPrior
!=0 && pSplit
->op
==op
; pSplit
=pSplit
->pPrior
){
3609 assert( pSplit
->pPrior
->pNext
==pSplit
);
3616 for(i
=2; i
<nSelect
; i
+=2){ pSplit
= pSplit
->pPrior
; }
3618 pPrior
= pSplit
->pPrior
;
3619 assert( pPrior
!=0 );
3622 assert( p
->pOrderBy
== pOrderBy
);
3623 assert( pOrderBy
!=0 || db
->mallocFailed
);
3624 pPrior
->pOrderBy
= sqlite3ExprListDup(pParse
->db
, pOrderBy
, 0);
3625 sqlite3ResolveOrderGroupBy(pParse
, p
, p
->pOrderBy
, "ORDER");
3626 sqlite3ResolveOrderGroupBy(pParse
, pPrior
, pPrior
->pOrderBy
, "ORDER");
3628 /* Compute the limit registers */
3629 computeLimitRegisters(pParse
, p
, labelEnd
);
3630 if( p
->iLimit
&& op
==TK_ALL
){
3631 regLimitA
= ++pParse
->nMem
;
3632 regLimitB
= ++pParse
->nMem
;
3633 sqlite3VdbeAddOp2(v
, OP_Copy
, p
->iOffset
? p
->iOffset
+1 : p
->iLimit
,
3635 sqlite3VdbeAddOp2(v
, OP_Copy
, regLimitA
, regLimitB
);
3637 regLimitA
= regLimitB
= 0;
3639 sqlite3ExprDelete(db
, p
->pLimit
);
3642 regAddrA
= ++pParse
->nMem
;
3643 regAddrB
= ++pParse
->nMem
;
3644 regOutA
= ++pParse
->nMem
;
3645 regOutB
= ++pParse
->nMem
;
3646 sqlite3SelectDestInit(&destA
, SRT_Coroutine
, regAddrA
);
3647 sqlite3SelectDestInit(&destB
, SRT_Coroutine
, regAddrB
);
3649 ExplainQueryPlan((pParse
, 1, "MERGE (%s)", sqlite3SelectOpName(p
->op
)));
3651 /* Generate a coroutine to evaluate the SELECT statement to the
3652 ** left of the compound operator - the "A" select.
3654 addrSelectA
= sqlite3VdbeCurrentAddr(v
) + 1;
3655 addr1
= sqlite3VdbeAddOp3(v
, OP_InitCoroutine
, regAddrA
, 0, addrSelectA
);
3656 VdbeComment((v
, "left SELECT"));
3657 pPrior
->iLimit
= regLimitA
;
3658 ExplainQueryPlan((pParse
, 1, "LEFT"));
3659 sqlite3Select(pParse
, pPrior
, &destA
);
3660 sqlite3VdbeEndCoroutine(v
, regAddrA
);
3661 sqlite3VdbeJumpHere(v
, addr1
);
3663 /* Generate a coroutine to evaluate the SELECT statement on
3664 ** the right - the "B" select
3666 addrSelectB
= sqlite3VdbeCurrentAddr(v
) + 1;
3667 addr1
= sqlite3VdbeAddOp3(v
, OP_InitCoroutine
, regAddrB
, 0, addrSelectB
);
3668 VdbeComment((v
, "right SELECT"));
3669 savedLimit
= p
->iLimit
;
3670 savedOffset
= p
->iOffset
;
3671 p
->iLimit
= regLimitB
;
3673 ExplainQueryPlan((pParse
, 1, "RIGHT"));
3674 sqlite3Select(pParse
, p
, &destB
);
3675 p
->iLimit
= savedLimit
;
3676 p
->iOffset
= savedOffset
;
3677 sqlite3VdbeEndCoroutine(v
, regAddrB
);
3679 /* Generate a subroutine that outputs the current row of the A
3680 ** select as the next output row of the compound select.
3682 VdbeNoopComment((v
, "Output routine for A"));
3683 addrOutA
= generateOutputSubroutine(pParse
,
3684 p
, &destA
, pDest
, regOutA
,
3685 regPrev
, pKeyDup
, labelEnd
);
3687 /* Generate a subroutine that outputs the current row of the B
3688 ** select as the next output row of the compound select.
3690 if( op
==TK_ALL
|| op
==TK_UNION
){
3691 VdbeNoopComment((v
, "Output routine for B"));
3692 addrOutB
= generateOutputSubroutine(pParse
,
3693 p
, &destB
, pDest
, regOutB
,
3694 regPrev
, pKeyDup
, labelEnd
);
3696 sqlite3KeyInfoUnref(pKeyDup
);
3698 /* Generate a subroutine to run when the results from select A
3699 ** are exhausted and only data in select B remains.
3701 if( op
==TK_EXCEPT
|| op
==TK_INTERSECT
){
3702 addrEofA_noB
= addrEofA
= labelEnd
;
3704 VdbeNoopComment((v
, "eof-A subroutine"));
3705 addrEofA
= sqlite3VdbeAddOp2(v
, OP_Gosub
, regOutB
, addrOutB
);
3706 addrEofA_noB
= sqlite3VdbeAddOp2(v
, OP_Yield
, regAddrB
, labelEnd
);
3708 sqlite3VdbeGoto(v
, addrEofA
);
3709 p
->nSelectRow
= sqlite3LogEstAdd(p
->nSelectRow
, pPrior
->nSelectRow
);
3712 /* Generate a subroutine to run when the results from select B
3713 ** are exhausted and only data in select A remains.
3715 if( op
==TK_INTERSECT
){
3716 addrEofB
= addrEofA
;
3717 if( p
->nSelectRow
> pPrior
->nSelectRow
) p
->nSelectRow
= pPrior
->nSelectRow
;
3719 VdbeNoopComment((v
, "eof-B subroutine"));
3720 addrEofB
= sqlite3VdbeAddOp2(v
, OP_Gosub
, regOutA
, addrOutA
);
3721 sqlite3VdbeAddOp2(v
, OP_Yield
, regAddrA
, labelEnd
); VdbeCoverage(v
);
3722 sqlite3VdbeGoto(v
, addrEofB
);
3725 /* Generate code to handle the case of A<B
3727 VdbeNoopComment((v
, "A-lt-B subroutine"));
3728 addrAltB
= sqlite3VdbeAddOp2(v
, OP_Gosub
, regOutA
, addrOutA
);
3729 sqlite3VdbeAddOp2(v
, OP_Yield
, regAddrA
, addrEofA
); VdbeCoverage(v
);
3730 sqlite3VdbeGoto(v
, labelCmpr
);
3732 /* Generate code to handle the case of A==B
3735 addrAeqB
= addrAltB
;
3736 }else if( op
==TK_INTERSECT
){
3737 addrAeqB
= addrAltB
;
3740 VdbeNoopComment((v
, "A-eq-B subroutine"));
3742 sqlite3VdbeAddOp2(v
, OP_Yield
, regAddrA
, addrEofA
); VdbeCoverage(v
);
3743 sqlite3VdbeGoto(v
, labelCmpr
);
3746 /* Generate code to handle the case of A>B
3748 VdbeNoopComment((v
, "A-gt-B subroutine"));
3749 addrAgtB
= sqlite3VdbeCurrentAddr(v
);
3750 if( op
==TK_ALL
|| op
==TK_UNION
){
3751 sqlite3VdbeAddOp2(v
, OP_Gosub
, regOutB
, addrOutB
);
3753 sqlite3VdbeAddOp2(v
, OP_Yield
, regAddrB
, addrEofB
); VdbeCoverage(v
);
3754 sqlite3VdbeGoto(v
, labelCmpr
);
3756 /* This code runs once to initialize everything.
3758 sqlite3VdbeJumpHere(v
, addr1
);
3759 sqlite3VdbeAddOp2(v
, OP_Yield
, regAddrA
, addrEofA_noB
); VdbeCoverage(v
);
3760 sqlite3VdbeAddOp2(v
, OP_Yield
, regAddrB
, addrEofB
); VdbeCoverage(v
);
3762 /* Implement the main merge loop
3764 sqlite3VdbeResolveLabel(v
, labelCmpr
);
3765 sqlite3VdbeAddOp4(v
, OP_Permutation
, 0, 0, 0, (char*)aPermute
, P4_INTARRAY
);
3766 sqlite3VdbeAddOp4(v
, OP_Compare
, destA
.iSdst
, destB
.iSdst
, nOrderBy
,
3767 (char*)pKeyMerge
, P4_KEYINFO
);
3768 sqlite3VdbeChangeP5(v
, OPFLAG_PERMUTE
);
3769 sqlite3VdbeAddOp3(v
, OP_Jump
, addrAltB
, addrAeqB
, addrAgtB
); VdbeCoverage(v
);
3771 /* Jump to the this point in order to terminate the query.
3773 sqlite3VdbeResolveLabel(v
, labelEnd
);
3775 /* Make arrangements to free the 2nd and subsequent arms of the compound
3776 ** after the parse has finished */
3777 if( pSplit
->pPrior
){
3778 sqlite3ParserAddCleanup(pParse
, sqlite3SelectDeleteGeneric
, pSplit
->pPrior
);
3780 pSplit
->pPrior
= pPrior
;
3781 pPrior
->pNext
= pSplit
;
3782 sqlite3ExprListDelete(db
, pPrior
->pOrderBy
);
3783 pPrior
->pOrderBy
= 0;
3785 /*** TBD: Insert subroutine calls to close cursors on incomplete
3786 **** subqueries ****/
3787 ExplainQueryPlanPop(pParse
);
3788 return pParse
->nErr
!=0;
3792 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
3794 /* An instance of the SubstContext object describes an substitution edit
3795 ** to be performed on a parse tree.
3797 ** All references to columns in table iTable are to be replaced by corresponding
3798 ** expressions in pEList.
3800 ** ## About "isOuterJoin":
3802 ** The isOuterJoin column indicates that the replacement will occur into a
3803 ** position in the parent that NULL-able due to an OUTER JOIN. Either the
3804 ** target slot in the parent is the right operand of a LEFT JOIN, or one of
3805 ** the left operands of a RIGHT JOIN. In either case, we need to potentially
3806 ** bypass the substituted expression with OP_IfNullRow.
3808 ** Suppose the original expression is an integer constant. Even though the table
3809 ** has the nullRow flag set, because the expression is an integer constant,
3810 ** it will not be NULLed out. So instead, we insert an OP_IfNullRow opcode
3811 ** that checks to see if the nullRow flag is set on the table. If the nullRow
3812 ** flag is set, then the value in the register is set to NULL and the original
3813 ** expression is bypassed. If the nullRow flag is not set, then the original
3814 ** expression runs to populate the register.
3816 ** Example where this is needed:
3818 ** CREATE TABLE t1(a INTEGER PRIMARY KEY, b INT);
3819 ** CREATE TABLE t2(x INT UNIQUE);
3821 ** SELECT a,b,m,x FROM t1 LEFT JOIN (SELECT 59 AS m,x FROM t2) ON b=x;
3823 ** When the subquery on the right side of the LEFT JOIN is flattened, we
3824 ** have to add OP_IfNullRow in front of the OP_Integer that implements the
3825 ** "m" value of the subquery so that a NULL will be loaded instead of 59
3826 ** when processing a non-matched row of the left.
3828 typedef struct SubstContext
{
3829 Parse
*pParse
; /* The parsing context */
3830 int iTable
; /* Replace references to this table */
3831 int iNewTable
; /* New table number */
3832 int isOuterJoin
; /* Add TK_IF_NULL_ROW opcodes on each replacement */
3833 ExprList
*pEList
; /* Replacement expressions */
3834 ExprList
*pCList
; /* Collation sequences for replacement expr */
3837 /* Forward Declarations */
3838 static void substExprList(SubstContext
*, ExprList
*);
3839 static void substSelect(SubstContext
*, Select
*, int);
3842 ** Scan through the expression pExpr. Replace every reference to
3843 ** a column in table number iTable with a copy of the iColumn-th
3844 ** entry in pEList. (But leave references to the ROWID column
3847 ** This routine is part of the flattening procedure. A subquery
3848 ** whose result set is defined by pEList appears as entry in the
3849 ** FROM clause of a SELECT such that the VDBE cursor assigned to that
3850 ** FORM clause entry is iTable. This routine makes the necessary
3851 ** changes to pExpr so that it refers directly to the source table
3852 ** of the subquery rather the result set of the subquery.
3854 static Expr
*substExpr(
3855 SubstContext
*pSubst
, /* Description of the substitution */
3856 Expr
*pExpr
/* Expr in which substitution occurs */
3858 if( pExpr
==0 ) return 0;
3859 if( ExprHasProperty(pExpr
, EP_OuterON
|EP_InnerON
)
3860 && pExpr
->w
.iJoin
==pSubst
->iTable
3862 testcase( ExprHasProperty(pExpr
, EP_InnerON
) );
3863 pExpr
->w
.iJoin
= pSubst
->iNewTable
;
3865 if( pExpr
->op
==TK_COLUMN
3866 && pExpr
->iTable
==pSubst
->iTable
3867 && !ExprHasProperty(pExpr
, EP_FixedCol
)
3869 #ifdef SQLITE_ALLOW_ROWID_IN_VIEW
3870 if( pExpr
->iColumn
<0 ){
3871 pExpr
->op
= TK_NULL
;
3879 iColumn
= pExpr
->iColumn
;
3880 assert( iColumn
>=0 );
3881 assert( pSubst
->pEList
!=0 && iColumn
<pSubst
->pEList
->nExpr
);
3882 assert( pExpr
->pRight
==0 );
3883 pCopy
= pSubst
->pEList
->a
[iColumn
].pExpr
;
3884 if( sqlite3ExprIsVector(pCopy
) ){
3885 sqlite3VectorErrorMsg(pSubst
->pParse
, pCopy
);
3887 sqlite3
*db
= pSubst
->pParse
->db
;
3888 if( pSubst
->isOuterJoin
3889 && (pCopy
->op
!=TK_COLUMN
|| pCopy
->iTable
!=pSubst
->iNewTable
)
3891 memset(&ifNullRow
, 0, sizeof(ifNullRow
));
3892 ifNullRow
.op
= TK_IF_NULL_ROW
;
3893 ifNullRow
.pLeft
= pCopy
;
3894 ifNullRow
.iTable
= pSubst
->iNewTable
;
3895 ifNullRow
.iColumn
= -99;
3896 ifNullRow
.flags
= EP_IfNullRow
;
3899 testcase( ExprHasProperty(pCopy
, EP_Subquery
) );
3900 pNew
= sqlite3ExprDup(db
, pCopy
, 0);
3901 if( db
->mallocFailed
){
3902 sqlite3ExprDelete(db
, pNew
);
3905 if( pSubst
->isOuterJoin
){
3906 ExprSetProperty(pNew
, EP_CanBeNull
);
3908 if( ExprHasProperty(pExpr
,EP_OuterON
|EP_InnerON
) ){
3909 sqlite3SetJoinExpr(pNew
, pExpr
->w
.iJoin
,
3910 pExpr
->flags
& (EP_OuterON
|EP_InnerON
));
3912 sqlite3ExprDelete(db
, pExpr
);
3914 if( pExpr
->op
==TK_TRUEFALSE
){
3915 pExpr
->u
.iValue
= sqlite3ExprTruthValue(pExpr
);
3916 pExpr
->op
= TK_INTEGER
;
3917 ExprSetProperty(pExpr
, EP_IntValue
);
3920 /* Ensure that the expression now has an implicit collation sequence,
3921 ** just as it did when it was a column of a view or sub-query. */
3923 CollSeq
*pNat
= sqlite3ExprCollSeq(pSubst
->pParse
, pExpr
);
3924 CollSeq
*pColl
= sqlite3ExprCollSeq(pSubst
->pParse
,
3925 pSubst
->pCList
->a
[iColumn
].pExpr
3927 if( pNat
!=pColl
|| (pExpr
->op
!=TK_COLUMN
&& pExpr
->op
!=TK_COLLATE
) ){
3928 pExpr
= sqlite3ExprAddCollateString(pSubst
->pParse
, pExpr
,
3929 (pColl
? pColl
->zName
: "BINARY")
3933 ExprClearProperty(pExpr
, EP_Collate
);
3937 if( pExpr
->op
==TK_IF_NULL_ROW
&& pExpr
->iTable
==pSubst
->iTable
){
3938 pExpr
->iTable
= pSubst
->iNewTable
;
3940 pExpr
->pLeft
= substExpr(pSubst
, pExpr
->pLeft
);
3941 pExpr
->pRight
= substExpr(pSubst
, pExpr
->pRight
);
3942 if( ExprUseXSelect(pExpr
) ){
3943 substSelect(pSubst
, pExpr
->x
.pSelect
, 1);
3945 substExprList(pSubst
, pExpr
->x
.pList
);
3947 #ifndef SQLITE_OMIT_WINDOWFUNC
3948 if( ExprHasProperty(pExpr
, EP_WinFunc
) ){
3949 Window
*pWin
= pExpr
->y
.pWin
;
3950 pWin
->pFilter
= substExpr(pSubst
, pWin
->pFilter
);
3951 substExprList(pSubst
, pWin
->pPartition
);
3952 substExprList(pSubst
, pWin
->pOrderBy
);
3958 static void substExprList(
3959 SubstContext
*pSubst
, /* Description of the substitution */
3960 ExprList
*pList
/* List to scan and in which to make substitutes */
3963 if( pList
==0 ) return;
3964 for(i
=0; i
<pList
->nExpr
; i
++){
3965 pList
->a
[i
].pExpr
= substExpr(pSubst
, pList
->a
[i
].pExpr
);
3968 static void substSelect(
3969 SubstContext
*pSubst
, /* Description of the substitution */
3970 Select
*p
, /* SELECT statement in which to make substitutions */
3971 int doPrior
/* Do substitutes on p->pPrior too */
3978 substExprList(pSubst
, p
->pEList
);
3979 substExprList(pSubst
, p
->pGroupBy
);
3980 substExprList(pSubst
, p
->pOrderBy
);
3981 p
->pHaving
= substExpr(pSubst
, p
->pHaving
);
3982 p
->pWhere
= substExpr(pSubst
, p
->pWhere
);
3985 for(i
=pSrc
->nSrc
, pItem
=pSrc
->a
; i
>0; i
--, pItem
++){
3986 substSelect(pSubst
, pItem
->pSelect
, 1);
3987 if( pItem
->fg
.isTabFunc
){
3988 substExprList(pSubst
, pItem
->u1
.pFuncArg
);
3991 }while( doPrior
&& (p
= p
->pPrior
)!=0 );
3993 #endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
3995 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
3997 ** pSelect is a SELECT statement and pSrcItem is one item in the FROM
3998 ** clause of that SELECT.
4000 ** This routine scans the entire SELECT statement and recomputes the
4001 ** pSrcItem->colUsed mask.
4003 static int recomputeColumnsUsedExpr(Walker
*pWalker
, Expr
*pExpr
){
4005 if( pExpr
->op
!=TK_COLUMN
) return WRC_Continue
;
4006 pItem
= pWalker
->u
.pSrcItem
;
4007 if( pItem
->iCursor
!=pExpr
->iTable
) return WRC_Continue
;
4008 if( pExpr
->iColumn
<0 ) return WRC_Continue
;
4009 pItem
->colUsed
|= sqlite3ExprColUsed(pExpr
);
4010 return WRC_Continue
;
4012 static void recomputeColumnsUsed(
4013 Select
*pSelect
, /* The complete SELECT statement */
4014 SrcItem
*pSrcItem
/* Which FROM clause item to recompute */
4017 if( NEVER(pSrcItem
->pTab
==0) ) return;
4018 memset(&w
, 0, sizeof(w
));
4019 w
.xExprCallback
= recomputeColumnsUsedExpr
;
4020 w
.xSelectCallback
= sqlite3SelectWalkNoop
;
4021 w
.u
.pSrcItem
= pSrcItem
;
4022 pSrcItem
->colUsed
= 0;
4023 sqlite3WalkSelect(&w
, pSelect
);
4025 #endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
4027 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
4029 ** Assign new cursor numbers to each of the items in pSrc. For each
4030 ** new cursor number assigned, set an entry in the aCsrMap[] array
4031 ** to map the old cursor number to the new:
4033 ** aCsrMap[iOld+1] = iNew;
4035 ** The array is guaranteed by the caller to be large enough for all
4036 ** existing cursor numbers in pSrc. aCsrMap[0] is the array size.
4038 ** If pSrc contains any sub-selects, call this routine recursively
4039 ** on the FROM clause of each such sub-select, with iExcept set to -1.
4041 static void srclistRenumberCursors(
4042 Parse
*pParse
, /* Parse context */
4043 int *aCsrMap
, /* Array to store cursor mappings in */
4044 SrcList
*pSrc
, /* FROM clause to renumber */
4045 int iExcept
/* FROM clause item to skip */
4049 for(i
=0, pItem
=pSrc
->a
; i
<pSrc
->nSrc
; i
++, pItem
++){
4052 assert( pItem
->iCursor
< aCsrMap
[0] );
4053 if( !pItem
->fg
.isRecursive
|| aCsrMap
[pItem
->iCursor
+1]==0 ){
4054 aCsrMap
[pItem
->iCursor
+1] = pParse
->nTab
++;
4056 pItem
->iCursor
= aCsrMap
[pItem
->iCursor
+1];
4057 for(p
=pItem
->pSelect
; p
; p
=p
->pPrior
){
4058 srclistRenumberCursors(pParse
, aCsrMap
, p
->pSrc
, -1);
4065 ** *piCursor is a cursor number. Change it if it needs to be mapped.
4067 static void renumberCursorDoMapping(Walker
*pWalker
, int *piCursor
){
4068 int *aCsrMap
= pWalker
->u
.aiCol
;
4069 int iCsr
= *piCursor
;
4070 if( iCsr
< aCsrMap
[0] && aCsrMap
[iCsr
+1]>0 ){
4071 *piCursor
= aCsrMap
[iCsr
+1];
4076 ** Expression walker callback used by renumberCursors() to update
4077 ** Expr objects to match newly assigned cursor numbers.
4079 static int renumberCursorsCb(Walker
*pWalker
, Expr
*pExpr
){
4081 if( op
==TK_COLUMN
|| op
==TK_IF_NULL_ROW
){
4082 renumberCursorDoMapping(pWalker
, &pExpr
->iTable
);
4084 if( ExprHasProperty(pExpr
, EP_OuterON
) ){
4085 renumberCursorDoMapping(pWalker
, &pExpr
->w
.iJoin
);
4087 return WRC_Continue
;
4091 ** Assign a new cursor number to each cursor in the FROM clause (Select.pSrc)
4092 ** of the SELECT statement passed as the second argument, and to each
4093 ** cursor in the FROM clause of any FROM clause sub-selects, recursively.
4094 ** Except, do not assign a new cursor number to the iExcept'th element in
4095 ** the FROM clause of (*p). Update all expressions and other references
4096 ** to refer to the new cursor numbers.
4098 ** Argument aCsrMap is an array that may be used for temporary working
4099 ** space. Two guarantees are made by the caller:
4101 ** * the array is larger than the largest cursor number used within the
4102 ** select statement passed as an argument, and
4104 ** * the array entries for all cursor numbers that do *not* appear in
4105 ** FROM clauses of the select statement as described above are
4106 ** initialized to zero.
4108 static void renumberCursors(
4109 Parse
*pParse
, /* Parse context */
4110 Select
*p
, /* Select to renumber cursors within */
4111 int iExcept
, /* FROM clause item to skip */
4112 int *aCsrMap
/* Working space */
4115 srclistRenumberCursors(pParse
, aCsrMap
, p
->pSrc
, iExcept
);
4116 memset(&w
, 0, sizeof(w
));
4117 w
.u
.aiCol
= aCsrMap
;
4118 w
.xExprCallback
= renumberCursorsCb
;
4119 w
.xSelectCallback
= sqlite3SelectWalkNoop
;
4120 sqlite3WalkSelect(&w
, p
);
4122 #endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
4125 ** If pSel is not part of a compound SELECT, return a pointer to its
4126 ** expression list. Otherwise, return a pointer to the expression list
4127 ** of the leftmost SELECT in the compound.
4129 static ExprList
*findLeftmostExprlist(Select
*pSel
){
4130 while( pSel
->pPrior
){
4131 pSel
= pSel
->pPrior
;
4133 return pSel
->pEList
;
4137 ** Return true if any of the result-set columns in the compound query
4138 ** have incompatible affinities on one or more arms of the compound.
4140 static int compoundHasDifferentAffinities(Select
*p
){
4144 assert( p
->pEList
!=0 );
4145 assert( p
->pPrior
!=0 );
4147 for(ii
=0; ii
<pList
->nExpr
; ii
++){
4150 assert( pList
->a
[ii
].pExpr
!=0 );
4151 aff
= sqlite3ExprAffinity(pList
->a
[ii
].pExpr
);
4152 for(pSub1
=p
->pPrior
; pSub1
; pSub1
=pSub1
->pPrior
){
4153 assert( pSub1
->pEList
!=0 );
4154 assert( pSub1
->pEList
->nExpr
>ii
);
4155 assert( pSub1
->pEList
->a
[ii
].pExpr
!=0 );
4156 if( sqlite3ExprAffinity(pSub1
->pEList
->a
[ii
].pExpr
)!=aff
){
4164 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
4166 ** This routine attempts to flatten subqueries as a performance optimization.
4167 ** This routine returns 1 if it makes changes and 0 if no flattening occurs.
4169 ** To understand the concept of flattening, consider the following
4172 ** SELECT a FROM (SELECT x+y AS a FROM t1 WHERE z<100) WHERE a>5
4174 ** The default way of implementing this query is to execute the
4175 ** subquery first and store the results in a temporary table, then
4176 ** run the outer query on that temporary table. This requires two
4177 ** passes over the data. Furthermore, because the temporary table
4178 ** has no indices, the WHERE clause on the outer query cannot be
4181 ** This routine attempts to rewrite queries such as the above into
4182 ** a single flat select, like this:
4184 ** SELECT x+y AS a FROM t1 WHERE z<100 AND a>5
4186 ** The code generated for this simplification gives the same result
4187 ** but only has to scan the data once. And because indices might
4188 ** exist on the table t1, a complete scan of the data might be
4191 ** Flattening is subject to the following constraints:
4193 ** (**) We no longer attempt to flatten aggregate subqueries. Was:
4194 ** The subquery and the outer query cannot both be aggregates.
4196 ** (**) We no longer attempt to flatten aggregate subqueries. Was:
4197 ** (2) If the subquery is an aggregate then
4198 ** (2a) the outer query must not be a join and
4199 ** (2b) the outer query must not use subqueries
4200 ** other than the one FROM-clause subquery that is a candidate
4201 ** for flattening. (This is due to ticket [2f7170d73bf9abf80]
4202 ** from 2015-02-09.)
4204 ** (3) If the subquery is the right operand of a LEFT JOIN then
4205 ** (3a) the subquery may not be a join and
4206 ** (3b) the FROM clause of the subquery may not contain a virtual
4208 ** (**) Was: "The outer query may not have a GROUP BY." This case
4209 ** is now managed correctly
4210 ** (3d) the outer query may not be DISTINCT.
4211 ** See also (26) for restrictions on RIGHT JOIN.
4213 ** (4) The subquery can not be DISTINCT.
4215 ** (**) At one point restrictions (4) and (5) defined a subset of DISTINCT
4216 ** sub-queries that were excluded from this optimization. Restriction
4217 ** (4) has since been expanded to exclude all DISTINCT subqueries.
4219 ** (**) We no longer attempt to flatten aggregate subqueries. Was:
4220 ** If the subquery is aggregate, the outer query may not be DISTINCT.
4222 ** (7) The subquery must have a FROM clause. TODO: For subqueries without
4223 ** A FROM clause, consider adding a FROM clause with the special
4224 ** table sqlite_once that consists of a single row containing a
4227 ** (8) If the subquery uses LIMIT then the outer query may not be a join.
4229 ** (9) If the subquery uses LIMIT then the outer query may not be aggregate.
4231 ** (**) Restriction (10) was removed from the code on 2005-02-05 but we
4232 ** accidentally carried the comment forward until 2014-09-15. Original
4233 ** constraint: "If the subquery is aggregate then the outer query
4234 ** may not use LIMIT."
4236 ** (11) The subquery and the outer query may not both have ORDER BY clauses.
4238 ** (**) Not implemented. Subsumed into restriction (3). Was previously
4239 ** a separate restriction deriving from ticket #350.
4241 ** (13) The subquery and outer query may not both use LIMIT.
4243 ** (14) The subquery may not use OFFSET.
4245 ** (15) If the outer query is part of a compound select, then the
4246 ** subquery may not use LIMIT.
4247 ** (See ticket #2339 and ticket [02a8e81d44]).
4249 ** (16) If the outer query is aggregate, then the subquery may not
4250 ** use ORDER BY. (Ticket #2942) This used to not matter
4251 ** until we introduced the group_concat() function.
4253 ** (17) If the subquery is a compound select, then
4254 ** (17a) all compound operators must be a UNION ALL, and
4255 ** (17b) no terms within the subquery compound may be aggregate
4257 ** (17c) every term within the subquery compound must have a FROM clause
4258 ** (17d) the outer query may not be
4259 ** (17d1) aggregate, or
4261 ** (17e) the subquery may not contain window functions, and
4262 ** (17f) the subquery must not be the RHS of a LEFT JOIN.
4263 ** (17g) either the subquery is the first element of the outer
4264 ** query or there are no RIGHT or FULL JOINs in any arm
4265 ** of the subquery. (This is a duplicate of condition (27b).)
4266 ** (17h) The corresponding result set expressions in all arms of the
4267 ** compound must have the same affinity.
4269 ** The parent and sub-query may contain WHERE clauses. Subject to
4270 ** rules (11), (13) and (14), they may also contain ORDER BY,
4271 ** LIMIT and OFFSET clauses. The subquery cannot use any compound
4272 ** operator other than UNION ALL because all the other compound
4273 ** operators have an implied DISTINCT which is disallowed by
4276 ** Also, each component of the sub-query must return the same number
4277 ** of result columns. This is actually a requirement for any compound
4278 ** SELECT statement, but all the code here does is make sure that no
4279 ** such (illegal) sub-query is flattened. The caller will detect the
4280 ** syntax error and return a detailed message.
4282 ** (18) If the sub-query is a compound select, then all terms of the
4283 ** ORDER BY clause of the parent must be copies of a term returned
4284 ** by the parent query.
4286 ** (19) If the subquery uses LIMIT then the outer query may not
4287 ** have a WHERE clause.
4289 ** (20) If the sub-query is a compound select, then it must not use
4290 ** an ORDER BY clause. Ticket #3773. We could relax this constraint
4291 ** somewhat by saying that the terms of the ORDER BY clause must
4292 ** appear as unmodified result columns in the outer query. But we
4293 ** have other optimizations in mind to deal with that case.
4295 ** (21) If the subquery uses LIMIT then the outer query may not be
4296 ** DISTINCT. (See ticket [752e1646fc]).
4298 ** (22) The subquery may not be a recursive CTE.
4300 ** (23) If the outer query is a recursive CTE, then the sub-query may not be
4301 ** a compound query. This restriction is because transforming the
4302 ** parent to a compound query confuses the code that handles
4303 ** recursive queries in multiSelect().
4305 ** (**) We no longer attempt to flatten aggregate subqueries. Was:
4306 ** The subquery may not be an aggregate that uses the built-in min() or
4307 ** or max() functions. (Without this restriction, a query like:
4308 ** "SELECT x FROM (SELECT max(y), x FROM t1)" would not necessarily
4309 ** return the value X for which Y was maximal.)
4311 ** (25) If either the subquery or the parent query contains a window
4312 ** function in the select list or ORDER BY clause, flattening
4313 ** is not attempted.
4315 ** (26) The subquery may not be the right operand of a RIGHT JOIN.
4316 ** See also (3) for restrictions on LEFT JOIN.
4318 ** (27) The subquery may not contain a FULL or RIGHT JOIN unless it
4319 ** is the first element of the parent query. Two subcases:
4320 ** (27a) the subquery is not a compound query.
4321 ** (27b) the subquery is a compound query and the RIGHT JOIN occurs
4322 ** in any arm of the compound query. (See also (17g).)
4324 ** (28) The subquery is not a MATERIALIZED CTE. (This is handled
4325 ** in the caller before ever reaching this routine.)
4328 ** In this routine, the "p" parameter is a pointer to the outer query.
4329 ** The subquery is p->pSrc->a[iFrom]. isAgg is true if the outer query
4332 ** If flattening is not attempted, this routine is a no-op and returns 0.
4333 ** If flattening is attempted this routine returns 1.
4335 ** All of the expression analysis must occur on both the outer query and
4336 ** the subquery before this routine runs.
4338 static int flattenSubquery(
4339 Parse
*pParse
, /* Parsing context */
4340 Select
*p
, /* The parent or outer SELECT statement */
4341 int iFrom
, /* Index in p->pSrc->a[] of the inner subquery */
4342 int isAgg
/* True if outer SELECT uses aggregate functions */
4344 const char *zSavedAuthContext
= pParse
->zAuthContext
;
4345 Select
*pParent
; /* Current UNION ALL term of the other query */
4346 Select
*pSub
; /* The inner query or "subquery" */
4347 Select
*pSub1
; /* Pointer to the rightmost select in sub-query */
4348 SrcList
*pSrc
; /* The FROM clause of the outer query */
4349 SrcList
*pSubSrc
; /* The FROM clause of the subquery */
4350 int iParent
; /* VDBE cursor number of the pSub result set temp table */
4351 int iNewParent
= -1;/* Replacement table for iParent */
4352 int isOuterJoin
= 0; /* True if pSub is the right side of a LEFT JOIN */
4353 int i
; /* Loop counter */
4354 Expr
*pWhere
; /* The WHERE clause */
4355 SrcItem
*pSubitem
; /* The subquery */
4356 sqlite3
*db
= pParse
->db
;
4357 Walker w
; /* Walker to persist agginfo data */
4360 /* Check to see if flattening is permitted. Return 0 if not.
4363 assert( p
->pPrior
==0 );
4364 if( OptimizationDisabled(db
, SQLITE_QueryFlattener
) ) return 0;
4366 assert( pSrc
&& iFrom
>=0 && iFrom
<pSrc
->nSrc
);
4367 pSubitem
= &pSrc
->a
[iFrom
];
4368 iParent
= pSubitem
->iCursor
;
4369 pSub
= pSubitem
->pSelect
;
4372 #ifndef SQLITE_OMIT_WINDOWFUNC
4373 if( p
->pWin
|| pSub
->pWin
) return 0; /* Restriction (25) */
4376 pSubSrc
= pSub
->pSrc
;
4378 /* Prior to version 3.1.2, when LIMIT and OFFSET had to be simple constants,
4379 ** not arbitrary expressions, we allowed some combining of LIMIT and OFFSET
4380 ** because they could be computed at compile-time. But when LIMIT and OFFSET
4381 ** became arbitrary expressions, we were forced to add restrictions (13)
4383 if( pSub
->pLimit
&& p
->pLimit
) return 0; /* Restriction (13) */
4384 if( pSub
->pLimit
&& pSub
->pLimit
->pRight
) return 0; /* Restriction (14) */
4385 if( (p
->selFlags
& SF_Compound
)!=0 && pSub
->pLimit
){
4386 return 0; /* Restriction (15) */
4388 if( pSubSrc
->nSrc
==0 ) return 0; /* Restriction (7) */
4389 if( pSub
->selFlags
& SF_Distinct
) return 0; /* Restriction (4) */
4390 if( pSub
->pLimit
&& (pSrc
->nSrc
>1 || isAgg
) ){
4391 return 0; /* Restrictions (8)(9) */
4393 if( p
->pOrderBy
&& pSub
->pOrderBy
){
4394 return 0; /* Restriction (11) */
4396 if( isAgg
&& pSub
->pOrderBy
) return 0; /* Restriction (16) */
4397 if( pSub
->pLimit
&& p
->pWhere
) return 0; /* Restriction (19) */
4398 if( pSub
->pLimit
&& (p
->selFlags
& SF_Distinct
)!=0 ){
4399 return 0; /* Restriction (21) */
4401 if( pSub
->selFlags
& (SF_Recursive
) ){
4402 return 0; /* Restrictions (22) */
4406 ** If the subquery is the right operand of a LEFT JOIN, then the
4407 ** subquery may not be a join itself (3a). Example of why this is not
4410 ** t1 LEFT OUTER JOIN (t2 JOIN t3)
4412 ** If we flatten the above, we would get
4414 ** (t1 LEFT OUTER JOIN t2) JOIN t3
4416 ** which is not at all the same thing.
4418 ** See also tickets #306, #350, and #3300.
4420 if( (pSubitem
->fg
.jointype
& (JT_OUTER
|JT_LTORJ
))!=0 ){
4421 if( pSubSrc
->nSrc
>1 /* (3a) */
4422 || IsVirtual(pSubSrc
->a
[0].pTab
) /* (3b) */
4423 || (p
->selFlags
& SF_Distinct
)!=0 /* (3d) */
4424 || (pSubitem
->fg
.jointype
& JT_RIGHT
)!=0 /* (26) */
4431 assert( pSubSrc
->nSrc
>0 ); /* True by restriction (7) */
4432 if( iFrom
>0 && (pSubSrc
->a
[0].fg
.jointype
& JT_LTORJ
)!=0 ){
4433 return 0; /* Restriction (27a) */
4436 /* Condition (28) is blocked by the caller */
4437 assert( !pSubitem
->fg
.isCte
|| pSubitem
->u2
.pCteUse
->eM10d
!=M10d_Yes
);
4439 /* Restriction (17): If the sub-query is a compound SELECT, then it must
4440 ** use only the UNION ALL operator. And none of the simple select queries
4441 ** that make up the compound SELECT are allowed to be aggregate or distinct
4446 if( pSub
->pOrderBy
){
4447 return 0; /* Restriction (20) */
4449 if( isAgg
|| (p
->selFlags
& SF_Distinct
)!=0 || isOuterJoin
>0 ){
4450 return 0; /* (17d1), (17d2), or (17f) */
4452 for(pSub1
=pSub
; pSub1
; pSub1
=pSub1
->pPrior
){
4453 testcase( (pSub1
->selFlags
& (SF_Distinct
|SF_Aggregate
))==SF_Distinct
);
4454 testcase( (pSub1
->selFlags
& (SF_Distinct
|SF_Aggregate
))==SF_Aggregate
);
4455 assert( pSub
->pSrc
!=0 );
4456 assert( (pSub
->selFlags
& SF_Recursive
)==0 );
4457 assert( pSub
->pEList
->nExpr
==pSub1
->pEList
->nExpr
);
4458 if( (pSub1
->selFlags
& (SF_Distinct
|SF_Aggregate
))!=0 /* (17b) */
4459 || (pSub1
->pPrior
&& pSub1
->op
!=TK_ALL
) /* (17a) */
4460 || pSub1
->pSrc
->nSrc
<1 /* (17c) */
4461 #ifndef SQLITE_OMIT_WINDOWFUNC
4462 || pSub1
->pWin
/* (17e) */
4467 if( iFrom
>0 && (pSub1
->pSrc
->a
[0].fg
.jointype
& JT_LTORJ
)!=0 ){
4468 /* Without this restriction, the JT_LTORJ flag would end up being
4469 ** omitted on left-hand tables of the right join that is being
4471 return 0; /* Restrictions (17g), (27b) */
4473 testcase( pSub1
->pSrc
->nSrc
>1 );
4476 /* Restriction (18). */
4478 for(ii
=0; ii
<p
->pOrderBy
->nExpr
; ii
++){
4479 if( p
->pOrderBy
->a
[ii
].u
.x
.iOrderByCol
==0 ) return 0;
4483 /* Restriction (23) */
4484 if( (p
->selFlags
& SF_Recursive
) ) return 0;
4486 /* Restriction (17h) */
4487 if( compoundHasDifferentAffinities(pSub
) ) return 0;
4490 if( pParse
->nSelect
>500 ) return 0;
4491 if( OptimizationDisabled(db
, SQLITE_FlttnUnionAll
) ) return 0;
4492 aCsrMap
= sqlite3DbMallocZero(db
, ((i64
)pParse
->nTab
+1)*sizeof(int));
4493 if( aCsrMap
) aCsrMap
[0] = pParse
->nTab
;
4497 /***** If we reach this point, flattening is permitted. *****/
4498 TREETRACE(0x4,pParse
,p
,("flatten %u.%p from term %d\n",
4499 pSub
->selId
, pSub
, iFrom
));
4501 /* Authorize the subquery */
4502 pParse
->zAuthContext
= pSubitem
->zName
;
4503 TESTONLY(i
=) sqlite3AuthCheck(pParse
, SQLITE_SELECT
, 0, 0, 0);
4504 testcase( i
==SQLITE_DENY
);
4505 pParse
->zAuthContext
= zSavedAuthContext
;
4507 /* Delete the transient structures associated with the subquery */
4508 pSub1
= pSubitem
->pSelect
;
4509 sqlite3DbFree(db
, pSubitem
->zDatabase
);
4510 sqlite3DbFree(db
, pSubitem
->zName
);
4511 sqlite3DbFree(db
, pSubitem
->zAlias
);
4512 pSubitem
->zDatabase
= 0;
4513 pSubitem
->zName
= 0;
4514 pSubitem
->zAlias
= 0;
4515 pSubitem
->pSelect
= 0;
4516 assert( pSubitem
->fg
.isUsing
!=0 || pSubitem
->u3
.pOn
==0 );
4518 /* If the sub-query is a compound SELECT statement, then (by restrictions
4519 ** 17 and 18 above) it must be a UNION ALL and the parent query must
4522 ** SELECT <expr-list> FROM (<sub-query>) <where-clause>
4524 ** followed by any ORDER BY, LIMIT and/or OFFSET clauses. This block
4525 ** creates N-1 copies of the parent query without any ORDER BY, LIMIT or
4526 ** OFFSET clauses and joins them to the left-hand-side of the original
4527 ** using UNION ALL operators. In this case N is the number of simple
4528 ** select statements in the compound sub-query.
4532 ** SELECT a+1 FROM (
4533 ** SELECT x FROM tab
4535 ** SELECT y FROM tab
4537 ** SELECT abs(z*2) FROM tab2
4538 ** ) WHERE a!=5 ORDER BY 1
4540 ** Transformed into:
4542 ** SELECT x+1 FROM tab WHERE x+1!=5
4544 ** SELECT y+1 FROM tab WHERE y+1!=5
4546 ** SELECT abs(z*2)+1 FROM tab2 WHERE abs(z*2)+1!=5
4549 ** We call this the "compound-subquery flattening".
4551 for(pSub
=pSub
->pPrior
; pSub
; pSub
=pSub
->pPrior
){
4553 ExprList
*pOrderBy
= p
->pOrderBy
;
4554 Expr
*pLimit
= p
->pLimit
;
4555 Select
*pPrior
= p
->pPrior
;
4556 Table
*pItemTab
= pSubitem
->pTab
;
4561 pNew
= sqlite3SelectDup(db
, p
, 0);
4563 p
->pOrderBy
= pOrderBy
;
4565 pSubitem
->pTab
= pItemTab
;
4569 pNew
->selId
= ++pParse
->nSelect
;
4570 if( aCsrMap
&& ALWAYS(db
->mallocFailed
==0) ){
4571 renumberCursors(pParse
, pNew
, iFrom
, aCsrMap
);
4573 pNew
->pPrior
= pPrior
;
4574 if( pPrior
) pPrior
->pNext
= pNew
;
4577 TREETRACE(0x4,pParse
,p
,("compound-subquery flattener"
4578 " creates %u as peer\n",pNew
->selId
));
4580 assert( pSubitem
->pSelect
==0 );
4582 sqlite3DbFree(db
, aCsrMap
);
4583 if( db
->mallocFailed
){
4584 pSubitem
->pSelect
= pSub1
;
4588 /* Defer deleting the Table object associated with the
4589 ** subquery until code generation is
4590 ** complete, since there may still exist Expr.pTab entries that
4591 ** refer to the subquery even after flattening. Ticket #3346.
4593 ** pSubitem->pTab is always non-NULL by test restrictions and tests above.
4595 if( ALWAYS(pSubitem
->pTab
!=0) ){
4596 Table
*pTabToDel
= pSubitem
->pTab
;
4597 if( pTabToDel
->nTabRef
==1 ){
4598 Parse
*pToplevel
= sqlite3ParseToplevel(pParse
);
4599 sqlite3ParserAddCleanup(pToplevel
, sqlite3DeleteTableGeneric
, pTabToDel
);
4600 testcase( pToplevel
->earlyCleanup
);
4602 pTabToDel
->nTabRef
--;
4607 /* The following loop runs once for each term in a compound-subquery
4608 ** flattening (as described above). If we are doing a different kind
4609 ** of flattening - a flattening other than a compound-subquery flattening -
4610 ** then this loop only runs once.
4612 ** This loop moves all of the FROM elements of the subquery into the
4613 ** the FROM clause of the outer query. Before doing this, remember
4614 ** the cursor number for the original outer query FROM element in
4615 ** iParent. The iParent cursor will never be used. Subsequent code
4616 ** will scan expressions looking for iParent references and replace
4617 ** those references with expressions that resolve to the subquery FROM
4618 ** elements we are now copying in.
4621 for(pParent
=p
; pParent
; pParent
=pParent
->pPrior
, pSub
=pSub
->pPrior
){
4624 u8 ltorj
= pSrc
->a
[iFrom
].fg
.jointype
& JT_LTORJ
;
4626 pSubSrc
= pSub
->pSrc
; /* FROM clause of subquery */
4627 nSubSrc
= pSubSrc
->nSrc
; /* Number of terms in subquery FROM clause */
4628 pSrc
= pParent
->pSrc
; /* FROM clause of the outer query */
4631 jointype
= pSubitem
->fg
.jointype
; /* First time through the loop */
4634 /* The subquery uses a single slot of the FROM clause of the outer
4635 ** query. If the subquery has more than one element in its FROM clause,
4636 ** then expand the outer query to make space for it to hold all elements
4641 ** SELECT * FROM tabA, (SELECT * FROM sub1, sub2), tabB;
4643 ** The outer query has 3 slots in its FROM clause. One slot of the
4644 ** outer query (the middle slot) is used by the subquery. The next
4645 ** block of code will expand the outer query FROM clause to 4 slots.
4646 ** The middle slot is expanded to two slots in order to make space
4647 ** for the two elements in the FROM clause of the subquery.
4650 pSrc
= sqlite3SrcListEnlarge(pParse
, pSrc
, nSubSrc
-1,iFrom
+1);
4651 if( pSrc
==0 ) break;
4652 pParent
->pSrc
= pSrc
;
4655 /* Transfer the FROM clause terms from the subquery into the
4658 for(i
=0; i
<nSubSrc
; i
++){
4659 SrcItem
*pItem
= &pSrc
->a
[i
+iFrom
];
4660 if( pItem
->fg
.isUsing
) sqlite3IdListDelete(db
, pItem
->u3
.pUsing
);
4661 assert( pItem
->fg
.isTabFunc
==0 );
4662 *pItem
= pSubSrc
->a
[i
];
4663 pItem
->fg
.jointype
|= ltorj
;
4664 iNewParent
= pSubSrc
->a
[i
].iCursor
;
4665 memset(&pSubSrc
->a
[i
], 0, sizeof(pSubSrc
->a
[i
]));
4667 pSrc
->a
[iFrom
].fg
.jointype
&= JT_LTORJ
;
4668 pSrc
->a
[iFrom
].fg
.jointype
|= jointype
| ltorj
;
4670 /* Now begin substituting subquery result set expressions for
4671 ** references to the iParent in the outer query.
4675 ** SELECT a+5, b*10 FROM (SELECT x*3 AS a, y+10 AS b FROM t1) WHERE a>b;
4676 ** \ \_____________ subquery __________/ /
4677 ** \_____________________ outer query ______________________________/
4679 ** We look at every expression in the outer query and every place we see
4680 ** "a" we substitute "x*3" and every place we see "b" we substitute "y+10".
4682 if( pSub
->pOrderBy
&& (pParent
->selFlags
& SF_NoopOrderBy
)==0 ){
4683 /* At this point, any non-zero iOrderByCol values indicate that the
4684 ** ORDER BY column expression is identical to the iOrderByCol'th
4685 ** expression returned by SELECT statement pSub. Since these values
4686 ** do not necessarily correspond to columns in SELECT statement pParent,
4687 ** zero them before transferring the ORDER BY clause.
4689 ** Not doing this may cause an error if a subsequent call to this
4690 ** function attempts to flatten a compound sub-query into pParent
4691 ** (the only way this can happen is if the compound sub-query is
4692 ** currently part of pSub->pSrc). See ticket [d11a6e908f]. */
4693 ExprList
*pOrderBy
= pSub
->pOrderBy
;
4694 for(i
=0; i
<pOrderBy
->nExpr
; i
++){
4695 pOrderBy
->a
[i
].u
.x
.iOrderByCol
= 0;
4697 assert( pParent
->pOrderBy
==0 );
4698 pParent
->pOrderBy
= pOrderBy
;
4701 pWhere
= pSub
->pWhere
;
4703 if( isOuterJoin
>0 ){
4704 sqlite3SetJoinExpr(pWhere
, iNewParent
, EP_OuterON
);
4707 if( pParent
->pWhere
){
4708 pParent
->pWhere
= sqlite3PExpr(pParse
, TK_AND
, pWhere
, pParent
->pWhere
);
4710 pParent
->pWhere
= pWhere
;
4713 if( db
->mallocFailed
==0 ){
4717 x
.iNewTable
= iNewParent
;
4718 x
.isOuterJoin
= isOuterJoin
;
4719 x
.pEList
= pSub
->pEList
;
4720 x
.pCList
= findLeftmostExprlist(pSub
);
4721 substSelect(&x
, pParent
, 0);
4724 /* The flattened query is a compound if either the inner or the
4725 ** outer query is a compound. */
4726 pParent
->selFlags
|= pSub
->selFlags
& SF_Compound
;
4727 assert( (pSub
->selFlags
& SF_Distinct
)==0 ); /* restriction (17b) */
4730 ** SELECT ... FROM (SELECT ... LIMIT a OFFSET b) LIMIT x OFFSET y;
4732 ** One is tempted to try to add a and b to combine the limits. But this
4733 ** does not work if either limit is negative.
4736 pParent
->pLimit
= pSub
->pLimit
;
4740 /* Recompute the SrcItem.colUsed masks for the flattened
4742 for(i
=0; i
<nSubSrc
; i
++){
4743 recomputeColumnsUsed(pParent
, &pSrc
->a
[i
+iFrom
]);
4747 /* Finally, delete what is left of the subquery and return success.
4749 sqlite3AggInfoPersistWalkerInit(&w
, pParse
);
4750 sqlite3WalkSelect(&w
,pSub1
);
4751 sqlite3SelectDelete(db
, pSub1
);
4753 #if TREETRACE_ENABLED
4754 if( sqlite3TreeTrace
& 0x4 ){
4755 TREETRACE(0x4,pParse
,p
,("After flattening:\n"));
4756 sqlite3TreeViewSelect(0, p
, 0);
4762 #endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
4765 ** A structure to keep track of all of the column values that are fixed to
4766 ** a known value due to WHERE clause constraints of the form COLUMN=VALUE.
4768 typedef struct WhereConst WhereConst
;
4770 Parse
*pParse
; /* Parsing context */
4771 u8
*pOomFault
; /* Pointer to pParse->db->mallocFailed */
4772 int nConst
; /* Number for COLUMN=CONSTANT terms */
4773 int nChng
; /* Number of times a constant is propagated */
4774 int bHasAffBlob
; /* At least one column in apExpr[] as affinity BLOB */
4775 u32 mExcludeOn
; /* Which ON expressions to exclude from considertion.
4776 ** Either EP_OuterON or EP_InnerON|EP_OuterON */
4777 Expr
**apExpr
; /* [i*2] is COLUMN and [i*2+1] is VALUE */
4781 ** Add a new entry to the pConst object. Except, do not add duplicate
4782 ** pColumn entries. Also, do not add if doing so would not be appropriate.
4784 ** The caller guarantees the pColumn is a column and pValue is a constant.
4785 ** This routine has to do some additional checks before completing the
4788 static void constInsert(
4789 WhereConst
*pConst
, /* The WhereConst into which we are inserting */
4790 Expr
*pColumn
, /* The COLUMN part of the constraint */
4791 Expr
*pValue
, /* The VALUE part of the constraint */
4792 Expr
*pExpr
/* Overall expression: COLUMN=VALUE or VALUE=COLUMN */
4795 assert( pColumn
->op
==TK_COLUMN
);
4796 assert( sqlite3ExprIsConstant(pConst
->pParse
, pValue
) );
4798 if( ExprHasProperty(pColumn
, EP_FixedCol
) ) return;
4799 if( sqlite3ExprAffinity(pValue
)!=0 ) return;
4800 if( !sqlite3IsBinary(sqlite3ExprCompareCollSeq(pConst
->pParse
,pExpr
)) ){
4804 /* 2018-10-25 ticket [cf5ed20f]
4805 ** Make sure the same pColumn is not inserted more than once */
4806 for(i
=0; i
<pConst
->nConst
; i
++){
4807 const Expr
*pE2
= pConst
->apExpr
[i
*2];
4808 assert( pE2
->op
==TK_COLUMN
);
4809 if( pE2
->iTable
==pColumn
->iTable
4810 && pE2
->iColumn
==pColumn
->iColumn
4812 return; /* Already present. Return without doing anything. */
4815 if( sqlite3ExprAffinity(pColumn
)==SQLITE_AFF_BLOB
){
4816 pConst
->bHasAffBlob
= 1;
4820 pConst
->apExpr
= sqlite3DbReallocOrFree(pConst
->pParse
->db
, pConst
->apExpr
,
4821 pConst
->nConst
*2*sizeof(Expr
*));
4822 if( pConst
->apExpr
==0 ){
4825 pConst
->apExpr
[pConst
->nConst
*2-2] = pColumn
;
4826 pConst
->apExpr
[pConst
->nConst
*2-1] = pValue
;
4831 ** Find all terms of COLUMN=VALUE or VALUE=COLUMN in pExpr where VALUE
4832 ** is a constant expression and where the term must be true because it
4833 ** is part of the AND-connected terms of the expression. For each term
4834 ** found, add it to the pConst structure.
4836 static void findConstInWhere(WhereConst
*pConst
, Expr
*pExpr
){
4837 Expr
*pRight
, *pLeft
;
4838 if( NEVER(pExpr
==0) ) return;
4839 if( ExprHasProperty(pExpr
, pConst
->mExcludeOn
) ){
4840 testcase( ExprHasProperty(pExpr
, EP_OuterON
) );
4841 testcase( ExprHasProperty(pExpr
, EP_InnerON
) );
4844 if( pExpr
->op
==TK_AND
){
4845 findConstInWhere(pConst
, pExpr
->pRight
);
4846 findConstInWhere(pConst
, pExpr
->pLeft
);
4849 if( pExpr
->op
!=TK_EQ
) return;
4850 pRight
= pExpr
->pRight
;
4851 pLeft
= pExpr
->pLeft
;
4852 assert( pRight
!=0 );
4854 if( pRight
->op
==TK_COLUMN
&& sqlite3ExprIsConstant(pConst
->pParse
, pLeft
) ){
4855 constInsert(pConst
,pRight
,pLeft
,pExpr
);
4857 if( pLeft
->op
==TK_COLUMN
&& sqlite3ExprIsConstant(pConst
->pParse
, pRight
) ){
4858 constInsert(pConst
,pLeft
,pRight
,pExpr
);
4863 ** This is a helper function for Walker callback propagateConstantExprRewrite().
4865 ** Argument pExpr is a candidate expression to be replaced by a value. If
4866 ** pExpr is equivalent to one of the columns named in pWalker->u.pConst,
4867 ** then overwrite it with the corresponding value. Except, do not do so
4868 ** if argument bIgnoreAffBlob is non-zero and the affinity of pExpr
4869 ** is SQLITE_AFF_BLOB.
4871 static int propagateConstantExprRewriteOne(
4877 if( pConst
->pOomFault
[0] ) return WRC_Prune
;
4878 if( pExpr
->op
!=TK_COLUMN
) return WRC_Continue
;
4879 if( ExprHasProperty(pExpr
, EP_FixedCol
|pConst
->mExcludeOn
) ){
4880 testcase( ExprHasProperty(pExpr
, EP_FixedCol
) );
4881 testcase( ExprHasProperty(pExpr
, EP_OuterON
) );
4882 testcase( ExprHasProperty(pExpr
, EP_InnerON
) );
4883 return WRC_Continue
;
4885 for(i
=0; i
<pConst
->nConst
; i
++){
4886 Expr
*pColumn
= pConst
->apExpr
[i
*2];
4887 if( pColumn
==pExpr
) continue;
4888 if( pColumn
->iTable
!=pExpr
->iTable
) continue;
4889 if( pColumn
->iColumn
!=pExpr
->iColumn
) continue;
4890 if( bIgnoreAffBlob
&& sqlite3ExprAffinity(pColumn
)==SQLITE_AFF_BLOB
){
4893 /* A match is found. Add the EP_FixedCol property */
4895 ExprClearProperty(pExpr
, EP_Leaf
);
4896 ExprSetProperty(pExpr
, EP_FixedCol
);
4897 assert( pExpr
->pLeft
==0 );
4898 pExpr
->pLeft
= sqlite3ExprDup(pConst
->pParse
->db
, pConst
->apExpr
[i
*2+1], 0);
4899 if( pConst
->pParse
->db
->mallocFailed
) return WRC_Prune
;
4906 ** This is a Walker expression callback. pExpr is a node from the WHERE
4907 ** clause of a SELECT statement. This function examines pExpr to see if
4908 ** any substitutions based on the contents of pWalker->u.pConst should
4909 ** be made to pExpr or its immediate children.
4911 ** A substitution is made if:
4913 ** + pExpr is a column with an affinity other than BLOB that matches
4914 ** one of the columns in pWalker->u.pConst, or
4916 ** + pExpr is a binary comparison operator (=, <=, >=, <, >) that
4917 ** uses an affinity other than TEXT and one of its immediate
4918 ** children is a column that matches one of the columns in
4919 ** pWalker->u.pConst.
4921 static int propagateConstantExprRewrite(Walker
*pWalker
, Expr
*pExpr
){
4922 WhereConst
*pConst
= pWalker
->u
.pConst
;
4923 assert( TK_GT
==TK_EQ
+1 );
4924 assert( TK_LE
==TK_EQ
+2 );
4925 assert( TK_LT
==TK_EQ
+3 );
4926 assert( TK_GE
==TK_EQ
+4 );
4927 if( pConst
->bHasAffBlob
){
4928 if( (pExpr
->op
>=TK_EQ
&& pExpr
->op
<=TK_GE
)
4931 propagateConstantExprRewriteOne(pConst
, pExpr
->pLeft
, 0);
4932 if( pConst
->pOomFault
[0] ) return WRC_Prune
;
4933 if( sqlite3ExprAffinity(pExpr
->pLeft
)!=SQLITE_AFF_TEXT
){
4934 propagateConstantExprRewriteOne(pConst
, pExpr
->pRight
, 0);
4938 return propagateConstantExprRewriteOne(pConst
, pExpr
, pConst
->bHasAffBlob
);
4942 ** The WHERE-clause constant propagation optimization.
4944 ** If the WHERE clause contains terms of the form COLUMN=CONSTANT or
4945 ** CONSTANT=COLUMN that are top-level AND-connected terms that are not
4946 ** part of a ON clause from a LEFT JOIN, then throughout the query
4947 ** replace all other occurrences of COLUMN with CONSTANT.
4949 ** For example, the query:
4951 ** SELECT * FROM t1, t2, t3 WHERE t1.a=39 AND t2.b=t1.a AND t3.c=t2.b
4953 ** Is transformed into
4955 ** SELECT * FROM t1, t2, t3 WHERE t1.a=39 AND t2.b=39 AND t3.c=39
4957 ** Return true if any transformations where made and false if not.
4959 ** Implementation note: Constant propagation is tricky due to affinity
4960 ** and collating sequence interactions. Consider this example:
4962 ** CREATE TABLE t1(a INT,b TEXT);
4963 ** INSERT INTO t1 VALUES(123,'0123');
4964 ** SELECT * FROM t1 WHERE a=123 AND b=a;
4965 ** SELECT * FROM t1 WHERE a=123 AND b=123;
4967 ** The two SELECT statements above should return different answers. b=a
4968 ** is always true because the comparison uses numeric affinity, but b=123
4969 ** is false because it uses text affinity and '0123' is not the same as '123'.
4970 ** To work around this, the expression tree is not actually changed from
4971 ** "b=a" to "b=123" but rather the "a" in "b=a" is tagged with EP_FixedCol
4972 ** and the "123" value is hung off of the pLeft pointer. Code generator
4973 ** routines know to generate the constant "123" instead of looking up the
4974 ** column value. Also, to avoid collation problems, this optimization is
4975 ** only attempted if the "a=123" term uses the default BINARY collation.
4977 ** 2021-05-25 forum post 6a06202608: Another troublesome case is...
4979 ** CREATE TABLE t1(x);
4980 ** INSERT INTO t1 VALUES(10.0);
4981 ** SELECT 1 FROM t1 WHERE x=10 AND x LIKE 10;
4983 ** The query should return no rows, because the t1.x value is '10.0' not '10'
4984 ** and '10.0' is not LIKE '10'. But if we are not careful, the first WHERE
4985 ** term "x=10" will cause the second WHERE term to become "10 LIKE 10",
4986 ** resulting in a false positive. To avoid this, constant propagation for
4987 ** columns with BLOB affinity is only allowed if the constant is used with
4988 ** operators ==, <=, <, >=, >, or IS in a way that will cause the correct
4989 ** type conversions to occur. See logic associated with the bHasAffBlob flag
4992 static int propagateConstants(
4993 Parse
*pParse
, /* The parsing context */
4994 Select
*p
/* The query in which to propagate constants */
5000 x
.pOomFault
= &pParse
->db
->mallocFailed
;
5006 if( ALWAYS(p
->pSrc
!=0)
5008 && (p
->pSrc
->a
[0].fg
.jointype
& JT_LTORJ
)!=0
5010 /* Do not propagate constants on any ON clause if there is a
5011 ** RIGHT JOIN anywhere in the query */
5012 x
.mExcludeOn
= EP_InnerON
| EP_OuterON
;
5014 /* Do not propagate constants through the ON clause of a LEFT JOIN */
5015 x
.mExcludeOn
= EP_OuterON
;
5017 findConstInWhere(&x
, p
->pWhere
);
5019 memset(&w
, 0, sizeof(w
));
5021 w
.xExprCallback
= propagateConstantExprRewrite
;
5022 w
.xSelectCallback
= sqlite3SelectWalkNoop
;
5023 w
.xSelectCallback2
= 0;
5026 sqlite3WalkExpr(&w
, p
->pWhere
);
5027 sqlite3DbFree(x
.pParse
->db
, x
.apExpr
);
5034 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
5035 # if !defined(SQLITE_OMIT_WINDOWFUNC)
5037 ** This function is called to determine whether or not it is safe to
5038 ** push WHERE clause expression pExpr down to FROM clause sub-query
5039 ** pSubq, which contains at least one window function. Return 1
5040 ** if it is safe and the expression should be pushed down, or 0
5043 ** It is only safe to push the expression down if it consists only
5044 ** of constants and copies of expressions that appear in the PARTITION
5045 ** BY clause of all window function used by the sub-query. It is safe
5046 ** to filter out entire partitions, but not rows within partitions, as
5047 ** this may change the results of the window functions.
5049 ** At the time this function is called it is guaranteed that
5051 ** * the sub-query uses only one distinct window frame, and
5052 ** * that the window frame has a PARTITION BY clause.
5054 static int pushDownWindowCheck(Parse
*pParse
, Select
*pSubq
, Expr
*pExpr
){
5055 assert( pSubq
->pWin
->pPartition
);
5056 assert( (pSubq
->selFlags
& SF_MultiPart
)==0 );
5057 assert( pSubq
->pPrior
==0 );
5058 return sqlite3ExprIsConstantOrGroupBy(pParse
, pExpr
, pSubq
->pWin
->pPartition
);
5060 # endif /* SQLITE_OMIT_WINDOWFUNC */
5061 #endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
5063 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
5065 ** Make copies of relevant WHERE clause terms of the outer query into
5066 ** the WHERE clause of subquery. Example:
5068 ** SELECT * FROM (SELECT a AS x, c-d AS y FROM t1) WHERE x=5 AND y=10;
5070 ** Transformed into:
5072 ** SELECT * FROM (SELECT a AS x, c-d AS y FROM t1 WHERE a=5 AND c-d=10)
5073 ** WHERE x=5 AND y=10;
5075 ** The hope is that the terms added to the inner query will make it more
5080 ** This optimization is called the "WHERE-clause push-down optimization"
5081 ** or sometimes the "predicate push-down optimization".
5083 ** Do not confuse this optimization with another unrelated optimization
5084 ** with a similar name: The "MySQL push-down optimization" causes WHERE
5085 ** clause terms that can be evaluated using only the index and without
5086 ** reference to the table are run first, so that if they are false,
5087 ** unnecessary table seeks are avoided.
5091 ** Do not attempt this optimization if:
5093 ** (1) (** This restriction was removed on 2017-09-29. We used to
5094 ** disallow this optimization for aggregate subqueries, but now
5095 ** it is allowed by putting the extra terms on the HAVING clause.
5096 ** The added HAVING clause is pointless if the subquery lacks
5097 ** a GROUP BY clause. But such a HAVING clause is also harmless
5098 ** so there does not appear to be any reason to add extra logic
5099 ** to suppress it. **)
5101 ** (2) The inner query is the recursive part of a common table expression.
5103 ** (3) The inner query has a LIMIT clause (since the changes to the WHERE
5104 ** clause would change the meaning of the LIMIT).
5106 ** (4) The inner query is the right operand of a LEFT JOIN and the
5107 ** expression to be pushed down does not come from the ON clause
5108 ** on that LEFT JOIN.
5110 ** (5) The WHERE clause expression originates in the ON or USING clause
5111 ** of a LEFT JOIN where iCursor is not the right-hand table of that
5112 ** left join. An example:
5115 ** FROM (SELECT 1 AS a1 UNION ALL SELECT 2) AS aa
5116 ** JOIN (SELECT 1 AS b2 UNION ALL SELECT 2) AS bb ON (a1=b2)
5117 ** LEFT JOIN (SELECT 8 AS c3 UNION ALL SELECT 9) AS cc ON (b2=2);
5119 ** The correct answer is three rows: (1,1,NULL),(2,2,8),(2,2,9).
5120 ** But if the (b2=2) term were to be pushed down into the bb subquery,
5121 ** then the (1,1,NULL) row would be suppressed.
5123 ** (6) Window functions make things tricky as changes to the WHERE clause
5124 ** of the inner query could change the window over which window
5125 ** functions are calculated. Therefore, do not attempt the optimization
5128 ** (6a) The inner query uses multiple incompatible window partitions.
5130 ** (6b) The inner query is a compound and uses window-functions.
5132 ** (6c) The WHERE clause does not consist entirely of constants and
5133 ** copies of expressions found in the PARTITION BY clause of
5134 ** all window-functions used by the sub-query. It is safe to
5135 ** filter out entire partitions, as this does not change the
5136 ** window over which any window-function is calculated.
5138 ** (7) The inner query is a Common Table Expression (CTE) that should
5139 ** be materialized. (This restriction is implemented in the calling
5142 ** (8) If the subquery is a compound that uses UNION, INTERSECT,
5143 ** or EXCEPT, then all of the result set columns for all arms of
5144 ** the compound must use the BINARY collating sequence.
5146 ** (9) All three of the following are true:
5148 ** (9a) The WHERE clause expression originates in the ON or USING clause
5149 ** of a join (either an INNER or an OUTER join), and
5151 ** (9b) The subquery is to the right of the ON/USING clause
5153 ** (9c) There is a RIGHT JOIN (or FULL JOIN) in between the ON/USING
5154 ** clause and the subquery.
5156 ** Without this restriction, the WHERE-clause push-down optimization
5157 ** might move the ON/USING filter expression from the left side of a
5158 ** RIGHT JOIN over to the right side, which leads to incorrect answers.
5159 ** See also restriction (6) in sqlite3ExprIsSingleTableConstraint().
5161 ** (10) The inner query is not the right-hand table of a RIGHT JOIN.
5163 ** (11) The subquery is not a VALUES clause
5165 ** (12) The WHERE clause is not "rowid ISNULL" or the equivalent. This
5166 ** case only comes up if SQLite is compiled using
5167 ** SQLITE_ALLOW_ROWID_IN_VIEW.
5169 ** Return 0 if no changes are made and non-zero if one or more WHERE clause
5170 ** terms are duplicated into the subquery.
5172 static int pushDownWhereTerms(
5173 Parse
*pParse
, /* Parse context (for malloc() and error reporting) */
5174 Select
*pSubq
, /* The subquery whose WHERE clause is to be augmented */
5175 Expr
*pWhere
, /* The WHERE clause of the outer query */
5176 SrcList
*pSrcList
, /* The complete from clause of the outer query */
5177 int iSrc
/* Which FROM clause term to try to push into */
5180 SrcItem
*pSrc
; /* The subquery FROM term into which WHERE is pushed */
5182 pSrc
= &pSrcList
->a
[iSrc
];
5183 if( pWhere
==0 ) return 0;
5184 if( pSubq
->selFlags
& (SF_Recursive
|SF_MultiPart
) ){
5185 return 0; /* restrictions (2) and (11) */
5187 if( pSrc
->fg
.jointype
& (JT_LTORJ
|JT_RIGHT
) ){
5188 return 0; /* restrictions (10) */
5191 if( pSubq
->pPrior
){
5193 int notUnionAll
= 0;
5194 for(pSel
=pSubq
; pSel
; pSel
=pSel
->pPrior
){
5196 assert( op
==TK_ALL
|| op
==TK_SELECT
5197 || op
==TK_UNION
|| op
==TK_INTERSECT
|| op
==TK_EXCEPT
);
5198 if( op
!=TK_ALL
&& op
!=TK_SELECT
){
5201 #ifndef SQLITE_OMIT_WINDOWFUNC
5202 if( pSel
->pWin
) return 0; /* restriction (6b) */
5206 /* If any of the compound arms are connected using UNION, INTERSECT,
5207 ** or EXCEPT, then we must ensure that none of the columns use a
5208 ** non-BINARY collating sequence. */
5209 for(pSel
=pSubq
; pSel
; pSel
=pSel
->pPrior
){
5211 const ExprList
*pList
= pSel
->pEList
;
5213 for(ii
=0; ii
<pList
->nExpr
; ii
++){
5214 CollSeq
*pColl
= sqlite3ExprCollSeq(pParse
, pList
->a
[ii
].pExpr
);
5215 if( !sqlite3IsBinary(pColl
) ){
5216 return 0; /* Restriction (8) */
5222 #ifndef SQLITE_OMIT_WINDOWFUNC
5223 if( pSubq
->pWin
&& pSubq
->pWin
->pPartition
==0 ) return 0;
5228 /* Only the first term of a compound can have a WITH clause. But make
5229 ** sure no other terms are marked SF_Recursive in case something changes
5234 for(pX
=pSubq
; pX
; pX
=pX
->pPrior
){
5235 assert( (pX
->selFlags
& (SF_Recursive
))==0 );
5240 if( pSubq
->pLimit
!=0 ){
5241 return 0; /* restriction (3) */
5243 while( pWhere
->op
==TK_AND
){
5244 nChng
+= pushDownWhereTerms(pParse
, pSubq
, pWhere
->pRight
, pSrcList
, iSrc
);
5245 pWhere
= pWhere
->pLeft
;
5248 #if 0 /* These checks now done by sqlite3ExprIsSingleTableConstraint() */
5249 if( ExprHasProperty(pWhere
, EP_OuterON
|EP_InnerON
) /* (9a) */
5250 && (pSrcList
->a
[0].fg
.jointype
& JT_LTORJ
)!=0 /* Fast pre-test of (9c) */
5253 for(jj
=0; jj
<iSrc
; jj
++){
5254 if( pWhere
->w
.iJoin
==pSrcList
->a
[jj
].iCursor
){
5255 /* If we reach this point, both (9a) and (9b) are satisfied.
5256 ** The following loop checks (9c):
5258 for(jj
++; jj
<iSrc
; jj
++){
5259 if( (pSrcList
->a
[jj
].fg
.jointype
& JT_RIGHT
)!=0 ){
5260 return 0; /* restriction (9) */
5267 && (ExprHasProperty(pWhere
,EP_OuterON
)==0
5268 || pWhere
->w
.iJoin
!=iCursor
)
5270 return 0; /* restriction (4) */
5272 if( ExprHasProperty(pWhere
,EP_OuterON
)
5273 && pWhere
->w
.iJoin
!=iCursor
5275 return 0; /* restriction (5) */
5279 #ifdef SQLITE_ALLOW_ROWID_IN_VIEW
5280 if( ViewCanHaveRowid
&& (pWhere
->op
==TK_ISNULL
|| pWhere
->op
==TK_NOTNULL
) ){
5281 Expr
*pLeft
= pWhere
->pLeft
;
5283 && pLeft
->op
==TK_COLUMN
5284 && pLeft
->iColumn
< 0
5286 return 0; /* Restriction (12) */
5291 if( sqlite3ExprIsSingleTableConstraint(pWhere
, pSrcList
, iSrc
, 1) ){
5293 pSubq
->selFlags
|= SF_PushDown
;
5296 pNew
= sqlite3ExprDup(pParse
->db
, pWhere
, 0);
5297 unsetJoinExpr(pNew
, -1, 1);
5299 x
.iTable
= pSrc
->iCursor
;
5300 x
.iNewTable
= pSrc
->iCursor
;
5302 x
.pEList
= pSubq
->pEList
;
5303 x
.pCList
= findLeftmostExprlist(pSubq
);
5304 pNew
= substExpr(&x
, pNew
);
5305 #ifndef SQLITE_OMIT_WINDOWFUNC
5306 if( pSubq
->pWin
&& 0==pushDownWindowCheck(pParse
, pSubq
, pNew
) ){
5307 /* Restriction 6c has prevented push-down in this case */
5308 sqlite3ExprDelete(pParse
->db
, pNew
);
5313 if( pSubq
->selFlags
& SF_Aggregate
){
5314 pSubq
->pHaving
= sqlite3ExprAnd(pParse
, pSubq
->pHaving
, pNew
);
5316 pSubq
->pWhere
= sqlite3ExprAnd(pParse
, pSubq
->pWhere
, pNew
);
5318 pSubq
= pSubq
->pPrior
;
5323 #endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
5326 ** Check to see if a subquery contains result-set columns that are
5327 ** never used. If it does, change the value of those result-set columns
5328 ** to NULL so that they do not cause unnecessary work to compute.
5330 ** Return the number of column that were changed to NULL.
5332 static int disableUnusedSubqueryResultColumns(SrcItem
*pItem
){
5334 Select
*pSub
; /* The subquery to be simplified */
5335 Select
*pX
; /* For looping over compound elements of pSub */
5336 Table
*pTab
; /* The table that describes the subquery */
5337 int j
; /* Column number */
5338 int nChng
= 0; /* Number of columns converted to NULL */
5339 Bitmask colUsed
; /* Columns that may not be NULLed out */
5342 if( pItem
->fg
.isCorrelated
|| pItem
->fg
.isCte
){
5345 assert( pItem
->pTab
!=0 );
5347 assert( pItem
->pSelect
!=0 );
5348 pSub
= pItem
->pSelect
;
5349 assert( pSub
->pEList
->nExpr
==pTab
->nCol
);
5350 for(pX
=pSub
; pX
; pX
=pX
->pPrior
){
5351 if( (pX
->selFlags
& (SF_Distinct
|SF_Aggregate
))!=0 ){
5352 testcase( pX
->selFlags
& SF_Distinct
);
5353 testcase( pX
->selFlags
& SF_Aggregate
);
5356 if( pX
->pPrior
&& pX
->op
!=TK_ALL
){
5357 /* This optimization does not work for compound subqueries that
5358 ** use UNION, INTERSECT, or EXCEPT. Only UNION ALL is allowed. */
5361 #ifndef SQLITE_OMIT_WINDOWFUNC
5363 /* This optimization does not work for subqueries that use window
5369 colUsed
= pItem
->colUsed
;
5370 if( pSub
->pOrderBy
){
5371 ExprList
*pList
= pSub
->pOrderBy
;
5372 for(j
=0; j
<pList
->nExpr
; j
++){
5373 u16 iCol
= pList
->a
[j
].u
.x
.iOrderByCol
;
5376 colUsed
|= ((Bitmask
)1)<<(iCol
>=BMS
? BMS
-1 : iCol
);
5381 for(j
=0; j
<nCol
; j
++){
5382 Bitmask m
= j
<BMS
-1 ? MASKBIT(j
) : TOPBIT
;
5383 if( (m
& colUsed
)!=0 ) continue;
5384 for(pX
=pSub
; pX
; pX
=pX
->pPrior
) {
5385 Expr
*pY
= pX
->pEList
->a
[j
].pExpr
;
5386 if( pY
->op
==TK_NULL
) continue;
5388 ExprClearProperty(pY
, EP_Skip
|EP_Unlikely
);
5389 pX
->selFlags
|= SF_PushDown
;
5398 ** The pFunc is the only aggregate function in the query. Check to see
5399 ** if the query is a candidate for the min/max optimization.
5401 ** If the query is a candidate for the min/max optimization, then set
5402 ** *ppMinMax to be an ORDER BY clause to be used for the optimization
5403 ** and return either WHERE_ORDERBY_MIN or WHERE_ORDERBY_MAX depending on
5404 ** whether pFunc is a min() or max() function.
5406 ** If the query is not a candidate for the min/max optimization, return
5407 ** WHERE_ORDERBY_NORMAL (which must be zero).
5409 ** This routine must be called after aggregate functions have been
5410 ** located but before their arguments have been subjected to aggregate
5413 static u8
minMaxQuery(sqlite3
*db
, Expr
*pFunc
, ExprList
**ppMinMax
){
5414 int eRet
= WHERE_ORDERBY_NORMAL
; /* Return value */
5415 ExprList
*pEList
; /* Arguments to agg function */
5416 const char *zFunc
; /* Name of aggregate function pFunc */
5420 assert( *ppMinMax
==0 );
5421 assert( pFunc
->op
==TK_AGG_FUNCTION
);
5422 assert( !IsWindowFunc(pFunc
) );
5423 assert( ExprUseXList(pFunc
) );
5424 pEList
= pFunc
->x
.pList
;
5427 || ExprHasProperty(pFunc
, EP_WinFunc
)
5428 || OptimizationDisabled(db
, SQLITE_MinMaxOpt
)
5432 assert( !ExprHasProperty(pFunc
, EP_IntValue
) );
5433 zFunc
= pFunc
->u
.zToken
;
5434 if( sqlite3StrICmp(zFunc
, "min")==0 ){
5435 eRet
= WHERE_ORDERBY_MIN
;
5436 if( sqlite3ExprCanBeNull(pEList
->a
[0].pExpr
) ){
5437 sortFlags
= KEYINFO_ORDER_BIGNULL
;
5439 }else if( sqlite3StrICmp(zFunc
, "max")==0 ){
5440 eRet
= WHERE_ORDERBY_MAX
;
5441 sortFlags
= KEYINFO_ORDER_DESC
;
5445 *ppMinMax
= pOrderBy
= sqlite3ExprListDup(db
, pEList
, 0);
5446 assert( pOrderBy
!=0 || db
->mallocFailed
);
5447 if( pOrderBy
) pOrderBy
->a
[0].fg
.sortFlags
= sortFlags
;
5452 ** The select statement passed as the first argument is an aggregate query.
5453 ** The second argument is the associated aggregate-info object. This
5454 ** function tests if the SELECT is of the form:
5456 ** SELECT count(*) FROM <tbl>
5458 ** where table is a database table, not a sub-select or view. If the query
5459 ** does match this pattern, then a pointer to the Table object representing
5460 ** <tbl> is returned. Otherwise, NULL is returned.
5462 ** This routine checks to see if it is safe to use the count optimization.
5463 ** A correct answer is still obtained (though perhaps more slowly) if
5464 ** this routine returns NULL when it could have returned a table pointer.
5465 ** But returning the pointer when NULL should have been returned can
5466 ** result in incorrect answers and/or crashes. So, when in doubt, return NULL.
5468 static Table
*isSimpleCount(Select
*p
, AggInfo
*pAggInfo
){
5472 assert( !p
->pGroupBy
);
5475 || p
->pEList
->nExpr
!=1
5477 || p
->pSrc
->a
[0].pSelect
5478 || pAggInfo
->nFunc
!=1
5483 pTab
= p
->pSrc
->a
[0].pTab
;
5485 assert( !IsView(pTab
) );
5486 if( !IsOrdinaryTable(pTab
) ) return 0;
5487 pExpr
= p
->pEList
->a
[0].pExpr
;
5489 if( pExpr
->op
!=TK_AGG_FUNCTION
) return 0;
5490 if( pExpr
->pAggInfo
!=pAggInfo
) return 0;
5491 if( (pAggInfo
->aFunc
[0].pFunc
->funcFlags
&SQLITE_FUNC_COUNT
)==0 ) return 0;
5492 assert( pAggInfo
->aFunc
[0].pFExpr
==pExpr
);
5493 testcase( ExprHasProperty(pExpr
, EP_Distinct
) );
5494 testcase( ExprHasProperty(pExpr
, EP_WinFunc
) );
5495 if( ExprHasProperty(pExpr
, EP_Distinct
|EP_WinFunc
) ) return 0;
5501 ** If the source-list item passed as an argument was augmented with an
5502 ** INDEXED BY clause, then try to locate the specified index. If there
5503 ** was such a clause and the named index cannot be found, return
5504 ** SQLITE_ERROR and leave an error in pParse. Otherwise, populate
5505 ** pFrom->pIndex and return SQLITE_OK.
5507 int sqlite3IndexedByLookup(Parse
*pParse
, SrcItem
*pFrom
){
5508 Table
*pTab
= pFrom
->pTab
;
5509 char *zIndexedBy
= pFrom
->u1
.zIndexedBy
;
5512 assert( pFrom
->fg
.isIndexedBy
!=0 );
5514 for(pIdx
=pTab
->pIndex
;
5515 pIdx
&& sqlite3StrICmp(pIdx
->zName
, zIndexedBy
);
5519 sqlite3ErrorMsg(pParse
, "no such index: %s", zIndexedBy
, 0);
5520 pParse
->checkSchema
= 1;
5521 return SQLITE_ERROR
;
5523 assert( pFrom
->fg
.isCte
==0 );
5524 pFrom
->u2
.pIBIndex
= pIdx
;
5529 ** Detect compound SELECT statements that use an ORDER BY clause with
5530 ** an alternative collating sequence.
5532 ** SELECT ... FROM t1 EXCEPT SELECT ... FROM t2 ORDER BY .. COLLATE ...
5534 ** These are rewritten as a subquery:
5536 ** SELECT * FROM (SELECT ... FROM t1 EXCEPT SELECT ... FROM t2)
5537 ** ORDER BY ... COLLATE ...
5539 ** This transformation is necessary because the multiSelectOrderBy() routine
5540 ** above that generates the code for a compound SELECT with an ORDER BY clause
5541 ** uses a merge algorithm that requires the same collating sequence on the
5542 ** result columns as on the ORDER BY clause. See ticket
5543 ** http://www.sqlite.org/src/info/6709574d2a
5545 ** This transformation is only needed for EXCEPT, INTERSECT, and UNION.
5546 ** The UNION ALL operator works fine with multiSelectOrderBy() even when
5547 ** there are COLLATE terms in the ORDER BY.
5549 static int convertCompoundSelectToSubquery(Walker
*pWalker
, Select
*p
){
5554 struct ExprList_item
*a
;
5559 if( p
->pPrior
==0 ) return WRC_Continue
;
5560 if( p
->pOrderBy
==0 ) return WRC_Continue
;
5561 for(pX
=p
; pX
&& (pX
->op
==TK_ALL
|| pX
->op
==TK_SELECT
); pX
=pX
->pPrior
){}
5562 if( pX
==0 ) return WRC_Continue
;
5564 #ifndef SQLITE_OMIT_WINDOWFUNC
5565 /* If iOrderByCol is already non-zero, then it has already been matched
5566 ** to a result column of the SELECT statement. This occurs when the
5567 ** SELECT is rewritten for window-functions processing and then passed
5568 ** to sqlite3SelectPrep() and similar a second time. The rewriting done
5569 ** by this function is not required in this case. */
5570 if( a
[0].u
.x
.iOrderByCol
) return WRC_Continue
;
5572 for(i
=p
->pOrderBy
->nExpr
-1; i
>=0; i
--){
5573 if( a
[i
].pExpr
->flags
& EP_Collate
) break;
5575 if( i
<0 ) return WRC_Continue
;
5577 /* If we reach this point, that means the transformation is required. */
5579 pParse
= pWalker
->pParse
;
5581 pNew
= sqlite3DbMallocZero(db
, sizeof(*pNew
) );
5582 if( pNew
==0 ) return WRC_Abort
;
5583 memset(&dummy
, 0, sizeof(dummy
));
5584 pNewSrc
= sqlite3SrcListAppendFromTerm(pParse
,0,0,0,&dummy
,pNew
,0);
5585 if( pNewSrc
==0 ) return WRC_Abort
;
5588 p
->pEList
= sqlite3ExprListAppend(pParse
, 0, sqlite3Expr(db
, TK_ASTERISK
, 0));
5597 #ifndef SQLITE_OMIT_WINDOWFUNC
5600 p
->selFlags
&= ~SF_Compound
;
5601 assert( (p
->selFlags
& SF_Converted
)==0 );
5602 p
->selFlags
|= SF_Converted
;
5603 assert( pNew
->pPrior
!=0 );
5604 pNew
->pPrior
->pNext
= pNew
;
5606 return WRC_Continue
;
5610 ** Check to see if the FROM clause term pFrom has table-valued function
5611 ** arguments. If it does, leave an error message in pParse and return
5612 ** non-zero, since pFrom is not allowed to be a table-valued function.
5614 static int cannotBeFunction(Parse
*pParse
, SrcItem
*pFrom
){
5615 if( pFrom
->fg
.isTabFunc
){
5616 sqlite3ErrorMsg(pParse
, "'%s' is not a function", pFrom
->zName
);
5622 #ifndef SQLITE_OMIT_CTE
5624 ** Argument pWith (which may be NULL) points to a linked list of nested
5625 ** WITH contexts, from inner to outermost. If the table identified by
5626 ** FROM clause element pItem is really a common-table-expression (CTE)
5627 ** then return a pointer to the CTE definition for that table. Otherwise
5630 ** If a non-NULL value is returned, set *ppContext to point to the With
5631 ** object that the returned CTE belongs to.
5633 static struct Cte
*searchWith(
5634 With
*pWith
, /* Current innermost WITH clause */
5635 SrcItem
*pItem
, /* FROM clause element to resolve */
5636 With
**ppContext
/* OUT: WITH clause return value belongs to */
5638 const char *zName
= pItem
->zName
;
5640 assert( pItem
->zDatabase
==0 );
5642 for(p
=pWith
; p
; p
=p
->pOuter
){
5644 for(i
=0; i
<p
->nCte
; i
++){
5645 if( sqlite3StrICmp(zName
, p
->a
[i
].zName
)==0 ){
5650 if( p
->bView
) break;
5655 /* The code generator maintains a stack of active WITH clauses
5656 ** with the inner-most WITH clause being at the top of the stack.
5658 ** This routine pushes the WITH clause passed as the second argument
5659 ** onto the top of the stack. If argument bFree is true, then this
5660 ** WITH clause will never be popped from the stack but should instead
5661 ** be freed along with the Parse object. In other cases, when
5662 ** bFree==0, the With object will be freed along with the SELECT
5663 ** statement with which it is associated.
5665 ** This routine returns a copy of pWith. Or, if bFree is true and
5666 ** the pWith object is destroyed immediately due to an OOM condition,
5667 ** then this routine return NULL.
5669 ** If bFree is true, do not continue to use the pWith pointer after
5670 ** calling this routine, Instead, use only the return value.
5672 With
*sqlite3WithPush(Parse
*pParse
, With
*pWith
, u8 bFree
){
5675 pWith
= (With
*)sqlite3ParserAddCleanup(pParse
, sqlite3WithDeleteGeneric
,
5677 if( pWith
==0 ) return 0;
5679 if( pParse
->nErr
==0 ){
5680 assert( pParse
->pWith
!=pWith
);
5681 pWith
->pOuter
= pParse
->pWith
;
5682 pParse
->pWith
= pWith
;
5689 ** This function checks if argument pFrom refers to a CTE declared by
5690 ** a WITH clause on the stack currently maintained by the parser (on the
5691 ** pParse->pWith linked list). And if currently processing a CTE
5692 ** CTE expression, through routine checks to see if the reference is
5693 ** a recursive reference to the CTE.
5695 ** If pFrom matches a CTE according to either of these two above, pFrom->pTab
5696 ** and other fields are populated accordingly.
5698 ** Return 0 if no match is found.
5699 ** Return 1 if a match is found.
5700 ** Return 2 if an error condition is detected.
5702 static int resolveFromTermToCte(
5703 Parse
*pParse
, /* The parsing context */
5704 Walker
*pWalker
, /* Current tree walker */
5705 SrcItem
*pFrom
/* The FROM clause term to check */
5707 Cte
*pCte
; /* Matched CTE (or NULL if no match) */
5708 With
*pWith
; /* The matching WITH */
5710 assert( pFrom
->pTab
==0 );
5711 if( pParse
->pWith
==0 ){
5712 /* There are no WITH clauses in the stack. No match is possible */
5716 /* Prior errors might have left pParse->pWith in a goofy state, so
5717 ** go no further. */
5720 if( pFrom
->zDatabase
!=0 ){
5721 /* The FROM term contains a schema qualifier (ex: main.t1) and so
5722 ** it cannot possibly be a CTE reference. */
5725 if( pFrom
->fg
.notCte
){
5726 /* The FROM term is specifically excluded from matching a CTE.
5727 ** (1) It is part of a trigger that used to have zDatabase but had
5728 ** zDatabase removed by sqlite3FixTriggerStep().
5729 ** (2) This is the first term in the FROM clause of an UPDATE.
5733 pCte
= searchWith(pParse
->pWith
, pFrom
, &pWith
);
5735 sqlite3
*db
= pParse
->db
;
5739 Select
*pLeft
; /* Left-most SELECT statement */
5740 Select
*pRecTerm
; /* Left-most recursive term */
5741 int bMayRecursive
; /* True if compound joined by UNION [ALL] */
5742 With
*pSavedWith
; /* Initial value of pParse->pWith */
5743 int iRecTab
= -1; /* Cursor for recursive table */
5746 /* If pCte->zCteErr is non-NULL at this point, then this is an illegal
5747 ** recursive reference to CTE pCte. Leave an error in pParse and return
5748 ** early. If pCte->zCteErr is NULL, then this is not a recursive reference.
5749 ** In this case, proceed. */
5750 if( pCte
->zCteErr
){
5751 sqlite3ErrorMsg(pParse
, pCte
->zCteErr
, pCte
->zName
);
5754 if( cannotBeFunction(pParse
, pFrom
) ) return 2;
5756 assert( pFrom
->pTab
==0 );
5757 pTab
= sqlite3DbMallocZero(db
, sizeof(Table
));
5758 if( pTab
==0 ) return 2;
5759 pCteUse
= pCte
->pUse
;
5761 pCte
->pUse
= pCteUse
= sqlite3DbMallocZero(db
, sizeof(pCteUse
[0]));
5763 || sqlite3ParserAddCleanup(pParse
,sqlite3DbFree
,pCteUse
)==0
5765 sqlite3DbFree(db
, pTab
);
5768 pCteUse
->eM10d
= pCte
->eM10d
;
5772 pTab
->zName
= sqlite3DbStrDup(db
, pCte
->zName
);
5774 pTab
->nRowLogEst
= 200; assert( 200==sqlite3LogEst(1048576) );
5775 pTab
->tabFlags
|= TF_Ephemeral
| TF_NoVisibleRowid
;
5776 pFrom
->pSelect
= sqlite3SelectDup(db
, pCte
->pSelect
, 0);
5777 if( db
->mallocFailed
) return 2;
5778 pFrom
->pSelect
->selFlags
|= SF_CopyCte
;
5779 assert( pFrom
->pSelect
);
5780 if( pFrom
->fg
.isIndexedBy
){
5781 sqlite3ErrorMsg(pParse
, "no such index: \"%s\"", pFrom
->u1
.zIndexedBy
);
5784 pFrom
->fg
.isCte
= 1;
5785 pFrom
->u2
.pCteUse
= pCteUse
;
5788 /* Check if this is a recursive CTE. */
5789 pRecTerm
= pSel
= pFrom
->pSelect
;
5790 bMayRecursive
= ( pSel
->op
==TK_ALL
|| pSel
->op
==TK_UNION
);
5791 while( bMayRecursive
&& pRecTerm
->op
==pSel
->op
){
5793 SrcList
*pSrc
= pRecTerm
->pSrc
;
5794 assert( pRecTerm
->pPrior
!=0 );
5795 for(i
=0; i
<pSrc
->nSrc
; i
++){
5796 SrcItem
*pItem
= &pSrc
->a
[i
];
5797 if( pItem
->zDatabase
==0
5799 && 0==sqlite3StrICmp(pItem
->zName
, pCte
->zName
)
5803 pItem
->fg
.isRecursive
= 1;
5804 if( pRecTerm
->selFlags
& SF_Recursive
){
5805 sqlite3ErrorMsg(pParse
,
5806 "multiple references to recursive table: %s", pCte
->zName
5810 pRecTerm
->selFlags
|= SF_Recursive
;
5811 if( iRecTab
<0 ) iRecTab
= pParse
->nTab
++;
5812 pItem
->iCursor
= iRecTab
;
5815 if( (pRecTerm
->selFlags
& SF_Recursive
)==0 ) break;
5816 pRecTerm
= pRecTerm
->pPrior
;
5819 pCte
->zCteErr
= "circular reference: %s";
5820 pSavedWith
= pParse
->pWith
;
5821 pParse
->pWith
= pWith
;
5822 if( pSel
->selFlags
& SF_Recursive
){
5824 assert( pRecTerm
!=0 );
5825 assert( (pRecTerm
->selFlags
& SF_Recursive
)==0 );
5826 assert( pRecTerm
->pNext
!=0 );
5827 assert( (pRecTerm
->pNext
->selFlags
& SF_Recursive
)!=0 );
5828 assert( pRecTerm
->pWith
==0 );
5829 pRecTerm
->pWith
= pSel
->pWith
;
5830 rc
= sqlite3WalkSelect(pWalker
, pRecTerm
);
5831 pRecTerm
->pWith
= 0;
5833 pParse
->pWith
= pSavedWith
;
5837 if( sqlite3WalkSelect(pWalker
, pSel
) ){
5838 pParse
->pWith
= pSavedWith
;
5842 pParse
->pWith
= pWith
;
5844 for(pLeft
=pSel
; pLeft
->pPrior
; pLeft
=pLeft
->pPrior
);
5845 pEList
= pLeft
->pEList
;
5847 if( pEList
&& pEList
->nExpr
!=pCte
->pCols
->nExpr
){
5848 sqlite3ErrorMsg(pParse
, "table %s has %d values for %d columns",
5849 pCte
->zName
, pEList
->nExpr
, pCte
->pCols
->nExpr
5851 pParse
->pWith
= pSavedWith
;
5854 pEList
= pCte
->pCols
;
5857 sqlite3ColumnsFromExprList(pParse
, pEList
, &pTab
->nCol
, &pTab
->aCol
);
5858 if( bMayRecursive
){
5859 if( pSel
->selFlags
& SF_Recursive
){
5860 pCte
->zCteErr
= "multiple recursive references: %s";
5862 pCte
->zCteErr
= "recursive reference in a subquery: %s";
5864 sqlite3WalkSelect(pWalker
, pSel
);
5867 pParse
->pWith
= pSavedWith
;
5868 return 1; /* Success */
5870 return 0; /* No match */
5874 #ifndef SQLITE_OMIT_CTE
5876 ** If the SELECT passed as the second argument has an associated WITH
5877 ** clause, pop it from the stack stored as part of the Parse object.
5879 ** This function is used as the xSelectCallback2() callback by
5880 ** sqlite3SelectExpand() when walking a SELECT tree to resolve table
5881 ** names and other FROM clause elements.
5883 void sqlite3SelectPopWith(Walker
*pWalker
, Select
*p
){
5884 Parse
*pParse
= pWalker
->pParse
;
5885 if( OK_IF_ALWAYS_TRUE(pParse
->pWith
) && p
->pPrior
==0 ){
5886 With
*pWith
= findRightmost(p
)->pWith
;
5888 assert( pParse
->pWith
==pWith
|| pParse
->nErr
);
5889 pParse
->pWith
= pWith
->pOuter
;
5896 ** The SrcItem structure passed as the second argument represents a
5897 ** sub-query in the FROM clause of a SELECT statement. This function
5898 ** allocates and populates the SrcItem.pTab object. If successful,
5899 ** SQLITE_OK is returned. Otherwise, if an OOM error is encountered,
5902 int sqlite3ExpandSubquery(Parse
*pParse
, SrcItem
*pFrom
){
5903 Select
*pSel
= pFrom
->pSelect
;
5907 pFrom
->pTab
= pTab
= sqlite3DbMallocZero(pParse
->db
, sizeof(Table
));
5908 if( pTab
==0 ) return SQLITE_NOMEM
;
5910 if( pFrom
->zAlias
){
5911 pTab
->zName
= sqlite3DbStrDup(pParse
->db
, pFrom
->zAlias
);
5913 pTab
->zName
= sqlite3MPrintf(pParse
->db
, "%!S", pFrom
);
5915 while( pSel
->pPrior
){ pSel
= pSel
->pPrior
; }
5916 sqlite3ColumnsFromExprList(pParse
, pSel
->pEList
,&pTab
->nCol
,&pTab
->aCol
);
5918 pTab
->eTabType
= TABTYP_VIEW
;
5919 pTab
->nRowLogEst
= 200; assert( 200==sqlite3LogEst(1048576) );
5920 #ifndef SQLITE_ALLOW_ROWID_IN_VIEW
5921 /* The usual case - do not allow ROWID on a subquery */
5922 pTab
->tabFlags
|= TF_Ephemeral
| TF_NoVisibleRowid
;
5924 /* Legacy compatibility mode */
5925 pTab
->tabFlags
|= TF_Ephemeral
| sqlite3Config
.mNoVisibleRowid
;
5927 return pParse
->nErr
? SQLITE_ERROR
: SQLITE_OK
;
5932 ** Check the N SrcItem objects to the right of pBase. (N might be zero!)
5933 ** If any of those SrcItem objects have a USING clause containing zName
5934 ** then return true.
5936 ** If N is zero, or none of the N SrcItem objects to the right of pBase
5937 ** contains a USING clause, or if none of the USING clauses contain zName,
5938 ** then return false.
5940 static int inAnyUsingClause(
5941 const char *zName
, /* Name we are looking for */
5942 SrcItem
*pBase
, /* The base SrcItem. Looking at pBase[1] and following */
5943 int N
/* How many SrcItems to check */
5948 if( pBase
->fg
.isUsing
==0 ) continue;
5949 if( NEVER(pBase
->u3
.pUsing
==0) ) continue;
5950 if( sqlite3IdListIndex(pBase
->u3
.pUsing
, zName
)>=0 ) return 1;
5957 ** This routine is a Walker callback for "expanding" a SELECT statement.
5958 ** "Expanding" means to do the following:
5960 ** (1) Make sure VDBE cursor numbers have been assigned to every
5961 ** element of the FROM clause.
5963 ** (2) Fill in the pTabList->a[].pTab fields in the SrcList that
5964 ** defines FROM clause. When views appear in the FROM clause,
5965 ** fill pTabList->a[].pSelect with a copy of the SELECT statement
5966 ** that implements the view. A copy is made of the view's SELECT
5967 ** statement so that we can freely modify or delete that statement
5968 ** without worrying about messing up the persistent representation
5971 ** (3) Add terms to the WHERE clause to accommodate the NATURAL keyword
5972 ** on joins and the ON and USING clause of joins.
5974 ** (4) Scan the list of columns in the result set (pEList) looking
5975 ** for instances of the "*" operator or the TABLE.* operator.
5976 ** If found, expand each "*" to be every column in every table
5977 ** and TABLE.* to be every column in TABLE.
5980 static int selectExpander(Walker
*pWalker
, Select
*p
){
5981 Parse
*pParse
= pWalker
->pParse
;
5986 sqlite3
*db
= pParse
->db
;
5987 Expr
*pE
, *pRight
, *pExpr
;
5988 u16 selFlags
= p
->selFlags
;
5991 p
->selFlags
|= SF_Expanded
;
5992 if( db
->mallocFailed
){
5995 assert( p
->pSrc
!=0 );
5996 if( (selFlags
& SF_Expanded
)!=0 ){
5999 if( pWalker
->eCode
){
6000 /* Renumber selId because it has been copied from a view */
6001 p
->selId
= ++pParse
->nSelect
;
6005 if( pParse
->pWith
&& (p
->selFlags
& SF_View
) ){
6007 p
->pWith
= (With
*)sqlite3DbMallocZero(db
, sizeof(With
));
6012 p
->pWith
->bView
= 1;
6014 sqlite3WithPush(pParse
, p
->pWith
, 0);
6016 /* Make sure cursor numbers have been assigned to all entries in
6017 ** the FROM clause of the SELECT statement.
6019 sqlite3SrcListAssignCursors(pParse
, pTabList
);
6021 /* Look up every table named in the FROM clause of the select. If
6022 ** an entry of the FROM clause is a subquery instead of a table or view,
6023 ** then create a transient table structure to describe the subquery.
6025 for(i
=0, pFrom
=pTabList
->a
; i
<pTabList
->nSrc
; i
++, pFrom
++){
6027 assert( pFrom
->fg
.isRecursive
==0 || pFrom
->pTab
!=0 );
6028 if( pFrom
->pTab
) continue;
6029 assert( pFrom
->fg
.isRecursive
==0 );
6030 if( pFrom
->zName
==0 ){
6031 #ifndef SQLITE_OMIT_SUBQUERY
6032 Select
*pSel
= pFrom
->pSelect
;
6033 /* A sub-query in the FROM clause of a SELECT */
6035 assert( pFrom
->pTab
==0 );
6036 if( sqlite3WalkSelect(pWalker
, pSel
) ) return WRC_Abort
;
6037 if( sqlite3ExpandSubquery(pParse
, pFrom
) ) return WRC_Abort
;
6039 #ifndef SQLITE_OMIT_CTE
6040 }else if( (rc
= resolveFromTermToCte(pParse
, pWalker
, pFrom
))!=0 ){
6041 if( rc
>1 ) return WRC_Abort
;
6046 /* An ordinary table or view name in the FROM clause */
6047 assert( pFrom
->pTab
==0 );
6048 pFrom
->pTab
= pTab
= sqlite3LocateTableItem(pParse
, 0, pFrom
);
6049 if( pTab
==0 ) return WRC_Abort
;
6050 if( pTab
->nTabRef
>=0xffff ){
6051 sqlite3ErrorMsg(pParse
, "too many references to \"%s\": max 65535",
6057 if( !IsVirtual(pTab
) && cannotBeFunction(pParse
, pFrom
) ){
6060 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
6061 if( !IsOrdinaryTable(pTab
) ){
6063 u8 eCodeOrig
= pWalker
->eCode
;
6064 if( sqlite3ViewGetColumnNames(pParse
, pTab
) ) return WRC_Abort
;
6065 assert( pFrom
->pSelect
==0 );
6067 if( (db
->flags
& SQLITE_EnableView
)==0
6068 && pTab
->pSchema
!=db
->aDb
[1].pSchema
6070 sqlite3ErrorMsg(pParse
, "access to view \"%s\" prohibited",
6073 pFrom
->pSelect
= sqlite3SelectDup(db
, pTab
->u
.view
.pSelect
, 0);
6075 #ifndef SQLITE_OMIT_VIRTUALTABLE
6076 else if( ALWAYS(IsVirtual(pTab
))
6077 && pFrom
->fg
.fromDDL
6078 && ALWAYS(pTab
->u
.vtab
.p
!=0)
6079 && pTab
->u
.vtab
.p
->eVtabRisk
> ((db
->flags
& SQLITE_TrustedSchema
)!=0)
6081 sqlite3ErrorMsg(pParse
, "unsafe use of virtual table \"%s\"",
6084 assert( SQLITE_VTABRISK_Normal
==1 && SQLITE_VTABRISK_High
==2 );
6088 pWalker
->eCode
= 1; /* Turn on Select.selId renumbering */
6089 sqlite3WalkSelect(pWalker
, pFrom
->pSelect
);
6090 pWalker
->eCode
= eCodeOrig
;
6096 /* Locate the index named by the INDEXED BY clause, if any. */
6097 if( pFrom
->fg
.isIndexedBy
&& sqlite3IndexedByLookup(pParse
, pFrom
) ){
6102 /* Process NATURAL keywords, and ON and USING clauses of joins.
6104 assert( db
->mallocFailed
==0 || pParse
->nErr
!=0 );
6105 if( pParse
->nErr
|| sqlite3ProcessJoin(pParse
, p
) ){
6109 /* For every "*" that occurs in the column list, insert the names of
6110 ** all columns in all tables. And for every TABLE.* insert the names
6111 ** of all columns in TABLE. The parser inserted a special expression
6112 ** with the TK_ASTERISK operator for each "*" that it found in the column
6113 ** list. The following code just has to locate the TK_ASTERISK
6114 ** expressions and expand each one to the list of all columns in
6117 ** The first loop just checks to see if there are any "*" operators
6118 ** that need expanding.
6120 for(k
=0; k
<pEList
->nExpr
; k
++){
6121 pE
= pEList
->a
[k
].pExpr
;
6122 if( pE
->op
==TK_ASTERISK
) break;
6123 assert( pE
->op
!=TK_DOT
|| pE
->pRight
!=0 );
6124 assert( pE
->op
!=TK_DOT
|| (pE
->pLeft
!=0 && pE
->pLeft
->op
==TK_ID
) );
6125 if( pE
->op
==TK_DOT
&& pE
->pRight
->op
==TK_ASTERISK
) break;
6126 elistFlags
|= pE
->flags
;
6128 if( k
<pEList
->nExpr
){
6130 ** If we get here it means the result set contains one or more "*"
6131 ** operators that need to be expanded. Loop through each expression
6132 ** in the result set and expand them one by one.
6134 struct ExprList_item
*a
= pEList
->a
;
6136 int flags
= pParse
->db
->flags
;
6137 int longNames
= (flags
& SQLITE_FullColNames
)!=0
6138 && (flags
& SQLITE_ShortColNames
)==0;
6140 for(k
=0; k
<pEList
->nExpr
; k
++){
6142 elistFlags
|= pE
->flags
;
6143 pRight
= pE
->pRight
;
6144 assert( pE
->op
!=TK_DOT
|| pRight
!=0 );
6145 if( pE
->op
!=TK_ASTERISK
6146 && (pE
->op
!=TK_DOT
|| pRight
->op
!=TK_ASTERISK
)
6148 /* This particular expression does not need to be expanded.
6150 pNew
= sqlite3ExprListAppend(pParse
, pNew
, a
[k
].pExpr
);
6152 pNew
->a
[pNew
->nExpr
-1].zEName
= a
[k
].zEName
;
6153 pNew
->a
[pNew
->nExpr
-1].fg
.eEName
= a
[k
].fg
.eEName
;
6158 /* This expression is a "*" or a "TABLE.*" and needs to be
6160 int tableSeen
= 0; /* Set to 1 when TABLE matches */
6161 char *zTName
= 0; /* text of name of TABLE */
6163 if( pE
->op
==TK_DOT
){
6164 assert( (selFlags
& SF_NestedFrom
)==0 );
6165 assert( pE
->pLeft
!=0 );
6166 assert( !ExprHasProperty(pE
->pLeft
, EP_IntValue
) );
6167 zTName
= pE
->pLeft
->u
.zToken
;
6168 assert( ExprUseWOfst(pE
->pLeft
) );
6169 iErrOfst
= pE
->pRight
->w
.iOfst
;
6171 assert( ExprUseWOfst(pE
) );
6172 iErrOfst
= pE
->w
.iOfst
;
6174 for(i
=0, pFrom
=pTabList
->a
; i
<pTabList
->nSrc
; i
++, pFrom
++){
6175 int nAdd
; /* Number of cols including rowid */
6176 Table
*pTab
= pFrom
->pTab
; /* Table for this data source */
6177 ExprList
*pNestedFrom
; /* Result-set of a nested FROM clause */
6178 char *zTabName
; /* AS name for this data source */
6179 const char *zSchemaName
= 0; /* Schema name for this data source */
6180 int iDb
; /* Schema index for this data src */
6181 IdList
*pUsing
; /* USING clause for pFrom[1] */
6183 if( (zTabName
= pFrom
->zAlias
)==0 ){
6184 zTabName
= pTab
->zName
;
6186 if( db
->mallocFailed
) break;
6187 assert( (int)pFrom
->fg
.isNestedFrom
== IsNestedFrom(pFrom
->pSelect
) );
6188 if( pFrom
->fg
.isNestedFrom
){
6189 assert( pFrom
->pSelect
!=0 );
6190 pNestedFrom
= pFrom
->pSelect
->pEList
;
6191 assert( pNestedFrom
!=0 );
6192 assert( pNestedFrom
->nExpr
==pTab
->nCol
);
6193 assert( VisibleRowid(pTab
)==0 || ViewCanHaveRowid
);
6195 if( zTName
&& sqlite3StrICmp(zTName
, zTabName
)!=0 ){
6199 iDb
= sqlite3SchemaToIndex(db
, pTab
->pSchema
);
6200 zSchemaName
= iDb
>=0 ? db
->aDb
[iDb
].zDbSName
: "*";
6202 if( i
+1<pTabList
->nSrc
6203 && pFrom
[1].fg
.isUsing
6204 && (selFlags
& SF_NestedFrom
)!=0
6207 pUsing
= pFrom
[1].u3
.pUsing
;
6208 for(ii
=0; ii
<pUsing
->nId
; ii
++){
6209 const char *zUName
= pUsing
->a
[ii
].zName
;
6210 pRight
= sqlite3Expr(db
, TK_ID
, zUName
);
6211 sqlite3ExprSetErrorOffset(pRight
, iErrOfst
);
6212 pNew
= sqlite3ExprListAppend(pParse
, pNew
, pRight
);
6214 struct ExprList_item
*pX
= &pNew
->a
[pNew
->nExpr
-1];
6215 assert( pX
->zEName
==0 );
6216 pX
->zEName
= sqlite3MPrintf(db
,"..%s", zUName
);
6217 pX
->fg
.eEName
= ENAME_TAB
;
6218 pX
->fg
.bUsingTerm
= 1;
6226 if( VisibleRowid(pTab
) && (selFlags
& SF_NestedFrom
)!=0 ) nAdd
++;
6227 for(j
=0; j
<nAdd
; j
++){
6229 struct ExprList_item
*pX
; /* Newly added ExprList term */
6231 if( j
==pTab
->nCol
){
6232 zName
= sqlite3RowidAlias(pTab
);
6233 if( zName
==0 ) continue;
6235 zName
= pTab
->aCol
[j
].zCnName
;
6237 /* If pTab is actually an SF_NestedFrom sub-select, do not
6238 ** expand any ENAME_ROWID columns. */
6239 if( pNestedFrom
&& pNestedFrom
->a
[j
].fg
.eEName
==ENAME_ROWID
){
6245 && sqlite3MatchEName(&pNestedFrom
->a
[j
], 0, zTName
, 0, 0)==0
6250 /* If a column is marked as 'hidden', omit it from the expanded
6251 ** result-set list unless the SELECT has the SF_IncludeHidden
6254 if( (p
->selFlags
& SF_IncludeHidden
)==0
6255 && IsHiddenColumn(&pTab
->aCol
[j
])
6259 if( (pTab
->aCol
[j
].colFlags
& COLFLAG_NOEXPAND
)!=0
6261 && (selFlags
& (SF_NestedFrom
))==0
6269 if( i
>0 && zTName
==0 && (selFlags
& SF_NestedFrom
)==0 ){
6270 if( pFrom
->fg
.isUsing
6271 && sqlite3IdListIndex(pFrom
->u3
.pUsing
, zName
)>=0
6273 /* In a join with a USING clause, omit columns in the
6274 ** using clause from the table on the right. */
6278 pRight
= sqlite3Expr(db
, TK_ID
, zName
);
6279 if( (pTabList
->nSrc
>1
6280 && ( (pFrom
->fg
.jointype
& JT_LTORJ
)==0
6281 || (selFlags
& SF_NestedFrom
)!=0
6282 || !inAnyUsingClause(zName
,pFrom
,pTabList
->nSrc
-i
-1)
6288 pLeft
= sqlite3Expr(db
, TK_ID
, zTabName
);
6289 pExpr
= sqlite3PExpr(pParse
, TK_DOT
, pLeft
, pRight
);
6290 if( IN_RENAME_OBJECT
&& pE
->pLeft
){
6291 sqlite3RenameTokenRemap(pParse
, pLeft
, pE
->pLeft
);
6294 pLeft
= sqlite3Expr(db
, TK_ID
, zSchemaName
);
6295 pExpr
= sqlite3PExpr(pParse
, TK_DOT
, pLeft
, pExpr
);
6300 sqlite3ExprSetErrorOffset(pExpr
, iErrOfst
);
6301 pNew
= sqlite3ExprListAppend(pParse
, pNew
, pExpr
);
6305 pX
= &pNew
->a
[pNew
->nExpr
-1];
6306 assert( pX
->zEName
==0 );
6307 if( (selFlags
& SF_NestedFrom
)!=0 && !IN_RENAME_OBJECT
){
6308 if( pNestedFrom
&& (!ViewCanHaveRowid
|| j
<pNestedFrom
->nExpr
) ){
6309 assert( j
<pNestedFrom
->nExpr
);
6310 pX
->zEName
= sqlite3DbStrDup(db
, pNestedFrom
->a
[j
].zEName
);
6311 testcase( pX
->zEName
==0 );
6313 pX
->zEName
= sqlite3MPrintf(db
, "%s.%s.%s",
6314 zSchemaName
, zTabName
, zName
);
6315 testcase( pX
->zEName
==0 );
6317 pX
->fg
.eEName
= (j
==pTab
->nCol
? ENAME_ROWID
: ENAME_TAB
);
6318 if( (pFrom
->fg
.isUsing
6319 && sqlite3IdListIndex(pFrom
->u3
.pUsing
, zName
)>=0)
6320 || (pUsing
&& sqlite3IdListIndex(pUsing
, zName
)>=0)
6321 || (j
<pTab
->nCol
&& (pTab
->aCol
[j
].colFlags
& COLFLAG_NOEXPAND
))
6323 pX
->fg
.bNoExpand
= 1;
6325 }else if( longNames
){
6326 pX
->zEName
= sqlite3MPrintf(db
, "%s.%s", zTabName
, zName
);
6327 pX
->fg
.eEName
= ENAME_NAME
;
6329 pX
->zEName
= sqlite3DbStrDup(db
, zName
);
6330 pX
->fg
.eEName
= ENAME_NAME
;
6336 sqlite3ErrorMsg(pParse
, "no such table: %s", zTName
);
6338 sqlite3ErrorMsg(pParse
, "no tables specified");
6343 sqlite3ExprListDelete(db
, pEList
);
6347 if( p
->pEList
->nExpr
>db
->aLimit
[SQLITE_LIMIT_COLUMN
] ){
6348 sqlite3ErrorMsg(pParse
, "too many columns in result set");
6351 if( (elistFlags
& (EP_HasFunc
|EP_Subquery
))!=0 ){
6352 p
->selFlags
|= SF_ComplexResult
;
6355 #if TREETRACE_ENABLED
6356 if( sqlite3TreeTrace
& 0x8 ){
6357 TREETRACE(0x8,pParse
,p
,("After result-set wildcard expansion:\n"));
6358 sqlite3TreeViewSelect(0, p
, 0);
6361 return WRC_Continue
;
6366 ** Always assert. This xSelectCallback2 implementation proves that the
6367 ** xSelectCallback2 is never invoked.
6369 void sqlite3SelectWalkAssert2(Walker
*NotUsed
, Select
*NotUsed2
){
6370 UNUSED_PARAMETER2(NotUsed
, NotUsed2
);
6375 ** This routine "expands" a SELECT statement and all of its subqueries.
6376 ** For additional information on what it means to "expand" a SELECT
6377 ** statement, see the comment on the selectExpand worker callback above.
6379 ** Expanding a SELECT statement is the first step in processing a
6380 ** SELECT statement. The SELECT statement must be expanded before
6381 ** name resolution is performed.
6383 ** If anything goes wrong, an error message is written into pParse.
6384 ** The calling function can detect the problem by looking at pParse->nErr
6385 ** and/or pParse->db->mallocFailed.
6387 static void sqlite3SelectExpand(Parse
*pParse
, Select
*pSelect
){
6389 w
.xExprCallback
= sqlite3ExprWalkNoop
;
6391 if( OK_IF_ALWAYS_TRUE(pParse
->hasCompound
) ){
6392 w
.xSelectCallback
= convertCompoundSelectToSubquery
;
6393 w
.xSelectCallback2
= 0;
6394 sqlite3WalkSelect(&w
, pSelect
);
6396 w
.xSelectCallback
= selectExpander
;
6397 w
.xSelectCallback2
= sqlite3SelectPopWith
;
6399 sqlite3WalkSelect(&w
, pSelect
);
6403 #ifndef SQLITE_OMIT_SUBQUERY
6405 ** This is a Walker.xSelectCallback callback for the sqlite3SelectTypeInfo()
6408 ** For each FROM-clause subquery, add Column.zType, Column.zColl, and
6409 ** Column.affinity information to the Table structure that represents
6410 ** the result set of that subquery.
6412 ** The Table structure that represents the result set was constructed
6413 ** by selectExpander() but the type and collation and affinity information
6414 ** was omitted at that point because identifiers had not yet been resolved.
6415 ** This routine is called after identifier resolution.
6417 static void selectAddSubqueryTypeInfo(Walker
*pWalker
, Select
*p
){
6423 if( p
->selFlags
& SF_HasTypeInfo
) return;
6424 p
->selFlags
|= SF_HasTypeInfo
;
6425 pParse
= pWalker
->pParse
;
6426 assert( (p
->selFlags
& SF_Resolved
) );
6428 for(i
=0, pFrom
=pTabList
->a
; i
<pTabList
->nSrc
; i
++, pFrom
++){
6429 Table
*pTab
= pFrom
->pTab
;
6431 if( (pTab
->tabFlags
& TF_Ephemeral
)!=0 ){
6432 /* A sub-query in the FROM clause of a SELECT */
6433 Select
*pSel
= pFrom
->pSelect
;
6435 sqlite3SubqueryColumnTypes(pParse
, pTab
, pSel
, SQLITE_AFF_NONE
);
6444 ** This routine adds datatype and collating sequence information to
6445 ** the Table structures of all FROM-clause subqueries in a
6446 ** SELECT statement.
6448 ** Use this routine after name resolution.
6450 static void sqlite3SelectAddTypeInfo(Parse
*pParse
, Select
*pSelect
){
6451 #ifndef SQLITE_OMIT_SUBQUERY
6453 w
.xSelectCallback
= sqlite3SelectWalkNoop
;
6454 w
.xSelectCallback2
= selectAddSubqueryTypeInfo
;
6455 w
.xExprCallback
= sqlite3ExprWalkNoop
;
6457 sqlite3WalkSelect(&w
, pSelect
);
6463 ** This routine sets up a SELECT statement for processing. The
6464 ** following is accomplished:
6466 ** * VDBE Cursor numbers are assigned to all FROM-clause terms.
6467 ** * Ephemeral Table objects are created for all FROM-clause subqueries.
6468 ** * ON and USING clauses are shifted into WHERE statements
6469 ** * Wildcards "*" and "TABLE.*" in result sets are expanded.
6470 ** * Identifiers in expression are matched to tables.
6472 ** This routine acts recursively on all subqueries within the SELECT.
6474 void sqlite3SelectPrep(
6475 Parse
*pParse
, /* The parser context */
6476 Select
*p
, /* The SELECT statement being coded. */
6477 NameContext
*pOuterNC
/* Name context for container */
6479 assert( p
!=0 || pParse
->db
->mallocFailed
);
6480 assert( pParse
->db
->pParse
==pParse
);
6481 if( pParse
->db
->mallocFailed
) return;
6482 if( p
->selFlags
& SF_HasTypeInfo
) return;
6483 sqlite3SelectExpand(pParse
, p
);
6484 if( pParse
->nErr
) return;
6485 sqlite3ResolveSelectNames(pParse
, p
, pOuterNC
);
6486 if( pParse
->nErr
) return;
6487 sqlite3SelectAddTypeInfo(pParse
, p
);
6490 #if TREETRACE_ENABLED
6492 ** Display all information about an AggInfo object
6494 static void printAggInfo(AggInfo
*pAggInfo
){
6496 sqlite3DebugPrintf("AggInfo %d/%p:\n",
6497 pAggInfo
->selId
, pAggInfo
);
6498 for(ii
=0; ii
<pAggInfo
->nColumn
; ii
++){
6499 struct AggInfo_col
*pCol
= &pAggInfo
->aCol
[ii
];
6501 "agg-column[%d] pTab=%s iTable=%d iColumn=%d iMem=%d"
6502 " iSorterColumn=%d %s\n",
6503 ii
, pCol
->pTab
? pCol
->pTab
->zName
: "NULL",
6504 pCol
->iTable
, pCol
->iColumn
, pAggInfo
->iFirstReg
+ii
,
6505 pCol
->iSorterColumn
,
6506 ii
>=pAggInfo
->nAccumulator
? "" : " Accumulator");
6507 sqlite3TreeViewExpr(0, pAggInfo
->aCol
[ii
].pCExpr
, 0);
6509 for(ii
=0; ii
<pAggInfo
->nFunc
; ii
++){
6510 sqlite3DebugPrintf("agg-func[%d]: iMem=%d\n",
6511 ii
, pAggInfo
->iFirstReg
+pAggInfo
->nColumn
+ii
);
6512 sqlite3TreeViewExpr(0, pAggInfo
->aFunc
[ii
].pFExpr
, 0);
6515 #endif /* TREETRACE_ENABLED */
6518 ** Analyze the arguments to aggregate functions. Create new pAggInfo->aCol[]
6519 ** entries for columns that are arguments to aggregate functions but which
6520 ** are not otherwise used.
6522 ** The aCol[] entries in AggInfo prior to nAccumulator are columns that
6523 ** are referenced outside of aggregate functions. These might be columns
6524 ** that are part of the GROUP by clause, for example. Other database engines
6525 ** would throw an error if there is a column reference that is not in the
6526 ** GROUP BY clause and that is not part of an aggregate function argument.
6527 ** But SQLite allows this.
6529 ** The aCol[] entries beginning with the aCol[nAccumulator] and following
6530 ** are column references that are used exclusively as arguments to
6531 ** aggregate functions. This routine is responsible for computing
6532 ** (or recomputing) those aCol[] entries.
6534 static void analyzeAggFuncArgs(
6539 assert( pAggInfo
!=0 );
6540 assert( pAggInfo
->iFirstReg
==0 );
6541 pNC
->ncFlags
|= NC_InAggFunc
;
6542 for(i
=0; i
<pAggInfo
->nFunc
; i
++){
6543 Expr
*pExpr
= pAggInfo
->aFunc
[i
].pFExpr
;
6544 assert( pExpr
->op
==TK_FUNCTION
|| pExpr
->op
==TK_AGG_FUNCTION
);
6545 assert( ExprUseXList(pExpr
) );
6546 sqlite3ExprAnalyzeAggList(pNC
, pExpr
->x
.pList
);
6548 assert( pExpr
->pLeft
->op
==TK_ORDER
);
6549 assert( ExprUseXList(pExpr
->pLeft
) );
6550 sqlite3ExprAnalyzeAggList(pNC
, pExpr
->pLeft
->x
.pList
);
6552 #ifndef SQLITE_OMIT_WINDOWFUNC
6553 assert( !IsWindowFunc(pExpr
) );
6554 if( ExprHasProperty(pExpr
, EP_WinFunc
) ){
6555 sqlite3ExprAnalyzeAggregates(pNC
, pExpr
->y
.pWin
->pFilter
);
6559 pNC
->ncFlags
&= ~NC_InAggFunc
;
6563 ** An index on expressions is being used in the inner loop of an
6564 ** aggregate query with a GROUP BY clause. This routine attempts
6565 ** to adjust the AggInfo object to take advantage of index and to
6566 ** perhaps use the index as a covering index.
6569 static void optimizeAggregateUseOfIndexedExpr(
6570 Parse
*pParse
, /* Parsing context */
6571 Select
*pSelect
, /* The SELECT statement being processed */
6572 AggInfo
*pAggInfo
, /* The aggregate info */
6573 NameContext
*pNC
/* Name context used to resolve agg-func args */
6575 assert( pAggInfo
->iFirstReg
==0 );
6576 assert( pSelect
!=0 );
6577 assert( pSelect
->pGroupBy
!=0 );
6578 pAggInfo
->nColumn
= pAggInfo
->nAccumulator
;
6579 if( ALWAYS(pAggInfo
->nSortingColumn
>0) ){
6580 int mx
= pSelect
->pGroupBy
->nExpr
- 1;
6582 for(j
=0; j
<pAggInfo
->nColumn
; j
++){
6583 k
= pAggInfo
->aCol
[j
].iSorterColumn
;
6586 pAggInfo
->nSortingColumn
= mx
+1;
6588 analyzeAggFuncArgs(pAggInfo
, pNC
);
6589 #if TREETRACE_ENABLED
6590 if( sqlite3TreeTrace
& 0x20 ){
6592 TREETRACE(0x20, pParse
, pSelect
,
6593 ("AggInfo (possibly) adjusted for Indexed Exprs\n"));
6594 sqlite3TreeViewSelect(0, pSelect
, 0);
6595 for(pIEpr
=pParse
->pIdxEpr
; pIEpr
; pIEpr
=pIEpr
->pIENext
){
6596 printf("data-cursor=%d index={%d,%d}\n",
6597 pIEpr
->iDataCur
, pIEpr
->iIdxCur
, pIEpr
->iIdxCol
);
6598 sqlite3TreeViewExpr(0, pIEpr
->pExpr
, 0);
6600 printAggInfo(pAggInfo
);
6603 UNUSED_PARAMETER(pSelect
);
6604 UNUSED_PARAMETER(pParse
);
6609 ** Walker callback for aggregateConvertIndexedExprRefToColumn().
6611 static int aggregateIdxEprRefToColCallback(Walker
*pWalker
, Expr
*pExpr
){
6613 struct AggInfo_col
*pCol
;
6614 UNUSED_PARAMETER(pWalker
);
6615 if( pExpr
->pAggInfo
==0 ) return WRC_Continue
;
6616 if( pExpr
->op
==TK_AGG_COLUMN
) return WRC_Continue
;
6617 if( pExpr
->op
==TK_AGG_FUNCTION
) return WRC_Continue
;
6618 if( pExpr
->op
==TK_IF_NULL_ROW
) return WRC_Continue
;
6619 pAggInfo
= pExpr
->pAggInfo
;
6620 if( NEVER(pExpr
->iAgg
>=pAggInfo
->nColumn
) ) return WRC_Continue
;
6621 assert( pExpr
->iAgg
>=0 );
6622 pCol
= &pAggInfo
->aCol
[pExpr
->iAgg
];
6623 pExpr
->op
= TK_AGG_COLUMN
;
6624 pExpr
->iTable
= pCol
->iTable
;
6625 pExpr
->iColumn
= pCol
->iColumn
;
6626 ExprClearProperty(pExpr
, EP_Skip
|EP_Collate
|EP_Unlikely
);
6631 ** Convert every pAggInfo->aFunc[].pExpr such that any node within
6632 ** those expressions that has pAppInfo set is changed into a TK_AGG_COLUMN
6635 static void aggregateConvertIndexedExprRefToColumn(AggInfo
*pAggInfo
){
6638 memset(&w
, 0, sizeof(w
));
6639 w
.xExprCallback
= aggregateIdxEprRefToColCallback
;
6640 for(i
=0; i
<pAggInfo
->nFunc
; i
++){
6641 sqlite3WalkExpr(&w
, pAggInfo
->aFunc
[i
].pFExpr
);
6647 ** Allocate a block of registers so that there is one register for each
6648 ** pAggInfo->aCol[] and pAggInfo->aFunc[] entry in pAggInfo. The first
6649 ** register in this block is stored in pAggInfo->iFirstReg.
6651 ** This routine may only be called once for each AggInfo object. Prior
6652 ** to calling this routine:
6654 ** * The aCol[] and aFunc[] arrays may be modified
6655 ** * The AggInfoColumnReg() and AggInfoFuncReg() macros may not be used
6657 ** After calling this routine:
6659 ** * The aCol[] and aFunc[] arrays are fixed
6660 ** * The AggInfoColumnReg() and AggInfoFuncReg() macros may be used
6663 static void assignAggregateRegisters(Parse
*pParse
, AggInfo
*pAggInfo
){
6664 assert( pAggInfo
!=0 );
6665 assert( pAggInfo
->iFirstReg
==0 );
6666 pAggInfo
->iFirstReg
= pParse
->nMem
+ 1;
6667 pParse
->nMem
+= pAggInfo
->nColumn
+ pAggInfo
->nFunc
;
6671 ** Reset the aggregate accumulator.
6673 ** The aggregate accumulator is a set of memory cells that hold
6674 ** intermediate results while calculating an aggregate. This
6675 ** routine generates code that stores NULLs in all of those memory
6678 static void resetAccumulator(Parse
*pParse
, AggInfo
*pAggInfo
){
6679 Vdbe
*v
= pParse
->pVdbe
;
6681 struct AggInfo_func
*pFunc
;
6682 int nReg
= pAggInfo
->nFunc
+ pAggInfo
->nColumn
;
6683 assert( pAggInfo
->iFirstReg
>0 );
6684 assert( pParse
->db
->pParse
==pParse
);
6685 assert( pParse
->db
->mallocFailed
==0 || pParse
->nErr
!=0 );
6686 if( nReg
==0 ) return;
6687 if( pParse
->nErr
) return;
6688 sqlite3VdbeAddOp3(v
, OP_Null
, 0, pAggInfo
->iFirstReg
,
6689 pAggInfo
->iFirstReg
+nReg
-1);
6690 for(pFunc
=pAggInfo
->aFunc
, i
=0; i
<pAggInfo
->nFunc
; i
++, pFunc
++){
6691 if( pFunc
->iDistinct
>=0 ){
6692 Expr
*pE
= pFunc
->pFExpr
;
6693 assert( ExprUseXList(pE
) );
6694 if( pE
->x
.pList
==0 || pE
->x
.pList
->nExpr
!=1 ){
6695 sqlite3ErrorMsg(pParse
, "DISTINCT aggregates must have exactly one "
6697 pFunc
->iDistinct
= -1;
6699 KeyInfo
*pKeyInfo
= sqlite3KeyInfoFromExprList(pParse
, pE
->x
.pList
,0,0);
6700 pFunc
->iDistAddr
= sqlite3VdbeAddOp4(v
, OP_OpenEphemeral
,
6701 pFunc
->iDistinct
, 0, 0, (char*)pKeyInfo
, P4_KEYINFO
);
6702 ExplainQueryPlan((pParse
, 0, "USE TEMP B-TREE FOR %s(DISTINCT)",
6703 pFunc
->pFunc
->zName
));
6706 if( pFunc
->iOBTab
>=0 ){
6710 assert( pFunc
->pFExpr
->pLeft
!=0 );
6711 assert( pFunc
->pFExpr
->pLeft
->op
==TK_ORDER
);
6712 assert( ExprUseXList(pFunc
->pFExpr
->pLeft
) );
6713 assert( pFunc
->pFunc
!=0 );
6714 pOBList
= pFunc
->pFExpr
->pLeft
->x
.pList
;
6715 if( !pFunc
->bOBUnique
){
6716 nExtra
++; /* One extra column for the OP_Sequence */
6718 if( pFunc
->bOBPayload
){
6719 /* extra columns for the function arguments */
6720 assert( ExprUseXList(pFunc
->pFExpr
) );
6721 nExtra
+= pFunc
->pFExpr
->x
.pList
->nExpr
;
6723 if( pFunc
->bUseSubtype
){
6724 nExtra
+= pFunc
->pFExpr
->x
.pList
->nExpr
;
6726 pKeyInfo
= sqlite3KeyInfoFromExprList(pParse
, pOBList
, 0, nExtra
);
6727 if( !pFunc
->bOBUnique
&& pParse
->nErr
==0 ){
6728 pKeyInfo
->nKeyField
++;
6730 sqlite3VdbeAddOp4(v
, OP_OpenEphemeral
,
6731 pFunc
->iOBTab
, pOBList
->nExpr
+nExtra
, 0,
6732 (char*)pKeyInfo
, P4_KEYINFO
);
6733 ExplainQueryPlan((pParse
, 0, "USE TEMP B-TREE FOR %s(ORDER BY)",
6734 pFunc
->pFunc
->zName
));
6740 ** Invoke the OP_AggFinalize opcode for every aggregate function
6741 ** in the AggInfo structure.
6743 static void finalizeAggFunctions(Parse
*pParse
, AggInfo
*pAggInfo
){
6744 Vdbe
*v
= pParse
->pVdbe
;
6746 struct AggInfo_func
*pF
;
6747 for(i
=0, pF
=pAggInfo
->aFunc
; i
<pAggInfo
->nFunc
; i
++, pF
++){
6749 assert( ExprUseXList(pF
->pFExpr
) );
6750 pList
= pF
->pFExpr
->x
.pList
;
6751 if( pF
->iOBTab
>=0 ){
6752 /* For an ORDER BY aggregate, calls to OP_AggStep were deferred. Inputs
6753 ** were stored in emphermal table pF->iOBTab. Here, we extract those
6754 ** inputs (in ORDER BY order) and make all calls to OP_AggStep
6755 ** before doing the OP_AggFinal call. */
6756 int iTop
; /* Start of loop for extracting columns */
6757 int nArg
; /* Number of columns to extract */
6758 int nKey
; /* Key columns to be skipped */
6759 int regAgg
; /* Extract into this array */
6760 int j
; /* Loop counter */
6762 assert( pF
->pFunc
!=0 );
6763 nArg
= pList
->nExpr
;
6764 regAgg
= sqlite3GetTempRange(pParse
, nArg
);
6766 if( pF
->bOBPayload
==0 ){
6769 assert( pF
->pFExpr
->pLeft
!=0 );
6770 assert( ExprUseXList(pF
->pFExpr
->pLeft
) );
6771 assert( pF
->pFExpr
->pLeft
->x
.pList
!=0 );
6772 nKey
= pF
->pFExpr
->pLeft
->x
.pList
->nExpr
;
6773 if( ALWAYS(!pF
->bOBUnique
) ) nKey
++;
6775 iTop
= sqlite3VdbeAddOp1(v
, OP_Rewind
, pF
->iOBTab
); VdbeCoverage(v
);
6776 for(j
=nArg
-1; j
>=0; j
--){
6777 sqlite3VdbeAddOp3(v
, OP_Column
, pF
->iOBTab
, nKey
+j
, regAgg
+j
);
6779 if( pF
->bUseSubtype
){
6780 int regSubtype
= sqlite3GetTempReg(pParse
);
6781 int iBaseCol
= nKey
+ nArg
+ (pF
->bOBPayload
==0 && pF
->bOBUnique
==0);
6782 for(j
=nArg
-1; j
>=0; j
--){
6783 sqlite3VdbeAddOp3(v
, OP_Column
, pF
->iOBTab
, iBaseCol
+j
, regSubtype
);
6784 sqlite3VdbeAddOp2(v
, OP_SetSubtype
, regSubtype
, regAgg
+j
);
6786 sqlite3ReleaseTempReg(pParse
, regSubtype
);
6788 sqlite3VdbeAddOp3(v
, OP_AggStep
, 0, regAgg
, AggInfoFuncReg(pAggInfo
,i
));
6789 sqlite3VdbeAppendP4(v
, pF
->pFunc
, P4_FUNCDEF
);
6790 sqlite3VdbeChangeP5(v
, (u8
)nArg
);
6791 sqlite3VdbeAddOp2(v
, OP_Next
, pF
->iOBTab
, iTop
+1); VdbeCoverage(v
);
6792 sqlite3VdbeJumpHere(v
, iTop
);
6793 sqlite3ReleaseTempRange(pParse
, regAgg
, nArg
);
6795 sqlite3VdbeAddOp2(v
, OP_AggFinal
, AggInfoFuncReg(pAggInfo
,i
),
6796 pList
? pList
->nExpr
: 0);
6797 sqlite3VdbeAppendP4(v
, pF
->pFunc
, P4_FUNCDEF
);
6802 ** Generate code that will update the accumulator memory cells for an
6803 ** aggregate based on the current cursor position.
6805 ** If regAcc is non-zero and there are no min() or max() aggregates
6806 ** in pAggInfo, then only populate the pAggInfo->nAccumulator accumulator
6807 ** registers if register regAcc contains 0. The caller will take care
6808 ** of setting and clearing regAcc.
6810 ** For an ORDER BY aggregate, the actual accumulator memory cell update
6811 ** is deferred until after all input rows have been received, so that they
6812 ** can be run in the requested order. In that case, instead of invoking
6813 ** OP_AggStep to update the accumulator, just add the arguments that would
6814 ** have been passed into OP_AggStep into the sorting ephemeral table
6815 ** (along with the appropriate sort key).
6817 static void updateAccumulator(
6823 Vdbe
*v
= pParse
->pVdbe
;
6826 int addrHitTest
= 0;
6827 struct AggInfo_func
*pF
;
6828 struct AggInfo_col
*pC
;
6830 assert( pAggInfo
->iFirstReg
>0 );
6831 if( pParse
->nErr
) return;
6832 pAggInfo
->directMode
= 1;
6833 for(i
=0, pF
=pAggInfo
->aFunc
; i
<pAggInfo
->nFunc
; i
++, pF
++){
6838 int regDistinct
= 0;
6840 assert( ExprUseXList(pF
->pFExpr
) );
6841 assert( !IsWindowFunc(pF
->pFExpr
) );
6842 assert( pF
->pFunc
!=0 );
6843 pList
= pF
->pFExpr
->x
.pList
;
6844 if( ExprHasProperty(pF
->pFExpr
, EP_WinFunc
) ){
6845 Expr
*pFilter
= pF
->pFExpr
->y
.pWin
->pFilter
;
6846 if( pAggInfo
->nAccumulator
6847 && (pF
->pFunc
->funcFlags
& SQLITE_FUNC_NEEDCOLL
)
6850 /* If regAcc==0, there there exists some min() or max() function
6851 ** without a FILTER clause that will ensure the magnet registers
6852 ** are populated. */
6853 if( regHit
==0 ) regHit
= ++pParse
->nMem
;
6854 /* If this is the first row of the group (regAcc contains 0), clear the
6855 ** "magnet" register regHit so that the accumulator registers
6856 ** are populated if the FILTER clause jumps over the the
6857 ** invocation of min() or max() altogether. Or, if this is not
6858 ** the first row (regAcc contains 1), set the magnet register so that
6859 ** the accumulators are not populated unless the min()/max() is invoked
6860 ** and indicates that they should be. */
6861 sqlite3VdbeAddOp2(v
, OP_Copy
, regAcc
, regHit
);
6863 addrNext
= sqlite3VdbeMakeLabel(pParse
);
6864 sqlite3ExprIfFalse(pParse
, pFilter
, addrNext
, SQLITE_JUMPIFNULL
);
6866 if( pF
->iOBTab
>=0 ){
6867 /* Instead of invoking AggStep, we must push the arguments that would
6868 ** have been passed to AggStep onto the sorting table. */
6869 int jj
; /* Registered used so far in building the record */
6870 ExprList
*pOBList
; /* The ORDER BY clause */
6872 nArg
= pList
->nExpr
;
6874 assert( pF
->pFExpr
->pLeft
!=0 );
6875 assert( pF
->pFExpr
->pLeft
->op
==TK_ORDER
);
6876 assert( ExprUseXList(pF
->pFExpr
->pLeft
) );
6877 pOBList
= pF
->pFExpr
->pLeft
->x
.pList
;
6878 assert( pOBList
!=0 );
6879 assert( pOBList
->nExpr
>0 );
6880 regAggSz
= pOBList
->nExpr
;
6881 if( !pF
->bOBUnique
){
6882 regAggSz
++; /* One register for OP_Sequence */
6884 if( pF
->bOBPayload
){
6887 if( pF
->bUseSubtype
){
6890 regAggSz
++; /* One extra register to hold result of MakeRecord */
6891 regAgg
= sqlite3GetTempRange(pParse
, regAggSz
);
6892 regDistinct
= regAgg
;
6893 sqlite3ExprCodeExprList(pParse
, pOBList
, regAgg
, 0, SQLITE_ECEL_DUP
);
6894 jj
= pOBList
->nExpr
;
6895 if( !pF
->bOBUnique
){
6896 sqlite3VdbeAddOp2(v
, OP_Sequence
, pF
->iOBTab
, regAgg
+jj
);
6899 if( pF
->bOBPayload
){
6900 regDistinct
= regAgg
+jj
;
6901 sqlite3ExprCodeExprList(pParse
, pList
, regDistinct
, 0, SQLITE_ECEL_DUP
);
6904 if( pF
->bUseSubtype
){
6906 int regBase
= pF
->bOBPayload
? regDistinct
: regAgg
;
6907 for(kk
=0; kk
<nArg
; kk
++, jj
++){
6908 sqlite3VdbeAddOp2(v
, OP_GetSubtype
, regBase
+kk
, regAgg
+jj
);
6912 nArg
= pList
->nExpr
;
6913 regAgg
= sqlite3GetTempRange(pParse
, nArg
);
6914 regDistinct
= regAgg
;
6915 sqlite3ExprCodeExprList(pParse
, pList
, regAgg
, 0, SQLITE_ECEL_DUP
);
6920 if( pF
->iDistinct
>=0 && pList
){
6922 addrNext
= sqlite3VdbeMakeLabel(pParse
);
6924 pF
->iDistinct
= codeDistinct(pParse
, eDistinctType
,
6925 pF
->iDistinct
, addrNext
, pList
, regDistinct
);
6927 if( pF
->iOBTab
>=0 ){
6928 /* Insert a new record into the ORDER BY table */
6929 sqlite3VdbeAddOp3(v
, OP_MakeRecord
, regAgg
, regAggSz
-1,
6931 sqlite3VdbeAddOp4Int(v
, OP_IdxInsert
, pF
->iOBTab
, regAgg
+regAggSz
-1,
6932 regAgg
, regAggSz
-1);
6933 sqlite3ReleaseTempRange(pParse
, regAgg
, regAggSz
);
6935 /* Invoke the AggStep function */
6936 if( pF
->pFunc
->funcFlags
& SQLITE_FUNC_NEEDCOLL
){
6938 struct ExprList_item
*pItem
;
6940 assert( pList
!=0 ); /* pList!=0 if pF->pFunc has NEEDCOLL */
6941 for(j
=0, pItem
=pList
->a
; !pColl
&& j
<nArg
; j
++, pItem
++){
6942 pColl
= sqlite3ExprCollSeq(pParse
, pItem
->pExpr
);
6945 pColl
= pParse
->db
->pDfltColl
;
6947 if( regHit
==0 && pAggInfo
->nAccumulator
) regHit
= ++pParse
->nMem
;
6948 sqlite3VdbeAddOp4(v
, OP_CollSeq
, regHit
, 0, 0,
6949 (char *)pColl
, P4_COLLSEQ
);
6951 sqlite3VdbeAddOp3(v
, OP_AggStep
, 0, regAgg
, AggInfoFuncReg(pAggInfo
,i
));
6952 sqlite3VdbeAppendP4(v
, pF
->pFunc
, P4_FUNCDEF
);
6953 sqlite3VdbeChangeP5(v
, (u8
)nArg
);
6954 sqlite3ReleaseTempRange(pParse
, regAgg
, nArg
);
6957 sqlite3VdbeResolveLabel(v
, addrNext
);
6960 if( regHit
==0 && pAggInfo
->nAccumulator
){
6964 addrHitTest
= sqlite3VdbeAddOp1(v
, OP_If
, regHit
); VdbeCoverage(v
);
6966 for(i
=0, pC
=pAggInfo
->aCol
; i
<pAggInfo
->nAccumulator
; i
++, pC
++){
6967 sqlite3ExprCode(pParse
, pC
->pCExpr
, AggInfoColumnReg(pAggInfo
,i
));
6970 pAggInfo
->directMode
= 0;
6972 sqlite3VdbeJumpHereOrPopInst(v
, addrHitTest
);
6977 ** Add a single OP_Explain instruction to the VDBE to explain a simple
6978 ** count(*) query ("SELECT count(*) FROM pTab").
6980 #ifndef SQLITE_OMIT_EXPLAIN
6981 static void explainSimpleCount(
6982 Parse
*pParse
, /* Parse context */
6983 Table
*pTab
, /* Table being queried */
6984 Index
*pIdx
/* Index used to optimize scan, or NULL */
6986 if( pParse
->explain
==2 ){
6987 int bCover
= (pIdx
!=0 && (HasRowid(pTab
) || !IsPrimaryKeyIndex(pIdx
)));
6988 sqlite3VdbeExplain(pParse
, 0, "SCAN %s%s%s",
6990 bCover
? " USING COVERING INDEX " : "",
6991 bCover
? pIdx
->zName
: ""
6996 # define explainSimpleCount(a,b,c)
7000 ** sqlite3WalkExpr() callback used by havingToWhere().
7002 ** If the node passed to the callback is a TK_AND node, return
7003 ** WRC_Continue to tell sqlite3WalkExpr() to iterate through child nodes.
7005 ** Otherwise, return WRC_Prune. In this case, also check if the
7006 ** sub-expression matches the criteria for being moved to the WHERE
7007 ** clause. If so, add it to the WHERE clause and replace the sub-expression
7008 ** within the HAVING expression with a constant "1".
7010 static int havingToWhereExprCb(Walker
*pWalker
, Expr
*pExpr
){
7011 if( pExpr
->op
!=TK_AND
){
7012 Select
*pS
= pWalker
->u
.pSelect
;
7013 /* This routine is called before the HAVING clause of the current
7014 ** SELECT is analyzed for aggregates. So if pExpr->pAggInfo is set
7015 ** here, it indicates that the expression is a correlated reference to a
7016 ** column from an outer aggregate query, or an aggregate function that
7017 ** belongs to an outer query. Do not move the expression to the WHERE
7018 ** clause in this obscure case, as doing so may corrupt the outer Select
7019 ** statements AggInfo structure. */
7020 if( sqlite3ExprIsConstantOrGroupBy(pWalker
->pParse
, pExpr
, pS
->pGroupBy
)
7021 && ExprAlwaysFalse(pExpr
)==0
7022 && pExpr
->pAggInfo
==0
7024 sqlite3
*db
= pWalker
->pParse
->db
;
7025 Expr
*pNew
= sqlite3Expr(db
, TK_INTEGER
, "1");
7027 Expr
*pWhere
= pS
->pWhere
;
7028 SWAP(Expr
, *pNew
, *pExpr
);
7029 pNew
= sqlite3ExprAnd(pWalker
->pParse
, pWhere
, pNew
);
7036 return WRC_Continue
;
7040 ** Transfer eligible terms from the HAVING clause of a query, which is
7041 ** processed after grouping, to the WHERE clause, which is processed before
7042 ** grouping. For example, the query:
7044 ** SELECT * FROM <tables> WHERE a=? GROUP BY b HAVING b=? AND c=?
7046 ** can be rewritten as:
7048 ** SELECT * FROM <tables> WHERE a=? AND b=? GROUP BY b HAVING c=?
7050 ** A term of the HAVING expression is eligible for transfer if it consists
7051 ** entirely of constants and expressions that are also GROUP BY terms that
7052 ** use the "BINARY" collation sequence.
7054 static void havingToWhere(Parse
*pParse
, Select
*p
){
7056 memset(&sWalker
, 0, sizeof(sWalker
));
7057 sWalker
.pParse
= pParse
;
7058 sWalker
.xExprCallback
= havingToWhereExprCb
;
7059 sWalker
.u
.pSelect
= p
;
7060 sqlite3WalkExpr(&sWalker
, p
->pHaving
);
7061 #if TREETRACE_ENABLED
7062 if( sWalker
.eCode
&& (sqlite3TreeTrace
& 0x100)!=0 ){
7063 TREETRACE(0x100,pParse
,p
,("Move HAVING terms into WHERE:\n"));
7064 sqlite3TreeViewSelect(0, p
, 0);
7070 ** Check to see if the pThis entry of pTabList is a self-join of another view.
7071 ** Search FROM-clause entries in the range of iFirst..iEnd, including iFirst
7072 ** but stopping before iEnd.
7074 ** If pThis is a self-join, then return the SrcItem for the first other
7075 ** instance of that view found. If pThis is not a self-join then return 0.
7077 static SrcItem
*isSelfJoinView(
7078 SrcList
*pTabList
, /* Search for self-joins in this FROM clause */
7079 SrcItem
*pThis
, /* Search for prior reference to this subquery */
7080 int iFirst
, int iEnd
/* Range of FROM-clause entries to search. */
7083 assert( pThis
->pSelect
!=0 );
7084 if( pThis
->pSelect
->selFlags
& SF_PushDown
) return 0;
7085 while( iFirst
<iEnd
){
7087 pItem
= &pTabList
->a
[iFirst
++];
7088 if( pItem
->pSelect
==0 ) continue;
7089 if( pItem
->fg
.viaCoroutine
) continue;
7090 if( pItem
->zName
==0 ) continue;
7091 assert( pItem
->pTab
!=0 );
7092 assert( pThis
->pTab
!=0 );
7093 if( pItem
->pTab
->pSchema
!=pThis
->pTab
->pSchema
) continue;
7094 if( sqlite3_stricmp(pItem
->zName
, pThis
->zName
)!=0 ) continue;
7095 pS1
= pItem
->pSelect
;
7096 if( pItem
->pTab
->pSchema
==0 && pThis
->pSelect
->selId
!=pS1
->selId
){
7097 /* The query flattener left two different CTE tables with identical
7098 ** names in the same FROM clause. */
7101 if( pItem
->pSelect
->selFlags
& SF_PushDown
){
7102 /* The view was modified by some other optimization such as
7103 ** pushDownWhereTerms() */
7112 ** Deallocate a single AggInfo object
7114 static void agginfoFree(sqlite3
*db
, void *pArg
){
7115 AggInfo
*p
= (AggInfo
*)pArg
;
7116 sqlite3DbFree(db
, p
->aCol
);
7117 sqlite3DbFree(db
, p
->aFunc
);
7118 sqlite3DbFreeNN(db
, p
);
7122 ** Attempt to transform a query of the form
7124 ** SELECT count(*) FROM (SELECT x FROM t1 UNION ALL SELECT y FROM t2)
7128 ** SELECT (SELECT count(*) FROM t1)+(SELECT count(*) FROM t2)
7130 ** The transformation only works if all of the following are true:
7132 ** * The subquery is a UNION ALL of two or more terms
7133 ** * The subquery does not have a LIMIT clause
7134 ** * There is no WHERE or GROUP BY or HAVING clauses on the subqueries
7135 ** * The outer query is a simple count(*) with no WHERE clause or other
7136 ** extraneous syntax.
7138 ** Return TRUE if the optimization is undertaken.
7140 static int countOfViewOptimization(Parse
*pParse
, Select
*p
){
7141 Select
*pSub
, *pPrior
;
7145 if( (p
->selFlags
& SF_Aggregate
)==0 ) return 0; /* This is an aggregate */
7146 if( p
->pEList
->nExpr
!=1 ) return 0; /* Single result column */
7147 if( p
->pWhere
) return 0;
7148 if( p
->pHaving
) return 0;
7149 if( p
->pGroupBy
) return 0;
7150 if( p
->pOrderBy
) return 0;
7151 pExpr
= p
->pEList
->a
[0].pExpr
;
7152 if( pExpr
->op
!=TK_AGG_FUNCTION
) return 0; /* Result is an aggregate */
7153 assert( ExprUseUToken(pExpr
) );
7154 if( sqlite3_stricmp(pExpr
->u
.zToken
,"count") ) return 0; /* Is count() */
7155 assert( ExprUseXList(pExpr
) );
7156 if( pExpr
->x
.pList
!=0 ) return 0; /* Must be count(*) */
7157 if( p
->pSrc
->nSrc
!=1 ) return 0; /* One table in FROM */
7158 if( ExprHasProperty(pExpr
, EP_WinFunc
) ) return 0;/* Not a window function */
7159 pSub
= p
->pSrc
->a
[0].pSelect
;
7160 if( pSub
==0 ) return 0; /* The FROM is a subquery */
7161 if( pSub
->pPrior
==0 ) return 0; /* Must be a compound */
7162 if( pSub
->selFlags
& SF_CopyCte
) return 0; /* Not a CTE */
7164 if( pSub
->op
!=TK_ALL
&& pSub
->pPrior
) return 0; /* Must be UNION ALL */
7165 if( pSub
->pWhere
) return 0; /* No WHERE clause */
7166 if( pSub
->pLimit
) return 0; /* No LIMIT clause */
7167 if( pSub
->selFlags
& SF_Aggregate
) return 0; /* Not an aggregate */
7168 assert( pSub
->pHaving
==0 ); /* Due to the previous */
7169 pSub
= pSub
->pPrior
; /* Repeat over compound */
7172 /* If we reach this point then it is OK to perform the transformation */
7177 pSub
= p
->pSrc
->a
[0].pSelect
;
7178 p
->pSrc
->a
[0].pSelect
= 0;
7179 sqlite3SrcListDelete(db
, p
->pSrc
);
7180 p
->pSrc
= sqlite3DbMallocZero(pParse
->db
, sizeof(*p
->pSrc
));
7183 pPrior
= pSub
->pPrior
;
7186 pSub
->selFlags
|= SF_Aggregate
;
7187 pSub
->selFlags
&= ~SF_Compound
;
7188 pSub
->nSelectRow
= 0;
7189 sqlite3ParserAddCleanup(pParse
, sqlite3ExprListDeleteGeneric
, pSub
->pEList
);
7190 pTerm
= pPrior
? sqlite3ExprDup(db
, pCount
, 0) : pCount
;
7191 pSub
->pEList
= sqlite3ExprListAppend(pParse
, 0, pTerm
);
7192 pTerm
= sqlite3PExpr(pParse
, TK_SELECT
, 0, 0);
7193 sqlite3PExprAddSelect(pParse
, pTerm
, pSub
);
7197 pExpr
= sqlite3PExpr(pParse
, TK_PLUS
, pTerm
, pExpr
);
7201 p
->pEList
->a
[0].pExpr
= pExpr
;
7202 p
->selFlags
&= ~SF_Aggregate
;
7204 #if TREETRACE_ENABLED
7205 if( sqlite3TreeTrace
& 0x200 ){
7206 TREETRACE(0x200,pParse
,p
,("After count-of-view optimization:\n"));
7207 sqlite3TreeViewSelect(0, p
, 0);
7214 ** If any term of pSrc, or any SF_NestedFrom sub-query, is not the same
7215 ** as pSrcItem but has the same alias as p0, then return true.
7216 ** Otherwise return false.
7218 static int sameSrcAlias(SrcItem
*p0
, SrcList
*pSrc
){
7220 for(i
=0; i
<pSrc
->nSrc
; i
++){
7221 SrcItem
*p1
= &pSrc
->a
[i
];
7222 if( p1
==p0
) continue;
7223 if( p0
->pTab
==p1
->pTab
&& 0==sqlite3_stricmp(p0
->zAlias
, p1
->zAlias
) ){
7227 && (p1
->pSelect
->selFlags
& SF_NestedFrom
)!=0
7228 && sameSrcAlias(p0
, p1
->pSelect
->pSrc
)
7237 ** Return TRUE (non-zero) if the i-th entry in the pTabList SrcList can
7238 ** be implemented as a co-routine. The i-th entry is guaranteed to be
7241 ** The subquery is implemented as a co-routine if all of the following are
7244 ** (1) The subquery will likely be implemented in the outer loop of
7245 ** the query. This will be the case if any one of the following
7247 ** (a) The subquery is the only term in the FROM clause
7248 ** (b) The subquery is the left-most term and a CROSS JOIN or similar
7249 ** requires it to be the outer loop
7250 ** (c) All of the following are true:
7251 ** (i) The subquery is the left-most subquery in the FROM clause
7252 ** (ii) There is nothing that would prevent the subquery from
7253 ** being used as the outer loop if the sqlite3WhereBegin()
7254 ** routine nominates it to that position.
7255 ** (iii) The query is not a UPDATE ... FROM
7256 ** (2) The subquery is not a CTE that should be materialized because
7257 ** (a) the AS MATERIALIZED keyword is used, or
7258 ** (b) the CTE is used multiple times and does not have the
7259 ** NOT MATERIALIZED keyword
7260 ** (3) The subquery is not part of a left operand for a RIGHT JOIN
7261 ** (4) The SQLITE_Coroutine optimization disable flag is not set
7262 ** (5) The subquery is not self-joined
7264 static int fromClauseTermCanBeCoroutine(
7265 Parse
*pParse
, /* Parsing context */
7266 SrcList
*pTabList
, /* FROM clause */
7267 int i
, /* Which term of the FROM clause holds the subquery */
7268 int selFlags
/* Flags on the SELECT statement */
7270 SrcItem
*pItem
= &pTabList
->a
[i
];
7271 if( pItem
->fg
.isCte
){
7272 const CteUse
*pCteUse
= pItem
->u2
.pCteUse
;
7273 if( pCteUse
->eM10d
==M10d_Yes
) return 0; /* (2a) */
7274 if( pCteUse
->nUse
>=2 && pCteUse
->eM10d
!=M10d_No
) return 0; /* (2b) */
7276 if( pTabList
->a
[0].fg
.jointype
& JT_LTORJ
) return 0; /* (3) */
7277 if( OptimizationDisabled(pParse
->db
, SQLITE_Coroutines
) ) return 0; /* (4) */
7278 if( isSelfJoinView(pTabList
, pItem
, i
+1, pTabList
->nSrc
)!=0 ){
7282 if( pTabList
->nSrc
==1 ) return 1; /* (1a) */
7283 if( pTabList
->a
[1].fg
.jointype
& JT_CROSS
) return 1; /* (1b) */
7284 if( selFlags
& SF_UpdateFrom
) return 0; /* (1c-iii) */
7287 if( selFlags
& SF_UpdateFrom
) return 0; /* (1c-iii) */
7288 while( 1 /*exit-by-break*/ ){
7289 if( pItem
->fg
.jointype
& (JT_OUTER
|JT_CROSS
) ) return 0; /* (1c-ii) */
7293 if( pItem
->pSelect
!=0 ) return 0; /* (1c-i) */
7299 ** Generate code for the SELECT statement given in the p argument.
7301 ** The results are returned according to the SelectDest structure.
7302 ** See comments in sqliteInt.h for further information.
7304 ** This routine returns the number of errors. If any errors are
7305 ** encountered, then an appropriate error message is left in
7308 ** This routine does NOT free the Select structure passed in. The
7309 ** calling function needs to do that.
7312 Parse
*pParse
, /* The parser context */
7313 Select
*p
, /* The SELECT statement being coded. */
7314 SelectDest
*pDest
/* What to do with the query results */
7316 int i
, j
; /* Loop counters */
7317 WhereInfo
*pWInfo
; /* Return from sqlite3WhereBegin() */
7318 Vdbe
*v
; /* The virtual machine under construction */
7319 int isAgg
; /* True for select lists like "count(*)" */
7320 ExprList
*pEList
= 0; /* List of columns to extract. */
7321 SrcList
*pTabList
; /* List of tables to select from */
7322 Expr
*pWhere
; /* The WHERE clause. May be NULL */
7323 ExprList
*pGroupBy
; /* The GROUP BY clause. May be NULL */
7324 Expr
*pHaving
; /* The HAVING clause. May be NULL */
7325 AggInfo
*pAggInfo
= 0; /* Aggregate information */
7326 int rc
= 1; /* Value to return from this function */
7327 DistinctCtx sDistinct
; /* Info on how to code the DISTINCT keyword */
7328 SortCtx sSort
; /* Info on how to code the ORDER BY clause */
7329 int iEnd
; /* Address of the end of the query */
7330 sqlite3
*db
; /* The database connection */
7331 ExprList
*pMinMaxOrderBy
= 0; /* Added ORDER BY for min/max queries */
7332 u8 minMaxFlag
; /* Flag for min/max queries */
7335 assert( pParse
==db
->pParse
);
7336 v
= sqlite3GetVdbe(pParse
);
7337 if( p
==0 || pParse
->nErr
){
7340 assert( db
->mallocFailed
==0 );
7341 if( sqlite3AuthCheck(pParse
, SQLITE_SELECT
, 0, 0, 0) ) return 1;
7342 #if TREETRACE_ENABLED
7343 TREETRACE(0x1,pParse
,p
, ("begin processing:\n", pParse
->addrExplain
));
7344 if( sqlite3TreeTrace
& 0x10000 ){
7345 if( (sqlite3TreeTrace
& 0x10001)==0x10000 ){
7346 sqlite3TreeViewLine(0, "In sqlite3Select() at %s:%d",
7347 __FILE__
, __LINE__
);
7349 sqlite3ShowSelect(p
);
7353 assert( p
->pOrderBy
==0 || pDest
->eDest
!=SRT_DistFifo
);
7354 assert( p
->pOrderBy
==0 || pDest
->eDest
!=SRT_Fifo
);
7355 assert( p
->pOrderBy
==0 || pDest
->eDest
!=SRT_DistQueue
);
7356 assert( p
->pOrderBy
==0 || pDest
->eDest
!=SRT_Queue
);
7357 if( IgnorableDistinct(pDest
) ){
7358 assert(pDest
->eDest
==SRT_Exists
|| pDest
->eDest
==SRT_Union
||
7359 pDest
->eDest
==SRT_Except
|| pDest
->eDest
==SRT_Discard
||
7360 pDest
->eDest
==SRT_DistQueue
|| pDest
->eDest
==SRT_DistFifo
);
7361 /* All of these destinations are also able to ignore the ORDER BY clause */
7363 #if TREETRACE_ENABLED
7364 TREETRACE(0x800,pParse
,p
, ("dropping superfluous ORDER BY:\n"));
7365 if( sqlite3TreeTrace
& 0x800 ){
7366 sqlite3TreeViewExprList(0, p
->pOrderBy
, 0, "ORDERBY");
7369 sqlite3ParserAddCleanup(pParse
, sqlite3ExprListDeleteGeneric
,
7371 testcase( pParse
->earlyCleanup
);
7374 p
->selFlags
&= ~SF_Distinct
;
7375 p
->selFlags
|= SF_NoopOrderBy
;
7377 sqlite3SelectPrep(pParse
, p
, 0);
7381 assert( db
->mallocFailed
==0 );
7382 assert( p
->pEList
!=0 );
7383 #if TREETRACE_ENABLED
7384 if( sqlite3TreeTrace
& 0x10 ){
7385 TREETRACE(0x10,pParse
,p
, ("after name resolution:\n"));
7386 sqlite3TreeViewSelect(0, p
, 0);
7390 /* If the SF_UFSrcCheck flag is set, then this function is being called
7391 ** as part of populating the temp table for an UPDATE...FROM statement.
7392 ** In this case, it is an error if the target object (pSrc->a[0]) name
7393 ** or alias is duplicated within FROM clause (pSrc->a[1..n]).
7395 ** Postgres disallows this case too. The reason is that some other
7396 ** systems handle this case differently, and not all the same way,
7397 ** which is just confusing. To avoid this, we follow PG's lead and
7398 ** disallow it altogether. */
7399 if( p
->selFlags
& SF_UFSrcCheck
){
7400 SrcItem
*p0
= &p
->pSrc
->a
[0];
7401 if( sameSrcAlias(p0
, p
->pSrc
) ){
7402 sqlite3ErrorMsg(pParse
,
7403 "target object/alias may not appear in FROM clause: %s",
7404 p0
->zAlias
? p0
->zAlias
: p0
->pTab
->zName
7409 /* Clear the SF_UFSrcCheck flag. The check has already been performed,
7410 ** and leaving this flag set can cause errors if a compound sub-query
7411 ** in p->pSrc is flattened into this query and this function called
7412 ** again as part of compound SELECT processing. */
7413 p
->selFlags
&= ~SF_UFSrcCheck
;
7416 if( pDest
->eDest
==SRT_Output
){
7417 sqlite3GenerateColumnNames(pParse
, p
);
7420 #ifndef SQLITE_OMIT_WINDOWFUNC
7421 if( sqlite3WindowRewrite(pParse
, p
) ){
7422 assert( pParse
->nErr
);
7425 #if TREETRACE_ENABLED
7426 if( p
->pWin
&& (sqlite3TreeTrace
& 0x40)!=0 ){
7427 TREETRACE(0x40,pParse
,p
, ("after window rewrite:\n"));
7428 sqlite3TreeViewSelect(0, p
, 0);
7431 #endif /* SQLITE_OMIT_WINDOWFUNC */
7433 isAgg
= (p
->selFlags
& SF_Aggregate
)!=0;
7434 memset(&sSort
, 0, sizeof(sSort
));
7435 sSort
.pOrderBy
= p
->pOrderBy
;
7437 /* Try to do various optimizations (flattening subqueries, and strength
7438 ** reduction of join operators) in the FROM clause up into the main query
7440 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
7441 for(i
=0; !p
->pPrior
&& i
<pTabList
->nSrc
; i
++){
7442 SrcItem
*pItem
= &pTabList
->a
[i
];
7443 Select
*pSub
= pItem
->pSelect
;
7444 Table
*pTab
= pItem
->pTab
;
7446 /* The expander should have already created transient Table objects
7447 ** even for FROM clause elements such as subqueries that do not correspond
7448 ** to a real table */
7451 /* Try to simplify joins:
7453 ** LEFT JOIN -> JOIN
7454 ** RIGHT JOIN -> JOIN
7455 ** FULL JOIN -> RIGHT JOIN
7457 ** If terms of the i-th table are used in the WHERE clause in such a
7458 ** way that the i-th table cannot be the NULL row of a join, then
7459 ** perform the appropriate simplification. This is called
7460 ** "OUTER JOIN strength reduction" in the SQLite documentation.
7462 if( (pItem
->fg
.jointype
& (JT_LEFT
|JT_LTORJ
))!=0
7463 && sqlite3ExprImpliesNonNullRow(p
->pWhere
, pItem
->iCursor
,
7464 pItem
->fg
.jointype
& JT_LTORJ
)
7465 && OptimizationEnabled(db
, SQLITE_SimplifyJoin
)
7467 if( pItem
->fg
.jointype
& JT_LEFT
){
7468 if( pItem
->fg
.jointype
& JT_RIGHT
){
7469 TREETRACE(0x1000,pParse
,p
,
7470 ("FULL-JOIN simplifies to RIGHT-JOIN on term %d\n",i
));
7471 pItem
->fg
.jointype
&= ~JT_LEFT
;
7473 TREETRACE(0x1000,pParse
,p
,
7474 ("LEFT-JOIN simplifies to JOIN on term %d\n",i
));
7475 pItem
->fg
.jointype
&= ~(JT_LEFT
|JT_OUTER
);
7476 unsetJoinExpr(p
->pWhere
, pItem
->iCursor
, 0);
7479 if( pItem
->fg
.jointype
& JT_LTORJ
){
7480 for(j
=i
+1; j
<pTabList
->nSrc
; j
++){
7481 SrcItem
*pI2
= &pTabList
->a
[j
];
7482 if( pI2
->fg
.jointype
& JT_RIGHT
){
7483 if( pI2
->fg
.jointype
& JT_LEFT
){
7484 TREETRACE(0x1000,pParse
,p
,
7485 ("FULL-JOIN simplifies to LEFT-JOIN on term %d\n",j
));
7486 pI2
->fg
.jointype
&= ~JT_RIGHT
;
7488 TREETRACE(0x1000,pParse
,p
,
7489 ("RIGHT-JOIN simplifies to JOIN on term %d\n",j
));
7490 pI2
->fg
.jointype
&= ~(JT_RIGHT
|JT_OUTER
);
7491 unsetJoinExpr(p
->pWhere
, pI2
->iCursor
, 1);
7495 for(j
=pTabList
->nSrc
-1; j
>=0; j
--){
7496 pTabList
->a
[j
].fg
.jointype
&= ~JT_LTORJ
;
7497 if( pTabList
->a
[j
].fg
.jointype
& JT_RIGHT
) break;
7502 /* No further action if this term of the FROM clause is not a subquery */
7503 if( pSub
==0 ) continue;
7505 /* Catch mismatch in the declared columns of a view and the number of
7506 ** columns in the SELECT on the RHS */
7507 if( pTab
->nCol
!=pSub
->pEList
->nExpr
){
7508 sqlite3ErrorMsg(pParse
, "expected %d columns for '%s' but got %d",
7509 pTab
->nCol
, pTab
->zName
, pSub
->pEList
->nExpr
);
7513 /* Do not attempt the usual optimizations (flattening and ORDER BY
7514 ** elimination) on a MATERIALIZED common table expression because
7515 ** a MATERIALIZED common table expression is an optimization fence.
7517 if( pItem
->fg
.isCte
&& pItem
->u2
.pCteUse
->eM10d
==M10d_Yes
){
7521 /* Do not try to flatten an aggregate subquery.
7523 ** Flattening an aggregate subquery is only possible if the outer query
7524 ** is not a join. But if the outer query is not a join, then the subquery
7525 ** will be implemented as a co-routine and there is no advantage to
7526 ** flattening in that case.
7528 if( (pSub
->selFlags
& SF_Aggregate
)!=0 ) continue;
7529 assert( pSub
->pGroupBy
==0 );
7531 /* If a FROM-clause subquery has an ORDER BY clause that is not
7532 ** really doing anything, then delete it now so that it does not
7533 ** interfere with query flattening. See the discussion at
7534 ** https://sqlite.org/forum/forumpost/2d76f2bcf65d256a
7536 ** Beware of these cases where the ORDER BY clause may not be safely
7539 ** (1) There is also a LIMIT clause
7540 ** (2) The subquery was added to help with window-function
7542 ** (3) The subquery is in the FROM clause of an UPDATE
7543 ** (4) The outer query uses an aggregate function other than
7544 ** the built-in count(), min(), or max().
7545 ** (5) The ORDER BY isn't going to accomplish anything because
7547 ** (a) The outer query has a different ORDER BY clause
7548 ** (b) The subquery is part of a join
7549 ** See forum post 062d576715d277c8
7550 ** (6) The subquery is not a recursive CTE. ORDER BY has a different
7551 ** meaning for recursive CTEs and this optimization does not
7554 ** Also retain the ORDER BY if the OmitOrderBy optimization is disabled.
7556 if( pSub
->pOrderBy
!=0
7557 && (p
->pOrderBy
!=0 || pTabList
->nSrc
>1) /* Condition (5) */
7558 && pSub
->pLimit
==0 /* Condition (1) */
7559 && (pSub
->selFlags
& (SF_OrderByReqd
|SF_Recursive
))==0 /* (2) and (6) */
7560 && (p
->selFlags
& SF_OrderByReqd
)==0 /* Condition (3) and (4) */
7561 && OptimizationEnabled(db
, SQLITE_OmitOrderBy
)
7563 TREETRACE(0x800,pParse
,p
,
7564 ("omit superfluous ORDER BY on %r FROM-clause subquery\n",i
+1));
7565 sqlite3ParserAddCleanup(pParse
, sqlite3ExprListDeleteGeneric
,
7570 /* If the outer query contains a "complex" result set (that is,
7571 ** if the result set of the outer query uses functions or subqueries)
7572 ** and if the subquery contains an ORDER BY clause and if
7573 ** it will be implemented as a co-routine, then do not flatten. This
7574 ** restriction allows SQL constructs like this:
7576 ** SELECT expensive_function(x)
7577 ** FROM (SELECT x FROM tab ORDER BY y LIMIT 10);
7579 ** The expensive_function() is only computed on the 10 rows that
7580 ** are output, rather than every row of the table.
7582 ** The requirement that the outer query have a complex result set
7583 ** means that flattening does occur on simpler SQL constraints without
7584 ** the expensive_function() like:
7586 ** SELECT x FROM (SELECT x FROM tab ORDER BY y LIMIT 10);
7588 if( pSub
->pOrderBy
!=0
7590 && (p
->selFlags
& SF_ComplexResult
)!=0
7591 && (pTabList
->nSrc
==1
7592 || (pTabList
->a
[1].fg
.jointype
&(JT_OUTER
|JT_CROSS
))!=0)
7597 if( flattenSubquery(pParse
, p
, i
, isAgg
) ){
7598 if( pParse
->nErr
) goto select_end
;
7599 /* This subquery can be absorbed into its parent. */
7603 if( db
->mallocFailed
) goto select_end
;
7604 if( !IgnorableOrderby(pDest
) ){
7605 sSort
.pOrderBy
= p
->pOrderBy
;
7610 #ifndef SQLITE_OMIT_COMPOUND_SELECT
7611 /* Handle compound SELECT statements using the separate multiSelect()
7615 rc
= multiSelect(pParse
, p
, pDest
);
7616 #if TREETRACE_ENABLED
7617 TREETRACE(0x400,pParse
,p
,("end compound-select processing\n"));
7618 if( (sqlite3TreeTrace
& 0x400)!=0 && ExplainQueryPlanParent(pParse
)==0 ){
7619 sqlite3TreeViewSelect(0, p
, 0);
7622 if( p
->pNext
==0 ) ExplainQueryPlanPop(pParse
);
7627 /* Do the WHERE-clause constant propagation optimization if this is
7628 ** a join. No need to speed time on this operation for non-join queries
7629 ** as the equivalent optimization will be handled by query planner in
7630 ** sqlite3WhereBegin().
7633 && p
->pWhere
->op
==TK_AND
7634 && OptimizationEnabled(db
, SQLITE_PropagateConst
)
7635 && propagateConstants(pParse
, p
)
7637 #if TREETRACE_ENABLED
7638 if( sqlite3TreeTrace
& 0x2000 ){
7639 TREETRACE(0x2000,pParse
,p
,("After constant propagation:\n"));
7640 sqlite3TreeViewSelect(0, p
, 0);
7644 TREETRACE(0x2000,pParse
,p
,("Constant propagation not helpful\n"));
7647 if( OptimizationEnabled(db
, SQLITE_QueryFlattener
|SQLITE_CountOfView
)
7648 && countOfViewOptimization(pParse
, p
)
7650 if( db
->mallocFailed
) goto select_end
;
7654 /* For each term in the FROM clause, do two things:
7655 ** (1) Authorized unreferenced tables
7656 ** (2) Generate code for all sub-queries
7658 for(i
=0; i
<pTabList
->nSrc
; i
++){
7659 SrcItem
*pItem
= &pTabList
->a
[i
];
7663 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
7664 const char *zSavedAuthContext
;
7667 /* Issue SQLITE_READ authorizations with a fake column name for any
7668 ** tables that are referenced but from which no values are extracted.
7669 ** Examples of where these kinds of null SQLITE_READ authorizations
7672 ** SELECT count(*) FROM t1; -- SQLITE_READ t1.""
7673 ** SELECT t1.* FROM t1, t2; -- SQLITE_READ t2.""
7675 ** The fake column name is an empty string. It is possible for a table to
7676 ** have a column named by the empty string, in which case there is no way to
7677 ** distinguish between an unreferenced table and an actual reference to the
7678 ** "" column. The original design was for the fake column name to be a NULL,
7679 ** which would be unambiguous. But legacy authorization callbacks might
7680 ** assume the column name is non-NULL and segfault. The use of an empty
7681 ** string for the fake column name seems safer.
7683 if( pItem
->colUsed
==0 && pItem
->zName
!=0 ){
7684 sqlite3AuthCheck(pParse
, SQLITE_READ
, pItem
->zName
, "", pItem
->zDatabase
);
7687 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
7688 /* Generate code for all sub-queries in the FROM clause
7690 pSub
= pItem
->pSelect
;
7691 if( pSub
==0 || pItem
->addrFillSub
!=0 ) continue;
7693 /* The code for a subquery should only be generated once. */
7694 assert( pItem
->addrFillSub
==0 );
7696 /* Increment Parse.nHeight by the height of the largest expression
7697 ** tree referred to by this, the parent select. The child select
7698 ** may contain expression trees of at most
7699 ** (SQLITE_MAX_EXPR_DEPTH-Parse.nHeight) height. This is a bit
7700 ** more conservative than necessary, but much easier than enforcing
7703 pParse
->nHeight
+= sqlite3SelectExprHeight(p
);
7705 /* Make copies of constant WHERE-clause terms in the outer query down
7706 ** inside the subquery. This can help the subquery to run more efficiently.
7708 if( OptimizationEnabled(db
, SQLITE_PushDown
)
7709 && (pItem
->fg
.isCte
==0
7710 || (pItem
->u2
.pCteUse
->eM10d
!=M10d_Yes
&& pItem
->u2
.pCteUse
->nUse
<2))
7711 && pushDownWhereTerms(pParse
, pSub
, p
->pWhere
, pTabList
, i
)
7713 #if TREETRACE_ENABLED
7714 if( sqlite3TreeTrace
& 0x4000 ){
7715 TREETRACE(0x4000,pParse
,p
,
7716 ("After WHERE-clause push-down into subquery %d:\n", pSub
->selId
));
7717 sqlite3TreeViewSelect(0, p
, 0);
7720 assert( pItem
->pSelect
&& (pItem
->pSelect
->selFlags
& SF_PushDown
)!=0 );
7722 TREETRACE(0x4000,pParse
,p
,("WHERE-lcause push-down not possible\n"));
7725 /* Convert unused result columns of the subquery into simple NULL
7726 ** expressions, to avoid unneeded searching and computation.
7728 if( OptimizationEnabled(db
, SQLITE_NullUnusedCols
)
7729 && disableUnusedSubqueryResultColumns(pItem
)
7731 #if TREETRACE_ENABLED
7732 if( sqlite3TreeTrace
& 0x4000 ){
7733 TREETRACE(0x4000,pParse
,p
,
7734 ("Change unused result columns to NULL for subquery %d:\n",
7736 sqlite3TreeViewSelect(0, p
, 0);
7741 zSavedAuthContext
= pParse
->zAuthContext
;
7742 pParse
->zAuthContext
= pItem
->zName
;
7744 /* Generate code to implement the subquery
7746 if( fromClauseTermCanBeCoroutine(pParse
, pTabList
, i
, p
->selFlags
) ){
7747 /* Implement a co-routine that will return a single row of the result
7748 ** set on each invocation.
7750 int addrTop
= sqlite3VdbeCurrentAddr(v
)+1;
7752 pItem
->regReturn
= ++pParse
->nMem
;
7753 sqlite3VdbeAddOp3(v
, OP_InitCoroutine
, pItem
->regReturn
, 0, addrTop
);
7754 VdbeComment((v
, "%!S", pItem
));
7755 pItem
->addrFillSub
= addrTop
;
7756 sqlite3SelectDestInit(&dest
, SRT_Coroutine
, pItem
->regReturn
);
7757 ExplainQueryPlan((pParse
, 1, "CO-ROUTINE %!S", pItem
));
7758 sqlite3Select(pParse
, pSub
, &dest
);
7759 pItem
->pTab
->nRowLogEst
= pSub
->nSelectRow
;
7760 pItem
->fg
.viaCoroutine
= 1;
7761 pItem
->regResult
= dest
.iSdst
;
7762 sqlite3VdbeEndCoroutine(v
, pItem
->regReturn
);
7763 sqlite3VdbeJumpHere(v
, addrTop
-1);
7764 sqlite3ClearTempRegCache(pParse
);
7765 }else if( pItem
->fg
.isCte
&& pItem
->u2
.pCteUse
->addrM9e
>0 ){
7766 /* This is a CTE for which materialization code has already been
7767 ** generated. Invoke the subroutine to compute the materialization,
7768 ** the make the pItem->iCursor be a copy of the ephemeral table that
7769 ** holds the result of the materialization. */
7770 CteUse
*pCteUse
= pItem
->u2
.pCteUse
;
7771 sqlite3VdbeAddOp2(v
, OP_Gosub
, pCteUse
->regRtn
, pCteUse
->addrM9e
);
7772 if( pItem
->iCursor
!=pCteUse
->iCur
){
7773 sqlite3VdbeAddOp2(v
, OP_OpenDup
, pItem
->iCursor
, pCteUse
->iCur
);
7774 VdbeComment((v
, "%!S", pItem
));
7776 pSub
->nSelectRow
= pCteUse
->nRowEst
;
7777 }else if( (pPrior
= isSelfJoinView(pTabList
, pItem
, 0, i
))!=0 ){
7778 /* This view has already been materialized by a prior entry in
7779 ** this same FROM clause. Reuse it. */
7780 if( pPrior
->addrFillSub
){
7781 sqlite3VdbeAddOp2(v
, OP_Gosub
, pPrior
->regReturn
, pPrior
->addrFillSub
);
7783 sqlite3VdbeAddOp2(v
, OP_OpenDup
, pItem
->iCursor
, pPrior
->iCursor
);
7784 pSub
->nSelectRow
= pPrior
->pSelect
->nSelectRow
;
7786 /* Materialize the view. If the view is not correlated, generate a
7787 ** subroutine to do the materialization so that subsequent uses of
7788 ** the same view can reuse the materialization. */
7791 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
7795 pItem
->regReturn
= ++pParse
->nMem
;
7796 topAddr
= sqlite3VdbeAddOp0(v
, OP_Goto
);
7797 pItem
->addrFillSub
= topAddr
+1;
7798 pItem
->fg
.isMaterialized
= 1;
7799 if( pItem
->fg
.isCorrelated
==0 ){
7800 /* If the subquery is not correlated and if we are not inside of
7801 ** a trigger, then we only need to compute the value of the subquery
7803 onceAddr
= sqlite3VdbeAddOp0(v
, OP_Once
); VdbeCoverage(v
);
7804 VdbeComment((v
, "materialize %!S", pItem
));
7806 VdbeNoopComment((v
, "materialize %!S", pItem
));
7808 sqlite3SelectDestInit(&dest
, SRT_EphemTab
, pItem
->iCursor
);
7810 ExplainQueryPlan2(addrExplain
, (pParse
, 1, "MATERIALIZE %!S", pItem
));
7811 sqlite3Select(pParse
, pSub
, &dest
);
7812 pItem
->pTab
->nRowLogEst
= pSub
->nSelectRow
;
7813 if( onceAddr
) sqlite3VdbeJumpHere(v
, onceAddr
);
7814 sqlite3VdbeAddOp2(v
, OP_Return
, pItem
->regReturn
, topAddr
+1);
7815 VdbeComment((v
, "end %!S", pItem
));
7816 sqlite3VdbeScanStatusRange(v
, addrExplain
, addrExplain
, -1);
7817 sqlite3VdbeJumpHere(v
, topAddr
);
7818 sqlite3ClearTempRegCache(pParse
);
7819 if( pItem
->fg
.isCte
&& pItem
->fg
.isCorrelated
==0 ){
7820 CteUse
*pCteUse
= pItem
->u2
.pCteUse
;
7821 pCteUse
->addrM9e
= pItem
->addrFillSub
;
7822 pCteUse
->regRtn
= pItem
->regReturn
;
7823 pCteUse
->iCur
= pItem
->iCursor
;
7824 pCteUse
->nRowEst
= pSub
->nSelectRow
;
7827 if( db
->mallocFailed
) goto select_end
;
7828 pParse
->nHeight
-= sqlite3SelectExprHeight(p
);
7829 pParse
->zAuthContext
= zSavedAuthContext
;
7833 /* Various elements of the SELECT copied into local variables for
7837 pGroupBy
= p
->pGroupBy
;
7838 pHaving
= p
->pHaving
;
7839 sDistinct
.isTnct
= (p
->selFlags
& SF_Distinct
)!=0;
7841 #if TREETRACE_ENABLED
7842 if( sqlite3TreeTrace
& 0x8000 ){
7843 TREETRACE(0x8000,pParse
,p
,("After all FROM-clause analysis:\n"));
7844 sqlite3TreeViewSelect(0, p
, 0);
7848 /* If the query is DISTINCT with an ORDER BY but is not an aggregate, and
7849 ** if the select-list is the same as the ORDER BY list, then this query
7850 ** can be rewritten as a GROUP BY. In other words, this:
7852 ** SELECT DISTINCT xyz FROM ... ORDER BY xyz
7854 ** is transformed to:
7856 ** SELECT xyz FROM ... GROUP BY xyz ORDER BY xyz
7858 ** The second form is preferred as a single index (or temp-table) may be
7859 ** used for both the ORDER BY and DISTINCT processing. As originally
7860 ** written the query must use a temp-table for at least one of the ORDER
7861 ** BY and DISTINCT, and an index or separate temp-table for the other.
7863 if( (p
->selFlags
& (SF_Distinct
|SF_Aggregate
))==SF_Distinct
7864 && sqlite3ExprListCompare(sSort
.pOrderBy
, pEList
, -1)==0
7865 && OptimizationEnabled(db
, SQLITE_GroupByOrder
)
7866 #ifndef SQLITE_OMIT_WINDOWFUNC
7870 p
->selFlags
&= ~SF_Distinct
;
7871 pGroupBy
= p
->pGroupBy
= sqlite3ExprListDup(db
, pEList
, 0);
7873 for(i
=0; i
<pGroupBy
->nExpr
; i
++){
7874 pGroupBy
->a
[i
].u
.x
.iOrderByCol
= i
+1;
7877 p
->selFlags
|= SF_Aggregate
;
7878 /* Notice that even thought SF_Distinct has been cleared from p->selFlags,
7879 ** the sDistinct.isTnct is still set. Hence, isTnct represents the
7880 ** original setting of the SF_Distinct flag, not the current setting */
7881 assert( sDistinct
.isTnct
);
7882 sDistinct
.isTnct
= 2;
7884 #if TREETRACE_ENABLED
7885 if( sqlite3TreeTrace
& 0x20000 ){
7886 TREETRACE(0x20000,pParse
,p
,("Transform DISTINCT into GROUP BY:\n"));
7887 sqlite3TreeViewSelect(0, p
, 0);
7892 /* If there is an ORDER BY clause, then create an ephemeral index to
7893 ** do the sorting. But this sorting ephemeral index might end up
7894 ** being unused if the data can be extracted in pre-sorted order.
7895 ** If that is the case, then the OP_OpenEphemeral instruction will be
7896 ** changed to an OP_Noop once we figure out that the sorting index is
7897 ** not needed. The sSort.addrSortIndex variable is used to facilitate
7900 if( sSort
.pOrderBy
){
7902 pKeyInfo
= sqlite3KeyInfoFromExprList(
7903 pParse
, sSort
.pOrderBy
, 0, pEList
->nExpr
);
7904 sSort
.iECursor
= pParse
->nTab
++;
7905 sSort
.addrSortIndex
=
7906 sqlite3VdbeAddOp4(v
, OP_OpenEphemeral
,
7907 sSort
.iECursor
, sSort
.pOrderBy
->nExpr
+1+pEList
->nExpr
, 0,
7908 (char*)pKeyInfo
, P4_KEYINFO
7911 sSort
.addrSortIndex
= -1;
7914 /* If the output is destined for a temporary table, open that table.
7916 if( pDest
->eDest
==SRT_EphemTab
){
7917 sqlite3VdbeAddOp2(v
, OP_OpenEphemeral
, pDest
->iSDParm
, pEList
->nExpr
);
7918 if( p
->selFlags
& SF_NestedFrom
){
7919 /* Delete or NULL-out result columns that will never be used */
7921 for(ii
=pEList
->nExpr
-1; ii
>0 && pEList
->a
[ii
].fg
.bUsed
==0; ii
--){
7922 sqlite3ExprDelete(db
, pEList
->a
[ii
].pExpr
);
7923 sqlite3DbFree(db
, pEList
->a
[ii
].zEName
);
7926 for(ii
=0; ii
<pEList
->nExpr
; ii
++){
7927 if( pEList
->a
[ii
].fg
.bUsed
==0 ) pEList
->a
[ii
].pExpr
->op
= TK_NULL
;
7934 iEnd
= sqlite3VdbeMakeLabel(pParse
);
7935 if( (p
->selFlags
& SF_FixedLimit
)==0 ){
7936 p
->nSelectRow
= 320; /* 4 billion rows */
7938 if( p
->pLimit
) computeLimitRegisters(pParse
, p
, iEnd
);
7939 if( p
->iLimit
==0 && sSort
.addrSortIndex
>=0 ){
7940 sqlite3VdbeChangeOpcode(v
, sSort
.addrSortIndex
, OP_SorterOpen
);
7941 sSort
.sortFlags
|= SORTFLAG_UseSorter
;
7944 /* Open an ephemeral index to use for the distinct set.
7946 if( p
->selFlags
& SF_Distinct
){
7947 sDistinct
.tabTnct
= pParse
->nTab
++;
7948 sDistinct
.addrTnct
= sqlite3VdbeAddOp4(v
, OP_OpenEphemeral
,
7949 sDistinct
.tabTnct
, 0, 0,
7950 (char*)sqlite3KeyInfoFromExprList(pParse
, p
->pEList
,0,0),
7952 sqlite3VdbeChangeP5(v
, BTREE_UNORDERED
);
7953 sDistinct
.eTnctType
= WHERE_DISTINCT_UNORDERED
;
7955 sDistinct
.eTnctType
= WHERE_DISTINCT_NOOP
;
7958 if( !isAgg
&& pGroupBy
==0 ){
7959 /* No aggregate functions and no GROUP BY clause */
7960 u16 wctrlFlags
= (sDistinct
.isTnct
? WHERE_WANT_DISTINCT
: 0)
7961 | (p
->selFlags
& SF_FixedLimit
);
7962 #ifndef SQLITE_OMIT_WINDOWFUNC
7963 Window
*pWin
= p
->pWin
; /* Main window object (or NULL) */
7965 sqlite3WindowCodeInit(pParse
, p
);
7968 assert( WHERE_USE_LIMIT
==SF_FixedLimit
);
7971 /* Begin the database scan. */
7972 TREETRACE(0x2,pParse
,p
,("WhereBegin\n"));
7973 pWInfo
= sqlite3WhereBegin(pParse
, pTabList
, pWhere
, sSort
.pOrderBy
,
7974 p
->pEList
, p
, wctrlFlags
, p
->nSelectRow
);
7975 if( pWInfo
==0 ) goto select_end
;
7976 if( sqlite3WhereOutputRowCount(pWInfo
) < p
->nSelectRow
){
7977 p
->nSelectRow
= sqlite3WhereOutputRowCount(pWInfo
);
7979 if( sDistinct
.isTnct
&& sqlite3WhereIsDistinct(pWInfo
) ){
7980 sDistinct
.eTnctType
= sqlite3WhereIsDistinct(pWInfo
);
7982 if( sSort
.pOrderBy
){
7983 sSort
.nOBSat
= sqlite3WhereIsOrdered(pWInfo
);
7984 sSort
.labelOBLopt
= sqlite3WhereOrderByLimitOptLabel(pWInfo
);
7985 if( sSort
.nOBSat
==sSort
.pOrderBy
->nExpr
){
7989 TREETRACE(0x2,pParse
,p
,("WhereBegin returns\n"));
7991 /* If sorting index that was created by a prior OP_OpenEphemeral
7992 ** instruction ended up not being needed, then change the OP_OpenEphemeral
7995 if( sSort
.addrSortIndex
>=0 && sSort
.pOrderBy
==0 ){
7996 sqlite3VdbeChangeToNoop(v
, sSort
.addrSortIndex
);
7999 assert( p
->pEList
==pEList
);
8000 #ifndef SQLITE_OMIT_WINDOWFUNC
8002 int addrGosub
= sqlite3VdbeMakeLabel(pParse
);
8003 int iCont
= sqlite3VdbeMakeLabel(pParse
);
8004 int iBreak
= sqlite3VdbeMakeLabel(pParse
);
8005 int regGosub
= ++pParse
->nMem
;
8007 sqlite3WindowCodeStep(pParse
, p
, pWInfo
, regGosub
, addrGosub
);
8009 sqlite3VdbeAddOp2(v
, OP_Goto
, 0, iBreak
);
8010 sqlite3VdbeResolveLabel(v
, addrGosub
);
8011 VdbeNoopComment((v
, "inner-loop subroutine"));
8012 sSort
.labelOBLopt
= 0;
8013 selectInnerLoop(pParse
, p
, -1, &sSort
, &sDistinct
, pDest
, iCont
, iBreak
);
8014 sqlite3VdbeResolveLabel(v
, iCont
);
8015 sqlite3VdbeAddOp1(v
, OP_Return
, regGosub
);
8016 VdbeComment((v
, "end inner-loop subroutine"));
8017 sqlite3VdbeResolveLabel(v
, iBreak
);
8019 #endif /* SQLITE_OMIT_WINDOWFUNC */
8021 /* Use the standard inner loop. */
8022 selectInnerLoop(pParse
, p
, -1, &sSort
, &sDistinct
, pDest
,
8023 sqlite3WhereContinueLabel(pWInfo
),
8024 sqlite3WhereBreakLabel(pWInfo
));
8026 /* End the database scan loop.
8028 TREETRACE(0x2,pParse
,p
,("WhereEnd\n"));
8029 sqlite3WhereEnd(pWInfo
);
8032 /* This case when there exist aggregate functions or a GROUP BY clause
8034 NameContext sNC
; /* Name context for processing aggregate information */
8035 int iAMem
; /* First Mem address for storing current GROUP BY */
8036 int iBMem
; /* First Mem address for previous GROUP BY */
8037 int iUseFlag
; /* Mem address holding flag indicating that at least
8038 ** one row of the input to the aggregator has been
8040 int iAbortFlag
; /* Mem address which causes query abort if positive */
8041 int groupBySort
; /* Rows come from source in GROUP BY order */
8042 int addrEnd
; /* End of processing for this SELECT */
8043 int sortPTab
= 0; /* Pseudotable used to decode sorting results */
8044 int sortOut
= 0; /* Output register from the sorter */
8045 int orderByGrp
= 0; /* True if the GROUP BY and ORDER BY are the same */
8047 /* Remove any and all aliases between the result set and the
8051 int k
; /* Loop counter */
8052 struct ExprList_item
*pItem
; /* For looping over expression in a list */
8054 for(k
=p
->pEList
->nExpr
, pItem
=p
->pEList
->a
; k
>0; k
--, pItem
++){
8055 pItem
->u
.x
.iAlias
= 0;
8057 for(k
=pGroupBy
->nExpr
, pItem
=pGroupBy
->a
; k
>0; k
--, pItem
++){
8058 pItem
->u
.x
.iAlias
= 0;
8060 assert( 66==sqlite3LogEst(100) );
8061 if( p
->nSelectRow
>66 ) p
->nSelectRow
= 66;
8063 /* If there is both a GROUP BY and an ORDER BY clause and they are
8064 ** identical, then it may be possible to disable the ORDER BY clause
8065 ** on the grounds that the GROUP BY will cause elements to come out
8066 ** in the correct order. It also may not - the GROUP BY might use a
8067 ** database index that causes rows to be grouped together as required
8068 ** but not actually sorted. Either way, record the fact that the
8069 ** ORDER BY and GROUP BY clauses are the same by setting the orderByGrp
8071 if( sSort
.pOrderBy
&& pGroupBy
->nExpr
==sSort
.pOrderBy
->nExpr
){
8073 /* The GROUP BY processing doesn't care whether rows are delivered in
8074 ** ASC or DESC order - only that each group is returned contiguously.
8075 ** So set the ASC/DESC flags in the GROUP BY to match those in the
8076 ** ORDER BY to maximize the chances of rows being delivered in an
8077 ** order that makes the ORDER BY redundant. */
8078 for(ii
=0; ii
<pGroupBy
->nExpr
; ii
++){
8080 sortFlags
= sSort
.pOrderBy
->a
[ii
].fg
.sortFlags
& KEYINFO_ORDER_DESC
;
8081 pGroupBy
->a
[ii
].fg
.sortFlags
= sortFlags
;
8083 if( sqlite3ExprListCompare(pGroupBy
, sSort
.pOrderBy
, -1)==0 ){
8088 assert( 0==sqlite3LogEst(1) );
8092 /* Create a label to jump to when we want to abort the query */
8093 addrEnd
= sqlite3VdbeMakeLabel(pParse
);
8095 /* Convert TK_COLUMN nodes into TK_AGG_COLUMN and make entries in
8096 ** sAggInfo for all TK_AGG_FUNCTION nodes in expressions of the
8097 ** SELECT statement.
8099 pAggInfo
= sqlite3DbMallocZero(db
, sizeof(*pAggInfo
) );
8101 sqlite3ParserAddCleanup(pParse
, agginfoFree
, pAggInfo
);
8102 testcase( pParse
->earlyCleanup
);
8104 if( db
->mallocFailed
){
8107 pAggInfo
->selId
= p
->selId
;
8109 pAggInfo
->pSelect
= p
;
8111 memset(&sNC
, 0, sizeof(sNC
));
8112 sNC
.pParse
= pParse
;
8113 sNC
.pSrcList
= pTabList
;
8114 sNC
.uNC
.pAggInfo
= pAggInfo
;
8115 VVA_ONLY( sNC
.ncFlags
= NC_UAggInfo
; )
8116 pAggInfo
->nSortingColumn
= pGroupBy
? pGroupBy
->nExpr
: 0;
8117 pAggInfo
->pGroupBy
= pGroupBy
;
8118 sqlite3ExprAnalyzeAggList(&sNC
, pEList
);
8119 sqlite3ExprAnalyzeAggList(&sNC
, sSort
.pOrderBy
);
8122 assert( pWhere
==p
->pWhere
);
8123 assert( pHaving
==p
->pHaving
);
8124 assert( pGroupBy
==p
->pGroupBy
);
8125 havingToWhere(pParse
, p
);
8128 sqlite3ExprAnalyzeAggregates(&sNC
, pHaving
);
8130 pAggInfo
->nAccumulator
= pAggInfo
->nColumn
;
8131 if( p
->pGroupBy
==0 && p
->pHaving
==0 && pAggInfo
->nFunc
==1 ){
8132 minMaxFlag
= minMaxQuery(db
, pAggInfo
->aFunc
[0].pFExpr
, &pMinMaxOrderBy
);
8134 minMaxFlag
= WHERE_ORDERBY_NORMAL
;
8136 analyzeAggFuncArgs(pAggInfo
, &sNC
);
8137 if( db
->mallocFailed
) goto select_end
;
8138 #if TREETRACE_ENABLED
8139 if( sqlite3TreeTrace
& 0x20 ){
8140 TREETRACE(0x20,pParse
,p
,("After aggregate analysis %p:\n", pAggInfo
));
8141 sqlite3TreeViewSelect(0, p
, 0);
8143 sqlite3DebugPrintf("MIN/MAX Optimization (0x%02x) adds:\n", minMaxFlag
);
8144 sqlite3TreeViewExprList(0, pMinMaxOrderBy
, 0, "ORDERBY");
8146 printAggInfo(pAggInfo
);
8151 /* Processing for aggregates with GROUP BY is very different and
8152 ** much more complex than aggregates without a GROUP BY.
8155 KeyInfo
*pKeyInfo
; /* Keying information for the group by clause */
8156 int addr1
; /* A-vs-B comparison jump */
8157 int addrOutputRow
; /* Start of subroutine that outputs a result row */
8158 int regOutputRow
; /* Return address register for output subroutine */
8159 int addrSetAbort
; /* Set the abort flag and return */
8160 int addrTopOfLoop
; /* Top of the input loop */
8161 int addrSortingIdx
; /* The OP_OpenEphemeral for the sorting index */
8162 int addrReset
; /* Subroutine for resetting the accumulator */
8163 int regReset
; /* Return address register for reset subroutine */
8164 ExprList
*pDistinct
= 0;
8166 int eDist
= WHERE_DISTINCT_NOOP
;
8168 if( pAggInfo
->nFunc
==1
8169 && pAggInfo
->aFunc
[0].iDistinct
>=0
8170 && ALWAYS(pAggInfo
->aFunc
[0].pFExpr
!=0)
8171 && ALWAYS(ExprUseXList(pAggInfo
->aFunc
[0].pFExpr
))
8172 && pAggInfo
->aFunc
[0].pFExpr
->x
.pList
!=0
8174 Expr
*pExpr
= pAggInfo
->aFunc
[0].pFExpr
->x
.pList
->a
[0].pExpr
;
8175 pExpr
= sqlite3ExprDup(db
, pExpr
, 0);
8176 pDistinct
= sqlite3ExprListDup(db
, pGroupBy
, 0);
8177 pDistinct
= sqlite3ExprListAppend(pParse
, pDistinct
, pExpr
);
8178 distFlag
= pDistinct
? (WHERE_WANT_DISTINCT
|WHERE_AGG_DISTINCT
) : 0;
8181 /* If there is a GROUP BY clause we might need a sorting index to
8182 ** implement it. Allocate that sorting index now. If it turns out
8183 ** that we do not need it after all, the OP_SorterOpen instruction
8184 ** will be converted into a Noop.
8186 pAggInfo
->sortingIdx
= pParse
->nTab
++;
8187 pKeyInfo
= sqlite3KeyInfoFromExprList(pParse
, pGroupBy
,
8188 0, pAggInfo
->nColumn
);
8189 addrSortingIdx
= sqlite3VdbeAddOp4(v
, OP_SorterOpen
,
8190 pAggInfo
->sortingIdx
, pAggInfo
->nSortingColumn
,
8191 0, (char*)pKeyInfo
, P4_KEYINFO
);
8193 /* Initialize memory locations used by GROUP BY aggregate processing
8195 iUseFlag
= ++pParse
->nMem
;
8196 iAbortFlag
= ++pParse
->nMem
;
8197 regOutputRow
= ++pParse
->nMem
;
8198 addrOutputRow
= sqlite3VdbeMakeLabel(pParse
);
8199 regReset
= ++pParse
->nMem
;
8200 addrReset
= sqlite3VdbeMakeLabel(pParse
);
8201 iAMem
= pParse
->nMem
+ 1;
8202 pParse
->nMem
+= pGroupBy
->nExpr
;
8203 iBMem
= pParse
->nMem
+ 1;
8204 pParse
->nMem
+= pGroupBy
->nExpr
;
8205 sqlite3VdbeAddOp2(v
, OP_Integer
, 0, iAbortFlag
);
8206 VdbeComment((v
, "clear abort flag"));
8207 sqlite3VdbeAddOp3(v
, OP_Null
, 0, iAMem
, iAMem
+pGroupBy
->nExpr
-1);
8209 /* Begin a loop that will extract all source rows in GROUP BY order.
8210 ** This might involve two separate loops with an OP_Sort in between, or
8211 ** it might be a single loop that uses an index to extract information
8212 ** in the right order to begin with.
8214 sqlite3VdbeAddOp2(v
, OP_Gosub
, regReset
, addrReset
);
8215 TREETRACE(0x2,pParse
,p
,("WhereBegin\n"));
8216 pWInfo
= sqlite3WhereBegin(pParse
, pTabList
, pWhere
, pGroupBy
, pDistinct
,
8217 p
, (sDistinct
.isTnct
==2 ? WHERE_DISTINCTBY
: WHERE_GROUPBY
)
8218 | (orderByGrp
? WHERE_SORTBYGROUP
: 0) | distFlag
, 0
8221 sqlite3ExprListDelete(db
, pDistinct
);
8224 if( pParse
->pIdxEpr
){
8225 optimizeAggregateUseOfIndexedExpr(pParse
, p
, pAggInfo
, &sNC
);
8227 assignAggregateRegisters(pParse
, pAggInfo
);
8228 eDist
= sqlite3WhereIsDistinct(pWInfo
);
8229 TREETRACE(0x2,pParse
,p
,("WhereBegin returns\n"));
8230 if( sqlite3WhereIsOrdered(pWInfo
)==pGroupBy
->nExpr
){
8231 /* The optimizer is able to deliver rows in group by order so
8232 ** we do not have to sort. The OP_OpenEphemeral table will be
8233 ** cancelled later because we still need to use the pKeyInfo
8237 /* Rows are coming out in undetermined order. We have to push
8238 ** each row into a sorting index, terminate the first loop,
8239 ** then loop over the sorting index in order to get the output
8247 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
8248 int addrExp
; /* Address of OP_Explain instruction */
8250 ExplainQueryPlan2(addrExp
, (pParse
, 0, "USE TEMP B-TREE FOR %s",
8251 (sDistinct
.isTnct
&& (p
->selFlags
&SF_Distinct
)==0) ?
8252 "DISTINCT" : "GROUP BY"
8256 nGroupBy
= pGroupBy
->nExpr
;
8259 for(i
=0; i
<pAggInfo
->nColumn
; i
++){
8260 if( pAggInfo
->aCol
[i
].iSorterColumn
>=j
){
8265 regBase
= sqlite3GetTempRange(pParse
, nCol
);
8266 sqlite3ExprCodeExprList(pParse
, pGroupBy
, regBase
, 0, 0);
8268 pAggInfo
->directMode
= 1;
8269 for(i
=0; i
<pAggInfo
->nColumn
; i
++){
8270 struct AggInfo_col
*pCol
= &pAggInfo
->aCol
[i
];
8271 if( pCol
->iSorterColumn
>=j
){
8272 sqlite3ExprCode(pParse
, pCol
->pCExpr
, j
+ regBase
);
8276 pAggInfo
->directMode
= 0;
8277 regRecord
= sqlite3GetTempReg(pParse
);
8278 sqlite3VdbeScanStatusCounters(v
, addrExp
, 0, sqlite3VdbeCurrentAddr(v
));
8279 sqlite3VdbeAddOp3(v
, OP_MakeRecord
, regBase
, nCol
, regRecord
);
8280 sqlite3VdbeAddOp2(v
, OP_SorterInsert
, pAggInfo
->sortingIdx
, regRecord
);
8281 sqlite3VdbeScanStatusRange(v
, addrExp
, sqlite3VdbeCurrentAddr(v
)-2, -1);
8282 sqlite3ReleaseTempReg(pParse
, regRecord
);
8283 sqlite3ReleaseTempRange(pParse
, regBase
, nCol
);
8284 TREETRACE(0x2,pParse
,p
,("WhereEnd\n"));
8285 sqlite3WhereEnd(pWInfo
);
8286 pAggInfo
->sortingIdxPTab
= sortPTab
= pParse
->nTab
++;
8287 sortOut
= sqlite3GetTempReg(pParse
);
8288 sqlite3VdbeScanStatusCounters(v
, addrExp
, sqlite3VdbeCurrentAddr(v
), 0);
8289 sqlite3VdbeAddOp3(v
, OP_OpenPseudo
, sortPTab
, sortOut
, nCol
);
8290 sqlite3VdbeAddOp2(v
, OP_SorterSort
, pAggInfo
->sortingIdx
, addrEnd
);
8291 VdbeComment((v
, "GROUP BY sort")); VdbeCoverage(v
);
8292 pAggInfo
->useSortingIdx
= 1;
8293 sqlite3VdbeScanStatusRange(v
, addrExp
, -1, sortPTab
);
8294 sqlite3VdbeScanStatusRange(v
, addrExp
, -1, pAggInfo
->sortingIdx
);
8297 /* If there are entries in pAgggInfo->aFunc[] that contain subexpressions
8298 ** that are indexed (and that were previously identified and tagged
8299 ** in optimizeAggregateUseOfIndexedExpr()) then those subexpressions
8300 ** must now be converted into a TK_AGG_COLUMN node so that the value
8301 ** is correctly pulled from the index rather than being recomputed. */
8302 if( pParse
->pIdxEpr
){
8303 aggregateConvertIndexedExprRefToColumn(pAggInfo
);
8304 #if TREETRACE_ENABLED
8305 if( sqlite3TreeTrace
& 0x20 ){
8306 TREETRACE(0x20, pParse
, p
,
8307 ("AggInfo function expressions converted to reference index\n"));
8308 sqlite3TreeViewSelect(0, p
, 0);
8309 printAggInfo(pAggInfo
);
8314 /* If the index or temporary table used by the GROUP BY sort
8315 ** will naturally deliver rows in the order required by the ORDER BY
8316 ** clause, cancel the ephemeral table open coded earlier.
8318 ** This is an optimization - the correct answer should result regardless.
8319 ** Use the SQLITE_GroupByOrder flag with SQLITE_TESTCTRL_OPTIMIZER to
8320 ** disable this optimization for testing purposes. */
8321 if( orderByGrp
&& OptimizationEnabled(db
, SQLITE_GroupByOrder
)
8322 && (groupBySort
|| sqlite3WhereIsSorted(pWInfo
))
8325 sqlite3VdbeChangeToNoop(v
, sSort
.addrSortIndex
);
8328 /* Evaluate the current GROUP BY terms and store in b0, b1, b2...
8329 ** (b0 is memory location iBMem+0, b1 is iBMem+1, and so forth)
8330 ** Then compare the current GROUP BY terms against the GROUP BY terms
8331 ** from the previous row currently stored in a0, a1, a2...
8333 addrTopOfLoop
= sqlite3VdbeCurrentAddr(v
);
8335 sqlite3VdbeAddOp3(v
, OP_SorterData
, pAggInfo
->sortingIdx
,
8338 for(j
=0; j
<pGroupBy
->nExpr
; j
++){
8339 int iOrderByCol
= pGroupBy
->a
[j
].u
.x
.iOrderByCol
;
8342 sqlite3VdbeAddOp3(v
, OP_Column
, sortPTab
, j
, iBMem
+j
);
8344 pAggInfo
->directMode
= 1;
8345 sqlite3ExprCode(pParse
, pGroupBy
->a
[j
].pExpr
, iBMem
+j
);
8349 Expr
*pX
= p
->pEList
->a
[iOrderByCol
-1].pExpr
;
8350 Expr
*pBase
= sqlite3ExprSkipCollateAndLikely(pX
);
8351 if( ALWAYS(pBase
!=0)
8352 && pBase
->op
!=TK_AGG_COLUMN
8353 && pBase
->op
!=TK_REGISTER
8355 sqlite3ExprToRegister(pX
, iAMem
+j
);
8359 sqlite3VdbeAddOp4(v
, OP_Compare
, iAMem
, iBMem
, pGroupBy
->nExpr
,
8360 (char*)sqlite3KeyInfoRef(pKeyInfo
), P4_KEYINFO
);
8361 addr1
= sqlite3VdbeCurrentAddr(v
);
8362 sqlite3VdbeAddOp3(v
, OP_Jump
, addr1
+1, 0, addr1
+1); VdbeCoverage(v
);
8364 /* Generate code that runs whenever the GROUP BY changes.
8365 ** Changes in the GROUP BY are detected by the previous code
8366 ** block. If there were no changes, this block is skipped.
8368 ** This code copies current group by terms in b0,b1,b2,...
8369 ** over to a0,a1,a2. It then calls the output subroutine
8370 ** and resets the aggregate accumulator registers in preparation
8371 ** for the next GROUP BY batch.
8373 sqlite3VdbeAddOp2(v
, OP_Gosub
, regOutputRow
, addrOutputRow
);
8374 VdbeComment((v
, "output one row"));
8375 sqlite3ExprCodeMove(pParse
, iBMem
, iAMem
, pGroupBy
->nExpr
);
8376 sqlite3VdbeAddOp2(v
, OP_IfPos
, iAbortFlag
, addrEnd
); VdbeCoverage(v
);
8377 VdbeComment((v
, "check abort flag"));
8378 sqlite3VdbeAddOp2(v
, OP_Gosub
, regReset
, addrReset
);
8379 VdbeComment((v
, "reset accumulator"));
8381 /* Update the aggregate accumulators based on the content of
8384 sqlite3VdbeJumpHere(v
, addr1
);
8385 updateAccumulator(pParse
, iUseFlag
, pAggInfo
, eDist
);
8386 sqlite3VdbeAddOp2(v
, OP_Integer
, 1, iUseFlag
);
8387 VdbeComment((v
, "indicate data in accumulator"));
8392 sqlite3VdbeAddOp2(v
, OP_SorterNext
, pAggInfo
->sortingIdx
,addrTopOfLoop
);
8395 TREETRACE(0x2,pParse
,p
,("WhereEnd\n"));
8396 sqlite3WhereEnd(pWInfo
);
8397 sqlite3VdbeChangeToNoop(v
, addrSortingIdx
);
8399 sqlite3ExprListDelete(db
, pDistinct
);
8401 /* Output the final row of result
8403 sqlite3VdbeAddOp2(v
, OP_Gosub
, regOutputRow
, addrOutputRow
);
8404 VdbeComment((v
, "output final row"));
8406 /* Jump over the subroutines
8408 sqlite3VdbeGoto(v
, addrEnd
);
8410 /* Generate a subroutine that outputs a single row of the result
8411 ** set. This subroutine first looks at the iUseFlag. If iUseFlag
8412 ** is less than or equal to zero, the subroutine is a no-op. If
8413 ** the processing calls for the query to abort, this subroutine
8414 ** increments the iAbortFlag memory location before returning in
8415 ** order to signal the caller to abort.
8417 addrSetAbort
= sqlite3VdbeCurrentAddr(v
);
8418 sqlite3VdbeAddOp2(v
, OP_Integer
, 1, iAbortFlag
);
8419 VdbeComment((v
, "set abort flag"));
8420 sqlite3VdbeAddOp1(v
, OP_Return
, regOutputRow
);
8421 sqlite3VdbeResolveLabel(v
, addrOutputRow
);
8422 addrOutputRow
= sqlite3VdbeCurrentAddr(v
);
8423 sqlite3VdbeAddOp2(v
, OP_IfPos
, iUseFlag
, addrOutputRow
+2);
8425 VdbeComment((v
, "Groupby result generator entry point"));
8426 sqlite3VdbeAddOp1(v
, OP_Return
, regOutputRow
);
8427 finalizeAggFunctions(pParse
, pAggInfo
);
8428 sqlite3ExprIfFalse(pParse
, pHaving
, addrOutputRow
+1, SQLITE_JUMPIFNULL
);
8429 selectInnerLoop(pParse
, p
, -1, &sSort
,
8431 addrOutputRow
+1, addrSetAbort
);
8432 sqlite3VdbeAddOp1(v
, OP_Return
, regOutputRow
);
8433 VdbeComment((v
, "end groupby result generator"));
8435 /* Generate a subroutine that will reset the group-by accumulator
8437 sqlite3VdbeResolveLabel(v
, addrReset
);
8438 resetAccumulator(pParse
, pAggInfo
);
8439 sqlite3VdbeAddOp2(v
, OP_Integer
, 0, iUseFlag
);
8440 VdbeComment((v
, "indicate accumulator empty"));
8441 sqlite3VdbeAddOp1(v
, OP_Return
, regReset
);
8443 if( distFlag
!=0 && eDist
!=WHERE_DISTINCT_NOOP
){
8444 struct AggInfo_func
*pF
= &pAggInfo
->aFunc
[0];
8445 fixDistinctOpenEph(pParse
, eDist
, pF
->iDistinct
, pF
->iDistAddr
);
8447 } /* endif pGroupBy. Begin aggregate queries without GROUP BY: */
8450 if( (pTab
= isSimpleCount(p
, pAggInfo
))!=0 ){
8451 /* If isSimpleCount() returns a pointer to a Table structure, then
8452 ** the SQL statement is of the form:
8454 ** SELECT count(*) FROM <tbl>
8456 ** where the Table structure returned represents table <tbl>.
8458 ** This statement is so common that it is optimized specially. The
8459 ** OP_Count instruction is executed either on the intkey table that
8460 ** contains the data for table <tbl> or on one of its indexes. It
8461 ** is better to execute the op on an index, as indexes are almost
8462 ** always spread across less pages than their corresponding tables.
8464 const int iDb
= sqlite3SchemaToIndex(pParse
->db
, pTab
->pSchema
);
8465 const int iCsr
= pParse
->nTab
++; /* Cursor to scan b-tree */
8466 Index
*pIdx
; /* Iterator variable */
8467 KeyInfo
*pKeyInfo
= 0; /* Keyinfo for scanned index */
8468 Index
*pBest
= 0; /* Best index found so far */
8469 Pgno iRoot
= pTab
->tnum
; /* Root page of scanned b-tree */
8471 sqlite3CodeVerifySchema(pParse
, iDb
);
8472 sqlite3TableLock(pParse
, iDb
, pTab
->tnum
, 0, pTab
->zName
);
8474 /* Search for the index that has the lowest scan cost.
8476 ** (2011-04-15) Do not do a full scan of an unordered index.
8478 ** (2013-10-03) Do not count the entries in a partial index.
8480 ** In practice the KeyInfo structure will not be used. It is only
8481 ** passed to keep OP_OpenRead happy.
8483 if( !HasRowid(pTab
) ) pBest
= sqlite3PrimaryKeyIndex(pTab
);
8484 if( !p
->pSrc
->a
[0].fg
.notIndexed
){
8485 for(pIdx
=pTab
->pIndex
; pIdx
; pIdx
=pIdx
->pNext
){
8486 if( pIdx
->bUnordered
==0
8487 && pIdx
->szIdxRow
<pTab
->szTabRow
8488 && pIdx
->pPartIdxWhere
==0
8489 && (!pBest
|| pIdx
->szIdxRow
<pBest
->szIdxRow
)
8496 iRoot
= pBest
->tnum
;
8497 pKeyInfo
= sqlite3KeyInfoOfIndex(pParse
, pBest
);
8500 /* Open a read-only cursor, execute the OP_Count, close the cursor. */
8501 sqlite3VdbeAddOp4Int(v
, OP_OpenRead
, iCsr
, (int)iRoot
, iDb
, 1);
8503 sqlite3VdbeChangeP4(v
, -1, (char *)pKeyInfo
, P4_KEYINFO
);
8505 assignAggregateRegisters(pParse
, pAggInfo
);
8506 sqlite3VdbeAddOp2(v
, OP_Count
, iCsr
, AggInfoFuncReg(pAggInfo
,0));
8507 sqlite3VdbeAddOp1(v
, OP_Close
, iCsr
);
8508 explainSimpleCount(pParse
, pTab
, pBest
);
8510 int regAcc
= 0; /* "populate accumulators" flag */
8511 ExprList
*pDistinct
= 0;
8515 /* If there are accumulator registers but no min() or max() functions
8516 ** without FILTER clauses, allocate register regAcc. Register regAcc
8517 ** will contain 0 the first time the inner loop runs, and 1 thereafter.
8518 ** The code generated by updateAccumulator() uses this to ensure
8519 ** that the accumulator registers are (a) updated only once if
8520 ** there are no min() or max functions or (b) always updated for the
8521 ** first row visited by the aggregate, so that they are updated at
8522 ** least once even if the FILTER clause means the min() or max()
8523 ** function visits zero rows. */
8524 if( pAggInfo
->nAccumulator
){
8525 for(i
=0; i
<pAggInfo
->nFunc
; i
++){
8526 if( ExprHasProperty(pAggInfo
->aFunc
[i
].pFExpr
, EP_WinFunc
) ){
8529 if( pAggInfo
->aFunc
[i
].pFunc
->funcFlags
&SQLITE_FUNC_NEEDCOLL
){
8533 if( i
==pAggInfo
->nFunc
){
8534 regAcc
= ++pParse
->nMem
;
8535 sqlite3VdbeAddOp2(v
, OP_Integer
, 0, regAcc
);
8537 }else if( pAggInfo
->nFunc
==1 && pAggInfo
->aFunc
[0].iDistinct
>=0 ){
8538 assert( ExprUseXList(pAggInfo
->aFunc
[0].pFExpr
) );
8539 pDistinct
= pAggInfo
->aFunc
[0].pFExpr
->x
.pList
;
8540 distFlag
= pDistinct
? (WHERE_WANT_DISTINCT
|WHERE_AGG_DISTINCT
) : 0;
8542 assignAggregateRegisters(pParse
, pAggInfo
);
8544 /* This case runs if the aggregate has no GROUP BY clause. The
8545 ** processing is much simpler since there is only a single row
8548 assert( p
->pGroupBy
==0 );
8549 resetAccumulator(pParse
, pAggInfo
);
8551 /* If this query is a candidate for the min/max optimization, then
8552 ** minMaxFlag will have been previously set to either
8553 ** WHERE_ORDERBY_MIN or WHERE_ORDERBY_MAX and pMinMaxOrderBy will
8554 ** be an appropriate ORDER BY expression for the optimization.
8556 assert( minMaxFlag
==WHERE_ORDERBY_NORMAL
|| pMinMaxOrderBy
!=0 );
8557 assert( pMinMaxOrderBy
==0 || pMinMaxOrderBy
->nExpr
==1 );
8559 TREETRACE(0x2,pParse
,p
,("WhereBegin\n"));
8560 pWInfo
= sqlite3WhereBegin(pParse
, pTabList
, pWhere
, pMinMaxOrderBy
,
8561 pDistinct
, p
, minMaxFlag
|distFlag
, 0);
8565 TREETRACE(0x2,pParse
,p
,("WhereBegin returns\n"));
8566 eDist
= sqlite3WhereIsDistinct(pWInfo
);
8567 updateAccumulator(pParse
, regAcc
, pAggInfo
, eDist
);
8568 if( eDist
!=WHERE_DISTINCT_NOOP
){
8569 struct AggInfo_func
*pF
= pAggInfo
->aFunc
;
8571 fixDistinctOpenEph(pParse
, eDist
, pF
->iDistinct
, pF
->iDistAddr
);
8575 if( regAcc
) sqlite3VdbeAddOp2(v
, OP_Integer
, 1, regAcc
);
8577 sqlite3WhereMinMaxOptEarlyOut(v
, pWInfo
);
8579 TREETRACE(0x2,pParse
,p
,("WhereEnd\n"));
8580 sqlite3WhereEnd(pWInfo
);
8581 finalizeAggFunctions(pParse
, pAggInfo
);
8585 sqlite3ExprIfFalse(pParse
, pHaving
, addrEnd
, SQLITE_JUMPIFNULL
);
8586 selectInnerLoop(pParse
, p
, -1, 0, 0,
8587 pDest
, addrEnd
, addrEnd
);
8589 sqlite3VdbeResolveLabel(v
, addrEnd
);
8591 } /* endif aggregate query */
8593 if( sDistinct
.eTnctType
==WHERE_DISTINCT_UNORDERED
){
8594 explainTempTable(pParse
, "DISTINCT");
8597 /* If there is an ORDER BY clause, then we need to sort the results
8598 ** and send them to the callback one by one.
8600 if( sSort
.pOrderBy
){
8601 assert( p
->pEList
==pEList
);
8602 generateSortTail(pParse
, p
, &sSort
, pEList
->nExpr
, pDest
);
8605 /* Jump here to skip this query
8607 sqlite3VdbeResolveLabel(v
, iEnd
);
8609 /* The SELECT has been coded. If there is an error in the Parse structure,
8610 ** set the return code to 1. Otherwise 0. */
8611 rc
= (pParse
->nErr
>0);
8613 /* Control jumps to here if an error is encountered above, or upon
8614 ** successful coding of the SELECT.
8617 assert( db
->mallocFailed
==0 || db
->mallocFailed
==1 );
8618 assert( db
->mallocFailed
==0 || pParse
->nErr
!=0 );
8619 sqlite3ExprListDelete(db
, pMinMaxOrderBy
);
8621 if( pAggInfo
&& !db
->mallocFailed
){
8622 #if TREETRACE_ENABLED
8623 if( sqlite3TreeTrace
& 0x20 ){
8624 TREETRACE(0x20,pParse
,p
,("Finished with AggInfo\n"));
8625 printAggInfo(pAggInfo
);
8628 for(i
=0; i
<pAggInfo
->nColumn
; i
++){
8629 Expr
*pExpr
= pAggInfo
->aCol
[i
].pCExpr
;
8630 if( pExpr
==0 ) continue;
8631 assert( pExpr
->pAggInfo
==pAggInfo
);
8632 assert( pExpr
->iAgg
==i
);
8634 for(i
=0; i
<pAggInfo
->nFunc
; i
++){
8635 Expr
*pExpr
= pAggInfo
->aFunc
[i
].pFExpr
;
8637 assert( pExpr
->pAggInfo
==pAggInfo
);
8638 assert( pExpr
->iAgg
==i
);
8643 #if TREETRACE_ENABLED
8644 TREETRACE(0x1,pParse
,p
,("end processing\n"));
8645 if( (sqlite3TreeTrace
& 0x40000)!=0 && ExplainQueryPlanParent(pParse
)==0 ){
8646 sqlite3TreeViewSelect(0, p
, 0);
8649 ExplainQueryPlanPop(pParse
);