aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/libraries/sqlite/win32/select.c
diff options
context:
space:
mode:
Diffstat (limited to 'libraries/sqlite/win32/select.c')
-rwxr-xr-xlibraries/sqlite/win32/select.c3539
1 files changed, 3539 insertions, 0 deletions
diff --git a/libraries/sqlite/win32/select.c b/libraries/sqlite/win32/select.c
new file mode 100755
index 0000000..fbe1b06
--- /dev/null
+++ b/libraries/sqlite/win32/select.c
@@ -0,0 +1,3539 @@
1/*
2** 2001 September 15
3**
4** The author disclaims copyright to this source code. In place of
5** a legal notice, here is a blessing:
6**
7** May you do good and not evil.
8** May you find forgiveness for yourself and forgive others.
9** May you share freely, never taking more than you give.
10**
11*************************************************************************
12** This file contains C code routines that are called by the parser
13** to handle SELECT statements in SQLite.
14**
15** $Id: select.c,v 1.359 2007/08/31 17:42:48 danielk1977 Exp $
16*/
17#include "sqliteInt.h"
18
19
20/*
21** Delete all the content of a Select structure but do not deallocate
22** the select structure itself.
23*/
24static void clearSelect(Select *p){
25 sqlite3ExprListDelete(p->pEList);
26 sqlite3SrcListDelete(p->pSrc);
27 sqlite3ExprDelete(p->pWhere);
28 sqlite3ExprListDelete(p->pGroupBy);
29 sqlite3ExprDelete(p->pHaving);
30 sqlite3ExprListDelete(p->pOrderBy);
31 sqlite3SelectDelete(p->pPrior);
32 sqlite3ExprDelete(p->pLimit);
33 sqlite3ExprDelete(p->pOffset);
34}
35
36
37/*
38** Allocate a new Select structure and return a pointer to that
39** structure.
40*/
41Select *sqlite3SelectNew(
42 Parse *pParse, /* Parsing context */
43 ExprList *pEList, /* which columns to include in the result */
44 SrcList *pSrc, /* the FROM clause -- which tables to scan */
45 Expr *pWhere, /* the WHERE clause */
46 ExprList *pGroupBy, /* the GROUP BY clause */
47 Expr *pHaving, /* the HAVING clause */
48 ExprList *pOrderBy, /* the ORDER BY clause */
49 int isDistinct, /* true if the DISTINCT keyword is present */
50 Expr *pLimit, /* LIMIT value. NULL means not used */
51 Expr *pOffset /* OFFSET value. NULL means no offset */
52){
53 Select *pNew;
54 Select standin;
55 sqlite3 *db = pParse->db;
56 pNew = sqlite3DbMallocZero(db, sizeof(*pNew) );
57 assert( !pOffset || pLimit ); /* Can't have OFFSET without LIMIT. */
58 if( pNew==0 ){
59 pNew = &standin;
60 memset(pNew, 0, sizeof(*pNew));
61 }
62 if( pEList==0 ){
63 pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db,TK_ALL,0,0,0), 0);
64 }
65 pNew->pEList = pEList;
66 pNew->pSrc = pSrc;
67 pNew->pWhere = pWhere;
68 pNew->pGroupBy = pGroupBy;
69 pNew->pHaving = pHaving;
70 pNew->pOrderBy = pOrderBy;
71 pNew->isDistinct = isDistinct;
72 pNew->op = TK_SELECT;
73 assert( pOffset==0 || pLimit!=0 );
74 pNew->pLimit = pLimit;
75 pNew->pOffset = pOffset;
76 pNew->iLimit = -1;
77 pNew->iOffset = -1;
78 pNew->addrOpenEphm[0] = -1;
79 pNew->addrOpenEphm[1] = -1;
80 pNew->addrOpenEphm[2] = -1;
81 if( pNew==&standin) {
82 clearSelect(pNew);
83 pNew = 0;
84 }
85 return pNew;
86}
87
88/*
89** Delete the given Select structure and all of its substructures.
90*/
91void sqlite3SelectDelete(Select *p){
92 if( p ){
93 clearSelect(p);
94 sqlite3_free(p);
95 }
96}
97
98/*
99** Given 1 to 3 identifiers preceeding the JOIN keyword, determine the
100** type of join. Return an integer constant that expresses that type
101** in terms of the following bit values:
102**
103** JT_INNER
104** JT_CROSS
105** JT_OUTER
106** JT_NATURAL
107** JT_LEFT
108** JT_RIGHT
109**
110** A full outer join is the combination of JT_LEFT and JT_RIGHT.
111**
112** If an illegal or unsupported join type is seen, then still return
113** a join type, but put an error in the pParse structure.
114*/
115int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){
116 int jointype = 0;
117 Token *apAll[3];
118 Token *p;
119 static const struct {
120 const char zKeyword[8];
121 u8 nChar;
122 u8 code;
123 } keywords[] = {
124 { "natural", 7, JT_NATURAL },
125 { "left", 4, JT_LEFT|JT_OUTER },
126 { "right", 5, JT_RIGHT|JT_OUTER },
127 { "full", 4, JT_LEFT|JT_RIGHT|JT_OUTER },
128 { "outer", 5, JT_OUTER },
129 { "inner", 5, JT_INNER },
130 { "cross", 5, JT_INNER|JT_CROSS },
131 };
132 int i, j;
133 apAll[0] = pA;
134 apAll[1] = pB;
135 apAll[2] = pC;
136 for(i=0; i<3 && apAll[i]; i++){
137 p = apAll[i];
138 for(j=0; j<sizeof(keywords)/sizeof(keywords[0]); j++){
139 if( p->n==keywords[j].nChar
140 && sqlite3StrNICmp((char*)p->z, keywords[j].zKeyword, p->n)==0 ){
141 jointype |= keywords[j].code;
142 break;
143 }
144 }
145 if( j>=sizeof(keywords)/sizeof(keywords[0]) ){
146 jointype |= JT_ERROR;
147 break;
148 }
149 }
150 if(
151 (jointype & (JT_INNER|JT_OUTER))==(JT_INNER|JT_OUTER) ||
152 (jointype & JT_ERROR)!=0
153 ){
154 const char *zSp1 = " ";
155 const char *zSp2 = " ";
156 if( pB==0 ){ zSp1++; }
157 if( pC==0 ){ zSp2++; }
158 sqlite3ErrorMsg(pParse, "unknown or unsupported join type: "
159 "%T%s%T%s%T", pA, zSp1, pB, zSp2, pC);
160 jointype = JT_INNER;
161 }else if( jointype & JT_RIGHT ){
162 sqlite3ErrorMsg(pParse,
163 "RIGHT and FULL OUTER JOINs are not currently supported");
164 jointype = JT_INNER;
165 }
166 return jointype;
167}
168
169/*
170** Return the index of a column in a table. Return -1 if the column
171** is not contained in the table.
172*/
173static int columnIndex(Table *pTab, const char *zCol){
174 int i;
175 for(i=0; i<pTab->nCol; i++){
176 if( sqlite3StrICmp(pTab->aCol[i].zName, zCol)==0 ) return i;
177 }
178 return -1;
179}
180
181/*
182** Set the value of a token to a '\000'-terminated string.
183*/
184static void setToken(Token *p, const char *z){
185 p->z = (u8*)z;
186 p->n = z ? strlen(z) : 0;
187 p->dyn = 0;
188}
189
190/*
191** Set the token to the double-quoted and escaped version of the string pointed
192** to by z. For example;
193**
194** {a"bc} -> {"a""bc"}
195*/
196static void setQuotedToken(Parse *pParse, Token *p, const char *z){
197 p->z = (u8 *)sqlite3MPrintf(0, "\"%w\"", z);
198 p->dyn = 1;
199 if( p->z ){
200 p->n = strlen((char *)p->z);
201 }else{
202 pParse->db->mallocFailed = 1;
203 }
204}
205
206/*
207** Create an expression node for an identifier with the name of zName
208*/
209Expr *sqlite3CreateIdExpr(Parse *pParse, const char *zName){
210 Token dummy;
211 setToken(&dummy, zName);
212 return sqlite3PExpr(pParse, TK_ID, 0, 0, &dummy);
213}
214
215
216/*
217** Add a term to the WHERE expression in *ppExpr that requires the
218** zCol column to be equal in the two tables pTab1 and pTab2.
219*/
220static void addWhereTerm(
221 Parse *pParse, /* Parsing context */
222 const char *zCol, /* Name of the column */
223 const Table *pTab1, /* First table */
224 const char *zAlias1, /* Alias for first table. May be NULL */
225 const Table *pTab2, /* Second table */
226 const char *zAlias2, /* Alias for second table. May be NULL */
227 int iRightJoinTable, /* VDBE cursor for the right table */
228 Expr **ppExpr /* Add the equality term to this expression */
229){
230 Expr *pE1a, *pE1b, *pE1c;
231 Expr *pE2a, *pE2b, *pE2c;
232 Expr *pE;
233
234 pE1a = sqlite3CreateIdExpr(pParse, zCol);
235 pE2a = sqlite3CreateIdExpr(pParse, zCol);
236 if( zAlias1==0 ){
237 zAlias1 = pTab1->zName;
238 }
239 pE1b = sqlite3CreateIdExpr(pParse, zAlias1);
240 if( zAlias2==0 ){
241 zAlias2 = pTab2->zName;
242 }
243 pE2b = sqlite3CreateIdExpr(pParse, zAlias2);
244 pE1c = sqlite3PExpr(pParse, TK_DOT, pE1b, pE1a, 0);
245 pE2c = sqlite3PExpr(pParse, TK_DOT, pE2b, pE2a, 0);
246 pE = sqlite3PExpr(pParse, TK_EQ, pE1c, pE2c, 0);
247 if( pE ){
248 ExprSetProperty(pE, EP_FromJoin);
249 pE->iRightJoinTable = iRightJoinTable;
250 }
251 pE = sqlite3ExprAnd(pParse->db,*ppExpr, pE);
252 if( pE ){
253 *ppExpr = pE;
254 }
255}
256
257/*
258** Set the EP_FromJoin property on all terms of the given expression.
259** And set the Expr.iRightJoinTable to iTable for every term in the
260** expression.
261**
262** The EP_FromJoin property is used on terms of an expression to tell
263** the LEFT OUTER JOIN processing logic that this term is part of the
264** join restriction specified in the ON or USING clause and not a part
265** of the more general WHERE clause. These terms are moved over to the
266** WHERE clause during join processing but we need to remember that they
267** originated in the ON or USING clause.
268**
269** The Expr.iRightJoinTable tells the WHERE clause processing that the
270** expression depends on table iRightJoinTable even if that table is not
271** explicitly mentioned in the expression. That information is needed
272** for cases like this:
273**
274** SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.b AND t1.x=5
275**
276** The where clause needs to defer the handling of the t1.x=5
277** term until after the t2 loop of the join. In that way, a
278** NULL t2 row will be inserted whenever t1.x!=5. If we do not
279** defer the handling of t1.x=5, it will be processed immediately
280** after the t1 loop and rows with t1.x!=5 will never appear in
281** the output, which is incorrect.
282*/
283static void setJoinExpr(Expr *p, int iTable){
284 while( p ){
285 ExprSetProperty(p, EP_FromJoin);
286 p->iRightJoinTable = iTable;
287 setJoinExpr(p->pLeft, iTable);
288 p = p->pRight;
289 }
290}
291
292/*
293** This routine processes the join information for a SELECT statement.
294** ON and USING clauses are converted into extra terms of the WHERE clause.
295** NATURAL joins also create extra WHERE clause terms.
296**
297** The terms of a FROM clause are contained in the Select.pSrc structure.
298** The left most table is the first entry in Select.pSrc. The right-most
299** table is the last entry. The join operator is held in the entry to
300** the left. Thus entry 0 contains the join operator for the join between
301** entries 0 and 1. Any ON or USING clauses associated with the join are
302** also attached to the left entry.
303**
304** This routine returns the number of errors encountered.
305*/
306static int sqliteProcessJoin(Parse *pParse, Select *p){
307 SrcList *pSrc; /* All tables in the FROM clause */
308 int i, j; /* Loop counters */
309 struct SrcList_item *pLeft; /* Left table being joined */
310 struct SrcList_item *pRight; /* Right table being joined */
311
312 pSrc = p->pSrc;
313 pLeft = &pSrc->a[0];
314 pRight = &pLeft[1];
315 for(i=0; i<pSrc->nSrc-1; i++, pRight++, pLeft++){
316 Table *pLeftTab = pLeft->pTab;
317 Table *pRightTab = pRight->pTab;
318
319 if( pLeftTab==0 || pRightTab==0 ) continue;
320
321 /* When the NATURAL keyword is present, add WHERE clause terms for
322 ** every column that the two tables have in common.
323 */
324 if( pRight->jointype & JT_NATURAL ){
325 if( pRight->pOn || pRight->pUsing ){
326 sqlite3ErrorMsg(pParse, "a NATURAL join may not have "
327 "an ON or USING clause", 0);
328 return 1;
329 }
330 for(j=0; j<pLeftTab->nCol; j++){
331 char *zName = pLeftTab->aCol[j].zName;
332 if( columnIndex(pRightTab, zName)>=0 ){
333 addWhereTerm(pParse, zName, pLeftTab, pLeft->zAlias,
334 pRightTab, pRight->zAlias,
335 pRight->iCursor, &p->pWhere);
336
337 }
338 }
339 }
340
341 /* Disallow both ON and USING clauses in the same join
342 */
343 if( pRight->pOn && pRight->pUsing ){
344 sqlite3ErrorMsg(pParse, "cannot have both ON and USING "
345 "clauses in the same join");
346 return 1;
347 }
348
349 /* Add the ON clause to the end of the WHERE clause, connected by
350 ** an AND operator.
351 */
352 if( pRight->pOn ){
353 setJoinExpr(pRight->pOn, pRight->iCursor);
354 p->pWhere = sqlite3ExprAnd(pParse->db, p->pWhere, pRight->pOn);
355 pRight->pOn = 0;
356 }
357
358 /* Create extra terms on the WHERE clause for each column named
359 ** in the USING clause. Example: If the two tables to be joined are
360 ** A and B and the USING clause names X, Y, and Z, then add this
361 ** to the WHERE clause: A.X=B.X AND A.Y=B.Y AND A.Z=B.Z
362 ** Report an error if any column mentioned in the USING clause is
363 ** not contained in both tables to be joined.
364 */
365 if( pRight->pUsing ){
366 IdList *pList = pRight->pUsing;
367 for(j=0; j<pList->nId; j++){
368 char *zName = pList->a[j].zName;
369 if( columnIndex(pLeftTab, zName)<0 || columnIndex(pRightTab, zName)<0 ){
370 sqlite3ErrorMsg(pParse, "cannot join using column %s - column "
371 "not present in both tables", zName);
372 return 1;
373 }
374 addWhereTerm(pParse, zName, pLeftTab, pLeft->zAlias,
375 pRightTab, pRight->zAlias,
376 pRight->iCursor, &p->pWhere);
377 }
378 }
379 }
380 return 0;
381}
382
383/*
384** Insert code into "v" that will push the record on the top of the
385** stack into the sorter.
386*/
387static void pushOntoSorter(
388 Parse *pParse, /* Parser context */
389 ExprList *pOrderBy, /* The ORDER BY clause */
390 Select *pSelect /* The whole SELECT statement */
391){
392 Vdbe *v = pParse->pVdbe;
393 sqlite3ExprCodeExprList(pParse, pOrderBy);
394 sqlite3VdbeAddOp(v, OP_Sequence, pOrderBy->iECursor, 0);
395 sqlite3VdbeAddOp(v, OP_Pull, pOrderBy->nExpr + 1, 0);
396 sqlite3VdbeAddOp(v, OP_MakeRecord, pOrderBy->nExpr + 2, 0);
397 sqlite3VdbeAddOp(v, OP_IdxInsert, pOrderBy->iECursor, 0);
398 if( pSelect->iLimit>=0 ){
399 int addr1, addr2;
400 addr1 = sqlite3VdbeAddOp(v, OP_IfMemZero, pSelect->iLimit+1, 0);
401 sqlite3VdbeAddOp(v, OP_MemIncr, -1, pSelect->iLimit+1);
402 addr2 = sqlite3VdbeAddOp(v, OP_Goto, 0, 0);
403 sqlite3VdbeJumpHere(v, addr1);
404 sqlite3VdbeAddOp(v, OP_Last, pOrderBy->iECursor, 0);
405 sqlite3VdbeAddOp(v, OP_Delete, pOrderBy->iECursor, 0);
406 sqlite3VdbeJumpHere(v, addr2);
407 pSelect->iLimit = -1;
408 }
409}
410
411/*
412** Add code to implement the OFFSET
413*/
414static void codeOffset(
415 Vdbe *v, /* Generate code into this VM */
416 Select *p, /* The SELECT statement being coded */
417 int iContinue, /* Jump here to skip the current record */
418 int nPop /* Number of times to pop stack when jumping */
419){
420 if( p->iOffset>=0 && iContinue!=0 ){
421 int addr;
422 sqlite3VdbeAddOp(v, OP_MemIncr, -1, p->iOffset);
423 addr = sqlite3VdbeAddOp(v, OP_IfMemNeg, p->iOffset, 0);
424 if( nPop>0 ){
425 sqlite3VdbeAddOp(v, OP_Pop, nPop, 0);
426 }
427 sqlite3VdbeAddOp(v, OP_Goto, 0, iContinue);
428 VdbeComment((v, "# skip OFFSET records"));
429 sqlite3VdbeJumpHere(v, addr);
430 }
431}
432
433/*
434** Add code that will check to make sure the top N elements of the
435** stack are distinct. iTab is a sorting index that holds previously
436** seen combinations of the N values. A new entry is made in iTab
437** if the current N values are new.
438**
439** A jump to addrRepeat is made and the N+1 values are popped from the
440** stack if the top N elements are not distinct.
441*/
442static void codeDistinct(
443 Vdbe *v, /* Generate code into this VM */
444 int iTab, /* A sorting index used to test for distinctness */
445 int addrRepeat, /* Jump to here if not distinct */
446 int N /* The top N elements of the stack must be distinct */
447){
448 sqlite3VdbeAddOp(v, OP_MakeRecord, -N, 0);
449 sqlite3VdbeAddOp(v, OP_Distinct, iTab, sqlite3VdbeCurrentAddr(v)+3);
450 sqlite3VdbeAddOp(v, OP_Pop, N+1, 0);
451 sqlite3VdbeAddOp(v, OP_Goto, 0, addrRepeat);
452 VdbeComment((v, "# skip indistinct records"));
453 sqlite3VdbeAddOp(v, OP_IdxInsert, iTab, 0);
454}
455
456/*
457** Generate an error message when a SELECT is used within a subexpression
458** (example: "a IN (SELECT * FROM table)") but it has more than 1 result
459** column. We do this in a subroutine because the error occurs in multiple
460** places.
461*/
462static int checkForMultiColumnSelectError(Parse *pParse, int eDest, int nExpr){
463 if( nExpr>1 && (eDest==SRT_Mem || eDest==SRT_Set) ){
464 sqlite3ErrorMsg(pParse, "only a single result allowed for "
465 "a SELECT that is part of an expression");
466 return 1;
467 }else{
468 return 0;
469 }
470}
471
472/*
473** This routine generates the code for the inside of the inner loop
474** of a SELECT.
475**
476** If srcTab and nColumn are both zero, then the pEList expressions
477** are evaluated in order to get the data for this row. If nColumn>0
478** then data is pulled from srcTab and pEList is used only to get the
479** datatypes for each column.
480*/
481static int selectInnerLoop(
482 Parse *pParse, /* The parser context */
483 Select *p, /* The complete select statement being coded */
484 ExprList *pEList, /* List of values being extracted */
485 int srcTab, /* Pull data from this table */
486 int nColumn, /* Number of columns in the source table */
487 ExprList *pOrderBy, /* If not NULL, sort results using this key */
488 int distinct, /* If >=0, make sure results are distinct */
489 int eDest, /* How to dispose of the results */
490 int iParm, /* An argument to the disposal method */
491 int iContinue, /* Jump here to continue with next row */
492 int iBreak, /* Jump here to break out of the inner loop */
493 char *aff /* affinity string if eDest is SRT_Union */
494){
495 Vdbe *v = pParse->pVdbe;
496 int i;
497 int hasDistinct; /* True if the DISTINCT keyword is present */
498
499 if( v==0 ) return 0;
500 assert( pEList!=0 );
501
502 /* If there was a LIMIT clause on the SELECT statement, then do the check
503 ** to see if this row should be output.
504 */
505 hasDistinct = distinct>=0 && pEList->nExpr>0;
506 if( pOrderBy==0 && !hasDistinct ){
507 codeOffset(v, p, iContinue, 0);
508 }
509
510 /* Pull the requested columns.
511 */
512 if( nColumn>0 ){
513 for(i=0; i<nColumn; i++){
514 sqlite3VdbeAddOp(v, OP_Column, srcTab, i);
515 }
516 }else{
517 nColumn = pEList->nExpr;
518 sqlite3ExprCodeExprList(pParse, pEList);
519 }
520
521 /* If the DISTINCT keyword was present on the SELECT statement
522 ** and this row has been seen before, then do not make this row
523 ** part of the result.
524 */
525 if( hasDistinct ){
526 assert( pEList!=0 );
527 assert( pEList->nExpr==nColumn );
528 codeDistinct(v, distinct, iContinue, nColumn);
529 if( pOrderBy==0 ){
530 codeOffset(v, p, iContinue, nColumn);
531 }
532 }
533
534 if( checkForMultiColumnSelectError(pParse, eDest, pEList->nExpr) ){
535 return 0;
536 }
537
538 switch( eDest ){
539 /* In this mode, write each query result to the key of the temporary
540 ** table iParm.
541 */
542#ifndef SQLITE_OMIT_COMPOUND_SELECT
543 case SRT_Union: {
544 sqlite3VdbeAddOp(v, OP_MakeRecord, nColumn, 0);
545 if( aff ){
546 sqlite3VdbeChangeP3(v, -1, aff, P3_STATIC);
547 }
548 sqlite3VdbeAddOp(v, OP_IdxInsert, iParm, 0);
549 break;
550 }
551
552 /* Construct a record from the query result, but instead of
553 ** saving that record, use it as a key to delete elements from
554 ** the temporary table iParm.
555 */
556 case SRT_Except: {
557 int addr;
558 addr = sqlite3VdbeAddOp(v, OP_MakeRecord, nColumn, 0);
559 sqlite3VdbeChangeP3(v, -1, aff, P3_STATIC);
560 sqlite3VdbeAddOp(v, OP_NotFound, iParm, addr+3);
561 sqlite3VdbeAddOp(v, OP_Delete, iParm, 0);
562 break;
563 }
564#endif
565
566 /* Store the result as data using a unique key.
567 */
568 case SRT_Table:
569 case SRT_EphemTab: {
570 sqlite3VdbeAddOp(v, OP_MakeRecord, nColumn, 0);
571 if( pOrderBy ){
572 pushOntoSorter(pParse, pOrderBy, p);
573 }else{
574 sqlite3VdbeAddOp(v, OP_NewRowid, iParm, 0);
575 sqlite3VdbeAddOp(v, OP_Pull, 1, 0);
576 sqlite3VdbeAddOp(v, OP_Insert, iParm, OPFLAG_APPEND);
577 }
578 break;
579 }
580
581#ifndef SQLITE_OMIT_SUBQUERY
582 /* If we are creating a set for an "expr IN (SELECT ...)" construct,
583 ** then there should be a single item on the stack. Write this
584 ** item into the set table with bogus data.
585 */
586 case SRT_Set: {
587 int addr1 = sqlite3VdbeCurrentAddr(v);
588 int addr2;
589
590 assert( nColumn==1 );
591 sqlite3VdbeAddOp(v, OP_NotNull, -1, addr1+3);
592 sqlite3VdbeAddOp(v, OP_Pop, 1, 0);
593 addr2 = sqlite3VdbeAddOp(v, OP_Goto, 0, 0);
594 p->affinity = sqlite3CompareAffinity(pEList->a[0].pExpr,(iParm>>16)&0xff);
595 if( pOrderBy ){
596 /* At first glance you would think we could optimize out the
597 ** ORDER BY in this case since the order of entries in the set
598 ** does not matter. But there might be a LIMIT clause, in which
599 ** case the order does matter */
600 pushOntoSorter(pParse, pOrderBy, p);
601 }else{
602 sqlite3VdbeOp3(v, OP_MakeRecord, 1, 0, &p->affinity, 1);
603 sqlite3VdbeAddOp(v, OP_IdxInsert, (iParm&0x0000FFFF), 0);
604 }
605 sqlite3VdbeJumpHere(v, addr2);
606 break;
607 }
608
609 /* If any row exist in the result set, record that fact and abort.
610 */
611 case SRT_Exists: {
612 sqlite3VdbeAddOp(v, OP_MemInt, 1, iParm);
613 sqlite3VdbeAddOp(v, OP_Pop, nColumn, 0);
614 /* The LIMIT clause will terminate the loop for us */
615 break;
616 }
617
618 /* If this is a scalar select that is part of an expression, then
619 ** store the results in the appropriate memory cell and break out
620 ** of the scan loop.
621 */
622 case SRT_Mem: {
623 assert( nColumn==1 );
624 if( pOrderBy ){
625 pushOntoSorter(pParse, pOrderBy, p);
626 }else{
627 sqlite3VdbeAddOp(v, OP_MemStore, iParm, 1);
628 /* The LIMIT clause will jump out of the loop for us */
629 }
630 break;
631 }
632#endif /* #ifndef SQLITE_OMIT_SUBQUERY */
633
634 /* Send the data to the callback function or to a subroutine. In the
635 ** case of a subroutine, the subroutine itself is responsible for
636 ** popping the data from the stack.
637 */
638 case SRT_Subroutine:
639 case SRT_Callback: {
640 if( pOrderBy ){
641 sqlite3VdbeAddOp(v, OP_MakeRecord, nColumn, 0);
642 pushOntoSorter(pParse, pOrderBy, p);
643 }else if( eDest==SRT_Subroutine ){
644 sqlite3VdbeAddOp(v, OP_Gosub, 0, iParm);
645 }else{
646 sqlite3VdbeAddOp(v, OP_Callback, nColumn, 0);
647 }
648 break;
649 }
650
651#if !defined(SQLITE_OMIT_TRIGGER)
652 /* Discard the results. This is used for SELECT statements inside
653 ** the body of a TRIGGER. The purpose of such selects is to call
654 ** user-defined functions that have side effects. We do not care
655 ** about the actual results of the select.
656 */
657 default: {
658 assert( eDest==SRT_Discard );
659 sqlite3VdbeAddOp(v, OP_Pop, nColumn, 0);
660 break;
661 }
662#endif
663 }
664
665 /* Jump to the end of the loop if the LIMIT is reached.
666 */
667 if( p->iLimit>=0 && pOrderBy==0 ){
668 sqlite3VdbeAddOp(v, OP_MemIncr, -1, p->iLimit);
669 sqlite3VdbeAddOp(v, OP_IfMemZero, p->iLimit, iBreak);
670 }
671 return 0;
672}
673
674/*
675** Given an expression list, generate a KeyInfo structure that records
676** the collating sequence for each expression in that expression list.
677**
678** If the ExprList is an ORDER BY or GROUP BY clause then the resulting
679** KeyInfo structure is appropriate for initializing a virtual index to
680** implement that clause. If the ExprList is the result set of a SELECT
681** then the KeyInfo structure is appropriate for initializing a virtual
682** index to implement a DISTINCT test.
683**
684** Space to hold the KeyInfo structure is obtain from malloc. The calling
685** function is responsible for seeing that this structure is eventually
686** freed. Add the KeyInfo structure to the P3 field of an opcode using
687** P3_KEYINFO_HANDOFF is the usual way of dealing with this.
688*/
689static KeyInfo *keyInfoFromExprList(Parse *pParse, ExprList *pList){
690 sqlite3 *db = pParse->db;
691 int nExpr;
692 KeyInfo *pInfo;
693 struct ExprList_item *pItem;
694 int i;
695
696 nExpr = pList->nExpr;
697 pInfo = sqlite3DbMallocZero(db, sizeof(*pInfo) + nExpr*(sizeof(CollSeq*)+1) );
698 if( pInfo ){
699 pInfo->aSortOrder = (u8*)&pInfo->aColl[nExpr];
700 pInfo->nField = nExpr;
701 pInfo->enc = ENC(db);
702 for(i=0, pItem=pList->a; i<nExpr; i++, pItem++){
703 CollSeq *pColl;
704 pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
705 if( !pColl ){
706 pColl = db->pDfltColl;
707 }
708 pInfo->aColl[i] = pColl;
709 pInfo->aSortOrder[i] = pItem->sortOrder;
710 }
711 }
712 return pInfo;
713}
714
715
716/*
717** If the inner loop was generated using a non-null pOrderBy argument,
718** then the results were placed in a sorter. After the loop is terminated
719** we need to run the sorter and output the results. The following
720** routine generates the code needed to do that.
721*/
722static void generateSortTail(
723 Parse *pParse, /* Parsing context */
724 Select *p, /* The SELECT statement */
725 Vdbe *v, /* Generate code into this VDBE */
726 int nColumn, /* Number of columns of data */
727 int eDest, /* Write the sorted results here */
728 int iParm /* Optional parameter associated with eDest */
729){
730 int brk = sqlite3VdbeMakeLabel(v);
731 int cont = sqlite3VdbeMakeLabel(v);
732 int addr;
733 int iTab;
734 int pseudoTab = 0;
735 ExprList *pOrderBy = p->pOrderBy;
736
737 iTab = pOrderBy->iECursor;
738 if( eDest==SRT_Callback || eDest==SRT_Subroutine ){
739 pseudoTab = pParse->nTab++;
740 sqlite3VdbeAddOp(v, OP_OpenPseudo, pseudoTab, 0);
741 sqlite3VdbeAddOp(v, OP_SetNumColumns, pseudoTab, nColumn);
742 }
743 addr = 1 + sqlite3VdbeAddOp(v, OP_Sort, iTab, brk);
744 codeOffset(v, p, cont, 0);
745 if( eDest==SRT_Callback || eDest==SRT_Subroutine ){
746 sqlite3VdbeAddOp(v, OP_Integer, 1, 0);
747 }
748 sqlite3VdbeAddOp(v, OP_Column, iTab, pOrderBy->nExpr + 1);
749 switch( eDest ){
750 case SRT_Table:
751 case SRT_EphemTab: {
752 sqlite3VdbeAddOp(v, OP_NewRowid, iParm, 0);
753 sqlite3VdbeAddOp(v, OP_Pull, 1, 0);
754 sqlite3VdbeAddOp(v, OP_Insert, iParm, OPFLAG_APPEND);
755 break;
756 }
757#ifndef SQLITE_OMIT_SUBQUERY
758 case SRT_Set: {
759 assert( nColumn==1 );
760 sqlite3VdbeAddOp(v, OP_NotNull, -1, sqlite3VdbeCurrentAddr(v)+3);
761 sqlite3VdbeAddOp(v, OP_Pop, 1, 0);
762 sqlite3VdbeAddOp(v, OP_Goto, 0, sqlite3VdbeCurrentAddr(v)+3);
763 sqlite3VdbeOp3(v, OP_MakeRecord, 1, 0, &p->affinity, 1);
764 sqlite3VdbeAddOp(v, OP_IdxInsert, (iParm&0x0000FFFF), 0);
765 break;
766 }
767 case SRT_Mem: {
768 assert( nColumn==1 );
769 sqlite3VdbeAddOp(v, OP_MemStore, iParm, 1);
770 /* The LIMIT clause will terminate the loop for us */
771 break;
772 }
773#endif
774 case SRT_Callback:
775 case SRT_Subroutine: {
776 int i;
777 sqlite3VdbeAddOp(v, OP_Insert, pseudoTab, 0);
778 for(i=0; i<nColumn; i++){
779 sqlite3VdbeAddOp(v, OP_Column, pseudoTab, i);
780 }
781 if( eDest==SRT_Callback ){
782 sqlite3VdbeAddOp(v, OP_Callback, nColumn, 0);
783 }else{
784 sqlite3VdbeAddOp(v, OP_Gosub, 0, iParm);
785 }
786 break;
787 }
788 default: {
789 /* Do nothing */
790 break;
791 }
792 }
793
794 /* Jump to the end of the loop when the LIMIT is reached
795 */
796 if( p->iLimit>=0 ){
797 sqlite3VdbeAddOp(v, OP_MemIncr, -1, p->iLimit);
798 sqlite3VdbeAddOp(v, OP_IfMemZero, p->iLimit, brk);
799 }
800
801 /* The bottom of the loop
802 */
803 sqlite3VdbeResolveLabel(v, cont);
804 sqlite3VdbeAddOp(v, OP_Next, iTab, addr);
805 sqlite3VdbeResolveLabel(v, brk);
806 if( eDest==SRT_Callback || eDest==SRT_Subroutine ){
807 sqlite3VdbeAddOp(v, OP_Close, pseudoTab, 0);
808 }
809
810}
811
812/*
813** Return a pointer to a string containing the 'declaration type' of the
814** expression pExpr. The string may be treated as static by the caller.
815**
816** The declaration type is the exact datatype definition extracted from the
817** original CREATE TABLE statement if the expression is a column. The
818** declaration type for a ROWID field is INTEGER. Exactly when an expression
819** is considered a column can be complex in the presence of subqueries. The
820** result-set expression in all of the following SELECT statements is
821** considered a column by this function.
822**
823** SELECT col FROM tbl;
824** SELECT (SELECT col FROM tbl;
825** SELECT (SELECT col FROM tbl);
826** SELECT abc FROM (SELECT col AS abc FROM tbl);
827**
828** The declaration type for any expression other than a column is NULL.
829*/
830static const char *columnType(
831 NameContext *pNC,
832 Expr *pExpr,
833 const char **pzOriginDb,
834 const char **pzOriginTab,
835 const char **pzOriginCol
836){
837 char const *zType = 0;
838 char const *zOriginDb = 0;
839 char const *zOriginTab = 0;
840 char const *zOriginCol = 0;
841 int j;
842 if( pExpr==0 || pNC->pSrcList==0 ) return 0;
843
844 switch( pExpr->op ){
845 case TK_AGG_COLUMN:
846 case TK_COLUMN: {
847 /* The expression is a column. Locate the table the column is being
848 ** extracted from in NameContext.pSrcList. This table may be real
849 ** database table or a subquery.
850 */
851 Table *pTab = 0; /* Table structure column is extracted from */
852 Select *pS = 0; /* Select the column is extracted from */
853 int iCol = pExpr->iColumn; /* Index of column in pTab */
854 while( pNC && !pTab ){
855 SrcList *pTabList = pNC->pSrcList;
856 for(j=0;j<pTabList->nSrc && pTabList->a[j].iCursor!=pExpr->iTable;j++);
857 if( j<pTabList->nSrc ){
858 pTab = pTabList->a[j].pTab;
859 pS = pTabList->a[j].pSelect;
860 }else{
861 pNC = pNC->pNext;
862 }
863 }
864
865 if( pTab==0 ){
866 /* FIX ME:
867 ** This can occurs if you have something like "SELECT new.x;" inside
868 ** a trigger. In other words, if you reference the special "new"
869 ** table in the result set of a select. We do not have a good way
870 ** to find the actual table type, so call it "TEXT". This is really
871 ** something of a bug, but I do not know how to fix it.
872 **
873 ** This code does not produce the correct answer - it just prevents
874 ** a segfault. See ticket #1229.
875 */
876 zType = "TEXT";
877 break;
878 }
879
880 assert( pTab );
881 if( pS ){
882 /* The "table" is actually a sub-select or a view in the FROM clause
883 ** of the SELECT statement. Return the declaration type and origin
884 ** data for the result-set column of the sub-select.
885 */
886 if( iCol>=0 && iCol<pS->pEList->nExpr ){
887 /* If iCol is less than zero, then the expression requests the
888 ** rowid of the sub-select or view. This expression is legal (see
889 ** test case misc2.2.2) - it always evaluates to NULL.
890 */
891 NameContext sNC;
892 Expr *p = pS->pEList->a[iCol].pExpr;
893 sNC.pSrcList = pS->pSrc;
894 sNC.pNext = 0;
895 sNC.pParse = pNC->pParse;
896 zType = columnType(&sNC, p, &zOriginDb, &zOriginTab, &zOriginCol);
897 }
898 }else if( pTab->pSchema ){
899 /* A real table */
900 assert( !pS );
901 if( iCol<0 ) iCol = pTab->iPKey;
902 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
903 if( iCol<0 ){
904 zType = "INTEGER";
905 zOriginCol = "rowid";
906 }else{
907 zType = pTab->aCol[iCol].zType;
908 zOriginCol = pTab->aCol[iCol].zName;
909 }
910 zOriginTab = pTab->zName;
911 if( pNC->pParse ){
912 int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema);
913 zOriginDb = pNC->pParse->db->aDb[iDb].zName;
914 }
915 }
916 break;
917 }
918#ifndef SQLITE_OMIT_SUBQUERY
919 case TK_SELECT: {
920 /* The expression is a sub-select. Return the declaration type and
921 ** origin info for the single column in the result set of the SELECT
922 ** statement.
923 */
924 NameContext sNC;
925 Select *pS = pExpr->pSelect;
926 Expr *p = pS->pEList->a[0].pExpr;
927 sNC.pSrcList = pS->pSrc;
928 sNC.pNext = pNC;
929 sNC.pParse = pNC->pParse;
930 zType = columnType(&sNC, p, &zOriginDb, &zOriginTab, &zOriginCol);
931 break;
932 }
933#endif
934 }
935
936 if( pzOriginDb ){
937 assert( pzOriginTab && pzOriginCol );
938 *pzOriginDb = zOriginDb;
939 *pzOriginTab = zOriginTab;
940 *pzOriginCol = zOriginCol;
941 }
942 return zType;
943}
944
945/*
946** Generate code that will tell the VDBE the declaration types of columns
947** in the result set.
948*/
949static void generateColumnTypes(
950 Parse *pParse, /* Parser context */
951 SrcList *pTabList, /* List of tables */
952 ExprList *pEList /* Expressions defining the result set */
953){
954 Vdbe *v = pParse->pVdbe;
955 int i;
956 NameContext sNC;
957 sNC.pSrcList = pTabList;
958 sNC.pParse = pParse;
959 for(i=0; i<pEList->nExpr; i++){
960 Expr *p = pEList->a[i].pExpr;
961 const char *zOrigDb = 0;
962 const char *zOrigTab = 0;
963 const char *zOrigCol = 0;
964 const char *zType = columnType(&sNC, p, &zOrigDb, &zOrigTab, &zOrigCol);
965
966 /* The vdbe must make it's own copy of the column-type and other
967 ** column specific strings, in case the schema is reset before this
968 ** virtual machine is deleted.
969 */
970 sqlite3VdbeSetColName(v, i, COLNAME_DECLTYPE, zType, P3_TRANSIENT);
971 sqlite3VdbeSetColName(v, i, COLNAME_DATABASE, zOrigDb, P3_TRANSIENT);
972 sqlite3VdbeSetColName(v, i, COLNAME_TABLE, zOrigTab, P3_TRANSIENT);
973 sqlite3VdbeSetColName(v, i, COLNAME_COLUMN, zOrigCol, P3_TRANSIENT);
974 }
975}
976
977/*
978** Generate code that will tell the VDBE the names of columns
979** in the result set. This information is used to provide the
980** azCol[] values in the callback.
981*/
982static void generateColumnNames(
983 Parse *pParse, /* Parser context */
984 SrcList *pTabList, /* List of tables */
985 ExprList *pEList /* Expressions defining the result set */
986){
987 Vdbe *v = pParse->pVdbe;
988 int i, j;
989 sqlite3 *db = pParse->db;
990 int fullNames, shortNames;
991
992#ifndef SQLITE_OMIT_EXPLAIN
993 /* If this is an EXPLAIN, skip this step */
994 if( pParse->explain ){
995 return;
996 }
997#endif
998
999 assert( v!=0 );
1000 if( pParse->colNamesSet || v==0 || db->mallocFailed ) return;
1001 pParse->colNamesSet = 1;
1002 fullNames = (db->flags & SQLITE_FullColNames)!=0;
1003 shortNames = (db->flags & SQLITE_ShortColNames)!=0;
1004 sqlite3VdbeSetNumCols(v, pEList->nExpr);
1005 for(i=0; i<pEList->nExpr; i++){
1006 Expr *p;
1007 p = pEList->a[i].pExpr;
1008 if( p==0 ) continue;
1009 if( pEList->a[i].zName ){
1010 char *zName = pEList->a[i].zName;
1011 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, strlen(zName));
1012 continue;
1013 }
1014 if( p->op==TK_COLUMN && pTabList ){
1015 Table *pTab;
1016 char *zCol;
1017 int iCol = p->iColumn;
1018 for(j=0; j<pTabList->nSrc && pTabList->a[j].iCursor!=p->iTable; j++){}
1019 assert( j<pTabList->nSrc );
1020 pTab = pTabList->a[j].pTab;
1021 if( iCol<0 ) iCol = pTab->iPKey;
1022 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
1023 if( iCol<0 ){
1024 zCol = "rowid";
1025 }else{
1026 zCol = pTab->aCol[iCol].zName;
1027 }
1028 if( !shortNames && !fullNames && p->span.z && p->span.z[0] ){
1029 sqlite3VdbeSetColName(v, i, COLNAME_NAME, (char*)p->span.z, p->span.n);
1030 }else if( fullNames || (!shortNames && pTabList->nSrc>1) ){
1031 char *zName = 0;
1032 char *zTab;
1033
1034 zTab = pTabList->a[j].zAlias;
1035 if( fullNames || zTab==0 ) zTab = pTab->zName;
1036 sqlite3SetString(&zName, zTab, ".", zCol, (char*)0);
1037 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, P3_DYNAMIC);
1038 }else{
1039 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zCol, strlen(zCol));
1040 }
1041 }else if( p->span.z && p->span.z[0] ){
1042 sqlite3VdbeSetColName(v, i, COLNAME_NAME, (char*)p->span.z, p->span.n);
1043 /* sqlite3VdbeCompressSpace(v, addr); */
1044 }else{
1045 char zName[30];
1046 assert( p->op!=TK_COLUMN || pTabList==0 );
1047 sqlite3_snprintf(sizeof(zName), zName, "column%d", i+1);
1048 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, 0);
1049 }
1050 }
1051 generateColumnTypes(pParse, pTabList, pEList);
1052}
1053
1054#ifndef SQLITE_OMIT_COMPOUND_SELECT
1055/*
1056** Name of the connection operator, used for error messages.
1057*/
1058static const char *selectOpName(int id){
1059 char *z;
1060 switch( id ){
1061 case TK_ALL: z = "UNION ALL"; break;
1062 case TK_INTERSECT: z = "INTERSECT"; break;
1063 case TK_EXCEPT: z = "EXCEPT"; break;
1064 default: z = "UNION"; break;
1065 }
1066 return z;
1067}
1068#endif /* SQLITE_OMIT_COMPOUND_SELECT */
1069
1070/*
1071** Forward declaration
1072*/
1073static int prepSelectStmt(Parse*, Select*);
1074
1075/*
1076** Given a SELECT statement, generate a Table structure that describes
1077** the result set of that SELECT.
1078*/
1079Table *sqlite3ResultSetOfSelect(Parse *pParse, char *zTabName, Select *pSelect){
1080 Table *pTab;
1081 int i, j;
1082 ExprList *pEList;
1083 Column *aCol, *pCol;
1084 sqlite3 *db = pParse->db;
1085
1086 while( pSelect->pPrior ) pSelect = pSelect->pPrior;
1087 if( prepSelectStmt(pParse, pSelect) ){
1088 return 0;
1089 }
1090 if( sqlite3SelectResolve(pParse, pSelect, 0) ){
1091 return 0;
1092 }
1093 pTab = sqlite3DbMallocZero(db, sizeof(Table) );
1094 if( pTab==0 ){
1095 return 0;
1096 }
1097 pTab->nRef = 1;
1098 pTab->zName = zTabName ? sqlite3DbStrDup(db, zTabName) : 0;
1099 pEList = pSelect->pEList;
1100 pTab->nCol = pEList->nExpr;
1101 assert( pTab->nCol>0 );
1102 pTab->aCol = aCol = sqlite3DbMallocZero(db, sizeof(pTab->aCol[0])*pTab->nCol);
1103 for(i=0, pCol=aCol; i<pTab->nCol; i++, pCol++){
1104 Expr *p, *pR;
1105 char *zType;
1106 char *zName;
1107 int nName;
1108 CollSeq *pColl;
1109 int cnt;
1110 NameContext sNC;
1111
1112 /* Get an appropriate name for the column
1113 */
1114 p = pEList->a[i].pExpr;
1115 assert( p->pRight==0 || p->pRight->token.z==0 || p->pRight->token.z[0]!=0 );
1116 if( (zName = pEList->a[i].zName)!=0 ){
1117 /* If the column contains an "AS <name>" phrase, use <name> as the name */
1118 zName = sqlite3DbStrDup(db, zName);
1119 }else if( p->op==TK_DOT
1120 && (pR=p->pRight)!=0 && pR->token.z && pR->token.z[0] ){
1121 /* For columns of the from A.B use B as the name */
1122 zName = sqlite3MPrintf(db, "%T", &pR->token);
1123 }else if( p->span.z && p->span.z[0] ){
1124 /* Use the original text of the column expression as its name */
1125 zName = sqlite3MPrintf(db, "%T", &p->span);
1126 }else{
1127 /* If all else fails, make up a name */
1128 zName = sqlite3MPrintf(db, "column%d", i+1);
1129 }
1130 if( !zName || db->mallocFailed ){
1131 db->mallocFailed = 1;
1132 sqlite3_free(zName);
1133 sqlite3DeleteTable(pTab);
1134 return 0;
1135 }
1136 sqlite3Dequote(zName);
1137
1138 /* Make sure the column name is unique. If the name is not unique,
1139 ** append a integer to the name so that it becomes unique.
1140 */
1141 nName = strlen(zName);
1142 for(j=cnt=0; j<i; j++){
1143 if( sqlite3StrICmp(aCol[j].zName, zName)==0 ){
1144 zName[nName] = 0;
1145 zName = sqlite3MPrintf(db, "%z:%d", zName, ++cnt);
1146 j = -1;
1147 if( zName==0 ) break;
1148 }
1149 }
1150 pCol->zName = zName;
1151
1152 /* Get the typename, type affinity, and collating sequence for the
1153 ** column.
1154 */
1155 memset(&sNC, 0, sizeof(sNC));
1156 sNC.pSrcList = pSelect->pSrc;
1157 zType = sqlite3DbStrDup(db, columnType(&sNC, p, 0, 0, 0));
1158 pCol->zType = zType;
1159 pCol->affinity = sqlite3ExprAffinity(p);
1160 pColl = sqlite3ExprCollSeq(pParse, p);
1161 if( pColl ){
1162 pCol->zColl = sqlite3DbStrDup(db, pColl->zName);
1163 }
1164 }
1165 pTab->iPKey = -1;
1166 return pTab;
1167}
1168
1169/*
1170** Prepare a SELECT statement for processing by doing the following
1171** things:
1172**
1173** (1) Make sure VDBE cursor numbers have been assigned to every
1174** element of the FROM clause.
1175**
1176** (2) Fill in the pTabList->a[].pTab fields in the SrcList that
1177** defines FROM clause. When views appear in the FROM clause,
1178** fill pTabList->a[].pSelect with a copy of the SELECT statement
1179** that implements the view. A copy is made of the view's SELECT
1180** statement so that we can freely modify or delete that statement
1181** without worrying about messing up the presistent representation
1182** of the view.
1183**
1184** (3) Add terms to the WHERE clause to accomodate the NATURAL keyword
1185** on joins and the ON and USING clause of joins.
1186**
1187** (4) Scan the list of columns in the result set (pEList) looking
1188** for instances of the "*" operator or the TABLE.* operator.
1189** If found, expand each "*" to be every column in every table
1190** and TABLE.* to be every column in TABLE.
1191**
1192** Return 0 on success. If there are problems, leave an error message
1193** in pParse and return non-zero.
1194*/
1195static int prepSelectStmt(Parse *pParse, Select *p){
1196 int i, j, k, rc;
1197 SrcList *pTabList;
1198 ExprList *pEList;
1199 struct SrcList_item *pFrom;
1200 sqlite3 *db = pParse->db;
1201
1202 if( p==0 || p->pSrc==0 || db->mallocFailed ){
1203 return 1;
1204 }
1205 pTabList = p->pSrc;
1206 pEList = p->pEList;
1207
1208 /* Make sure cursor numbers have been assigned to all entries in
1209 ** the FROM clause of the SELECT statement.
1210 */
1211 sqlite3SrcListAssignCursors(pParse, p->pSrc);
1212
1213 /* Look up every table named in the FROM clause of the select. If
1214 ** an entry of the FROM clause is a subquery instead of a table or view,
1215 ** then create a transient table structure to describe the subquery.
1216 */
1217 for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
1218 Table *pTab;
1219 if( pFrom->pTab!=0 ){
1220 /* This statement has already been prepared. There is no need
1221 ** to go further. */
1222 assert( i==0 );
1223 return 0;
1224 }
1225 if( pFrom->zName==0 ){
1226#ifndef SQLITE_OMIT_SUBQUERY
1227 /* A sub-query in the FROM clause of a SELECT */
1228 assert( pFrom->pSelect!=0 );
1229 if( pFrom->zAlias==0 ){
1230 pFrom->zAlias =
1231 sqlite3MPrintf(db, "sqlite_subquery_%p_", (void*)pFrom->pSelect);
1232 }
1233 assert( pFrom->pTab==0 );
1234 pFrom->pTab = pTab =
1235 sqlite3ResultSetOfSelect(pParse, pFrom->zAlias, pFrom->pSelect);
1236 if( pTab==0 ){
1237 return 1;
1238 }
1239 /* The isEphem flag indicates that the Table structure has been
1240 ** dynamically allocated and may be freed at any time. In other words,
1241 ** pTab is not pointing to a persistent table structure that defines
1242 ** part of the schema. */
1243 pTab->isEphem = 1;
1244#endif
1245 }else{
1246 /* An ordinary table or view name in the FROM clause */
1247 assert( pFrom->pTab==0 );
1248 pFrom->pTab = pTab =
1249 sqlite3LocateTable(pParse,pFrom->zName,pFrom->zDatabase);
1250 if( pTab==0 ){
1251 return 1;
1252 }
1253 pTab->nRef++;
1254#if !defined(SQLITE_OMIT_VIEW) || !defined (SQLITE_OMIT_VIRTUALTABLE)
1255 if( pTab->pSelect || IsVirtual(pTab) ){
1256 /* We reach here if the named table is a really a view */
1257 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
1258 return 1;
1259 }
1260 /* If pFrom->pSelect!=0 it means we are dealing with a
1261 ** view within a view. The SELECT structure has already been
1262 ** copied by the outer view so we can skip the copy step here
1263 ** in the inner view.
1264 */
1265 if( pFrom->pSelect==0 ){
1266 pFrom->pSelect = sqlite3SelectDup(db, pTab->pSelect);
1267 }
1268 }
1269#endif
1270 }
1271 }
1272
1273 /* Process NATURAL keywords, and ON and USING clauses of joins.
1274 */
1275 if( sqliteProcessJoin(pParse, p) ) return 1;
1276
1277 /* For every "*" that occurs in the column list, insert the names of
1278 ** all columns in all tables. And for every TABLE.* insert the names
1279 ** of all columns in TABLE. The parser inserted a special expression
1280 ** with the TK_ALL operator for each "*" that it found in the column list.
1281 ** The following code just has to locate the TK_ALL expressions and expand
1282 ** each one to the list of all columns in all tables.
1283 **
1284 ** The first loop just checks to see if there are any "*" operators
1285 ** that need expanding.
1286 */
1287 for(k=0; k<pEList->nExpr; k++){
1288 Expr *pE = pEList->a[k].pExpr;
1289 if( pE->op==TK_ALL ) break;
1290 if( pE->op==TK_DOT && pE->pRight && pE->pRight->op==TK_ALL
1291 && pE->pLeft && pE->pLeft->op==TK_ID ) break;
1292 }
1293 rc = 0;
1294 if( k<pEList->nExpr ){
1295 /*
1296 ** If we get here it means the result set contains one or more "*"
1297 ** operators that need to be expanded. Loop through each expression
1298 ** in the result set and expand them one by one.
1299 */
1300 struct ExprList_item *a = pEList->a;
1301 ExprList *pNew = 0;
1302 int flags = pParse->db->flags;
1303 int longNames = (flags & SQLITE_FullColNames)!=0 &&
1304 (flags & SQLITE_ShortColNames)==0;
1305
1306 for(k=0; k<pEList->nExpr; k++){
1307 Expr *pE = a[k].pExpr;
1308 if( pE->op!=TK_ALL &&
1309 (pE->op!=TK_DOT || pE->pRight==0 || pE->pRight->op!=TK_ALL) ){
1310 /* This particular expression does not need to be expanded.
1311 */
1312 pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr, 0);
1313 if( pNew ){
1314 pNew->a[pNew->nExpr-1].zName = a[k].zName;
1315 }else{
1316 rc = 1;
1317 }
1318 a[k].pExpr = 0;
1319 a[k].zName = 0;
1320 }else{
1321 /* This expression is a "*" or a "TABLE.*" and needs to be
1322 ** expanded. */
1323 int tableSeen = 0; /* Set to 1 when TABLE matches */
1324 char *zTName; /* text of name of TABLE */
1325 if( pE->op==TK_DOT && pE->pLeft ){
1326 zTName = sqlite3NameFromToken(db, &pE->pLeft->token);
1327 }else{
1328 zTName = 0;
1329 }
1330 for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
1331 Table *pTab = pFrom->pTab;
1332 char *zTabName = pFrom->zAlias;
1333 if( zTabName==0 || zTabName[0]==0 ){
1334 zTabName = pTab->zName;
1335 }
1336 if( zTName && (zTabName==0 || zTabName[0]==0 ||
1337 sqlite3StrICmp(zTName, zTabName)!=0) ){
1338 continue;
1339 }
1340 tableSeen = 1;
1341 for(j=0; j<pTab->nCol; j++){
1342 Expr *pExpr, *pRight;
1343 char *zName = pTab->aCol[j].zName;
1344
1345 /* If a column is marked as 'hidden' (currently only possible
1346 ** for virtual tables), do not include it in the expanded
1347 ** result-set list.
1348 */
1349 if( IsHiddenColumn(&pTab->aCol[j]) ){
1350 assert(IsVirtual(pTab));
1351 continue;
1352 }
1353
1354 if( i>0 ){
1355 struct SrcList_item *pLeft = &pTabList->a[i-1];
1356 if( (pLeft[1].jointype & JT_NATURAL)!=0 &&
1357 columnIndex(pLeft->pTab, zName)>=0 ){
1358 /* In a NATURAL join, omit the join columns from the
1359 ** table on the right */
1360 continue;
1361 }
1362 if( sqlite3IdListIndex(pLeft[1].pUsing, zName)>=0 ){
1363 /* In a join with a USING clause, omit columns in the
1364 ** using clause from the table on the right. */
1365 continue;
1366 }
1367 }
1368 pRight = sqlite3PExpr(pParse, TK_ID, 0, 0, 0);
1369 if( pRight==0 ) break;
1370 setQuotedToken(pParse, &pRight->token, zName);
1371 if( zTabName && (longNames || pTabList->nSrc>1) ){
1372 Expr *pLeft = sqlite3PExpr(pParse, TK_ID, 0, 0, 0);
1373 pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight, 0);
1374 if( pExpr==0 ) break;
1375 setQuotedToken(pParse, &pLeft->token, zTabName);
1376 setToken(&pExpr->span,
1377 sqlite3MPrintf(db, "%s.%s", zTabName, zName));
1378 pExpr->span.dyn = 1;
1379 pExpr->token.z = 0;
1380 pExpr->token.n = 0;
1381 pExpr->token.dyn = 0;
1382 }else{
1383 pExpr = pRight;
1384 pExpr->span = pExpr->token;
1385 pExpr->span.dyn = 0;
1386 }
1387 if( longNames ){
1388 pNew = sqlite3ExprListAppend(pParse, pNew, pExpr, &pExpr->span);
1389 }else{
1390 pNew = sqlite3ExprListAppend(pParse, pNew, pExpr, &pRight->token);
1391 }
1392 }
1393 }
1394 if( !tableSeen ){
1395 if( zTName ){
1396 sqlite3ErrorMsg(pParse, "no such table: %s", zTName);
1397 }else{
1398 sqlite3ErrorMsg(pParse, "no tables specified");
1399 }
1400 rc = 1;
1401 }
1402 sqlite3_free(zTName);
1403 }
1404 }
1405 sqlite3ExprListDelete(pEList);
1406 p->pEList = pNew;
1407 }
1408 if( p->pEList && p->pEList->nExpr>SQLITE_MAX_COLUMN ){
1409 sqlite3ErrorMsg(pParse, "too many columns in result set");
1410 rc = SQLITE_ERROR;
1411 }
1412 if( db->mallocFailed ){
1413 rc = SQLITE_NOMEM;
1414 }
1415 return rc;
1416}
1417
1418#ifndef SQLITE_OMIT_COMPOUND_SELECT
1419/*
1420** This routine associates entries in an ORDER BY expression list with
1421** columns in a result. For each ORDER BY expression, the opcode of
1422** the top-level node is changed to TK_COLUMN and the iColumn value of
1423** the top-level node is filled in with column number and the iTable
1424** value of the top-level node is filled with iTable parameter.
1425**
1426** If there are prior SELECT clauses, they are processed first. A match
1427** in an earlier SELECT takes precedence over a later SELECT.
1428**
1429** Any entry that does not match is flagged as an error. The number
1430** of errors is returned.
1431*/
1432static int matchOrderbyToColumn(
1433 Parse *pParse, /* A place to leave error messages */
1434 Select *pSelect, /* Match to result columns of this SELECT */
1435 ExprList *pOrderBy, /* The ORDER BY values to match against columns */
1436 int iTable, /* Insert this value in iTable */
1437 int mustComplete /* If TRUE all ORDER BYs must match */
1438){
1439 int nErr = 0;
1440 int i, j;
1441 ExprList *pEList;
1442 sqlite3 *db = pParse->db;
1443
1444 if( pSelect==0 || pOrderBy==0 ) return 1;
1445 if( mustComplete ){
1446 for(i=0; i<pOrderBy->nExpr; i++){ pOrderBy->a[i].done = 0; }
1447 }
1448 if( prepSelectStmt(pParse, pSelect) ){
1449 return 1;
1450 }
1451 if( pSelect->pPrior ){
1452 if( matchOrderbyToColumn(pParse, pSelect->pPrior, pOrderBy, iTable, 0) ){
1453 return 1;
1454 }
1455 }
1456 pEList = pSelect->pEList;
1457 for(i=0; i<pOrderBy->nExpr; i++){
1458 struct ExprList_item *pItem;
1459 Expr *pE = pOrderBy->a[i].pExpr;
1460 int iCol = -1;
1461 char *zLabel;
1462
1463 if( pOrderBy->a[i].done ) continue;
1464 if( sqlite3ExprIsInteger(pE, &iCol) ){
1465 if( iCol<=0 || iCol>pEList->nExpr ){
1466 sqlite3ErrorMsg(pParse,
1467 "ORDER BY position %d should be between 1 and %d",
1468 iCol, pEList->nExpr);
1469 nErr++;
1470 break;
1471 }
1472 if( !mustComplete ) continue;
1473 iCol--;
1474 }
1475 if( iCol<0 && (zLabel = sqlite3NameFromToken(db, &pE->token))!=0 ){
1476 for(j=0, pItem=pEList->a; j<pEList->nExpr; j++, pItem++){
1477 char *zName;
1478 int isMatch;
1479 if( pItem->zName ){
1480 zName = sqlite3DbStrDup(db, pItem->zName);
1481 }else{
1482 zName = sqlite3NameFromToken(db, &pItem->pExpr->token);
1483 }
1484 isMatch = zName && sqlite3StrICmp(zName, zLabel)==0;
1485 sqlite3_free(zName);
1486 if( isMatch ){
1487 iCol = j;
1488 break;
1489 }
1490 }
1491 sqlite3_free(zLabel);
1492 }
1493 if( iCol>=0 ){
1494 pE->op = TK_COLUMN;
1495 pE->iColumn = iCol;
1496 pE->iTable = iTable;
1497 pE->iAgg = -1;
1498 pOrderBy->a[i].done = 1;
1499 }else if( mustComplete ){
1500 sqlite3ErrorMsg(pParse,
1501 "ORDER BY term number %d does not match any result column", i+1);
1502 nErr++;
1503 break;
1504 }
1505 }
1506 return nErr;
1507}
1508#endif /* #ifndef SQLITE_OMIT_COMPOUND_SELECT */
1509
1510/*
1511** Get a VDBE for the given parser context. Create a new one if necessary.
1512** If an error occurs, return NULL and leave a message in pParse.
1513*/
1514Vdbe *sqlite3GetVdbe(Parse *pParse){
1515 Vdbe *v = pParse->pVdbe;
1516 if( v==0 ){
1517 v = pParse->pVdbe = sqlite3VdbeCreate(pParse->db);
1518 }
1519 return v;
1520}
1521
1522
1523/*
1524** Compute the iLimit and iOffset fields of the SELECT based on the
1525** pLimit and pOffset expressions. pLimit and pOffset hold the expressions
1526** that appear in the original SQL statement after the LIMIT and OFFSET
1527** keywords. Or NULL if those keywords are omitted. iLimit and iOffset
1528** are the integer memory register numbers for counters used to compute
1529** the limit and offset. If there is no limit and/or offset, then
1530** iLimit and iOffset are negative.
1531**
1532** This routine changes the values of iLimit and iOffset only if
1533** a limit or offset is defined by pLimit and pOffset. iLimit and
1534** iOffset should have been preset to appropriate default values
1535** (usually but not always -1) prior to calling this routine.
1536** Only if pLimit!=0 or pOffset!=0 do the limit registers get
1537** redefined. The UNION ALL operator uses this property to force
1538** the reuse of the same limit and offset registers across multiple
1539** SELECT statements.
1540*/
1541static void computeLimitRegisters(Parse *pParse, Select *p, int iBreak){
1542 Vdbe *v = 0;
1543 int iLimit = 0;
1544 int iOffset;
1545 int addr1, addr2;
1546
1547 /*
1548 ** "LIMIT -1" always shows all rows. There is some
1549 ** contraversy about what the correct behavior should be.
1550 ** The current implementation interprets "LIMIT 0" to mean
1551 ** no rows.
1552 */
1553 if( p->pLimit ){
1554 p->iLimit = iLimit = pParse->nMem;
1555 pParse->nMem += 2;
1556 v = sqlite3GetVdbe(pParse);
1557 if( v==0 ) return;
1558 sqlite3ExprCode(pParse, p->pLimit);
1559 sqlite3VdbeAddOp(v, OP_MustBeInt, 0, 0);
1560 sqlite3VdbeAddOp(v, OP_MemStore, iLimit, 1);
1561 VdbeComment((v, "# LIMIT counter"));
1562 sqlite3VdbeAddOp(v, OP_IfMemZero, iLimit, iBreak);
1563 sqlite3VdbeAddOp(v, OP_MemLoad, iLimit, 0);
1564 }
1565 if( p->pOffset ){
1566 p->iOffset = iOffset = pParse->nMem++;
1567 v = sqlite3GetVdbe(pParse);
1568 if( v==0 ) return;
1569 sqlite3ExprCode(pParse, p->pOffset);
1570 sqlite3VdbeAddOp(v, OP_MustBeInt, 0, 0);
1571 sqlite3VdbeAddOp(v, OP_MemStore, iOffset, p->pLimit==0);
1572 VdbeComment((v, "# OFFSET counter"));
1573 addr1 = sqlite3VdbeAddOp(v, OP_IfMemPos, iOffset, 0);
1574 sqlite3VdbeAddOp(v, OP_Pop, 1, 0);
1575 sqlite3VdbeAddOp(v, OP_Integer, 0, 0);
1576 sqlite3VdbeJumpHere(v, addr1);
1577 if( p->pLimit ){
1578 sqlite3VdbeAddOp(v, OP_Add, 0, 0);
1579 }
1580 }
1581 if( p->pLimit ){
1582 addr1 = sqlite3VdbeAddOp(v, OP_IfMemPos, iLimit, 0);
1583 sqlite3VdbeAddOp(v, OP_Pop, 1, 0);
1584 sqlite3VdbeAddOp(v, OP_MemInt, -1, iLimit+1);
1585 addr2 = sqlite3VdbeAddOp(v, OP_Goto, 0, 0);
1586 sqlite3VdbeJumpHere(v, addr1);
1587 sqlite3VdbeAddOp(v, OP_MemStore, iLimit+1, 1);
1588 VdbeComment((v, "# LIMIT+OFFSET"));
1589 sqlite3VdbeJumpHere(v, addr2);
1590 }
1591}
1592
1593/*
1594** Allocate a virtual index to use for sorting.
1595*/
1596static void createSortingIndex(Parse *pParse, Select *p, ExprList *pOrderBy){
1597 if( pOrderBy ){
1598 int addr;
1599 assert( pOrderBy->iECursor==0 );
1600 pOrderBy->iECursor = pParse->nTab++;
1601 addr = sqlite3VdbeAddOp(pParse->pVdbe, OP_OpenEphemeral,
1602 pOrderBy->iECursor, pOrderBy->nExpr+1);
1603 assert( p->addrOpenEphm[2] == -1 );
1604 p->addrOpenEphm[2] = addr;
1605 }
1606}
1607
1608#ifndef SQLITE_OMIT_COMPOUND_SELECT
1609/*
1610** Return the appropriate collating sequence for the iCol-th column of
1611** the result set for the compound-select statement "p". Return NULL if
1612** the column has no default collating sequence.
1613**
1614** The collating sequence for the compound select is taken from the
1615** left-most term of the select that has a collating sequence.
1616*/
1617static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){
1618 CollSeq *pRet;
1619 if( p->pPrior ){
1620 pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
1621 }else{
1622 pRet = 0;
1623 }
1624 if( pRet==0 ){
1625 pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
1626 }
1627 return pRet;
1628}
1629#endif /* SQLITE_OMIT_COMPOUND_SELECT */
1630
1631#ifndef SQLITE_OMIT_COMPOUND_SELECT
1632/*
1633** This routine is called to process a query that is really the union
1634** or intersection of two or more separate queries.
1635**
1636** "p" points to the right-most of the two queries. the query on the
1637** left is p->pPrior. The left query could also be a compound query
1638** in which case this routine will be called recursively.
1639**
1640** The results of the total query are to be written into a destination
1641** of type eDest with parameter iParm.
1642**
1643** Example 1: Consider a three-way compound SQL statement.
1644**
1645** SELECT a FROM t1 UNION SELECT b FROM t2 UNION SELECT c FROM t3
1646**
1647** This statement is parsed up as follows:
1648**
1649** SELECT c FROM t3
1650** |
1651** `-----> SELECT b FROM t2
1652** |
1653** `------> SELECT a FROM t1
1654**
1655** The arrows in the diagram above represent the Select.pPrior pointer.
1656** So if this routine is called with p equal to the t3 query, then
1657** pPrior will be the t2 query. p->op will be TK_UNION in this case.
1658**
1659** Notice that because of the way SQLite parses compound SELECTs, the
1660** individual selects always group from left to right.
1661*/
1662static int multiSelect(
1663 Parse *pParse, /* Parsing context */
1664 Select *p, /* The right-most of SELECTs to be coded */
1665 int eDest, /* \___ Store query results as specified */
1666 int iParm, /* / by these two parameters. */
1667 char *aff /* If eDest is SRT_Union, the affinity string */
1668){
1669 int rc = SQLITE_OK; /* Success code from a subroutine */
1670 Select *pPrior; /* Another SELECT immediately to our left */
1671 Vdbe *v; /* Generate code to this VDBE */
1672 int nCol; /* Number of columns in the result set */
1673 ExprList *pOrderBy; /* The ORDER BY clause on p */
1674 int aSetP2[2]; /* Set P2 value of these op to number of columns */
1675 int nSetP2 = 0; /* Number of slots in aSetP2[] used */
1676
1677 /* Make sure there is no ORDER BY or LIMIT clause on prior SELECTs. Only
1678 ** the last (right-most) SELECT in the series may have an ORDER BY or LIMIT.
1679 */
1680 if( p==0 || p->pPrior==0 ){
1681 rc = 1;
1682 goto multi_select_end;
1683 }
1684 pPrior = p->pPrior;
1685 assert( pPrior->pRightmost!=pPrior );
1686 assert( pPrior->pRightmost==p->pRightmost );
1687 if( pPrior->pOrderBy ){
1688 sqlite3ErrorMsg(pParse,"ORDER BY clause should come after %s not before",
1689 selectOpName(p->op));
1690 rc = 1;
1691 goto multi_select_end;
1692 }
1693 if( pPrior->pLimit ){
1694 sqlite3ErrorMsg(pParse,"LIMIT clause should come after %s not before",
1695 selectOpName(p->op));
1696 rc = 1;
1697 goto multi_select_end;
1698 }
1699
1700 /* Make sure we have a valid query engine. If not, create a new one.
1701 */
1702 v = sqlite3GetVdbe(pParse);
1703 if( v==0 ){
1704 rc = 1;
1705 goto multi_select_end;
1706 }
1707
1708 /* Create the destination temporary table if necessary
1709 */
1710 if( eDest==SRT_EphemTab ){
1711 assert( p->pEList );
1712 assert( nSetP2<sizeof(aSetP2)/sizeof(aSetP2[0]) );
1713 aSetP2[nSetP2++] = sqlite3VdbeAddOp(v, OP_OpenEphemeral, iParm, 0);
1714 eDest = SRT_Table;
1715 }
1716
1717 /* Generate code for the left and right SELECT statements.
1718 */
1719 pOrderBy = p->pOrderBy;
1720 switch( p->op ){
1721 case TK_ALL: {
1722 if( pOrderBy==0 ){
1723 int addr = 0;
1724 assert( !pPrior->pLimit );
1725 pPrior->pLimit = p->pLimit;
1726 pPrior->pOffset = p->pOffset;
1727 rc = sqlite3Select(pParse, pPrior, eDest, iParm, 0, 0, 0, aff);
1728 p->pLimit = 0;
1729 p->pOffset = 0;
1730 if( rc ){
1731 goto multi_select_end;
1732 }
1733 p->pPrior = 0;
1734 p->iLimit = pPrior->iLimit;
1735 p->iOffset = pPrior->iOffset;
1736 if( p->iLimit>=0 ){
1737 addr = sqlite3VdbeAddOp(v, OP_IfMemZero, p->iLimit, 0);
1738 VdbeComment((v, "# Jump ahead if LIMIT reached"));
1739 }
1740 rc = sqlite3Select(pParse, p, eDest, iParm, 0, 0, 0, aff);
1741 p->pPrior = pPrior;
1742 if( rc ){
1743 goto multi_select_end;
1744 }
1745 if( addr ){
1746 sqlite3VdbeJumpHere(v, addr);
1747 }
1748 break;
1749 }
1750 /* For UNION ALL ... ORDER BY fall through to the next case */
1751 }
1752 case TK_EXCEPT:
1753 case TK_UNION: {
1754 int unionTab; /* Cursor number of the temporary table holding result */
1755 int op = 0; /* One of the SRT_ operations to apply to self */
1756 int priorOp; /* The SRT_ operation to apply to prior selects */
1757 Expr *pLimit, *pOffset; /* Saved values of p->nLimit and p->nOffset */
1758 int addr;
1759
1760 priorOp = p->op==TK_ALL ? SRT_Table : SRT_Union;
1761 if( eDest==priorOp && pOrderBy==0 && !p->pLimit && !p->pOffset ){
1762 /* We can reuse a temporary table generated by a SELECT to our
1763 ** right.
1764 */
1765 unionTab = iParm;
1766 }else{
1767 /* We will need to create our own temporary table to hold the
1768 ** intermediate results.
1769 */
1770 unionTab = pParse->nTab++;
1771 if( pOrderBy && matchOrderbyToColumn(pParse, p, pOrderBy, unionTab,1) ){
1772 rc = 1;
1773 goto multi_select_end;
1774 }
1775 addr = sqlite3VdbeAddOp(v, OP_OpenEphemeral, unionTab, 0);
1776 if( priorOp==SRT_Table ){
1777 assert( nSetP2<sizeof(aSetP2)/sizeof(aSetP2[0]) );
1778 aSetP2[nSetP2++] = addr;
1779 }else{
1780 assert( p->addrOpenEphm[0] == -1 );
1781 p->addrOpenEphm[0] = addr;
1782 p->pRightmost->usesEphm = 1;
1783 }
1784 createSortingIndex(pParse, p, pOrderBy);
1785 assert( p->pEList );
1786 }
1787
1788 /* Code the SELECT statements to our left
1789 */
1790 assert( !pPrior->pOrderBy );
1791 rc = sqlite3Select(pParse, pPrior, priorOp, unionTab, 0, 0, 0, aff);
1792 if( rc ){
1793 goto multi_select_end;
1794 }
1795
1796 /* Code the current SELECT statement
1797 */
1798 switch( p->op ){
1799 case TK_EXCEPT: op = SRT_Except; break;
1800 case TK_UNION: op = SRT_Union; break;
1801 case TK_ALL: op = SRT_Table; break;
1802 }
1803 p->pPrior = 0;
1804 p->pOrderBy = 0;
1805 p->disallowOrderBy = pOrderBy!=0;
1806 pLimit = p->pLimit;
1807 p->pLimit = 0;
1808 pOffset = p->pOffset;
1809 p->pOffset = 0;
1810 rc = sqlite3Select(pParse, p, op, unionTab, 0, 0, 0, aff);
1811 /* Query flattening in sqlite3Select() might refill p->pOrderBy.
1812 ** Be sure to delete p->pOrderBy, therefore, to avoid a memory leak. */
1813 sqlite3ExprListDelete(p->pOrderBy);
1814 p->pPrior = pPrior;
1815 p->pOrderBy = pOrderBy;
1816 sqlite3ExprDelete(p->pLimit);
1817 p->pLimit = pLimit;
1818 p->pOffset = pOffset;
1819 p->iLimit = -1;
1820 p->iOffset = -1;
1821 if( rc ){
1822 goto multi_select_end;
1823 }
1824
1825
1826 /* Convert the data in the temporary table into whatever form
1827 ** it is that we currently need.
1828 */
1829 if( eDest!=priorOp || unionTab!=iParm ){
1830 int iCont, iBreak, iStart;
1831 assert( p->pEList );
1832 if( eDest==SRT_Callback ){
1833 Select *pFirst = p;
1834 while( pFirst->pPrior ) pFirst = pFirst->pPrior;
1835 generateColumnNames(pParse, 0, pFirst->pEList);
1836 }
1837 iBreak = sqlite3VdbeMakeLabel(v);
1838 iCont = sqlite3VdbeMakeLabel(v);
1839 computeLimitRegisters(pParse, p, iBreak);
1840 sqlite3VdbeAddOp(v, OP_Rewind, unionTab, iBreak);
1841 iStart = sqlite3VdbeCurrentAddr(v);
1842 rc = selectInnerLoop(pParse, p, p->pEList, unionTab, p->pEList->nExpr,
1843 pOrderBy, -1, eDest, iParm,
1844 iCont, iBreak, 0);
1845 if( rc ){
1846 rc = 1;
1847 goto multi_select_end;
1848 }
1849 sqlite3VdbeResolveLabel(v, iCont);
1850 sqlite3VdbeAddOp(v, OP_Next, unionTab, iStart);
1851 sqlite3VdbeResolveLabel(v, iBreak);
1852 sqlite3VdbeAddOp(v, OP_Close, unionTab, 0);
1853 }
1854 break;
1855 }
1856 case TK_INTERSECT: {
1857 int tab1, tab2;
1858 int iCont, iBreak, iStart;
1859 Expr *pLimit, *pOffset;
1860 int addr;
1861
1862 /* INTERSECT is different from the others since it requires
1863 ** two temporary tables. Hence it has its own case. Begin
1864 ** by allocating the tables we will need.
1865 */
1866 tab1 = pParse->nTab++;
1867 tab2 = pParse->nTab++;
1868 if( pOrderBy && matchOrderbyToColumn(pParse,p,pOrderBy,tab1,1) ){
1869 rc = 1;
1870 goto multi_select_end;
1871 }
1872 createSortingIndex(pParse, p, pOrderBy);
1873
1874 addr = sqlite3VdbeAddOp(v, OP_OpenEphemeral, tab1, 0);
1875 assert( p->addrOpenEphm[0] == -1 );
1876 p->addrOpenEphm[0] = addr;
1877 p->pRightmost->usesEphm = 1;
1878 assert( p->pEList );
1879
1880 /* Code the SELECTs to our left into temporary table "tab1".
1881 */
1882 rc = sqlite3Select(pParse, pPrior, SRT_Union, tab1, 0, 0, 0, aff);
1883 if( rc ){
1884 goto multi_select_end;
1885 }
1886
1887 /* Code the current SELECT into temporary table "tab2"
1888 */
1889 addr = sqlite3VdbeAddOp(v, OP_OpenEphemeral, tab2, 0);
1890 assert( p->addrOpenEphm[1] == -1 );
1891 p->addrOpenEphm[1] = addr;
1892 p->pPrior = 0;
1893 pLimit = p->pLimit;
1894 p->pLimit = 0;
1895 pOffset = p->pOffset;
1896 p->pOffset = 0;
1897 rc = sqlite3Select(pParse, p, SRT_Union, tab2, 0, 0, 0, aff);
1898 p->pPrior = pPrior;
1899 sqlite3ExprDelete(p->pLimit);
1900 p->pLimit = pLimit;
1901 p->pOffset = pOffset;
1902 if( rc ){
1903 goto multi_select_end;
1904 }
1905
1906 /* Generate code to take the intersection of the two temporary
1907 ** tables.
1908 */
1909 assert( p->pEList );
1910 if( eDest==SRT_Callback ){
1911 Select *pFirst = p;
1912 while( pFirst->pPrior ) pFirst = pFirst->pPrior;
1913 generateColumnNames(pParse, 0, pFirst->pEList);
1914 }
1915 iBreak = sqlite3VdbeMakeLabel(v);
1916 iCont = sqlite3VdbeMakeLabel(v);
1917 computeLimitRegisters(pParse, p, iBreak);
1918 sqlite3VdbeAddOp(v, OP_Rewind, tab1, iBreak);
1919 iStart = sqlite3VdbeAddOp(v, OP_RowKey, tab1, 0);
1920 sqlite3VdbeAddOp(v, OP_NotFound, tab2, iCont);
1921 rc = selectInnerLoop(pParse, p, p->pEList, tab1, p->pEList->nExpr,
1922 pOrderBy, -1, eDest, iParm,
1923 iCont, iBreak, 0);
1924 if( rc ){
1925 rc = 1;
1926 goto multi_select_end;
1927 }
1928 sqlite3VdbeResolveLabel(v, iCont);
1929 sqlite3VdbeAddOp(v, OP_Next, tab1, iStart);
1930 sqlite3VdbeResolveLabel(v, iBreak);
1931 sqlite3VdbeAddOp(v, OP_Close, tab2, 0);
1932 sqlite3VdbeAddOp(v, OP_Close, tab1, 0);
1933 break;
1934 }
1935 }
1936
1937 /* Make sure all SELECTs in the statement have the same number of elements
1938 ** in their result sets.
1939 */
1940 assert( p->pEList && pPrior->pEList );
1941 if( p->pEList->nExpr!=pPrior->pEList->nExpr ){
1942 sqlite3ErrorMsg(pParse, "SELECTs to the left and right of %s"
1943 " do not have the same number of result columns", selectOpName(p->op));
1944 rc = 1;
1945 goto multi_select_end;
1946 }
1947
1948 /* Set the number of columns in temporary tables
1949 */
1950 nCol = p->pEList->nExpr;
1951 while( nSetP2 ){
1952 sqlite3VdbeChangeP2(v, aSetP2[--nSetP2], nCol);
1953 }
1954
1955 /* Compute collating sequences used by either the ORDER BY clause or
1956 ** by any temporary tables needed to implement the compound select.
1957 ** Attach the KeyInfo structure to all temporary tables. Invoke the
1958 ** ORDER BY processing if there is an ORDER BY clause.
1959 **
1960 ** This section is run by the right-most SELECT statement only.
1961 ** SELECT statements to the left always skip this part. The right-most
1962 ** SELECT might also skip this part if it has no ORDER BY clause and
1963 ** no temp tables are required.
1964 */
1965 if( pOrderBy || p->usesEphm ){
1966 int i; /* Loop counter */
1967 KeyInfo *pKeyInfo; /* Collating sequence for the result set */
1968 Select *pLoop; /* For looping through SELECT statements */
1969 int nKeyCol; /* Number of entries in pKeyInfo->aCol[] */
1970 CollSeq **apColl; /* For looping through pKeyInfo->aColl[] */
1971 CollSeq **aCopy; /* A copy of pKeyInfo->aColl[] */
1972
1973 assert( p->pRightmost==p );
1974 nKeyCol = nCol + (pOrderBy ? pOrderBy->nExpr : 0);
1975 pKeyInfo = sqlite3DbMallocZero(pParse->db,
1976 sizeof(*pKeyInfo)+nKeyCol*(sizeof(CollSeq*) + 1));
1977 if( !pKeyInfo ){
1978 rc = SQLITE_NOMEM;
1979 goto multi_select_end;
1980 }
1981
1982 pKeyInfo->enc = ENC(pParse->db);
1983 pKeyInfo->nField = nCol;
1984
1985 for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
1986 *apColl = multiSelectCollSeq(pParse, p, i);
1987 if( 0==*apColl ){
1988 *apColl = pParse->db->pDfltColl;
1989 }
1990 }
1991
1992 for(pLoop=p; pLoop; pLoop=pLoop->pPrior){
1993 for(i=0; i<2; i++){
1994 int addr = pLoop->addrOpenEphm[i];
1995 if( addr<0 ){
1996 /* If [0] is unused then [1] is also unused. So we can
1997 ** always safely abort as soon as the first unused slot is found */
1998 assert( pLoop->addrOpenEphm[1]<0 );
1999 break;
2000 }
2001 sqlite3VdbeChangeP2(v, addr, nCol);
2002 sqlite3VdbeChangeP3(v, addr, (char*)pKeyInfo, P3_KEYINFO);
2003 pLoop->addrOpenEphm[i] = -1;
2004 }
2005 }
2006
2007 if( pOrderBy ){
2008 struct ExprList_item *pOTerm = pOrderBy->a;
2009 int nOrderByExpr = pOrderBy->nExpr;
2010 int addr;
2011 u8 *pSortOrder;
2012
2013 /* Reuse the same pKeyInfo for the ORDER BY as was used above for
2014 ** the compound select statements. Except we have to change out the
2015 ** pKeyInfo->aColl[] values. Some of the aColl[] values will be
2016 ** reused when constructing the pKeyInfo for the ORDER BY, so make
2017 ** a copy. Sufficient space to hold both the nCol entries for
2018 ** the compound select and the nOrderbyExpr entries for the ORDER BY
2019 ** was allocated above. But we need to move the compound select
2020 ** entries out of the way before constructing the ORDER BY entries.
2021 ** Move the compound select entries into aCopy[] where they can be
2022 ** accessed and reused when constructing the ORDER BY entries.
2023 ** Because nCol might be greater than or less than nOrderByExpr
2024 ** we have to use memmove() when doing the copy.
2025 */
2026 aCopy = &pKeyInfo->aColl[nOrderByExpr];
2027 pSortOrder = pKeyInfo->aSortOrder = (u8*)&aCopy[nCol];
2028 memmove(aCopy, pKeyInfo->aColl, nCol*sizeof(CollSeq*));
2029
2030 apColl = pKeyInfo->aColl;
2031 for(i=0; i<nOrderByExpr; i++, pOTerm++, apColl++, pSortOrder++){
2032 Expr *pExpr = pOTerm->pExpr;
2033 if( (pExpr->flags & EP_ExpCollate) ){
2034 assert( pExpr->pColl!=0 );
2035 *apColl = pExpr->pColl;
2036 }else{
2037 *apColl = aCopy[pExpr->iColumn];
2038 }
2039 *pSortOrder = pOTerm->sortOrder;
2040 }
2041 assert( p->pRightmost==p );
2042 assert( p->addrOpenEphm[2]>=0 );
2043 addr = p->addrOpenEphm[2];
2044 sqlite3VdbeChangeP2(v, addr, p->pOrderBy->nExpr+2);
2045 pKeyInfo->nField = nOrderByExpr;
2046 sqlite3VdbeChangeP3(v, addr, (char*)pKeyInfo, P3_KEYINFO_HANDOFF);
2047 pKeyInfo = 0;
2048 generateSortTail(pParse, p, v, p->pEList->nExpr, eDest, iParm);
2049 }
2050
2051 sqlite3_free(pKeyInfo);
2052 }
2053
2054multi_select_end:
2055 return rc;
2056}
2057#endif /* SQLITE_OMIT_COMPOUND_SELECT */
2058
2059#ifndef SQLITE_OMIT_VIEW
2060/* Forward Declarations */
2061static void substExprList(sqlite3*, ExprList*, int, ExprList*);
2062static void substSelect(sqlite3*, Select *, int, ExprList *);
2063
2064/*
2065** Scan through the expression pExpr. Replace every reference to
2066** a column in table number iTable with a copy of the iColumn-th
2067** entry in pEList. (But leave references to the ROWID column
2068** unchanged.)
2069**
2070** This routine is part of the flattening procedure. A subquery
2071** whose result set is defined by pEList appears as entry in the
2072** FROM clause of a SELECT such that the VDBE cursor assigned to that
2073** FORM clause entry is iTable. This routine make the necessary
2074** changes to pExpr so that it refers directly to the source table
2075** of the subquery rather the result set of the subquery.
2076*/
2077static void substExpr(
2078 sqlite3 *db, /* Report malloc errors to this connection */
2079 Expr *pExpr, /* Expr in which substitution occurs */
2080 int iTable, /* Table to be substituted */
2081 ExprList *pEList /* Substitute expressions */
2082){
2083 if( pExpr==0 ) return;
2084 if( pExpr->op==TK_COLUMN && pExpr->iTable==iTable ){
2085 if( pExpr->iColumn<0 ){
2086 pExpr->op = TK_NULL;
2087 }else{
2088 Expr *pNew;
2089 assert( pEList!=0 && pExpr->iColumn<pEList->nExpr );
2090 assert( pExpr->pLeft==0 && pExpr->pRight==0 && pExpr->pList==0 );
2091 pNew = pEList->a[pExpr->iColumn].pExpr;
2092 assert( pNew!=0 );
2093 pExpr->op = pNew->op;
2094 assert( pExpr->pLeft==0 );
2095 pExpr->pLeft = sqlite3ExprDup(db, pNew->pLeft);
2096 assert( pExpr->pRight==0 );
2097 pExpr->pRight = sqlite3ExprDup(db, pNew->pRight);
2098 assert( pExpr->pList==0 );
2099 pExpr->pList = sqlite3ExprListDup(db, pNew->pList);
2100 pExpr->iTable = pNew->iTable;
2101 pExpr->pTab = pNew->pTab;
2102 pExpr->iColumn = pNew->iColumn;
2103 pExpr->iAgg = pNew->iAgg;
2104 sqlite3TokenCopy(db, &pExpr->token, &pNew->token);
2105 sqlite3TokenCopy(db, &pExpr->span, &pNew->span);
2106 pExpr->pSelect = sqlite3SelectDup(db, pNew->pSelect);
2107 pExpr->flags = pNew->flags;
2108 }
2109 }else{
2110 substExpr(db, pExpr->pLeft, iTable, pEList);
2111 substExpr(db, pExpr->pRight, iTable, pEList);
2112 substSelect(db, pExpr->pSelect, iTable, pEList);
2113 substExprList(db, pExpr->pList, iTable, pEList);
2114 }
2115}
2116static void substExprList(
2117 sqlite3 *db, /* Report malloc errors here */
2118 ExprList *pList, /* List to scan and in which to make substitutes */
2119 int iTable, /* Table to be substituted */
2120 ExprList *pEList /* Substitute values */
2121){
2122 int i;
2123 if( pList==0 ) return;
2124 for(i=0; i<pList->nExpr; i++){
2125 substExpr(db, pList->a[i].pExpr, iTable, pEList);
2126 }
2127}
2128static void substSelect(
2129 sqlite3 *db, /* Report malloc errors here */
2130 Select *p, /* SELECT statement in which to make substitutions */
2131 int iTable, /* Table to be replaced */
2132 ExprList *pEList /* Substitute values */
2133){
2134 if( !p ) return;
2135 substExprList(db, p->pEList, iTable, pEList);
2136 substExprList(db, p->pGroupBy, iTable, pEList);
2137 substExprList(db, p->pOrderBy, iTable, pEList);
2138 substExpr(db, p->pHaving, iTable, pEList);
2139 substExpr(db, p->pWhere, iTable, pEList);
2140 substSelect(db, p->pPrior, iTable, pEList);
2141}
2142#endif /* !defined(SQLITE_OMIT_VIEW) */
2143
2144#ifndef SQLITE_OMIT_VIEW
2145/*
2146** This routine attempts to flatten subqueries in order to speed
2147** execution. It returns 1 if it makes changes and 0 if no flattening
2148** occurs.
2149**
2150** To understand the concept of flattening, consider the following
2151** query:
2152**
2153** SELECT a FROM (SELECT x+y AS a FROM t1 WHERE z<100) WHERE a>5
2154**
2155** The default way of implementing this query is to execute the
2156** subquery first and store the results in a temporary table, then
2157** run the outer query on that temporary table. This requires two
2158** passes over the data. Furthermore, because the temporary table
2159** has no indices, the WHERE clause on the outer query cannot be
2160** optimized.
2161**
2162** This routine attempts to rewrite queries such as the above into
2163** a single flat select, like this:
2164**
2165** SELECT x+y AS a FROM t1 WHERE z<100 AND a>5
2166**
2167** The code generated for this simpification gives the same result
2168** but only has to scan the data once. And because indices might
2169** exist on the table t1, a complete scan of the data might be
2170** avoided.
2171**
2172** Flattening is only attempted if all of the following are true:
2173**
2174** (1) The subquery and the outer query do not both use aggregates.
2175**
2176** (2) The subquery is not an aggregate or the outer query is not a join.
2177**
2178** (3) The subquery is not the right operand of a left outer join, or
2179** the subquery is not itself a join. (Ticket #306)
2180**
2181** (4) The subquery is not DISTINCT or the outer query is not a join.
2182**
2183** (5) The subquery is not DISTINCT or the outer query does not use
2184** aggregates.
2185**
2186** (6) The subquery does not use aggregates or the outer query is not
2187** DISTINCT.
2188**
2189** (7) The subquery has a FROM clause.
2190**
2191** (8) The subquery does not use LIMIT or the outer query is not a join.
2192**
2193** (9) The subquery does not use LIMIT or the outer query does not use
2194** aggregates.
2195**
2196** (10) The subquery does not use aggregates or the outer query does not
2197** use LIMIT.
2198**
2199** (11) The subquery and the outer query do not both have ORDER BY clauses.
2200**
2201** (12) The subquery is not the right term of a LEFT OUTER JOIN or the
2202** subquery has no WHERE clause. (added by ticket #350)
2203**
2204** (13) The subquery and outer query do not both use LIMIT
2205**
2206** (14) The subquery does not use OFFSET
2207**
2208** (15) The outer query is not part of a compound select or the
2209** subquery does not have both an ORDER BY and a LIMIT clause.
2210** (See ticket #2339)
2211**
2212** In this routine, the "p" parameter is a pointer to the outer query.
2213** The subquery is p->pSrc->a[iFrom]. isAgg is true if the outer query
2214** uses aggregates and subqueryIsAgg is true if the subquery uses aggregates.
2215**
2216** If flattening is not attempted, this routine is a no-op and returns 0.
2217** If flattening is attempted this routine returns 1.
2218**
2219** All of the expression analysis must occur on both the outer query and
2220** the subquery before this routine runs.
2221*/
2222static int flattenSubquery(
2223 sqlite3 *db, /* Database connection */
2224 Select *p, /* The parent or outer SELECT statement */
2225 int iFrom, /* Index in p->pSrc->a[] of the inner subquery */
2226 int isAgg, /* True if outer SELECT uses aggregate functions */
2227 int subqueryIsAgg /* True if the subquery uses aggregate functions */
2228){
2229 Select *pSub; /* The inner query or "subquery" */
2230 SrcList *pSrc; /* The FROM clause of the outer query */
2231 SrcList *pSubSrc; /* The FROM clause of the subquery */
2232 ExprList *pList; /* The result set of the outer query */
2233 int iParent; /* VDBE cursor number of the pSub result set temp table */
2234 int i; /* Loop counter */
2235 Expr *pWhere; /* The WHERE clause */
2236 struct SrcList_item *pSubitem; /* The subquery */
2237
2238 /* Check to see if flattening is permitted. Return 0 if not.
2239 */
2240 if( p==0 ) return 0;
2241 pSrc = p->pSrc;
2242 assert( pSrc && iFrom>=0 && iFrom<pSrc->nSrc );
2243 pSubitem = &pSrc->a[iFrom];
2244 pSub = pSubitem->pSelect;
2245 assert( pSub!=0 );
2246 if( isAgg && subqueryIsAgg ) return 0; /* Restriction (1) */
2247 if( subqueryIsAgg && pSrc->nSrc>1 ) return 0; /* Restriction (2) */
2248 pSubSrc = pSub->pSrc;
2249 assert( pSubSrc );
2250 /* Prior to version 3.1.2, when LIMIT and OFFSET had to be simple constants,
2251 ** not arbitrary expresssions, we allowed some combining of LIMIT and OFFSET
2252 ** because they could be computed at compile-time. But when LIMIT and OFFSET
2253 ** became arbitrary expressions, we were forced to add restrictions (13)
2254 ** and (14). */
2255 if( pSub->pLimit && p->pLimit ) return 0; /* Restriction (13) */
2256 if( pSub->pOffset ) return 0; /* Restriction (14) */
2257 if( p->pRightmost && pSub->pLimit && pSub->pOrderBy ){
2258 return 0; /* Restriction (15) */
2259 }
2260 if( pSubSrc->nSrc==0 ) return 0; /* Restriction (7) */
2261 if( (pSub->isDistinct || pSub->pLimit)
2262 && (pSrc->nSrc>1 || isAgg) ){ /* Restrictions (4)(5)(8)(9) */
2263 return 0;
2264 }
2265 if( p->isDistinct && subqueryIsAgg ) return 0; /* Restriction (6) */
2266 if( (p->disallowOrderBy || p->pOrderBy) && pSub->pOrderBy ){
2267 return 0; /* Restriction (11) */
2268 }
2269
2270 /* Restriction 3: If the subquery is a join, make sure the subquery is
2271 ** not used as the right operand of an outer join. Examples of why this
2272 ** is not allowed:
2273 **
2274 ** t1 LEFT OUTER JOIN (t2 JOIN t3)
2275 **
2276 ** If we flatten the above, we would get
2277 **
2278 ** (t1 LEFT OUTER JOIN t2) JOIN t3
2279 **
2280 ** which is not at all the same thing.
2281 */
2282 if( pSubSrc->nSrc>1 && (pSubitem->jointype & JT_OUTER)!=0 ){
2283 return 0;
2284 }
2285
2286 /* Restriction 12: If the subquery is the right operand of a left outer
2287 ** join, make sure the subquery has no WHERE clause.
2288 ** An examples of why this is not allowed:
2289 **
2290 ** t1 LEFT OUTER JOIN (SELECT * FROM t2 WHERE t2.x>0)
2291 **
2292 ** If we flatten the above, we would get
2293 **
2294 ** (t1 LEFT OUTER JOIN t2) WHERE t2.x>0
2295 **
2296 ** But the t2.x>0 test will always fail on a NULL row of t2, which
2297 ** effectively converts the OUTER JOIN into an INNER JOIN.
2298 */
2299 if( (pSubitem->jointype & JT_OUTER)!=0 && pSub->pWhere!=0 ){
2300 return 0;
2301 }
2302
2303 /* If we reach this point, it means flattening is permitted for the
2304 ** iFrom-th entry of the FROM clause in the outer query.
2305 */
2306
2307 /* Move all of the FROM elements of the subquery into the
2308 ** the FROM clause of the outer query. Before doing this, remember
2309 ** the cursor number for the original outer query FROM element in
2310 ** iParent. The iParent cursor will never be used. Subsequent code
2311 ** will scan expressions looking for iParent references and replace
2312 ** those references with expressions that resolve to the subquery FROM
2313 ** elements we are now copying in.
2314 */
2315 iParent = pSubitem->iCursor;
2316 {
2317 int nSubSrc = pSubSrc->nSrc;
2318 int jointype = pSubitem->jointype;
2319
2320 sqlite3DeleteTable(pSubitem->pTab);
2321 sqlite3_free(pSubitem->zDatabase);
2322 sqlite3_free(pSubitem->zName);
2323 sqlite3_free(pSubitem->zAlias);
2324 if( nSubSrc>1 ){
2325 int extra = nSubSrc - 1;
2326 for(i=1; i<nSubSrc; i++){
2327 pSrc = sqlite3SrcListAppend(db, pSrc, 0, 0);
2328 }
2329 p->pSrc = pSrc;
2330 for(i=pSrc->nSrc-1; i-extra>=iFrom; i--){
2331 pSrc->a[i] = pSrc->a[i-extra];
2332 }
2333 }
2334 for(i=0; i<nSubSrc; i++){
2335 pSrc->a[i+iFrom] = pSubSrc->a[i];
2336 memset(&pSubSrc->a[i], 0, sizeof(pSubSrc->a[i]));
2337 }
2338 pSrc->a[iFrom].jointype = jointype;
2339 }
2340
2341 /* Now begin substituting subquery result set expressions for
2342 ** references to the iParent in the outer query.
2343 **
2344 ** Example:
2345 **
2346 ** SELECT a+5, b*10 FROM (SELECT x*3 AS a, y+10 AS b FROM t1) WHERE a>b;
2347 ** \ \_____________ subquery __________/ /
2348 ** \_____________________ outer query ______________________________/
2349 **
2350 ** We look at every expression in the outer query and every place we see
2351 ** "a" we substitute "x*3" and every place we see "b" we substitute "y+10".
2352 */
2353 pList = p->pEList;
2354 for(i=0; i<pList->nExpr; i++){
2355 Expr *pExpr;
2356 if( pList->a[i].zName==0 && (pExpr = pList->a[i].pExpr)->span.z!=0 ){
2357 pList->a[i].zName =
2358 sqlite3DbStrNDup(db, (char*)pExpr->span.z, pExpr->span.n);
2359 }
2360 }
2361 substExprList(db, p->pEList, iParent, pSub->pEList);
2362 if( isAgg ){
2363 substExprList(db, p->pGroupBy, iParent, pSub->pEList);
2364 substExpr(db, p->pHaving, iParent, pSub->pEList);
2365 }
2366 if( pSub->pOrderBy ){
2367 assert( p->pOrderBy==0 );
2368 p->pOrderBy = pSub->pOrderBy;
2369 pSub->pOrderBy = 0;
2370 }else if( p->pOrderBy ){
2371 substExprList(db, p->pOrderBy, iParent, pSub->pEList);
2372 }
2373 if( pSub->pWhere ){
2374 pWhere = sqlite3ExprDup(db, pSub->pWhere);
2375 }else{
2376 pWhere = 0;
2377 }
2378 if( subqueryIsAgg ){
2379 assert( p->pHaving==0 );
2380 p->pHaving = p->pWhere;
2381 p->pWhere = pWhere;
2382 substExpr(db, p->pHaving, iParent, pSub->pEList);
2383 p->pHaving = sqlite3ExprAnd(db, p->pHaving,
2384 sqlite3ExprDup(db, pSub->pHaving));
2385 assert( p->pGroupBy==0 );
2386 p->pGroupBy = sqlite3ExprListDup(db, pSub->pGroupBy);
2387 }else{
2388 substExpr(db, p->pWhere, iParent, pSub->pEList);
2389 p->pWhere = sqlite3ExprAnd(db, p->pWhere, pWhere);
2390 }
2391
2392 /* The flattened query is distinct if either the inner or the
2393 ** outer query is distinct.
2394 */
2395 p->isDistinct = p->isDistinct || pSub->isDistinct;
2396
2397 /*
2398 ** SELECT ... FROM (SELECT ... LIMIT a OFFSET b) LIMIT x OFFSET y;
2399 **
2400 ** One is tempted to try to add a and b to combine the limits. But this
2401 ** does not work if either limit is negative.
2402 */
2403 if( pSub->pLimit ){
2404 p->pLimit = pSub->pLimit;
2405 pSub->pLimit = 0;
2406 }
2407
2408 /* Finially, delete what is left of the subquery and return
2409 ** success.
2410 */
2411 sqlite3SelectDelete(pSub);
2412 return 1;
2413}
2414#endif /* SQLITE_OMIT_VIEW */
2415
2416/*
2417** Analyze the SELECT statement passed in as an argument to see if it
2418** is a simple min() or max() query. If it is and this query can be
2419** satisfied using a single seek to the beginning or end of an index,
2420** then generate the code for this SELECT and return 1. If this is not a
2421** simple min() or max() query, then return 0;
2422**
2423** A simply min() or max() query looks like this:
2424**
2425** SELECT min(a) FROM table;
2426** SELECT max(a) FROM table;
2427**
2428** The query may have only a single table in its FROM argument. There
2429** can be no GROUP BY or HAVING or WHERE clauses. The result set must
2430** be the min() or max() of a single column of the table. The column
2431** in the min() or max() function must be indexed.
2432**
2433** The parameters to this routine are the same as for sqlite3Select().
2434** See the header comment on that routine for additional information.
2435*/
2436static int simpleMinMaxQuery(Parse *pParse, Select *p, int eDest, int iParm){
2437 Expr *pExpr;
2438 int iCol;
2439 Table *pTab;
2440 Index *pIdx;
2441 int base;
2442 Vdbe *v;
2443 int seekOp;
2444 ExprList *pEList, *pList, eList;
2445 struct ExprList_item eListItem;
2446 SrcList *pSrc;
2447 int brk;
2448 int iDb;
2449
2450 /* Check to see if this query is a simple min() or max() query. Return
2451 ** zero if it is not.
2452 */
2453 if( p->pGroupBy || p->pHaving || p->pWhere ) return 0;
2454 pSrc = p->pSrc;
2455 if( pSrc->nSrc!=1 ) return 0;
2456 pEList = p->pEList;
2457 if( pEList->nExpr!=1 ) return 0;
2458 pExpr = pEList->a[0].pExpr;
2459 if( pExpr->op!=TK_AGG_FUNCTION ) return 0;
2460 pList = pExpr->pList;
2461 if( pList==0 || pList->nExpr!=1 ) return 0;
2462 if( pExpr->token.n!=3 ) return 0;
2463 if( sqlite3StrNICmp((char*)pExpr->token.z,"min",3)==0 ){
2464 seekOp = OP_Rewind;
2465 }else if( sqlite3StrNICmp((char*)pExpr->token.z,"max",3)==0 ){
2466 seekOp = OP_Last;
2467 }else{
2468 return 0;
2469 }
2470 pExpr = pList->a[0].pExpr;
2471 if( pExpr->op!=TK_COLUMN ) return 0;
2472 iCol = pExpr->iColumn;
2473 pTab = pSrc->a[0].pTab;
2474
2475 /* This optimization cannot be used with virtual tables. */
2476 if( IsVirtual(pTab) ) return 0;
2477
2478 /* If we get to here, it means the query is of the correct form.
2479 ** Check to make sure we have an index and make pIdx point to the
2480 ** appropriate index. If the min() or max() is on an INTEGER PRIMARY
2481 ** key column, no index is necessary so set pIdx to NULL. If no
2482 ** usable index is found, return 0.
2483 */
2484 if( iCol<0 ){
2485 pIdx = 0;
2486 }else{
2487 CollSeq *pColl = sqlite3ExprCollSeq(pParse, pExpr);
2488 if( pColl==0 ) return 0;
2489 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
2490 assert( pIdx->nColumn>=1 );
2491 if( pIdx->aiColumn[0]==iCol &&
2492 0==sqlite3StrICmp(pIdx->azColl[0], pColl->zName) ){
2493 break;
2494 }
2495 }
2496 if( pIdx==0 ) return 0;
2497 }
2498
2499 /* Identify column types if we will be using the callback. This
2500 ** step is skipped if the output is going to a table or a memory cell.
2501 ** The column names have already been generated in the calling function.
2502 */
2503 v = sqlite3GetVdbe(pParse);
2504 if( v==0 ) return 0;
2505
2506 /* If the output is destined for a temporary table, open that table.
2507 */
2508 if( eDest==SRT_EphemTab ){
2509 sqlite3VdbeAddOp(v, OP_OpenEphemeral, iParm, 1);
2510 }
2511
2512 /* Generating code to find the min or the max. Basically all we have
2513 ** to do is find the first or the last entry in the chosen index. If
2514 ** the min() or max() is on the INTEGER PRIMARY KEY, then find the first
2515 ** or last entry in the main table.
2516 */
2517 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
2518 assert( iDb>=0 || pTab->isEphem );
2519 sqlite3CodeVerifySchema(pParse, iDb);
2520 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
2521 base = pSrc->a[0].iCursor;
2522 brk = sqlite3VdbeMakeLabel(v);
2523 computeLimitRegisters(pParse, p, brk);
2524 if( pSrc->a[0].pSelect==0 ){
2525 sqlite3OpenTable(pParse, base, iDb, pTab, OP_OpenRead);
2526 }
2527 if( pIdx==0 ){
2528 sqlite3VdbeAddOp(v, seekOp, base, 0);
2529 }else{
2530 /* Even though the cursor used to open the index here is closed
2531 ** as soon as a single value has been read from it, allocate it
2532 ** using (pParse->nTab++) to prevent the cursor id from being
2533 ** reused. This is important for statements of the form
2534 ** "INSERT INTO x SELECT max() FROM x".
2535 */
2536 int iIdx;
2537 KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx);
2538 iIdx = pParse->nTab++;
2539 assert( pIdx->pSchema==pTab->pSchema );
2540 sqlite3VdbeAddOp(v, OP_Integer, iDb, 0);
2541 sqlite3VdbeOp3(v, OP_OpenRead, iIdx, pIdx->tnum,
2542 (char*)pKey, P3_KEYINFO_HANDOFF);
2543 if( seekOp==OP_Rewind ){
2544 sqlite3VdbeAddOp(v, OP_Null, 0, 0);
2545 sqlite3VdbeAddOp(v, OP_MakeRecord, 1, 0);
2546 seekOp = OP_MoveGt;
2547 }
2548 if( pIdx->aSortOrder[0]==SQLITE_SO_DESC ){
2549 /* Ticket #2514: invert the seek operator if we are using
2550 ** a descending index. */
2551 if( seekOp==OP_Last ){
2552 seekOp = OP_Rewind;
2553 }else{
2554 assert( seekOp==OP_MoveGt );
2555 seekOp = OP_MoveLt;
2556 }
2557 }
2558 sqlite3VdbeAddOp(v, seekOp, iIdx, 0);
2559 sqlite3VdbeAddOp(v, OP_IdxRowid, iIdx, 0);
2560 sqlite3VdbeAddOp(v, OP_Close, iIdx, 0);
2561 sqlite3VdbeAddOp(v, OP_MoveGe, base, 0);
2562 }
2563 eList.nExpr = 1;
2564 memset(&eListItem, 0, sizeof(eListItem));
2565 eList.a = &eListItem;
2566 eList.a[0].pExpr = pExpr;
2567 selectInnerLoop(pParse, p, &eList, 0, 0, 0, -1, eDest, iParm, brk, brk, 0);
2568 sqlite3VdbeResolveLabel(v, brk);
2569 sqlite3VdbeAddOp(v, OP_Close, base, 0);
2570
2571 return 1;
2572}
2573
2574/*
2575** Analyze and ORDER BY or GROUP BY clause in a SELECT statement. Return
2576** the number of errors seen.
2577**
2578** An ORDER BY or GROUP BY is a list of expressions. If any expression
2579** is an integer constant, then that expression is replaced by the
2580** corresponding entry in the result set.
2581*/
2582static int processOrderGroupBy(
2583 NameContext *pNC, /* Name context of the SELECT statement. */
2584 ExprList *pOrderBy, /* The ORDER BY or GROUP BY clause to be processed */
2585 const char *zType /* Either "ORDER" or "GROUP", as appropriate */
2586){
2587 int i;
2588 ExprList *pEList = pNC->pEList; /* The result set of the SELECT */
2589 Parse *pParse = pNC->pParse; /* The result set of the SELECT */
2590 assert( pEList );
2591
2592 if( pOrderBy==0 ) return 0;
2593 if( pOrderBy->nExpr>SQLITE_MAX_COLUMN ){
2594 sqlite3ErrorMsg(pParse, "too many terms in %s BY clause", zType);
2595 return 1;
2596 }
2597 for(i=0; i<pOrderBy->nExpr; i++){
2598 int iCol;
2599 Expr *pE = pOrderBy->a[i].pExpr;
2600 if( sqlite3ExprIsInteger(pE, &iCol) ){
2601 if( iCol>0 && iCol<=pEList->nExpr ){
2602 CollSeq *pColl = pE->pColl;
2603 int flags = pE->flags & EP_ExpCollate;
2604 sqlite3ExprDelete(pE);
2605 pE = sqlite3ExprDup(pParse->db, pEList->a[iCol-1].pExpr);
2606 pOrderBy->a[i].pExpr = pE;
2607 if( pColl && flags ){
2608 pE->pColl = pColl;
2609 pE->flags |= flags;
2610 }
2611 }else{
2612 sqlite3ErrorMsg(pParse,
2613 "%s BY column number %d out of range - should be "
2614 "between 1 and %d", zType, iCol, pEList->nExpr);
2615 return 1;
2616 }
2617 }
2618 if( sqlite3ExprResolveNames(pNC, pE) ){
2619 return 1;
2620 }
2621 }
2622 return 0;
2623}
2624
2625/*
2626** This routine resolves any names used in the result set of the
2627** supplied SELECT statement. If the SELECT statement being resolved
2628** is a sub-select, then pOuterNC is a pointer to the NameContext
2629** of the parent SELECT.
2630*/
2631int sqlite3SelectResolve(
2632 Parse *pParse, /* The parser context */
2633 Select *p, /* The SELECT statement being coded. */
2634 NameContext *pOuterNC /* The outer name context. May be NULL. */
2635){
2636 ExprList *pEList; /* Result set. */
2637 int i; /* For-loop variable used in multiple places */
2638 NameContext sNC; /* Local name-context */
2639 ExprList *pGroupBy; /* The group by clause */
2640
2641 /* If this routine has run before, return immediately. */
2642 if( p->isResolved ){
2643 assert( !pOuterNC );
2644 return SQLITE_OK;
2645 }
2646 p->isResolved = 1;
2647
2648 /* If there have already been errors, do nothing. */
2649 if( pParse->nErr>0 ){
2650 return SQLITE_ERROR;
2651 }
2652
2653 /* Prepare the select statement. This call will allocate all cursors
2654 ** required to handle the tables and subqueries in the FROM clause.
2655 */
2656 if( prepSelectStmt(pParse, p) ){
2657 return SQLITE_ERROR;
2658 }
2659
2660 /* Resolve the expressions in the LIMIT and OFFSET clauses. These
2661 ** are not allowed to refer to any names, so pass an empty NameContext.
2662 */
2663 memset(&sNC, 0, sizeof(sNC));
2664 sNC.pParse = pParse;
2665 if( sqlite3ExprResolveNames(&sNC, p->pLimit) ||
2666 sqlite3ExprResolveNames(&sNC, p->pOffset) ){
2667 return SQLITE_ERROR;
2668 }
2669
2670 /* Set up the local name-context to pass to ExprResolveNames() to
2671 ** resolve the expression-list.
2672 */
2673 sNC.allowAgg = 1;
2674 sNC.pSrcList = p->pSrc;
2675 sNC.pNext = pOuterNC;
2676
2677 /* Resolve names in the result set. */
2678 pEList = p->pEList;
2679 if( !pEList ) return SQLITE_ERROR;
2680 for(i=0; i<pEList->nExpr; i++){
2681 Expr *pX = pEList->a[i].pExpr;
2682 if( sqlite3ExprResolveNames(&sNC, pX) ){
2683 return SQLITE_ERROR;
2684 }
2685 }
2686
2687 /* If there are no aggregate functions in the result-set, and no GROUP BY
2688 ** expression, do not allow aggregates in any of the other expressions.
2689 */
2690 assert( !p->isAgg );
2691 pGroupBy = p->pGroupBy;
2692 if( pGroupBy || sNC.hasAgg ){
2693 p->isAgg = 1;
2694 }else{
2695 sNC.allowAgg = 0;
2696 }
2697
2698 /* If a HAVING clause is present, then there must be a GROUP BY clause.
2699 */
2700 if( p->pHaving && !pGroupBy ){
2701 sqlite3ErrorMsg(pParse, "a GROUP BY clause is required before HAVING");
2702 return SQLITE_ERROR;
2703 }
2704
2705 /* Add the expression list to the name-context before parsing the
2706 ** other expressions in the SELECT statement. This is so that
2707 ** expressions in the WHERE clause (etc.) can refer to expressions by
2708 ** aliases in the result set.
2709 **
2710 ** Minor point: If this is the case, then the expression will be
2711 ** re-evaluated for each reference to it.
2712 */
2713 sNC.pEList = p->pEList;
2714 if( sqlite3ExprResolveNames(&sNC, p->pWhere) ||
2715 sqlite3ExprResolveNames(&sNC, p->pHaving) ){
2716 return SQLITE_ERROR;
2717 }
2718 if( p->pPrior==0 ){
2719 if( processOrderGroupBy(&sNC, p->pOrderBy, "ORDER") ||
2720 processOrderGroupBy(&sNC, pGroupBy, "GROUP") ){
2721 return SQLITE_ERROR;
2722 }
2723 }
2724
2725 if( pParse->db->mallocFailed ){
2726 return SQLITE_NOMEM;
2727 }
2728
2729 /* Make sure the GROUP BY clause does not contain aggregate functions.
2730 */
2731 if( pGroupBy ){
2732 struct ExprList_item *pItem;
2733
2734 for(i=0, pItem=pGroupBy->a; i<pGroupBy->nExpr; i++, pItem++){
2735 if( ExprHasProperty(pItem->pExpr, EP_Agg) ){
2736 sqlite3ErrorMsg(pParse, "aggregate functions are not allowed in "
2737 "the GROUP BY clause");
2738 return SQLITE_ERROR;
2739 }
2740 }
2741 }
2742
2743 /* If this is one SELECT of a compound, be sure to resolve names
2744 ** in the other SELECTs.
2745 */
2746 if( p->pPrior ){
2747 return sqlite3SelectResolve(pParse, p->pPrior, pOuterNC);
2748 }else{
2749 return SQLITE_OK;
2750 }
2751}
2752
2753/*
2754** Reset the aggregate accumulator.
2755**
2756** The aggregate accumulator is a set of memory cells that hold
2757** intermediate results while calculating an aggregate. This
2758** routine simply stores NULLs in all of those memory cells.
2759*/
2760static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){
2761 Vdbe *v = pParse->pVdbe;
2762 int i;
2763 struct AggInfo_func *pFunc;
2764 if( pAggInfo->nFunc+pAggInfo->nColumn==0 ){
2765 return;
2766 }
2767 for(i=0; i<pAggInfo->nColumn; i++){
2768 sqlite3VdbeAddOp(v, OP_MemNull, pAggInfo->aCol[i].iMem, 0);
2769 }
2770 for(pFunc=pAggInfo->aFunc, i=0; i<pAggInfo->nFunc; i++, pFunc++){
2771 sqlite3VdbeAddOp(v, OP_MemNull, pFunc->iMem, 0);
2772 if( pFunc->iDistinct>=0 ){
2773 Expr *pE = pFunc->pExpr;
2774 if( pE->pList==0 || pE->pList->nExpr!=1 ){
2775 sqlite3ErrorMsg(pParse, "DISTINCT in aggregate must be followed "
2776 "by an expression");
2777 pFunc->iDistinct = -1;
2778 }else{
2779 KeyInfo *pKeyInfo = keyInfoFromExprList(pParse, pE->pList);
2780 sqlite3VdbeOp3(v, OP_OpenEphemeral, pFunc->iDistinct, 0,
2781 (char*)pKeyInfo, P3_KEYINFO_HANDOFF);
2782 }
2783 }
2784 }
2785}
2786
2787/*
2788** Invoke the OP_AggFinalize opcode for every aggregate function
2789** in the AggInfo structure.
2790*/
2791static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){
2792 Vdbe *v = pParse->pVdbe;
2793 int i;
2794 struct AggInfo_func *pF;
2795 for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
2796 ExprList *pList = pF->pExpr->pList;
2797 sqlite3VdbeOp3(v, OP_AggFinal, pF->iMem, pList ? pList->nExpr : 0,
2798 (void*)pF->pFunc, P3_FUNCDEF);
2799 }
2800}
2801
2802/*
2803** Update the accumulator memory cells for an aggregate based on
2804** the current cursor position.
2805*/
2806static void updateAccumulator(Parse *pParse, AggInfo *pAggInfo){
2807 Vdbe *v = pParse->pVdbe;
2808 int i;
2809 struct AggInfo_func *pF;
2810 struct AggInfo_col *pC;
2811
2812 pAggInfo->directMode = 1;
2813 for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
2814 int nArg;
2815 int addrNext = 0;
2816 ExprList *pList = pF->pExpr->pList;
2817 if( pList ){
2818 nArg = pList->nExpr;
2819 sqlite3ExprCodeExprList(pParse, pList);
2820 }else{
2821 nArg = 0;
2822 }
2823 if( pF->iDistinct>=0 ){
2824 addrNext = sqlite3VdbeMakeLabel(v);
2825 assert( nArg==1 );
2826 codeDistinct(v, pF->iDistinct, addrNext, 1);
2827 }
2828 if( pF->pFunc->needCollSeq ){
2829 CollSeq *pColl = 0;
2830 struct ExprList_item *pItem;
2831 int j;
2832 assert( pList!=0 ); /* pList!=0 if pF->pFunc->needCollSeq is true */
2833 for(j=0, pItem=pList->a; !pColl && j<nArg; j++, pItem++){
2834 pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
2835 }
2836 if( !pColl ){
2837 pColl = pParse->db->pDfltColl;
2838 }
2839 sqlite3VdbeOp3(v, OP_CollSeq, 0, 0, (char *)pColl, P3_COLLSEQ);
2840 }
2841 sqlite3VdbeOp3(v, OP_AggStep, pF->iMem, nArg, (void*)pF->pFunc, P3_FUNCDEF);
2842 if( addrNext ){
2843 sqlite3VdbeResolveLabel(v, addrNext);
2844 }
2845 }
2846 for(i=0, pC=pAggInfo->aCol; i<pAggInfo->nAccumulator; i++, pC++){
2847 sqlite3ExprCode(pParse, pC->pExpr);
2848 sqlite3VdbeAddOp(v, OP_MemStore, pC->iMem, 1);
2849 }
2850 pAggInfo->directMode = 0;
2851}
2852
2853
2854/*
2855** Generate code for the given SELECT statement.
2856**
2857** The results are distributed in various ways depending on the
2858** value of eDest and iParm.
2859**
2860** eDest Value Result
2861** ------------ -------------------------------------------
2862** SRT_Callback Invoke the callback for each row of the result.
2863**
2864** SRT_Mem Store first result in memory cell iParm
2865**
2866** SRT_Set Store results as keys of table iParm.
2867**
2868** SRT_Union Store results as a key in a temporary table iParm
2869**
2870** SRT_Except Remove results from the temporary table iParm.
2871**
2872** SRT_Table Store results in temporary table iParm
2873**
2874** The table above is incomplete. Additional eDist value have be added
2875** since this comment was written. See the selectInnerLoop() function for
2876** a complete listing of the allowed values of eDest and their meanings.
2877**
2878** This routine returns the number of errors. If any errors are
2879** encountered, then an appropriate error message is left in
2880** pParse->zErrMsg.
2881**
2882** This routine does NOT free the Select structure passed in. The
2883** calling function needs to do that.
2884**
2885** The pParent, parentTab, and *pParentAgg fields are filled in if this
2886** SELECT is a subquery. This routine may try to combine this SELECT
2887** with its parent to form a single flat query. In so doing, it might
2888** change the parent query from a non-aggregate to an aggregate query.
2889** For that reason, the pParentAgg flag is passed as a pointer, so it
2890** can be changed.
2891**
2892** Example 1: The meaning of the pParent parameter.
2893**
2894** SELECT * FROM t1 JOIN (SELECT x, count(*) FROM t2) JOIN t3;
2895** \ \_______ subquery _______/ /
2896** \ /
2897** \____________________ outer query ___________________/
2898**
2899** This routine is called for the outer query first. For that call,
2900** pParent will be NULL. During the processing of the outer query, this
2901** routine is called recursively to handle the subquery. For the recursive
2902** call, pParent will point to the outer query. Because the subquery is
2903** the second element in a three-way join, the parentTab parameter will
2904** be 1 (the 2nd value of a 0-indexed array.)
2905*/
2906int sqlite3Select(
2907 Parse *pParse, /* The parser context */
2908 Select *p, /* The SELECT statement being coded. */
2909 int eDest, /* How to dispose of the results */
2910 int iParm, /* A parameter used by the eDest disposal method */
2911 Select *pParent, /* Another SELECT for which this is a sub-query */
2912 int parentTab, /* Index in pParent->pSrc of this query */
2913 int *pParentAgg, /* True if pParent uses aggregate functions */
2914 char *aff /* If eDest is SRT_Union, the affinity string */
2915){
2916 int i, j; /* Loop counters */
2917 WhereInfo *pWInfo; /* Return from sqlite3WhereBegin() */
2918 Vdbe *v; /* The virtual machine under construction */
2919 int isAgg; /* True for select lists like "count(*)" */
2920 ExprList *pEList; /* List of columns to extract. */
2921 SrcList *pTabList; /* List of tables to select from */
2922 Expr *pWhere; /* The WHERE clause. May be NULL */
2923 ExprList *pOrderBy; /* The ORDER BY clause. May be NULL */
2924 ExprList *pGroupBy; /* The GROUP BY clause. May be NULL */
2925 Expr *pHaving; /* The HAVING clause. May be NULL */
2926 int isDistinct; /* True if the DISTINCT keyword is present */
2927 int distinct; /* Table to use for the distinct set */
2928 int rc = 1; /* Value to return from this function */
2929 int addrSortIndex; /* Address of an OP_OpenEphemeral instruction */
2930 AggInfo sAggInfo; /* Information used by aggregate queries */
2931 int iEnd; /* Address of the end of the query */
2932 sqlite3 *db; /* The database connection */
2933
2934 db = pParse->db;
2935 if( p==0 || db->mallocFailed || pParse->nErr ){
2936 return 1;
2937 }
2938 if( sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1;
2939 memset(&sAggInfo, 0, sizeof(sAggInfo));
2940
2941#ifndef SQLITE_OMIT_COMPOUND_SELECT
2942 /* If there is are a sequence of queries, do the earlier ones first.
2943 */
2944 if( p->pPrior ){
2945 if( p->pRightmost==0 ){
2946 Select *pLoop;
2947 int cnt = 0;
2948 for(pLoop=p; pLoop; pLoop=pLoop->pPrior, cnt++){
2949 pLoop->pRightmost = p;
2950 }
2951 if( SQLITE_MAX_COMPOUND_SELECT>0 && cnt>SQLITE_MAX_COMPOUND_SELECT ){
2952 sqlite3ErrorMsg(pParse, "too many terms in compound SELECT");
2953 return 1;
2954 }
2955 }
2956 return multiSelect(pParse, p, eDest, iParm, aff);
2957 }
2958#endif
2959
2960 pOrderBy = p->pOrderBy;
2961 if( IgnorableOrderby(eDest) ){
2962 p->pOrderBy = 0;
2963 }
2964 if( sqlite3SelectResolve(pParse, p, 0) ){
2965 goto select_end;
2966 }
2967 p->pOrderBy = pOrderBy;
2968
2969 /* Make local copies of the parameters for this query.
2970 */
2971 pTabList = p->pSrc;
2972 pWhere = p->pWhere;
2973 pGroupBy = p->pGroupBy;
2974 pHaving = p->pHaving;
2975 isAgg = p->isAgg;
2976 isDistinct = p->isDistinct;
2977 pEList = p->pEList;
2978 if( pEList==0 ) goto select_end;
2979
2980 /*
2981 ** Do not even attempt to generate any code if we have already seen
2982 ** errors before this routine starts.
2983 */
2984 if( pParse->nErr>0 ) goto select_end;
2985
2986 /* If writing to memory or generating a set
2987 ** only a single column may be output.
2988 */
2989#ifndef SQLITE_OMIT_SUBQUERY
2990 if( checkForMultiColumnSelectError(pParse, eDest, pEList->nExpr) ){
2991 goto select_end;
2992 }
2993#endif
2994
2995 /* ORDER BY is ignored for some destinations.
2996 */
2997 if( IgnorableOrderby(eDest) ){
2998 pOrderBy = 0;
2999 }
3000
3001 /* Begin generating code.
3002 */
3003 v = sqlite3GetVdbe(pParse);
3004 if( v==0 ) goto select_end;
3005
3006 /* Generate code for all sub-queries in the FROM clause
3007 */
3008#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
3009 for(i=0; i<pTabList->nSrc; i++){
3010 const char *zSavedAuthContext = 0;
3011 int needRestoreContext;
3012 struct SrcList_item *pItem = &pTabList->a[i];
3013
3014 if( pItem->pSelect==0 || pItem->isPopulated ) continue;
3015 if( pItem->zName!=0 ){
3016 zSavedAuthContext = pParse->zAuthContext;
3017 pParse->zAuthContext = pItem->zName;
3018 needRestoreContext = 1;
3019 }else{
3020 needRestoreContext = 0;
3021 }
3022#if defined(SQLITE_TEST) || SQLITE_MAX_EXPR_DEPTH>0
3023 /* Increment Parse.nHeight by the height of the largest expression
3024 ** tree refered to by this, the parent select. The child select
3025 ** may contain expression trees of at most
3026 ** (SQLITE_MAX_EXPR_DEPTH-Parse.nHeight) height. This is a bit
3027 ** more conservative than necessary, but much easier than enforcing
3028 ** an exact limit.
3029 */
3030 pParse->nHeight += sqlite3SelectExprHeight(p);
3031#endif
3032 sqlite3Select(pParse, pItem->pSelect, SRT_EphemTab,
3033 pItem->iCursor, p, i, &isAgg, 0);
3034#if defined(SQLITE_TEST) || SQLITE_MAX_EXPR_DEPTH>0
3035 pParse->nHeight -= sqlite3SelectExprHeight(p);
3036#endif
3037 if( needRestoreContext ){
3038 pParse->zAuthContext = zSavedAuthContext;
3039 }
3040 pTabList = p->pSrc;
3041 pWhere = p->pWhere;
3042 if( !IgnorableOrderby(eDest) ){
3043 pOrderBy = p->pOrderBy;
3044 }
3045 pGroupBy = p->pGroupBy;
3046 pHaving = p->pHaving;
3047 isDistinct = p->isDistinct;
3048 }
3049#endif
3050
3051 /* Check for the special case of a min() or max() function by itself
3052 ** in the result set.
3053 */
3054 if( simpleMinMaxQuery(pParse, p, eDest, iParm) ){
3055 rc = 0;
3056 goto select_end;
3057 }
3058
3059 /* Check to see if this is a subquery that can be "flattened" into its parent.
3060 ** If flattening is a possiblity, do so and return immediately.
3061 */
3062#ifndef SQLITE_OMIT_VIEW
3063 if( pParent && pParentAgg &&
3064 flattenSubquery(db, pParent, parentTab, *pParentAgg, isAgg) ){
3065 if( isAgg ) *pParentAgg = 1;
3066 goto select_end;
3067 }
3068#endif
3069
3070 /* If there is an ORDER BY clause, then this sorting
3071 ** index might end up being unused if the data can be
3072 ** extracted in pre-sorted order. If that is the case, then the
3073 ** OP_OpenEphemeral instruction will be changed to an OP_Noop once
3074 ** we figure out that the sorting index is not needed. The addrSortIndex
3075 ** variable is used to facilitate that change.
3076 */
3077 if( pOrderBy ){
3078 KeyInfo *pKeyInfo;
3079 if( pParse->nErr ){
3080 goto select_end;
3081 }
3082 pKeyInfo = keyInfoFromExprList(pParse, pOrderBy);
3083 pOrderBy->iECursor = pParse->nTab++;
3084 p->addrOpenEphm[2] = addrSortIndex =
3085 sqlite3VdbeOp3(v, OP_OpenEphemeral, pOrderBy->iECursor, pOrderBy->nExpr+2, (char*)pKeyInfo, P3_KEYINFO_HANDOFF);
3086 }else{
3087 addrSortIndex = -1;
3088 }
3089
3090 /* If the output is destined for a temporary table, open that table.
3091 */
3092 if( eDest==SRT_EphemTab ){
3093 sqlite3VdbeAddOp(v, OP_OpenEphemeral, iParm, pEList->nExpr);
3094 }
3095
3096 /* Set the limiter.
3097 */
3098 iEnd = sqlite3VdbeMakeLabel(v);
3099 computeLimitRegisters(pParse, p, iEnd);
3100
3101 /* Open a virtual index to use for the distinct set.
3102 */
3103 if( isDistinct ){
3104 KeyInfo *pKeyInfo;
3105 distinct = pParse->nTab++;
3106 pKeyInfo = keyInfoFromExprList(pParse, p->pEList);
3107 sqlite3VdbeOp3(v, OP_OpenEphemeral, distinct, 0,
3108 (char*)pKeyInfo, P3_KEYINFO_HANDOFF);
3109 }else{
3110 distinct = -1;
3111 }
3112
3113 /* Aggregate and non-aggregate queries are handled differently */
3114 if( !isAgg && pGroupBy==0 ){
3115 /* This case is for non-aggregate queries
3116 ** Begin the database scan
3117 */
3118 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, &pOrderBy);
3119 if( pWInfo==0 ) goto select_end;
3120
3121 /* If sorting index that was created by a prior OP_OpenEphemeral
3122 ** instruction ended up not being needed, then change the OP_OpenEphemeral
3123 ** into an OP_Noop.
3124 */
3125 if( addrSortIndex>=0 && pOrderBy==0 ){
3126 sqlite3VdbeChangeToNoop(v, addrSortIndex, 1);
3127 p->addrOpenEphm[2] = -1;
3128 }
3129
3130 /* Use the standard inner loop
3131 */
3132 if( selectInnerLoop(pParse, p, pEList, 0, 0, pOrderBy, distinct, eDest,
3133 iParm, pWInfo->iContinue, pWInfo->iBreak, aff) ){
3134 goto select_end;
3135 }
3136
3137 /* End the database scan loop.
3138 */
3139 sqlite3WhereEnd(pWInfo);
3140 }else{
3141 /* This is the processing for aggregate queries */
3142 NameContext sNC; /* Name context for processing aggregate information */
3143 int iAMem; /* First Mem address for storing current GROUP BY */
3144 int iBMem; /* First Mem address for previous GROUP BY */
3145 int iUseFlag; /* Mem address holding flag indicating that at least
3146 ** one row of the input to the aggregator has been
3147 ** processed */
3148 int iAbortFlag; /* Mem address which causes query abort if positive */
3149 int groupBySort; /* Rows come from source in GROUP BY order */
3150
3151
3152 /* The following variables hold addresses or labels for parts of the
3153 ** virtual machine program we are putting together */
3154 int addrOutputRow; /* Start of subroutine that outputs a result row */
3155 int addrSetAbort; /* Set the abort flag and return */
3156 int addrInitializeLoop; /* Start of code that initializes the input loop */
3157 int addrTopOfLoop; /* Top of the input loop */
3158 int addrGroupByChange; /* Code that runs when any GROUP BY term changes */
3159 int addrProcessRow; /* Code to process a single input row */
3160 int addrEnd; /* End of all processing */
3161 int addrSortingIdx; /* The OP_OpenEphemeral for the sorting index */
3162 int addrReset; /* Subroutine for resetting the accumulator */
3163
3164 addrEnd = sqlite3VdbeMakeLabel(v);
3165
3166 /* Convert TK_COLUMN nodes into TK_AGG_COLUMN and make entries in
3167 ** sAggInfo for all TK_AGG_FUNCTION nodes in expressions of the
3168 ** SELECT statement.
3169 */
3170 memset(&sNC, 0, sizeof(sNC));
3171 sNC.pParse = pParse;
3172 sNC.pSrcList = pTabList;
3173 sNC.pAggInfo = &sAggInfo;
3174 sAggInfo.nSortingColumn = pGroupBy ? pGroupBy->nExpr+1 : 0;
3175 sAggInfo.pGroupBy = pGroupBy;
3176 if( sqlite3ExprAnalyzeAggList(&sNC, pEList) ){
3177 goto select_end;
3178 }
3179 if( sqlite3ExprAnalyzeAggList(&sNC, pOrderBy) ){
3180 goto select_end;
3181 }
3182 if( pHaving && sqlite3ExprAnalyzeAggregates(&sNC, pHaving) ){
3183 goto select_end;
3184 }
3185 sAggInfo.nAccumulator = sAggInfo.nColumn;
3186 for(i=0; i<sAggInfo.nFunc; i++){
3187 if( sqlite3ExprAnalyzeAggList(&sNC, sAggInfo.aFunc[i].pExpr->pList) ){
3188 goto select_end;
3189 }
3190 }
3191 if( db->mallocFailed ) goto select_end;
3192
3193 /* Processing for aggregates with GROUP BY is very different and
3194 ** much more complex tha aggregates without a GROUP BY.
3195 */
3196 if( pGroupBy ){
3197 KeyInfo *pKeyInfo; /* Keying information for the group by clause */
3198
3199 /* Create labels that we will be needing
3200 */
3201
3202 addrInitializeLoop = sqlite3VdbeMakeLabel(v);
3203 addrGroupByChange = sqlite3VdbeMakeLabel(v);
3204 addrProcessRow = sqlite3VdbeMakeLabel(v);
3205
3206 /* If there is a GROUP BY clause we might need a sorting index to
3207 ** implement it. Allocate that sorting index now. If it turns out
3208 ** that we do not need it after all, the OpenEphemeral instruction
3209 ** will be converted into a Noop.
3210 */
3211 sAggInfo.sortingIdx = pParse->nTab++;
3212 pKeyInfo = keyInfoFromExprList(pParse, pGroupBy);
3213 addrSortingIdx =
3214 sqlite3VdbeOp3(v, OP_OpenEphemeral, sAggInfo.sortingIdx,
3215 sAggInfo.nSortingColumn,
3216 (char*)pKeyInfo, P3_KEYINFO_HANDOFF);
3217
3218 /* Initialize memory locations used by GROUP BY aggregate processing
3219 */
3220 iUseFlag = pParse->nMem++;
3221 iAbortFlag = pParse->nMem++;
3222 iAMem = pParse->nMem;
3223 pParse->nMem += pGroupBy->nExpr;
3224 iBMem = pParse->nMem;
3225 pParse->nMem += pGroupBy->nExpr;
3226 sqlite3VdbeAddOp(v, OP_MemInt, 0, iAbortFlag);
3227 VdbeComment((v, "# clear abort flag"));
3228 sqlite3VdbeAddOp(v, OP_MemInt, 0, iUseFlag);
3229 VdbeComment((v, "# indicate accumulator empty"));
3230 sqlite3VdbeAddOp(v, OP_Goto, 0, addrInitializeLoop);
3231
3232 /* Generate a subroutine that outputs a single row of the result
3233 ** set. This subroutine first looks at the iUseFlag. If iUseFlag
3234 ** is less than or equal to zero, the subroutine is a no-op. If
3235 ** the processing calls for the query to abort, this subroutine
3236 ** increments the iAbortFlag memory location before returning in
3237 ** order to signal the caller to abort.
3238 */
3239 addrSetAbort = sqlite3VdbeCurrentAddr(v);
3240 sqlite3VdbeAddOp(v, OP_MemInt, 1, iAbortFlag);
3241 VdbeComment((v, "# set abort flag"));
3242 sqlite3VdbeAddOp(v, OP_Return, 0, 0);
3243 addrOutputRow = sqlite3VdbeCurrentAddr(v);
3244 sqlite3VdbeAddOp(v, OP_IfMemPos, iUseFlag, addrOutputRow+2);
3245 VdbeComment((v, "# Groupby result generator entry point"));
3246 sqlite3VdbeAddOp(v, OP_Return, 0, 0);
3247 finalizeAggFunctions(pParse, &sAggInfo);
3248 if( pHaving ){
3249 sqlite3ExprIfFalse(pParse, pHaving, addrOutputRow+1, 1);
3250 }
3251 rc = selectInnerLoop(pParse, p, p->pEList, 0, 0, pOrderBy,
3252 distinct, eDest, iParm,
3253 addrOutputRow+1, addrSetAbort, aff);
3254 if( rc ){
3255 goto select_end;
3256 }
3257 sqlite3VdbeAddOp(v, OP_Return, 0, 0);
3258 VdbeComment((v, "# end groupby result generator"));
3259
3260 /* Generate a subroutine that will reset the group-by accumulator
3261 */
3262 addrReset = sqlite3VdbeCurrentAddr(v);
3263 resetAccumulator(pParse, &sAggInfo);
3264 sqlite3VdbeAddOp(v, OP_Return, 0, 0);
3265
3266 /* Begin a loop that will extract all source rows in GROUP BY order.
3267 ** This might involve two separate loops with an OP_Sort in between, or
3268 ** it might be a single loop that uses an index to extract information
3269 ** in the right order to begin with.
3270 */
3271 sqlite3VdbeResolveLabel(v, addrInitializeLoop);
3272 sqlite3VdbeAddOp(v, OP_Gosub, 0, addrReset);
3273 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, &pGroupBy);
3274 if( pWInfo==0 ) goto select_end;
3275 if( pGroupBy==0 ){
3276 /* The optimizer is able to deliver rows in group by order so
3277 ** we do not have to sort. The OP_OpenEphemeral table will be
3278 ** cancelled later because we still need to use the pKeyInfo
3279 */
3280 pGroupBy = p->pGroupBy;
3281 groupBySort = 0;
3282 }else{
3283 /* Rows are coming out in undetermined order. We have to push
3284 ** each row into a sorting index, terminate the first loop,
3285 ** then loop over the sorting index in order to get the output
3286 ** in sorted order
3287 */
3288 groupBySort = 1;
3289 sqlite3ExprCodeExprList(pParse, pGroupBy);
3290 sqlite3VdbeAddOp(v, OP_Sequence, sAggInfo.sortingIdx, 0);
3291 j = pGroupBy->nExpr+1;
3292 for(i=0; i<sAggInfo.nColumn; i++){
3293 struct AggInfo_col *pCol = &sAggInfo.aCol[i];
3294 if( pCol->iSorterColumn<j ) continue;
3295 sqlite3ExprCodeGetColumn(v, pCol->pTab, pCol->iColumn, pCol->iTable);
3296 j++;
3297 }
3298 sqlite3VdbeAddOp(v, OP_MakeRecord, j, 0);
3299 sqlite3VdbeAddOp(v, OP_IdxInsert, sAggInfo.sortingIdx, 0);
3300 sqlite3WhereEnd(pWInfo);
3301 sqlite3VdbeAddOp(v, OP_Sort, sAggInfo.sortingIdx, addrEnd);
3302 VdbeComment((v, "# GROUP BY sort"));
3303 sAggInfo.useSortingIdx = 1;
3304 }
3305
3306 /* Evaluate the current GROUP BY terms and store in b0, b1, b2...
3307 ** (b0 is memory location iBMem+0, b1 is iBMem+1, and so forth)
3308 ** Then compare the current GROUP BY terms against the GROUP BY terms
3309 ** from the previous row currently stored in a0, a1, a2...
3310 */
3311 addrTopOfLoop = sqlite3VdbeCurrentAddr(v);
3312 for(j=0; j<pGroupBy->nExpr; j++){
3313 if( groupBySort ){
3314 sqlite3VdbeAddOp(v, OP_Column, sAggInfo.sortingIdx, j);
3315 }else{
3316 sAggInfo.directMode = 1;
3317 sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr);
3318 }
3319 sqlite3VdbeAddOp(v, OP_MemStore, iBMem+j, j<pGroupBy->nExpr-1);
3320 }
3321 for(j=pGroupBy->nExpr-1; j>=0; j--){
3322 if( j<pGroupBy->nExpr-1 ){
3323 sqlite3VdbeAddOp(v, OP_MemLoad, iBMem+j, 0);
3324 }
3325 sqlite3VdbeAddOp(v, OP_MemLoad, iAMem+j, 0);
3326 if( j==0 ){
3327 sqlite3VdbeAddOp(v, OP_Eq, 0x200, addrProcessRow);
3328 }else{
3329 sqlite3VdbeAddOp(v, OP_Ne, 0x200, addrGroupByChange);
3330 }
3331 sqlite3VdbeChangeP3(v, -1, (void*)pKeyInfo->aColl[j], P3_COLLSEQ);
3332 }
3333
3334 /* Generate code that runs whenever the GROUP BY changes.
3335 ** Change in the GROUP BY are detected by the previous code
3336 ** block. If there were no changes, this block is skipped.
3337 **
3338 ** This code copies current group by terms in b0,b1,b2,...
3339 ** over to a0,a1,a2. It then calls the output subroutine
3340 ** and resets the aggregate accumulator registers in preparation
3341 ** for the next GROUP BY batch.
3342 */
3343 sqlite3VdbeResolveLabel(v, addrGroupByChange);
3344 for(j=0; j<pGroupBy->nExpr; j++){
3345 sqlite3VdbeAddOp(v, OP_MemMove, iAMem+j, iBMem+j);
3346 }
3347 sqlite3VdbeAddOp(v, OP_Gosub, 0, addrOutputRow);
3348 VdbeComment((v, "# output one row"));
3349 sqlite3VdbeAddOp(v, OP_IfMemPos, iAbortFlag, addrEnd);
3350 VdbeComment((v, "# check abort flag"));
3351 sqlite3VdbeAddOp(v, OP_Gosub, 0, addrReset);
3352 VdbeComment((v, "# reset accumulator"));
3353
3354 /* Update the aggregate accumulators based on the content of
3355 ** the current row
3356 */
3357 sqlite3VdbeResolveLabel(v, addrProcessRow);
3358 updateAccumulator(pParse, &sAggInfo);
3359 sqlite3VdbeAddOp(v, OP_MemInt, 1, iUseFlag);
3360 VdbeComment((v, "# indicate data in accumulator"));
3361
3362 /* End of the loop
3363 */
3364 if( groupBySort ){
3365 sqlite3VdbeAddOp(v, OP_Next, sAggInfo.sortingIdx, addrTopOfLoop);
3366 }else{
3367 sqlite3WhereEnd(pWInfo);
3368 sqlite3VdbeChangeToNoop(v, addrSortingIdx, 1);
3369 }
3370
3371 /* Output the final row of result
3372 */
3373 sqlite3VdbeAddOp(v, OP_Gosub, 0, addrOutputRow);
3374 VdbeComment((v, "# output final row"));
3375
3376 } /* endif pGroupBy */
3377 else {
3378 /* This case runs if the aggregate has no GROUP BY clause. The
3379 ** processing is much simpler since there is only a single row
3380 ** of output.
3381 */
3382 resetAccumulator(pParse, &sAggInfo);
3383 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0);
3384 if( pWInfo==0 ) goto select_end;
3385 updateAccumulator(pParse, &sAggInfo);
3386 sqlite3WhereEnd(pWInfo);
3387 finalizeAggFunctions(pParse, &sAggInfo);
3388 pOrderBy = 0;
3389 if( pHaving ){
3390 sqlite3ExprIfFalse(pParse, pHaving, addrEnd, 1);
3391 }
3392 selectInnerLoop(pParse, p, p->pEList, 0, 0, 0, -1,
3393 eDest, iParm, addrEnd, addrEnd, aff);
3394 }
3395 sqlite3VdbeResolveLabel(v, addrEnd);
3396
3397 } /* endif aggregate query */
3398
3399 /* If there is an ORDER BY clause, then we need to sort the results
3400 ** and send them to the callback one by one.
3401 */
3402 if( pOrderBy ){
3403 generateSortTail(pParse, p, v, pEList->nExpr, eDest, iParm);
3404 }
3405
3406#ifndef SQLITE_OMIT_SUBQUERY
3407 /* If this was a subquery, we have now converted the subquery into a
3408 ** temporary table. So set the SrcList_item.isPopulated flag to prevent
3409 ** this subquery from being evaluated again and to force the use of
3410 ** the temporary table.
3411 */
3412 if( pParent ){
3413 assert( pParent->pSrc->nSrc>parentTab );
3414 assert( pParent->pSrc->a[parentTab].pSelect==p );
3415 pParent->pSrc->a[parentTab].isPopulated = 1;
3416 }
3417#endif
3418
3419 /* Jump here to skip this query
3420 */
3421 sqlite3VdbeResolveLabel(v, iEnd);
3422
3423 /* The SELECT was successfully coded. Set the return code to 0
3424 ** to indicate no errors.
3425 */
3426 rc = 0;
3427
3428 /* Control jumps to here if an error is encountered above, or upon
3429 ** successful coding of the SELECT.
3430 */
3431select_end:
3432
3433 /* Identify column names if we will be using them in a callback. This
3434 ** step is skipped if the output is going to some other destination.
3435 */
3436 if( rc==SQLITE_OK && eDest==SRT_Callback ){
3437 generateColumnNames(pParse, pTabList, pEList);
3438 }
3439
3440 sqlite3_free(sAggInfo.aCol);
3441 sqlite3_free(sAggInfo.aFunc);
3442 return rc;
3443}
3444
3445#if defined(SQLITE_DEBUG)
3446/*
3447*******************************************************************************
3448** The following code is used for testing and debugging only. The code
3449** that follows does not appear in normal builds.
3450**
3451** These routines are used to print out the content of all or part of a
3452** parse structures such as Select or Expr. Such printouts are useful
3453** for helping to understand what is happening inside the code generator
3454** during the execution of complex SELECT statements.
3455**
3456** These routine are not called anywhere from within the normal
3457** code base. Then are intended to be called from within the debugger
3458** or from temporary "printf" statements inserted for debugging.
3459*/
3460void sqlite3PrintExpr(Expr *p){
3461 if( p->token.z && p->token.n>0 ){
3462 sqlite3DebugPrintf("(%.*s", p->token.n, p->token.z);
3463 }else{
3464 sqlite3DebugPrintf("(%d", p->op);
3465 }
3466 if( p->pLeft ){
3467 sqlite3DebugPrintf(" ");
3468 sqlite3PrintExpr(p->pLeft);
3469 }
3470 if( p->pRight ){
3471 sqlite3DebugPrintf(" ");
3472 sqlite3PrintExpr(p->pRight);
3473 }
3474 sqlite3DebugPrintf(")");
3475}
3476void sqlite3PrintExprList(ExprList *pList){
3477 int i;
3478 for(i=0; i<pList->nExpr; i++){
3479 sqlite3PrintExpr(pList->a[i].pExpr);
3480 if( i<pList->nExpr-1 ){
3481 sqlite3DebugPrintf(", ");
3482 }
3483 }
3484}
3485void sqlite3PrintSelect(Select *p, int indent){
3486 sqlite3DebugPrintf("%*sSELECT(%p) ", indent, "", p);
3487 sqlite3PrintExprList(p->pEList);
3488 sqlite3DebugPrintf("\n");
3489 if( p->pSrc ){
3490 char *zPrefix;
3491 int i;
3492 zPrefix = "FROM";
3493 for(i=0; i<p->pSrc->nSrc; i++){
3494 struct SrcList_item *pItem = &p->pSrc->a[i];
3495 sqlite3DebugPrintf("%*s ", indent+6, zPrefix);
3496 zPrefix = "";
3497 if( pItem->pSelect ){
3498 sqlite3DebugPrintf("(\n");
3499 sqlite3PrintSelect(pItem->pSelect, indent+10);
3500 sqlite3DebugPrintf("%*s)", indent+8, "");
3501 }else if( pItem->zName ){
3502 sqlite3DebugPrintf("%s", pItem->zName);
3503 }
3504 if( pItem->pTab ){
3505 sqlite3DebugPrintf("(table: %s)", pItem->pTab->zName);
3506 }
3507 if( pItem->zAlias ){
3508 sqlite3DebugPrintf(" AS %s", pItem->zAlias);
3509 }
3510 if( i<p->pSrc->nSrc-1 ){
3511 sqlite3DebugPrintf(",");
3512 }
3513 sqlite3DebugPrintf("\n");
3514 }
3515 }
3516 if( p->pWhere ){
3517 sqlite3DebugPrintf("%*s WHERE ", indent, "");
3518 sqlite3PrintExpr(p->pWhere);
3519 sqlite3DebugPrintf("\n");
3520 }
3521 if( p->pGroupBy ){
3522 sqlite3DebugPrintf("%*s GROUP BY ", indent, "");
3523 sqlite3PrintExprList(p->pGroupBy);
3524 sqlite3DebugPrintf("\n");
3525 }
3526 if( p->pHaving ){
3527 sqlite3DebugPrintf("%*s HAVING ", indent, "");
3528 sqlite3PrintExpr(p->pHaving);
3529 sqlite3DebugPrintf("\n");
3530 }
3531 if( p->pOrderBy ){
3532 sqlite3DebugPrintf("%*s ORDER BY ", indent, "");
3533 sqlite3PrintExprList(p->pOrderBy);
3534 sqlite3DebugPrintf("\n");
3535 }
3536}
3537/* End of the structure debug printing code
3538*****************************************************************************/
3539#endif /* defined(SQLITE_TEST) || defined(SQLITE_DEBUG) */
generated by cgit v1.1 at 2024-11-12 12:53:11 +0000