1.1 --- a/extensions/sqlite/sqlite-source/select.c Fri Mar 28 06:21:34 2008 +0000
1.2 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000
1.3 @@ -1,3539 +0,0 @@
1.4 -/*
1.5 -** 2001 September 15
1.6 -**
1.7 -** The author disclaims copyright to this source code. In place of
1.8 -** a legal notice, here is a blessing:
1.9 -**
1.10 -** May you do good and not evil.
1.11 -** May you find forgiveness for yourself and forgive others.
1.12 -** May you share freely, never taking more than you give.
1.13 -**
1.14 -*************************************************************************
1.15 -** This file contains C code routines that are called by the parser
1.16 -** to handle SELECT statements in SQLite.
1.17 -**
1.18 -** $Id$
1.19 -*/
1.20 -#include "sqliteInt.h"
1.21 -
1.22 -
1.23 -/*
1.24 -** Delete all the content of a Select structure but do not deallocate
1.25 -** the select structure itself.
1.26 -*/
1.27 -static void clearSelect(Select *p){
1.28 - sqlite3ExprListDelete(p->pEList);
1.29 - sqlite3SrcListDelete(p->pSrc);
1.30 - sqlite3ExprDelete(p->pWhere);
1.31 - sqlite3ExprListDelete(p->pGroupBy);
1.32 - sqlite3ExprDelete(p->pHaving);
1.33 - sqlite3ExprListDelete(p->pOrderBy);
1.34 - sqlite3SelectDelete(p->pPrior);
1.35 - sqlite3ExprDelete(p->pLimit);
1.36 - sqlite3ExprDelete(p->pOffset);
1.37 -}
1.38 -
1.39 -
1.40 -/*
1.41 -** Allocate a new Select structure and return a pointer to that
1.42 -** structure.
1.43 -*/
1.44 -Select *sqlite3SelectNew(
1.45 - Parse *pParse, /* Parsing context */
1.46 - ExprList *pEList, /* which columns to include in the result */
1.47 - SrcList *pSrc, /* the FROM clause -- which tables to scan */
1.48 - Expr *pWhere, /* the WHERE clause */
1.49 - ExprList *pGroupBy, /* the GROUP BY clause */
1.50 - Expr *pHaving, /* the HAVING clause */
1.51 - ExprList *pOrderBy, /* the ORDER BY clause */
1.52 - int isDistinct, /* true if the DISTINCT keyword is present */
1.53 - Expr *pLimit, /* LIMIT value. NULL means not used */
1.54 - Expr *pOffset /* OFFSET value. NULL means no offset */
1.55 -){
1.56 - Select *pNew;
1.57 - Select standin;
1.58 - sqlite3 *db = pParse->db;
1.59 - pNew = sqlite3DbMallocZero(db, sizeof(*pNew) );
1.60 - assert( !pOffset || pLimit ); /* Can't have OFFSET without LIMIT. */
1.61 - if( pNew==0 ){
1.62 - pNew = &standin;
1.63 - memset(pNew, 0, sizeof(*pNew));
1.64 - }
1.65 - if( pEList==0 ){
1.66 - pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db,TK_ALL,0,0,0), 0);
1.67 - }
1.68 - pNew->pEList = pEList;
1.69 - pNew->pSrc = pSrc;
1.70 - pNew->pWhere = pWhere;
1.71 - pNew->pGroupBy = pGroupBy;
1.72 - pNew->pHaving = pHaving;
1.73 - pNew->pOrderBy = pOrderBy;
1.74 - pNew->isDistinct = isDistinct;
1.75 - pNew->op = TK_SELECT;
1.76 - assert( pOffset==0 || pLimit!=0 );
1.77 - pNew->pLimit = pLimit;
1.78 - pNew->pOffset = pOffset;
1.79 - pNew->iLimit = -1;
1.80 - pNew->iOffset = -1;
1.81 - pNew->addrOpenEphm[0] = -1;
1.82 - pNew->addrOpenEphm[1] = -1;
1.83 - pNew->addrOpenEphm[2] = -1;
1.84 - if( pNew==&standin) {
1.85 - clearSelect(pNew);
1.86 - pNew = 0;
1.87 - }
1.88 - return pNew;
1.89 -}
1.90 -
1.91 -/*
1.92 -** Delete the given Select structure and all of its substructures.
1.93 -*/
1.94 -void sqlite3SelectDelete(Select *p){
1.95 - if( p ){
1.96 - clearSelect(p);
1.97 - sqlite3_free(p);
1.98 - }
1.99 -}
1.100 -
1.101 -/*
1.102 -** Given 1 to 3 identifiers preceeding the JOIN keyword, determine the
1.103 -** type of join. Return an integer constant that expresses that type
1.104 -** in terms of the following bit values:
1.105 -**
1.106 -** JT_INNER
1.107 -** JT_CROSS
1.108 -** JT_OUTER
1.109 -** JT_NATURAL
1.110 -** JT_LEFT
1.111 -** JT_RIGHT
1.112 -**
1.113 -** A full outer join is the combination of JT_LEFT and JT_RIGHT.
1.114 -**
1.115 -** If an illegal or unsupported join type is seen, then still return
1.116 -** a join type, but put an error in the pParse structure.
1.117 -*/
1.118 -int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){
1.119 - int jointype = 0;
1.120 - Token *apAll[3];
1.121 - Token *p;
1.122 - static const struct {
1.123 - const char zKeyword[8];
1.124 - u8 nChar;
1.125 - u8 code;
1.126 - } keywords[] = {
1.127 - { "natural", 7, JT_NATURAL },
1.128 - { "left", 4, JT_LEFT|JT_OUTER },
1.129 - { "right", 5, JT_RIGHT|JT_OUTER },
1.130 - { "full", 4, JT_LEFT|JT_RIGHT|JT_OUTER },
1.131 - { "outer", 5, JT_OUTER },
1.132 - { "inner", 5, JT_INNER },
1.133 - { "cross", 5, JT_INNER|JT_CROSS },
1.134 - };
1.135 - int i, j;
1.136 - apAll[0] = pA;
1.137 - apAll[1] = pB;
1.138 - apAll[2] = pC;
1.139 - for(i=0; i<3 && apAll[i]; i++){
1.140 - p = apAll[i];
1.141 - for(j=0; j<sizeof(keywords)/sizeof(keywords[0]); j++){
1.142 - if( p->n==keywords[j].nChar
1.143 - && sqlite3StrNICmp((char*)p->z, keywords[j].zKeyword, p->n)==0 ){
1.144 - jointype |= keywords[j].code;
1.145 - break;
1.146 - }
1.147 - }
1.148 - if( j>=sizeof(keywords)/sizeof(keywords[0]) ){
1.149 - jointype |= JT_ERROR;
1.150 - break;
1.151 - }
1.152 - }
1.153 - if(
1.154 - (jointype & (JT_INNER|JT_OUTER))==(JT_INNER|JT_OUTER) ||
1.155 - (jointype & JT_ERROR)!=0
1.156 - ){
1.157 - const char *zSp1 = " ";
1.158 - const char *zSp2 = " ";
1.159 - if( pB==0 ){ zSp1++; }
1.160 - if( pC==0 ){ zSp2++; }
1.161 - sqlite3ErrorMsg(pParse, "unknown or unsupported join type: "
1.162 - "%T%s%T%s%T", pA, zSp1, pB, zSp2, pC);
1.163 - jointype = JT_INNER;
1.164 - }else if( jointype & JT_RIGHT ){
1.165 - sqlite3ErrorMsg(pParse,
1.166 - "RIGHT and FULL OUTER JOINs are not currently supported");
1.167 - jointype = JT_INNER;
1.168 - }
1.169 - return jointype;
1.170 -}
1.171 -
1.172 -/*
1.173 -** Return the index of a column in a table. Return -1 if the column
1.174 -** is not contained in the table.
1.175 -*/
1.176 -static int columnIndex(Table *pTab, const char *zCol){
1.177 - int i;
1.178 - for(i=0; i<pTab->nCol; i++){
1.179 - if( sqlite3StrICmp(pTab->aCol[i].zName, zCol)==0 ) return i;
1.180 - }
1.181 - return -1;
1.182 -}
1.183 -
1.184 -/*
1.185 -** Set the value of a token to a '\000'-terminated string.
1.186 -*/
1.187 -static void setToken(Token *p, const char *z){
1.188 - p->z = (u8*)z;
1.189 - p->n = z ? strlen(z) : 0;
1.190 - p->dyn = 0;
1.191 -}
1.192 -
1.193 -/*
1.194 -** Set the token to the double-quoted and escaped version of the string pointed
1.195 -** to by z. For example;
1.196 -**
1.197 -** {a"bc} -> {"a""bc"}
1.198 -*/
1.199 -static void setQuotedToken(Parse *pParse, Token *p, const char *z){
1.200 - p->z = (u8 *)sqlite3MPrintf(0, "\"%w\"", z);
1.201 - p->dyn = 1;
1.202 - if( p->z ){
1.203 - p->n = strlen((char *)p->z);
1.204 - }else{
1.205 - pParse->db->mallocFailed = 1;
1.206 - }
1.207 -}
1.208 -
1.209 -/*
1.210 -** Create an expression node for an identifier with the name of zName
1.211 -*/
1.212 -Expr *sqlite3CreateIdExpr(Parse *pParse, const char *zName){
1.213 - Token dummy;
1.214 - setToken(&dummy, zName);
1.215 - return sqlite3PExpr(pParse, TK_ID, 0, 0, &dummy);
1.216 -}
1.217 -
1.218 -
1.219 -/*
1.220 -** Add a term to the WHERE expression in *ppExpr that requires the
1.221 -** zCol column to be equal in the two tables pTab1 and pTab2.
1.222 -*/
1.223 -static void addWhereTerm(
1.224 - Parse *pParse, /* Parsing context */
1.225 - const char *zCol, /* Name of the column */
1.226 - const Table *pTab1, /* First table */
1.227 - const char *zAlias1, /* Alias for first table. May be NULL */
1.228 - const Table *pTab2, /* Second table */
1.229 - const char *zAlias2, /* Alias for second table. May be NULL */
1.230 - int iRightJoinTable, /* VDBE cursor for the right table */
1.231 - Expr **ppExpr /* Add the equality term to this expression */
1.232 -){
1.233 - Expr *pE1a, *pE1b, *pE1c;
1.234 - Expr *pE2a, *pE2b, *pE2c;
1.235 - Expr *pE;
1.236 -
1.237 - pE1a = sqlite3CreateIdExpr(pParse, zCol);
1.238 - pE2a = sqlite3CreateIdExpr(pParse, zCol);
1.239 - if( zAlias1==0 ){
1.240 - zAlias1 = pTab1->zName;
1.241 - }
1.242 - pE1b = sqlite3CreateIdExpr(pParse, zAlias1);
1.243 - if( zAlias2==0 ){
1.244 - zAlias2 = pTab2->zName;
1.245 - }
1.246 - pE2b = sqlite3CreateIdExpr(pParse, zAlias2);
1.247 - pE1c = sqlite3PExpr(pParse, TK_DOT, pE1b, pE1a, 0);
1.248 - pE2c = sqlite3PExpr(pParse, TK_DOT, pE2b, pE2a, 0);
1.249 - pE = sqlite3PExpr(pParse, TK_EQ, pE1c, pE2c, 0);
1.250 - if( pE ){
1.251 - ExprSetProperty(pE, EP_FromJoin);
1.252 - pE->iRightJoinTable = iRightJoinTable;
1.253 - }
1.254 - pE = sqlite3ExprAnd(pParse->db,*ppExpr, pE);
1.255 - if( pE ){
1.256 - *ppExpr = pE;
1.257 - }
1.258 -}
1.259 -
1.260 -/*
1.261 -** Set the EP_FromJoin property on all terms of the given expression.
1.262 -** And set the Expr.iRightJoinTable to iTable for every term in the
1.263 -** expression.
1.264 -**
1.265 -** The EP_FromJoin property is used on terms of an expression to tell
1.266 -** the LEFT OUTER JOIN processing logic that this term is part of the
1.267 -** join restriction specified in the ON or USING clause and not a part
1.268 -** of the more general WHERE clause. These terms are moved over to the
1.269 -** WHERE clause during join processing but we need to remember that they
1.270 -** originated in the ON or USING clause.
1.271 -**
1.272 -** The Expr.iRightJoinTable tells the WHERE clause processing that the
1.273 -** expression depends on table iRightJoinTable even if that table is not
1.274 -** explicitly mentioned in the expression. That information is needed
1.275 -** for cases like this:
1.276 -**
1.277 -** SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.b AND t1.x=5
1.278 -**
1.279 -** The where clause needs to defer the handling of the t1.x=5
1.280 -** term until after the t2 loop of the join. In that way, a
1.281 -** NULL t2 row will be inserted whenever t1.x!=5. If we do not
1.282 -** defer the handling of t1.x=5, it will be processed immediately
1.283 -** after the t1 loop and rows with t1.x!=5 will never appear in
1.284 -** the output, which is incorrect.
1.285 -*/
1.286 -static void setJoinExpr(Expr *p, int iTable){
1.287 - while( p ){
1.288 - ExprSetProperty(p, EP_FromJoin);
1.289 - p->iRightJoinTable = iTable;
1.290 - setJoinExpr(p->pLeft, iTable);
1.291 - p = p->pRight;
1.292 - }
1.293 -}
1.294 -
1.295 -/*
1.296 -** This routine processes the join information for a SELECT statement.
1.297 -** ON and USING clauses are converted into extra terms of the WHERE clause.
1.298 -** NATURAL joins also create extra WHERE clause terms.
1.299 -**
1.300 -** The terms of a FROM clause are contained in the Select.pSrc structure.
1.301 -** The left most table is the first entry in Select.pSrc. The right-most
1.302 -** table is the last entry. The join operator is held in the entry to
1.303 -** the left. Thus entry 0 contains the join operator for the join between
1.304 -** entries 0 and 1. Any ON or USING clauses associated with the join are
1.305 -** also attached to the left entry.
1.306 -**
1.307 -** This routine returns the number of errors encountered.
1.308 -*/
1.309 -static int sqliteProcessJoin(Parse *pParse, Select *p){
1.310 - SrcList *pSrc; /* All tables in the FROM clause */
1.311 - int i, j; /* Loop counters */
1.312 - struct SrcList_item *pLeft; /* Left table being joined */
1.313 - struct SrcList_item *pRight; /* Right table being joined */
1.314 -
1.315 - pSrc = p->pSrc;
1.316 - pLeft = &pSrc->a[0];
1.317 - pRight = &pLeft[1];
1.318 - for(i=0; i<pSrc->nSrc-1; i++, pRight++, pLeft++){
1.319 - Table *pLeftTab = pLeft->pTab;
1.320 - Table *pRightTab = pRight->pTab;
1.321 -
1.322 - if( pLeftTab==0 || pRightTab==0 ) continue;
1.323 -
1.324 - /* When the NATURAL keyword is present, add WHERE clause terms for
1.325 - ** every column that the two tables have in common.
1.326 - */
1.327 - if( pRight->jointype & JT_NATURAL ){
1.328 - if( pRight->pOn || pRight->pUsing ){
1.329 - sqlite3ErrorMsg(pParse, "a NATURAL join may not have "
1.330 - "an ON or USING clause", 0);
1.331 - return 1;
1.332 - }
1.333 - for(j=0; j<pLeftTab->nCol; j++){
1.334 - char *zName = pLeftTab->aCol[j].zName;
1.335 - if( columnIndex(pRightTab, zName)>=0 ){
1.336 - addWhereTerm(pParse, zName, pLeftTab, pLeft->zAlias,
1.337 - pRightTab, pRight->zAlias,
1.338 - pRight->iCursor, &p->pWhere);
1.339 -
1.340 - }
1.341 - }
1.342 - }
1.343 -
1.344 - /* Disallow both ON and USING clauses in the same join
1.345 - */
1.346 - if( pRight->pOn && pRight->pUsing ){
1.347 - sqlite3ErrorMsg(pParse, "cannot have both ON and USING "
1.348 - "clauses in the same join");
1.349 - return 1;
1.350 - }
1.351 -
1.352 - /* Add the ON clause to the end of the WHERE clause, connected by
1.353 - ** an AND operator.
1.354 - */
1.355 - if( pRight->pOn ){
1.356 - setJoinExpr(pRight->pOn, pRight->iCursor);
1.357 - p->pWhere = sqlite3ExprAnd(pParse->db, p->pWhere, pRight->pOn);
1.358 - pRight->pOn = 0;
1.359 - }
1.360 -
1.361 - /* Create extra terms on the WHERE clause for each column named
1.362 - ** in the USING clause. Example: If the two tables to be joined are
1.363 - ** A and B and the USING clause names X, Y, and Z, then add this
1.364 - ** to the WHERE clause: A.X=B.X AND A.Y=B.Y AND A.Z=B.Z
1.365 - ** Report an error if any column mentioned in the USING clause is
1.366 - ** not contained in both tables to be joined.
1.367 - */
1.368 - if( pRight->pUsing ){
1.369 - IdList *pList = pRight->pUsing;
1.370 - for(j=0; j<pList->nId; j++){
1.371 - char *zName = pList->a[j].zName;
1.372 - if( columnIndex(pLeftTab, zName)<0 || columnIndex(pRightTab, zName)<0 ){
1.373 - sqlite3ErrorMsg(pParse, "cannot join using column %s - column "
1.374 - "not present in both tables", zName);
1.375 - return 1;
1.376 - }
1.377 - addWhereTerm(pParse, zName, pLeftTab, pLeft->zAlias,
1.378 - pRightTab, pRight->zAlias,
1.379 - pRight->iCursor, &p->pWhere);
1.380 - }
1.381 - }
1.382 - }
1.383 - return 0;
1.384 -}
1.385 -
1.386 -/*
1.387 -** Insert code into "v" that will push the record on the top of the
1.388 -** stack into the sorter.
1.389 -*/
1.390 -static void pushOntoSorter(
1.391 - Parse *pParse, /* Parser context */
1.392 - ExprList *pOrderBy, /* The ORDER BY clause */
1.393 - Select *pSelect /* The whole SELECT statement */
1.394 -){
1.395 - Vdbe *v = pParse->pVdbe;
1.396 - sqlite3ExprCodeExprList(pParse, pOrderBy);
1.397 - sqlite3VdbeAddOp(v, OP_Sequence, pOrderBy->iECursor, 0);
1.398 - sqlite3VdbeAddOp(v, OP_Pull, pOrderBy->nExpr + 1, 0);
1.399 - sqlite3VdbeAddOp(v, OP_MakeRecord, pOrderBy->nExpr + 2, 0);
1.400 - sqlite3VdbeAddOp(v, OP_IdxInsert, pOrderBy->iECursor, 0);
1.401 - if( pSelect->iLimit>=0 ){
1.402 - int addr1, addr2;
1.403 - addr1 = sqlite3VdbeAddOp(v, OP_IfMemZero, pSelect->iLimit+1, 0);
1.404 - sqlite3VdbeAddOp(v, OP_MemIncr, -1, pSelect->iLimit+1);
1.405 - addr2 = sqlite3VdbeAddOp(v, OP_Goto, 0, 0);
1.406 - sqlite3VdbeJumpHere(v, addr1);
1.407 - sqlite3VdbeAddOp(v, OP_Last, pOrderBy->iECursor, 0);
1.408 - sqlite3VdbeAddOp(v, OP_Delete, pOrderBy->iECursor, 0);
1.409 - sqlite3VdbeJumpHere(v, addr2);
1.410 - pSelect->iLimit = -1;
1.411 - }
1.412 -}
1.413 -
1.414 -/*
1.415 -** Add code to implement the OFFSET
1.416 -*/
1.417 -static void codeOffset(
1.418 - Vdbe *v, /* Generate code into this VM */
1.419 - Select *p, /* The SELECT statement being coded */
1.420 - int iContinue, /* Jump here to skip the current record */
1.421 - int nPop /* Number of times to pop stack when jumping */
1.422 -){
1.423 - if( p->iOffset>=0 && iContinue!=0 ){
1.424 - int addr;
1.425 - sqlite3VdbeAddOp(v, OP_MemIncr, -1, p->iOffset);
1.426 - addr = sqlite3VdbeAddOp(v, OP_IfMemNeg, p->iOffset, 0);
1.427 - if( nPop>0 ){
1.428 - sqlite3VdbeAddOp(v, OP_Pop, nPop, 0);
1.429 - }
1.430 - sqlite3VdbeAddOp(v, OP_Goto, 0, iContinue);
1.431 - VdbeComment((v, "# skip OFFSET records"));
1.432 - sqlite3VdbeJumpHere(v, addr);
1.433 - }
1.434 -}
1.435 -
1.436 -/*
1.437 -** Add code that will check to make sure the top N elements of the
1.438 -** stack are distinct. iTab is a sorting index that holds previously
1.439 -** seen combinations of the N values. A new entry is made in iTab
1.440 -** if the current N values are new.
1.441 -**
1.442 -** A jump to addrRepeat is made and the N+1 values are popped from the
1.443 -** stack if the top N elements are not distinct.
1.444 -*/
1.445 -static void codeDistinct(
1.446 - Vdbe *v, /* Generate code into this VM */
1.447 - int iTab, /* A sorting index used to test for distinctness */
1.448 - int addrRepeat, /* Jump to here if not distinct */
1.449 - int N /* The top N elements of the stack must be distinct */
1.450 -){
1.451 - sqlite3VdbeAddOp(v, OP_MakeRecord, -N, 0);
1.452 - sqlite3VdbeAddOp(v, OP_Distinct, iTab, sqlite3VdbeCurrentAddr(v)+3);
1.453 - sqlite3VdbeAddOp(v, OP_Pop, N+1, 0);
1.454 - sqlite3VdbeAddOp(v, OP_Goto, 0, addrRepeat);
1.455 - VdbeComment((v, "# skip indistinct records"));
1.456 - sqlite3VdbeAddOp(v, OP_IdxInsert, iTab, 0);
1.457 -}
1.458 -
1.459 -/*
1.460 -** Generate an error message when a SELECT is used within a subexpression
1.461 -** (example: "a IN (SELECT * FROM table)") but it has more than 1 result
1.462 -** column. We do this in a subroutine because the error occurs in multiple
1.463 -** places.
1.464 -*/
1.465 -static int checkForMultiColumnSelectError(Parse *pParse, int eDest, int nExpr){
1.466 - if( nExpr>1 && (eDest==SRT_Mem || eDest==SRT_Set) ){
1.467 - sqlite3ErrorMsg(pParse, "only a single result allowed for "
1.468 - "a SELECT that is part of an expression");
1.469 - return 1;
1.470 - }else{
1.471 - return 0;
1.472 - }
1.473 -}
1.474 -
1.475 -/*
1.476 -** This routine generates the code for the inside of the inner loop
1.477 -** of a SELECT.
1.478 -**
1.479 -** If srcTab and nColumn are both zero, then the pEList expressions
1.480 -** are evaluated in order to get the data for this row. If nColumn>0
1.481 -** then data is pulled from srcTab and pEList is used only to get the
1.482 -** datatypes for each column.
1.483 -*/
1.484 -static int selectInnerLoop(
1.485 - Parse *pParse, /* The parser context */
1.486 - Select *p, /* The complete select statement being coded */
1.487 - ExprList *pEList, /* List of values being extracted */
1.488 - int srcTab, /* Pull data from this table */
1.489 - int nColumn, /* Number of columns in the source table */
1.490 - ExprList *pOrderBy, /* If not NULL, sort results using this key */
1.491 - int distinct, /* If >=0, make sure results are distinct */
1.492 - int eDest, /* How to dispose of the results */
1.493 - int iParm, /* An argument to the disposal method */
1.494 - int iContinue, /* Jump here to continue with next row */
1.495 - int iBreak, /* Jump here to break out of the inner loop */
1.496 - char *aff /* affinity string if eDest is SRT_Union */
1.497 -){
1.498 - Vdbe *v = pParse->pVdbe;
1.499 - int i;
1.500 - int hasDistinct; /* True if the DISTINCT keyword is present */
1.501 -
1.502 - if( v==0 ) return 0;
1.503 - assert( pEList!=0 );
1.504 -
1.505 - /* If there was a LIMIT clause on the SELECT statement, then do the check
1.506 - ** to see if this row should be output.
1.507 - */
1.508 - hasDistinct = distinct>=0 && pEList->nExpr>0;
1.509 - if( pOrderBy==0 && !hasDistinct ){
1.510 - codeOffset(v, p, iContinue, 0);
1.511 - }
1.512 -
1.513 - /* Pull the requested columns.
1.514 - */
1.515 - if( nColumn>0 ){
1.516 - for(i=0; i<nColumn; i++){
1.517 - sqlite3VdbeAddOp(v, OP_Column, srcTab, i);
1.518 - }
1.519 - }else{
1.520 - nColumn = pEList->nExpr;
1.521 - sqlite3ExprCodeExprList(pParse, pEList);
1.522 - }
1.523 -
1.524 - /* If the DISTINCT keyword was present on the SELECT statement
1.525 - ** and this row has been seen before, then do not make this row
1.526 - ** part of the result.
1.527 - */
1.528 - if( hasDistinct ){
1.529 - assert( pEList!=0 );
1.530 - assert( pEList->nExpr==nColumn );
1.531 - codeDistinct(v, distinct, iContinue, nColumn);
1.532 - if( pOrderBy==0 ){
1.533 - codeOffset(v, p, iContinue, nColumn);
1.534 - }
1.535 - }
1.536 -
1.537 - if( checkForMultiColumnSelectError(pParse, eDest, pEList->nExpr) ){
1.538 - return 0;
1.539 - }
1.540 -
1.541 - switch( eDest ){
1.542 - /* In this mode, write each query result to the key of the temporary
1.543 - ** table iParm.
1.544 - */
1.545 -#ifndef SQLITE_OMIT_COMPOUND_SELECT
1.546 - case SRT_Union: {
1.547 - sqlite3VdbeAddOp(v, OP_MakeRecord, nColumn, 0);
1.548 - if( aff ){
1.549 - sqlite3VdbeChangeP3(v, -1, aff, P3_STATIC);
1.550 - }
1.551 - sqlite3VdbeAddOp(v, OP_IdxInsert, iParm, 0);
1.552 - break;
1.553 - }
1.554 -
1.555 - /* Construct a record from the query result, but instead of
1.556 - ** saving that record, use it as a key to delete elements from
1.557 - ** the temporary table iParm.
1.558 - */
1.559 - case SRT_Except: {
1.560 - int addr;
1.561 - addr = sqlite3VdbeAddOp(v, OP_MakeRecord, nColumn, 0);
1.562 - sqlite3VdbeChangeP3(v, -1, aff, P3_STATIC);
1.563 - sqlite3VdbeAddOp(v, OP_NotFound, iParm, addr+3);
1.564 - sqlite3VdbeAddOp(v, OP_Delete, iParm, 0);
1.565 - break;
1.566 - }
1.567 -#endif
1.568 -
1.569 - /* Store the result as data using a unique key.
1.570 - */
1.571 - case SRT_Table:
1.572 - case SRT_EphemTab: {
1.573 - sqlite3VdbeAddOp(v, OP_MakeRecord, nColumn, 0);
1.574 - if( pOrderBy ){
1.575 - pushOntoSorter(pParse, pOrderBy, p);
1.576 - }else{
1.577 - sqlite3VdbeAddOp(v, OP_NewRowid, iParm, 0);
1.578 - sqlite3VdbeAddOp(v, OP_Pull, 1, 0);
1.579 - sqlite3VdbeAddOp(v, OP_Insert, iParm, OPFLAG_APPEND);
1.580 - }
1.581 - break;
1.582 - }
1.583 -
1.584 -#ifndef SQLITE_OMIT_SUBQUERY
1.585 - /* If we are creating a set for an "expr IN (SELECT ...)" construct,
1.586 - ** then there should be a single item on the stack. Write this
1.587 - ** item into the set table with bogus data.
1.588 - */
1.589 - case SRT_Set: {
1.590 - int addr1 = sqlite3VdbeCurrentAddr(v);
1.591 - int addr2;
1.592 -
1.593 - assert( nColumn==1 );
1.594 - sqlite3VdbeAddOp(v, OP_NotNull, -1, addr1+3);
1.595 - sqlite3VdbeAddOp(v, OP_Pop, 1, 0);
1.596 - addr2 = sqlite3VdbeAddOp(v, OP_Goto, 0, 0);
1.597 - p->affinity = sqlite3CompareAffinity(pEList->a[0].pExpr,(iParm>>16)&0xff);
1.598 - if( pOrderBy ){
1.599 - /* At first glance you would think we could optimize out the
1.600 - ** ORDER BY in this case since the order of entries in the set
1.601 - ** does not matter. But there might be a LIMIT clause, in which
1.602 - ** case the order does matter */
1.603 - pushOntoSorter(pParse, pOrderBy, p);
1.604 - }else{
1.605 - sqlite3VdbeOp3(v, OP_MakeRecord, 1, 0, &p->affinity, 1);
1.606 - sqlite3VdbeAddOp(v, OP_IdxInsert, (iParm&0x0000FFFF), 0);
1.607 - }
1.608 - sqlite3VdbeJumpHere(v, addr2);
1.609 - break;
1.610 - }
1.611 -
1.612 - /* If any row exist in the result set, record that fact and abort.
1.613 - */
1.614 - case SRT_Exists: {
1.615 - sqlite3VdbeAddOp(v, OP_MemInt, 1, iParm);
1.616 - sqlite3VdbeAddOp(v, OP_Pop, nColumn, 0);
1.617 - /* The LIMIT clause will terminate the loop for us */
1.618 - break;
1.619 - }
1.620 -
1.621 - /* If this is a scalar select that is part of an expression, then
1.622 - ** store the results in the appropriate memory cell and break out
1.623 - ** of the scan loop.
1.624 - */
1.625 - case SRT_Mem: {
1.626 - assert( nColumn==1 );
1.627 - if( pOrderBy ){
1.628 - pushOntoSorter(pParse, pOrderBy, p);
1.629 - }else{
1.630 - sqlite3VdbeAddOp(v, OP_MemStore, iParm, 1);
1.631 - /* The LIMIT clause will jump out of the loop for us */
1.632 - }
1.633 - break;
1.634 - }
1.635 -#endif /* #ifndef SQLITE_OMIT_SUBQUERY */
1.636 -
1.637 - /* Send the data to the callback function or to a subroutine. In the
1.638 - ** case of a subroutine, the subroutine itself is responsible for
1.639 - ** popping the data from the stack.
1.640 - */
1.641 - case SRT_Subroutine:
1.642 - case SRT_Callback: {
1.643 - if( pOrderBy ){
1.644 - sqlite3VdbeAddOp(v, OP_MakeRecord, nColumn, 0);
1.645 - pushOntoSorter(pParse, pOrderBy, p);
1.646 - }else if( eDest==SRT_Subroutine ){
1.647 - sqlite3VdbeAddOp(v, OP_Gosub, 0, iParm);
1.648 - }else{
1.649 - sqlite3VdbeAddOp(v, OP_Callback, nColumn, 0);
1.650 - }
1.651 - break;
1.652 - }
1.653 -
1.654 -#if !defined(SQLITE_OMIT_TRIGGER)
1.655 - /* Discard the results. This is used for SELECT statements inside
1.656 - ** the body of a TRIGGER. The purpose of such selects is to call
1.657 - ** user-defined functions that have side effects. We do not care
1.658 - ** about the actual results of the select.
1.659 - */
1.660 - default: {
1.661 - assert( eDest==SRT_Discard );
1.662 - sqlite3VdbeAddOp(v, OP_Pop, nColumn, 0);
1.663 - break;
1.664 - }
1.665 -#endif
1.666 - }
1.667 -
1.668 - /* Jump to the end of the loop if the LIMIT is reached.
1.669 - */
1.670 - if( p->iLimit>=0 && pOrderBy==0 ){
1.671 - sqlite3VdbeAddOp(v, OP_MemIncr, -1, p->iLimit);
1.672 - sqlite3VdbeAddOp(v, OP_IfMemZero, p->iLimit, iBreak);
1.673 - }
1.674 - return 0;
1.675 -}
1.676 -
1.677 -/*
1.678 -** Given an expression list, generate a KeyInfo structure that records
1.679 -** the collating sequence for each expression in that expression list.
1.680 -**
1.681 -** If the ExprList is an ORDER BY or GROUP BY clause then the resulting
1.682 -** KeyInfo structure is appropriate for initializing a virtual index to
1.683 -** implement that clause. If the ExprList is the result set of a SELECT
1.684 -** then the KeyInfo structure is appropriate for initializing a virtual
1.685 -** index to implement a DISTINCT test.
1.686 -**
1.687 -** Space to hold the KeyInfo structure is obtain from malloc. The calling
1.688 -** function is responsible for seeing that this structure is eventually
1.689 -** freed. Add the KeyInfo structure to the P3 field of an opcode using
1.690 -** P3_KEYINFO_HANDOFF is the usual way of dealing with this.
1.691 -*/
1.692 -static KeyInfo *keyInfoFromExprList(Parse *pParse, ExprList *pList){
1.693 - sqlite3 *db = pParse->db;
1.694 - int nExpr;
1.695 - KeyInfo *pInfo;
1.696 - struct ExprList_item *pItem;
1.697 - int i;
1.698 -
1.699 - nExpr = pList->nExpr;
1.700 - pInfo = sqlite3DbMallocZero(db, sizeof(*pInfo) + nExpr*(sizeof(CollSeq*)+1) );
1.701 - if( pInfo ){
1.702 - pInfo->aSortOrder = (u8*)&pInfo->aColl[nExpr];
1.703 - pInfo->nField = nExpr;
1.704 - pInfo->enc = ENC(db);
1.705 - for(i=0, pItem=pList->a; i<nExpr; i++, pItem++){
1.706 - CollSeq *pColl;
1.707 - pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
1.708 - if( !pColl ){
1.709 - pColl = db->pDfltColl;
1.710 - }
1.711 - pInfo->aColl[i] = pColl;
1.712 - pInfo->aSortOrder[i] = pItem->sortOrder;
1.713 - }
1.714 - }
1.715 - return pInfo;
1.716 -}
1.717 -
1.718 -
1.719 -/*
1.720 -** If the inner loop was generated using a non-null pOrderBy argument,
1.721 -** then the results were placed in a sorter. After the loop is terminated
1.722 -** we need to run the sorter and output the results. The following
1.723 -** routine generates the code needed to do that.
1.724 -*/
1.725 -static void generateSortTail(
1.726 - Parse *pParse, /* Parsing context */
1.727 - Select *p, /* The SELECT statement */
1.728 - Vdbe *v, /* Generate code into this VDBE */
1.729 - int nColumn, /* Number of columns of data */
1.730 - int eDest, /* Write the sorted results here */
1.731 - int iParm /* Optional parameter associated with eDest */
1.732 -){
1.733 - int brk = sqlite3VdbeMakeLabel(v);
1.734 - int cont = sqlite3VdbeMakeLabel(v);
1.735 - int addr;
1.736 - int iTab;
1.737 - int pseudoTab = 0;
1.738 - ExprList *pOrderBy = p->pOrderBy;
1.739 -
1.740 - iTab = pOrderBy->iECursor;
1.741 - if( eDest==SRT_Callback || eDest==SRT_Subroutine ){
1.742 - pseudoTab = pParse->nTab++;
1.743 - sqlite3VdbeAddOp(v, OP_OpenPseudo, pseudoTab, 0);
1.744 - sqlite3VdbeAddOp(v, OP_SetNumColumns, pseudoTab, nColumn);
1.745 - }
1.746 - addr = 1 + sqlite3VdbeAddOp(v, OP_Sort, iTab, brk);
1.747 - codeOffset(v, p, cont, 0);
1.748 - if( eDest==SRT_Callback || eDest==SRT_Subroutine ){
1.749 - sqlite3VdbeAddOp(v, OP_Integer, 1, 0);
1.750 - }
1.751 - sqlite3VdbeAddOp(v, OP_Column, iTab, pOrderBy->nExpr + 1);
1.752 - switch( eDest ){
1.753 - case SRT_Table:
1.754 - case SRT_EphemTab: {
1.755 - sqlite3VdbeAddOp(v, OP_NewRowid, iParm, 0);
1.756 - sqlite3VdbeAddOp(v, OP_Pull, 1, 0);
1.757 - sqlite3VdbeAddOp(v, OP_Insert, iParm, OPFLAG_APPEND);
1.758 - break;
1.759 - }
1.760 -#ifndef SQLITE_OMIT_SUBQUERY
1.761 - case SRT_Set: {
1.762 - assert( nColumn==1 );
1.763 - sqlite3VdbeAddOp(v, OP_NotNull, -1, sqlite3VdbeCurrentAddr(v)+3);
1.764 - sqlite3VdbeAddOp(v, OP_Pop, 1, 0);
1.765 - sqlite3VdbeAddOp(v, OP_Goto, 0, sqlite3VdbeCurrentAddr(v)+3);
1.766 - sqlite3VdbeOp3(v, OP_MakeRecord, 1, 0, &p->affinity, 1);
1.767 - sqlite3VdbeAddOp(v, OP_IdxInsert, (iParm&0x0000FFFF), 0);
1.768 - break;
1.769 - }
1.770 - case SRT_Mem: {
1.771 - assert( nColumn==1 );
1.772 - sqlite3VdbeAddOp(v, OP_MemStore, iParm, 1);
1.773 - /* The LIMIT clause will terminate the loop for us */
1.774 - break;
1.775 - }
1.776 -#endif
1.777 - case SRT_Callback:
1.778 - case SRT_Subroutine: {
1.779 - int i;
1.780 - sqlite3VdbeAddOp(v, OP_Insert, pseudoTab, 0);
1.781 - for(i=0; i<nColumn; i++){
1.782 - sqlite3VdbeAddOp(v, OP_Column, pseudoTab, i);
1.783 - }
1.784 - if( eDest==SRT_Callback ){
1.785 - sqlite3VdbeAddOp(v, OP_Callback, nColumn, 0);
1.786 - }else{
1.787 - sqlite3VdbeAddOp(v, OP_Gosub, 0, iParm);
1.788 - }
1.789 - break;
1.790 - }
1.791 - default: {
1.792 - /* Do nothing */
1.793 - break;
1.794 - }
1.795 - }
1.796 -
1.797 - /* Jump to the end of the loop when the LIMIT is reached
1.798 - */
1.799 - if( p->iLimit>=0 ){
1.800 - sqlite3VdbeAddOp(v, OP_MemIncr, -1, p->iLimit);
1.801 - sqlite3VdbeAddOp(v, OP_IfMemZero, p->iLimit, brk);
1.802 - }
1.803 -
1.804 - /* The bottom of the loop
1.805 - */
1.806 - sqlite3VdbeResolveLabel(v, cont);
1.807 - sqlite3VdbeAddOp(v, OP_Next, iTab, addr);
1.808 - sqlite3VdbeResolveLabel(v, brk);
1.809 - if( eDest==SRT_Callback || eDest==SRT_Subroutine ){
1.810 - sqlite3VdbeAddOp(v, OP_Close, pseudoTab, 0);
1.811 - }
1.812 -
1.813 -}
1.814 -
1.815 -/*
1.816 -** Return a pointer to a string containing the 'declaration type' of the
1.817 -** expression pExpr. The string may be treated as static by the caller.
1.818 -**
1.819 -** The declaration type is the exact datatype definition extracted from the
1.820 -** original CREATE TABLE statement if the expression is a column. The
1.821 -** declaration type for a ROWID field is INTEGER. Exactly when an expression
1.822 -** is considered a column can be complex in the presence of subqueries. The
1.823 -** result-set expression in all of the following SELECT statements is
1.824 -** considered a column by this function.
1.825 -**
1.826 -** SELECT col FROM tbl;
1.827 -** SELECT (SELECT col FROM tbl;
1.828 -** SELECT (SELECT col FROM tbl);
1.829 -** SELECT abc FROM (SELECT col AS abc FROM tbl);
1.830 -**
1.831 -** The declaration type for any expression other than a column is NULL.
1.832 -*/
1.833 -static const char *columnType(
1.834 - NameContext *pNC,
1.835 - Expr *pExpr,
1.836 - const char **pzOriginDb,
1.837 - const char **pzOriginTab,
1.838 - const char **pzOriginCol
1.839 -){
1.840 - char const *zType = 0;
1.841 - char const *zOriginDb = 0;
1.842 - char const *zOriginTab = 0;
1.843 - char const *zOriginCol = 0;
1.844 - int j;
1.845 - if( pExpr==0 || pNC->pSrcList==0 ) return 0;
1.846 -
1.847 - switch( pExpr->op ){
1.848 - case TK_AGG_COLUMN:
1.849 - case TK_COLUMN: {
1.850 - /* The expression is a column. Locate the table the column is being
1.851 - ** extracted from in NameContext.pSrcList. This table may be real
1.852 - ** database table or a subquery.
1.853 - */
1.854 - Table *pTab = 0; /* Table structure column is extracted from */
1.855 - Select *pS = 0; /* Select the column is extracted from */
1.856 - int iCol = pExpr->iColumn; /* Index of column in pTab */
1.857 - while( pNC && !pTab ){
1.858 - SrcList *pTabList = pNC->pSrcList;
1.859 - for(j=0;j<pTabList->nSrc && pTabList->a[j].iCursor!=pExpr->iTable;j++);
1.860 - if( j<pTabList->nSrc ){
1.861 - pTab = pTabList->a[j].pTab;
1.862 - pS = pTabList->a[j].pSelect;
1.863 - }else{
1.864 - pNC = pNC->pNext;
1.865 - }
1.866 - }
1.867 -
1.868 - if( pTab==0 ){
1.869 - /* FIX ME:
1.870 - ** This can occurs if you have something like "SELECT new.x;" inside
1.871 - ** a trigger. In other words, if you reference the special "new"
1.872 - ** table in the result set of a select. We do not have a good way
1.873 - ** to find the actual table type, so call it "TEXT". This is really
1.874 - ** something of a bug, but I do not know how to fix it.
1.875 - **
1.876 - ** This code does not produce the correct answer - it just prevents
1.877 - ** a segfault. See ticket #1229.
1.878 - */
1.879 - zType = "TEXT";
1.880 - break;
1.881 - }
1.882 -
1.883 - assert( pTab );
1.884 - if( pS ){
1.885 - /* The "table" is actually a sub-select or a view in the FROM clause
1.886 - ** of the SELECT statement. Return the declaration type and origin
1.887 - ** data for the result-set column of the sub-select.
1.888 - */
1.889 - if( iCol>=0 && iCol<pS->pEList->nExpr ){
1.890 - /* If iCol is less than zero, then the expression requests the
1.891 - ** rowid of the sub-select or view. This expression is legal (see
1.892 - ** test case misc2.2.2) - it always evaluates to NULL.
1.893 - */
1.894 - NameContext sNC;
1.895 - Expr *p = pS->pEList->a[iCol].pExpr;
1.896 - sNC.pSrcList = pS->pSrc;
1.897 - sNC.pNext = 0;
1.898 - sNC.pParse = pNC->pParse;
1.899 - zType = columnType(&sNC, p, &zOriginDb, &zOriginTab, &zOriginCol);
1.900 - }
1.901 - }else if( pTab->pSchema ){
1.902 - /* A real table */
1.903 - assert( !pS );
1.904 - if( iCol<0 ) iCol = pTab->iPKey;
1.905 - assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
1.906 - if( iCol<0 ){
1.907 - zType = "INTEGER";
1.908 - zOriginCol = "rowid";
1.909 - }else{
1.910 - zType = pTab->aCol[iCol].zType;
1.911 - zOriginCol = pTab->aCol[iCol].zName;
1.912 - }
1.913 - zOriginTab = pTab->zName;
1.914 - if( pNC->pParse ){
1.915 - int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema);
1.916 - zOriginDb = pNC->pParse->db->aDb[iDb].zName;
1.917 - }
1.918 - }
1.919 - break;
1.920 - }
1.921 -#ifndef SQLITE_OMIT_SUBQUERY
1.922 - case TK_SELECT: {
1.923 - /* The expression is a sub-select. Return the declaration type and
1.924 - ** origin info for the single column in the result set of the SELECT
1.925 - ** statement.
1.926 - */
1.927 - NameContext sNC;
1.928 - Select *pS = pExpr->pSelect;
1.929 - Expr *p = pS->pEList->a[0].pExpr;
1.930 - sNC.pSrcList = pS->pSrc;
1.931 - sNC.pNext = pNC;
1.932 - sNC.pParse = pNC->pParse;
1.933 - zType = columnType(&sNC, p, &zOriginDb, &zOriginTab, &zOriginCol);
1.934 - break;
1.935 - }
1.936 -#endif
1.937 - }
1.938 -
1.939 - if( pzOriginDb ){
1.940 - assert( pzOriginTab && pzOriginCol );
1.941 - *pzOriginDb = zOriginDb;
1.942 - *pzOriginTab = zOriginTab;
1.943 - *pzOriginCol = zOriginCol;
1.944 - }
1.945 - return zType;
1.946 -}
1.947 -
1.948 -/*
1.949 -** Generate code that will tell the VDBE the declaration types of columns
1.950 -** in the result set.
1.951 -*/
1.952 -static void generateColumnTypes(
1.953 - Parse *pParse, /* Parser context */
1.954 - SrcList *pTabList, /* List of tables */
1.955 - ExprList *pEList /* Expressions defining the result set */
1.956 -){
1.957 - Vdbe *v = pParse->pVdbe;
1.958 - int i;
1.959 - NameContext sNC;
1.960 - sNC.pSrcList = pTabList;
1.961 - sNC.pParse = pParse;
1.962 - for(i=0; i<pEList->nExpr; i++){
1.963 - Expr *p = pEList->a[i].pExpr;
1.964 - const char *zOrigDb = 0;
1.965 - const char *zOrigTab = 0;
1.966 - const char *zOrigCol = 0;
1.967 - const char *zType = columnType(&sNC, p, &zOrigDb, &zOrigTab, &zOrigCol);
1.968 -
1.969 - /* The vdbe must make it's own copy of the column-type and other
1.970 - ** column specific strings, in case the schema is reset before this
1.971 - ** virtual machine is deleted.
1.972 - */
1.973 - sqlite3VdbeSetColName(v, i, COLNAME_DECLTYPE, zType, P3_TRANSIENT);
1.974 - sqlite3VdbeSetColName(v, i, COLNAME_DATABASE, zOrigDb, P3_TRANSIENT);
1.975 - sqlite3VdbeSetColName(v, i, COLNAME_TABLE, zOrigTab, P3_TRANSIENT);
1.976 - sqlite3VdbeSetColName(v, i, COLNAME_COLUMN, zOrigCol, P3_TRANSIENT);
1.977 - }
1.978 -}
1.979 -
1.980 -/*
1.981 -** Generate code that will tell the VDBE the names of columns
1.982 -** in the result set. This information is used to provide the
1.983 -** azCol[] values in the callback.
1.984 -*/
1.985 -static void generateColumnNames(
1.986 - Parse *pParse, /* Parser context */
1.987 - SrcList *pTabList, /* List of tables */
1.988 - ExprList *pEList /* Expressions defining the result set */
1.989 -){
1.990 - Vdbe *v = pParse->pVdbe;
1.991 - int i, j;
1.992 - sqlite3 *db = pParse->db;
1.993 - int fullNames, shortNames;
1.994 -
1.995 -#ifndef SQLITE_OMIT_EXPLAIN
1.996 - /* If this is an EXPLAIN, skip this step */
1.997 - if( pParse->explain ){
1.998 - return;
1.999 - }
1.1000 -#endif
1.1001 -
1.1002 - assert( v!=0 );
1.1003 - if( pParse->colNamesSet || v==0 || db->mallocFailed ) return;
1.1004 - pParse->colNamesSet = 1;
1.1005 - fullNames = (db->flags & SQLITE_FullColNames)!=0;
1.1006 - shortNames = (db->flags & SQLITE_ShortColNames)!=0;
1.1007 - sqlite3VdbeSetNumCols(v, pEList->nExpr);
1.1008 - for(i=0; i<pEList->nExpr; i++){
1.1009 - Expr *p;
1.1010 - p = pEList->a[i].pExpr;
1.1011 - if( p==0 ) continue;
1.1012 - if( pEList->a[i].zName ){
1.1013 - char *zName = pEList->a[i].zName;
1.1014 - sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, strlen(zName));
1.1015 - continue;
1.1016 - }
1.1017 - if( p->op==TK_COLUMN && pTabList ){
1.1018 - Table *pTab;
1.1019 - char *zCol;
1.1020 - int iCol = p->iColumn;
1.1021 - for(j=0; j<pTabList->nSrc && pTabList->a[j].iCursor!=p->iTable; j++){}
1.1022 - assert( j<pTabList->nSrc );
1.1023 - pTab = pTabList->a[j].pTab;
1.1024 - if( iCol<0 ) iCol = pTab->iPKey;
1.1025 - assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
1.1026 - if( iCol<0 ){
1.1027 - zCol = "rowid";
1.1028 - }else{
1.1029 - zCol = pTab->aCol[iCol].zName;
1.1030 - }
1.1031 - if( !shortNames && !fullNames && p->span.z && p->span.z[0] ){
1.1032 - sqlite3VdbeSetColName(v, i, COLNAME_NAME, (char*)p->span.z, p->span.n);
1.1033 - }else if( fullNames || (!shortNames && pTabList->nSrc>1) ){
1.1034 - char *zName = 0;
1.1035 - char *zTab;
1.1036 -
1.1037 - zTab = pTabList->a[j].zAlias;
1.1038 - if( fullNames || zTab==0 ) zTab = pTab->zName;
1.1039 - sqlite3SetString(&zName, zTab, ".", zCol, (char*)0);
1.1040 - sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, P3_DYNAMIC);
1.1041 - }else{
1.1042 - sqlite3VdbeSetColName(v, i, COLNAME_NAME, zCol, strlen(zCol));
1.1043 - }
1.1044 - }else if( p->span.z && p->span.z[0] ){
1.1045 - sqlite3VdbeSetColName(v, i, COLNAME_NAME, (char*)p->span.z, p->span.n);
1.1046 - /* sqlite3VdbeCompressSpace(v, addr); */
1.1047 - }else{
1.1048 - char zName[30];
1.1049 - assert( p->op!=TK_COLUMN || pTabList==0 );
1.1050 - sqlite3_snprintf(sizeof(zName), zName, "column%d", i+1);
1.1051 - sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, 0);
1.1052 - }
1.1053 - }
1.1054 - generateColumnTypes(pParse, pTabList, pEList);
1.1055 -}
1.1056 -
1.1057 -#ifndef SQLITE_OMIT_COMPOUND_SELECT
1.1058 -/*
1.1059 -** Name of the connection operator, used for error messages.
1.1060 -*/
1.1061 -static const char *selectOpName(int id){
1.1062 - char *z;
1.1063 - switch( id ){
1.1064 - case TK_ALL: z = "UNION ALL"; break;
1.1065 - case TK_INTERSECT: z = "INTERSECT"; break;
1.1066 - case TK_EXCEPT: z = "EXCEPT"; break;
1.1067 - default: z = "UNION"; break;
1.1068 - }
1.1069 - return z;
1.1070 -}
1.1071 -#endif /* SQLITE_OMIT_COMPOUND_SELECT */
1.1072 -
1.1073 -/*
1.1074 -** Forward declaration
1.1075 -*/
1.1076 -static int prepSelectStmt(Parse*, Select*);
1.1077 -
1.1078 -/*
1.1079 -** Given a SELECT statement, generate a Table structure that describes
1.1080 -** the result set of that SELECT.
1.1081 -*/
1.1082 -Table *sqlite3ResultSetOfSelect(Parse *pParse, char *zTabName, Select *pSelect){
1.1083 - Table *pTab;
1.1084 - int i, j;
1.1085 - ExprList *pEList;
1.1086 - Column *aCol, *pCol;
1.1087 - sqlite3 *db = pParse->db;
1.1088 -
1.1089 - while( pSelect->pPrior ) pSelect = pSelect->pPrior;
1.1090 - if( prepSelectStmt(pParse, pSelect) ){
1.1091 - return 0;
1.1092 - }
1.1093 - if( sqlite3SelectResolve(pParse, pSelect, 0) ){
1.1094 - return 0;
1.1095 - }
1.1096 - pTab = sqlite3DbMallocZero(db, sizeof(Table) );
1.1097 - if( pTab==0 ){
1.1098 - return 0;
1.1099 - }
1.1100 - pTab->nRef = 1;
1.1101 - pTab->zName = zTabName ? sqlite3DbStrDup(db, zTabName) : 0;
1.1102 - pEList = pSelect->pEList;
1.1103 - pTab->nCol = pEList->nExpr;
1.1104 - assert( pTab->nCol>0 );
1.1105 - pTab->aCol = aCol = sqlite3DbMallocZero(db, sizeof(pTab->aCol[0])*pTab->nCol);
1.1106 - for(i=0, pCol=aCol; i<pTab->nCol; i++, pCol++){
1.1107 - Expr *p, *pR;
1.1108 - char *zType;
1.1109 - char *zName;
1.1110 - int nName;
1.1111 - CollSeq *pColl;
1.1112 - int cnt;
1.1113 - NameContext sNC;
1.1114 -
1.1115 - /* Get an appropriate name for the column
1.1116 - */
1.1117 - p = pEList->a[i].pExpr;
1.1118 - assert( p->pRight==0 || p->pRight->token.z==0 || p->pRight->token.z[0]!=0 );
1.1119 - if( (zName = pEList->a[i].zName)!=0 ){
1.1120 - /* If the column contains an "AS <name>" phrase, use <name> as the name */
1.1121 - zName = sqlite3DbStrDup(db, zName);
1.1122 - }else if( p->op==TK_DOT
1.1123 - && (pR=p->pRight)!=0 && pR->token.z && pR->token.z[0] ){
1.1124 - /* For columns of the from A.B use B as the name */
1.1125 - zName = sqlite3MPrintf(db, "%T", &pR->token);
1.1126 - }else if( p->span.z && p->span.z[0] ){
1.1127 - /* Use the original text of the column expression as its name */
1.1128 - zName = sqlite3MPrintf(db, "%T", &p->span);
1.1129 - }else{
1.1130 - /* If all else fails, make up a name */
1.1131 - zName = sqlite3MPrintf(db, "column%d", i+1);
1.1132 - }
1.1133 - if( !zName || db->mallocFailed ){
1.1134 - db->mallocFailed = 1;
1.1135 - sqlite3_free(zName);
1.1136 - sqlite3DeleteTable(pTab);
1.1137 - return 0;
1.1138 - }
1.1139 - sqlite3Dequote(zName);
1.1140 -
1.1141 - /* Make sure the column name is unique. If the name is not unique,
1.1142 - ** append a integer to the name so that it becomes unique.
1.1143 - */
1.1144 - nName = strlen(zName);
1.1145 - for(j=cnt=0; j<i; j++){
1.1146 - if( sqlite3StrICmp(aCol[j].zName, zName)==0 ){
1.1147 - zName[nName] = 0;
1.1148 - zName = sqlite3MPrintf(db, "%z:%d", zName, ++cnt);
1.1149 - j = -1;
1.1150 - if( zName==0 ) break;
1.1151 - }
1.1152 - }
1.1153 - pCol->zName = zName;
1.1154 -
1.1155 - /* Get the typename, type affinity, and collating sequence for the
1.1156 - ** column.
1.1157 - */
1.1158 - memset(&sNC, 0, sizeof(sNC));
1.1159 - sNC.pSrcList = pSelect->pSrc;
1.1160 - zType = sqlite3DbStrDup(db, columnType(&sNC, p, 0, 0, 0));
1.1161 - pCol->zType = zType;
1.1162 - pCol->affinity = sqlite3ExprAffinity(p);
1.1163 - pColl = sqlite3ExprCollSeq(pParse, p);
1.1164 - if( pColl ){
1.1165 - pCol->zColl = sqlite3DbStrDup(db, pColl->zName);
1.1166 - }
1.1167 - }
1.1168 - pTab->iPKey = -1;
1.1169 - return pTab;
1.1170 -}
1.1171 -
1.1172 -/*
1.1173 -** Prepare a SELECT statement for processing by doing the following
1.1174 -** things:
1.1175 -**
1.1176 -** (1) Make sure VDBE cursor numbers have been assigned to every
1.1177 -** element of the FROM clause.
1.1178 -**
1.1179 -** (2) Fill in the pTabList->a[].pTab fields in the SrcList that
1.1180 -** defines FROM clause. When views appear in the FROM clause,
1.1181 -** fill pTabList->a[].pSelect with a copy of the SELECT statement
1.1182 -** that implements the view. A copy is made of the view's SELECT
1.1183 -** statement so that we can freely modify or delete that statement
1.1184 -** without worrying about messing up the presistent representation
1.1185 -** of the view.
1.1186 -**
1.1187 -** (3) Add terms to the WHERE clause to accomodate the NATURAL keyword
1.1188 -** on joins and the ON and USING clause of joins.
1.1189 -**
1.1190 -** (4) Scan the list of columns in the result set (pEList) looking
1.1191 -** for instances of the "*" operator or the TABLE.* operator.
1.1192 -** If found, expand each "*" to be every column in every table
1.1193 -** and TABLE.* to be every column in TABLE.
1.1194 -**
1.1195 -** Return 0 on success. If there are problems, leave an error message
1.1196 -** in pParse and return non-zero.
1.1197 -*/
1.1198 -static int prepSelectStmt(Parse *pParse, Select *p){
1.1199 - int i, j, k, rc;
1.1200 - SrcList *pTabList;
1.1201 - ExprList *pEList;
1.1202 - struct SrcList_item *pFrom;
1.1203 - sqlite3 *db = pParse->db;
1.1204 -
1.1205 - if( p==0 || p->pSrc==0 || db->mallocFailed ){
1.1206 - return 1;
1.1207 - }
1.1208 - pTabList = p->pSrc;
1.1209 - pEList = p->pEList;
1.1210 -
1.1211 - /* Make sure cursor numbers have been assigned to all entries in
1.1212 - ** the FROM clause of the SELECT statement.
1.1213 - */
1.1214 - sqlite3SrcListAssignCursors(pParse, p->pSrc);
1.1215 -
1.1216 - /* Look up every table named in the FROM clause of the select. If
1.1217 - ** an entry of the FROM clause is a subquery instead of a table or view,
1.1218 - ** then create a transient table structure to describe the subquery.
1.1219 - */
1.1220 - for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
1.1221 - Table *pTab;
1.1222 - if( pFrom->pTab!=0 ){
1.1223 - /* This statement has already been prepared. There is no need
1.1224 - ** to go further. */
1.1225 - assert( i==0 );
1.1226 - return 0;
1.1227 - }
1.1228 - if( pFrom->zName==0 ){
1.1229 -#ifndef SQLITE_OMIT_SUBQUERY
1.1230 - /* A sub-query in the FROM clause of a SELECT */
1.1231 - assert( pFrom->pSelect!=0 );
1.1232 - if( pFrom->zAlias==0 ){
1.1233 - pFrom->zAlias =
1.1234 - sqlite3MPrintf(db, "sqlite_subquery_%p_", (void*)pFrom->pSelect);
1.1235 - }
1.1236 - assert( pFrom->pTab==0 );
1.1237 - pFrom->pTab = pTab =
1.1238 - sqlite3ResultSetOfSelect(pParse, pFrom->zAlias, pFrom->pSelect);
1.1239 - if( pTab==0 ){
1.1240 - return 1;
1.1241 - }
1.1242 - /* The isEphem flag indicates that the Table structure has been
1.1243 - ** dynamically allocated and may be freed at any time. In other words,
1.1244 - ** pTab is not pointing to a persistent table structure that defines
1.1245 - ** part of the schema. */
1.1246 - pTab->isEphem = 1;
1.1247 -#endif
1.1248 - }else{
1.1249 - /* An ordinary table or view name in the FROM clause */
1.1250 - assert( pFrom->pTab==0 );
1.1251 - pFrom->pTab = pTab =
1.1252 - sqlite3LocateTable(pParse,pFrom->zName,pFrom->zDatabase);
1.1253 - if( pTab==0 ){
1.1254 - return 1;
1.1255 - }
1.1256 - pTab->nRef++;
1.1257 -#if !defined(SQLITE_OMIT_VIEW) || !defined (SQLITE_OMIT_VIRTUALTABLE)
1.1258 - if( pTab->pSelect || IsVirtual(pTab) ){
1.1259 - /* We reach here if the named table is a really a view */
1.1260 - if( sqlite3ViewGetColumnNames(pParse, pTab) ){
1.1261 - return 1;
1.1262 - }
1.1263 - /* If pFrom->pSelect!=0 it means we are dealing with a
1.1264 - ** view within a view. The SELECT structure has already been
1.1265 - ** copied by the outer view so we can skip the copy step here
1.1266 - ** in the inner view.
1.1267 - */
1.1268 - if( pFrom->pSelect==0 ){
1.1269 - pFrom->pSelect = sqlite3SelectDup(db, pTab->pSelect);
1.1270 - }
1.1271 - }
1.1272 -#endif
1.1273 - }
1.1274 - }
1.1275 -
1.1276 - /* Process NATURAL keywords, and ON and USING clauses of joins.
1.1277 - */
1.1278 - if( sqliteProcessJoin(pParse, p) ) return 1;
1.1279 -
1.1280 - /* For every "*" that occurs in the column list, insert the names of
1.1281 - ** all columns in all tables. And for every TABLE.* insert the names
1.1282 - ** of all columns in TABLE. The parser inserted a special expression
1.1283 - ** with the TK_ALL operator for each "*" that it found in the column list.
1.1284 - ** The following code just has to locate the TK_ALL expressions and expand
1.1285 - ** each one to the list of all columns in all tables.
1.1286 - **
1.1287 - ** The first loop just checks to see if there are any "*" operators
1.1288 - ** that need expanding.
1.1289 - */
1.1290 - for(k=0; k<pEList->nExpr; k++){
1.1291 - Expr *pE = pEList->a[k].pExpr;
1.1292 - if( pE->op==TK_ALL ) break;
1.1293 - if( pE->op==TK_DOT && pE->pRight && pE->pRight->op==TK_ALL
1.1294 - && pE->pLeft && pE->pLeft->op==TK_ID ) break;
1.1295 - }
1.1296 - rc = 0;
1.1297 - if( k<pEList->nExpr ){
1.1298 - /*
1.1299 - ** If we get here it means the result set contains one or more "*"
1.1300 - ** operators that need to be expanded. Loop through each expression
1.1301 - ** in the result set and expand them one by one.
1.1302 - */
1.1303 - struct ExprList_item *a = pEList->a;
1.1304 - ExprList *pNew = 0;
1.1305 - int flags = pParse->db->flags;
1.1306 - int longNames = (flags & SQLITE_FullColNames)!=0 &&
1.1307 - (flags & SQLITE_ShortColNames)==0;
1.1308 -
1.1309 - for(k=0; k<pEList->nExpr; k++){
1.1310 - Expr *pE = a[k].pExpr;
1.1311 - if( pE->op!=TK_ALL &&
1.1312 - (pE->op!=TK_DOT || pE->pRight==0 || pE->pRight->op!=TK_ALL) ){
1.1313 - /* This particular expression does not need to be expanded.
1.1314 - */
1.1315 - pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr, 0);
1.1316 - if( pNew ){
1.1317 - pNew->a[pNew->nExpr-1].zName = a[k].zName;
1.1318 - }else{
1.1319 - rc = 1;
1.1320 - }
1.1321 - a[k].pExpr = 0;
1.1322 - a[k].zName = 0;
1.1323 - }else{
1.1324 - /* This expression is a "*" or a "TABLE.*" and needs to be
1.1325 - ** expanded. */
1.1326 - int tableSeen = 0; /* Set to 1 when TABLE matches */
1.1327 - char *zTName; /* text of name of TABLE */
1.1328 - if( pE->op==TK_DOT && pE->pLeft ){
1.1329 - zTName = sqlite3NameFromToken(db, &pE->pLeft->token);
1.1330 - }else{
1.1331 - zTName = 0;
1.1332 - }
1.1333 - for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
1.1334 - Table *pTab = pFrom->pTab;
1.1335 - char *zTabName = pFrom->zAlias;
1.1336 - if( zTabName==0 || zTabName[0]==0 ){
1.1337 - zTabName = pTab->zName;
1.1338 - }
1.1339 - if( zTName && (zTabName==0 || zTabName[0]==0 ||
1.1340 - sqlite3StrICmp(zTName, zTabName)!=0) ){
1.1341 - continue;
1.1342 - }
1.1343 - tableSeen = 1;
1.1344 - for(j=0; j<pTab->nCol; j++){
1.1345 - Expr *pExpr, *pRight;
1.1346 - char *zName = pTab->aCol[j].zName;
1.1347 -
1.1348 - /* If a column is marked as 'hidden' (currently only possible
1.1349 - ** for virtual tables), do not include it in the expanded
1.1350 - ** result-set list.
1.1351 - */
1.1352 - if( IsHiddenColumn(&pTab->aCol[j]) ){
1.1353 - assert(IsVirtual(pTab));
1.1354 - continue;
1.1355 - }
1.1356 -
1.1357 - if( i>0 ){
1.1358 - struct SrcList_item *pLeft = &pTabList->a[i-1];
1.1359 - if( (pLeft[1].jointype & JT_NATURAL)!=0 &&
1.1360 - columnIndex(pLeft->pTab, zName)>=0 ){
1.1361 - /* In a NATURAL join, omit the join columns from the
1.1362 - ** table on the right */
1.1363 - continue;
1.1364 - }
1.1365 - if( sqlite3IdListIndex(pLeft[1].pUsing, zName)>=0 ){
1.1366 - /* In a join with a USING clause, omit columns in the
1.1367 - ** using clause from the table on the right. */
1.1368 - continue;
1.1369 - }
1.1370 - }
1.1371 - pRight = sqlite3PExpr(pParse, TK_ID, 0, 0, 0);
1.1372 - if( pRight==0 ) break;
1.1373 - setQuotedToken(pParse, &pRight->token, zName);
1.1374 - if( zTabName && (longNames || pTabList->nSrc>1) ){
1.1375 - Expr *pLeft = sqlite3PExpr(pParse, TK_ID, 0, 0, 0);
1.1376 - pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight, 0);
1.1377 - if( pExpr==0 ) break;
1.1378 - setQuotedToken(pParse, &pLeft->token, zTabName);
1.1379 - setToken(&pExpr->span,
1.1380 - sqlite3MPrintf(db, "%s.%s", zTabName, zName));
1.1381 - pExpr->span.dyn = 1;
1.1382 - pExpr->token.z = 0;
1.1383 - pExpr->token.n = 0;
1.1384 - pExpr->token.dyn = 0;
1.1385 - }else{
1.1386 - pExpr = pRight;
1.1387 - pExpr->span = pExpr->token;
1.1388 - pExpr->span.dyn = 0;
1.1389 - }
1.1390 - if( longNames ){
1.1391 - pNew = sqlite3ExprListAppend(pParse, pNew, pExpr, &pExpr->span);
1.1392 - }else{
1.1393 - pNew = sqlite3ExprListAppend(pParse, pNew, pExpr, &pRight->token);
1.1394 - }
1.1395 - }
1.1396 - }
1.1397 - if( !tableSeen ){
1.1398 - if( zTName ){
1.1399 - sqlite3ErrorMsg(pParse, "no such table: %s", zTName);
1.1400 - }else{
1.1401 - sqlite3ErrorMsg(pParse, "no tables specified");
1.1402 - }
1.1403 - rc = 1;
1.1404 - }
1.1405 - sqlite3_free(zTName);
1.1406 - }
1.1407 - }
1.1408 - sqlite3ExprListDelete(pEList);
1.1409 - p->pEList = pNew;
1.1410 - }
1.1411 - if( p->pEList && p->pEList->nExpr>SQLITE_MAX_COLUMN ){
1.1412 - sqlite3ErrorMsg(pParse, "too many columns in result set");
1.1413 - rc = SQLITE_ERROR;
1.1414 - }
1.1415 - if( db->mallocFailed ){
1.1416 - rc = SQLITE_NOMEM;
1.1417 - }
1.1418 - return rc;
1.1419 -}
1.1420 -
1.1421 -#ifndef SQLITE_OMIT_COMPOUND_SELECT
1.1422 -/*
1.1423 -** This routine associates entries in an ORDER BY expression list with
1.1424 -** columns in a result. For each ORDER BY expression, the opcode of
1.1425 -** the top-level node is changed to TK_COLUMN and the iColumn value of
1.1426 -** the top-level node is filled in with column number and the iTable
1.1427 -** value of the top-level node is filled with iTable parameter.
1.1428 -**
1.1429 -** If there are prior SELECT clauses, they are processed first. A match
1.1430 -** in an earlier SELECT takes precedence over a later SELECT.
1.1431 -**
1.1432 -** Any entry that does not match is flagged as an error. The number
1.1433 -** of errors is returned.
1.1434 -*/
1.1435 -static int matchOrderbyToColumn(
1.1436 - Parse *pParse, /* A place to leave error messages */
1.1437 - Select *pSelect, /* Match to result columns of this SELECT */
1.1438 - ExprList *pOrderBy, /* The ORDER BY values to match against columns */
1.1439 - int iTable, /* Insert this value in iTable */
1.1440 - int mustComplete /* If TRUE all ORDER BYs must match */
1.1441 -){
1.1442 - int nErr = 0;
1.1443 - int i, j;
1.1444 - ExprList *pEList;
1.1445 - sqlite3 *db = pParse->db;
1.1446 -
1.1447 - if( pSelect==0 || pOrderBy==0 ) return 1;
1.1448 - if( mustComplete ){
1.1449 - for(i=0; i<pOrderBy->nExpr; i++){ pOrderBy->a[i].done = 0; }
1.1450 - }
1.1451 - if( prepSelectStmt(pParse, pSelect) ){
1.1452 - return 1;
1.1453 - }
1.1454 - if( pSelect->pPrior ){
1.1455 - if( matchOrderbyToColumn(pParse, pSelect->pPrior, pOrderBy, iTable, 0) ){
1.1456 - return 1;
1.1457 - }
1.1458 - }
1.1459 - pEList = pSelect->pEList;
1.1460 - for(i=0; i<pOrderBy->nExpr; i++){
1.1461 - struct ExprList_item *pItem;
1.1462 - Expr *pE = pOrderBy->a[i].pExpr;
1.1463 - int iCol = -1;
1.1464 - char *zLabel;
1.1465 -
1.1466 - if( pOrderBy->a[i].done ) continue;
1.1467 - if( sqlite3ExprIsInteger(pE, &iCol) ){
1.1468 - if( iCol<=0 || iCol>pEList->nExpr ){
1.1469 - sqlite3ErrorMsg(pParse,
1.1470 - "ORDER BY position %d should be between 1 and %d",
1.1471 - iCol, pEList->nExpr);
1.1472 - nErr++;
1.1473 - break;
1.1474 - }
1.1475 - if( !mustComplete ) continue;
1.1476 - iCol--;
1.1477 - }
1.1478 - if( iCol<0 && (zLabel = sqlite3NameFromToken(db, &pE->token))!=0 ){
1.1479 - for(j=0, pItem=pEList->a; j<pEList->nExpr; j++, pItem++){
1.1480 - char *zName;
1.1481 - int isMatch;
1.1482 - if( pItem->zName ){
1.1483 - zName = sqlite3DbStrDup(db, pItem->zName);
1.1484 - }else{
1.1485 - zName = sqlite3NameFromToken(db, &pItem->pExpr->token);
1.1486 - }
1.1487 - isMatch = zName && sqlite3StrICmp(zName, zLabel)==0;
1.1488 - sqlite3_free(zName);
1.1489 - if( isMatch ){
1.1490 - iCol = j;
1.1491 - break;
1.1492 - }
1.1493 - }
1.1494 - sqlite3_free(zLabel);
1.1495 - }
1.1496 - if( iCol>=0 ){
1.1497 - pE->op = TK_COLUMN;
1.1498 - pE->iColumn = iCol;
1.1499 - pE->iTable = iTable;
1.1500 - pE->iAgg = -1;
1.1501 - pOrderBy->a[i].done = 1;
1.1502 - }else if( mustComplete ){
1.1503 - sqlite3ErrorMsg(pParse,
1.1504 - "ORDER BY term number %d does not match any result column", i+1);
1.1505 - nErr++;
1.1506 - break;
1.1507 - }
1.1508 - }
1.1509 - return nErr;
1.1510 -}
1.1511 -#endif /* #ifndef SQLITE_OMIT_COMPOUND_SELECT */
1.1512 -
1.1513 -/*
1.1514 -** Get a VDBE for the given parser context. Create a new one if necessary.
1.1515 -** If an error occurs, return NULL and leave a message in pParse.
1.1516 -*/
1.1517 -Vdbe *sqlite3GetVdbe(Parse *pParse){
1.1518 - Vdbe *v = pParse->pVdbe;
1.1519 - if( v==0 ){
1.1520 - v = pParse->pVdbe = sqlite3VdbeCreate(pParse->db);
1.1521 - }
1.1522 - return v;
1.1523 -}
1.1524 -
1.1525 -
1.1526 -/*
1.1527 -** Compute the iLimit and iOffset fields of the SELECT based on the
1.1528 -** pLimit and pOffset expressions. pLimit and pOffset hold the expressions
1.1529 -** that appear in the original SQL statement after the LIMIT and OFFSET
1.1530 -** keywords. Or NULL if those keywords are omitted. iLimit and iOffset
1.1531 -** are the integer memory register numbers for counters used to compute
1.1532 -** the limit and offset. If there is no limit and/or offset, then
1.1533 -** iLimit and iOffset are negative.
1.1534 -**
1.1535 -** This routine changes the values of iLimit and iOffset only if
1.1536 -** a limit or offset is defined by pLimit and pOffset. iLimit and
1.1537 -** iOffset should have been preset to appropriate default values
1.1538 -** (usually but not always -1) prior to calling this routine.
1.1539 -** Only if pLimit!=0 or pOffset!=0 do the limit registers get
1.1540 -** redefined. The UNION ALL operator uses this property to force
1.1541 -** the reuse of the same limit and offset registers across multiple
1.1542 -** SELECT statements.
1.1543 -*/
1.1544 -static void computeLimitRegisters(Parse *pParse, Select *p, int iBreak){
1.1545 - Vdbe *v = 0;
1.1546 - int iLimit = 0;
1.1547 - int iOffset;
1.1548 - int addr1, addr2;
1.1549 -
1.1550 - /*
1.1551 - ** "LIMIT -1" always shows all rows. There is some
1.1552 - ** contraversy about what the correct behavior should be.
1.1553 - ** The current implementation interprets "LIMIT 0" to mean
1.1554 - ** no rows.
1.1555 - */
1.1556 - if( p->pLimit ){
1.1557 - p->iLimit = iLimit = pParse->nMem;
1.1558 - pParse->nMem += 2;
1.1559 - v = sqlite3GetVdbe(pParse);
1.1560 - if( v==0 ) return;
1.1561 - sqlite3ExprCode(pParse, p->pLimit);
1.1562 - sqlite3VdbeAddOp(v, OP_MustBeInt, 0, 0);
1.1563 - sqlite3VdbeAddOp(v, OP_MemStore, iLimit, 1);
1.1564 - VdbeComment((v, "# LIMIT counter"));
1.1565 - sqlite3VdbeAddOp(v, OP_IfMemZero, iLimit, iBreak);
1.1566 - sqlite3VdbeAddOp(v, OP_MemLoad, iLimit, 0);
1.1567 - }
1.1568 - if( p->pOffset ){
1.1569 - p->iOffset = iOffset = pParse->nMem++;
1.1570 - v = sqlite3GetVdbe(pParse);
1.1571 - if( v==0 ) return;
1.1572 - sqlite3ExprCode(pParse, p->pOffset);
1.1573 - sqlite3VdbeAddOp(v, OP_MustBeInt, 0, 0);
1.1574 - sqlite3VdbeAddOp(v, OP_MemStore, iOffset, p->pLimit==0);
1.1575 - VdbeComment((v, "# OFFSET counter"));
1.1576 - addr1 = sqlite3VdbeAddOp(v, OP_IfMemPos, iOffset, 0);
1.1577 - sqlite3VdbeAddOp(v, OP_Pop, 1, 0);
1.1578 - sqlite3VdbeAddOp(v, OP_Integer, 0, 0);
1.1579 - sqlite3VdbeJumpHere(v, addr1);
1.1580 - if( p->pLimit ){
1.1581 - sqlite3VdbeAddOp(v, OP_Add, 0, 0);
1.1582 - }
1.1583 - }
1.1584 - if( p->pLimit ){
1.1585 - addr1 = sqlite3VdbeAddOp(v, OP_IfMemPos, iLimit, 0);
1.1586 - sqlite3VdbeAddOp(v, OP_Pop, 1, 0);
1.1587 - sqlite3VdbeAddOp(v, OP_MemInt, -1, iLimit+1);
1.1588 - addr2 = sqlite3VdbeAddOp(v, OP_Goto, 0, 0);
1.1589 - sqlite3VdbeJumpHere(v, addr1);
1.1590 - sqlite3VdbeAddOp(v, OP_MemStore, iLimit+1, 1);
1.1591 - VdbeComment((v, "# LIMIT+OFFSET"));
1.1592 - sqlite3VdbeJumpHere(v, addr2);
1.1593 - }
1.1594 -}
1.1595 -
1.1596 -/*
1.1597 -** Allocate a virtual index to use for sorting.
1.1598 -*/
1.1599 -static void createSortingIndex(Parse *pParse, Select *p, ExprList *pOrderBy){
1.1600 - if( pOrderBy ){
1.1601 - int addr;
1.1602 - assert( pOrderBy->iECursor==0 );
1.1603 - pOrderBy->iECursor = pParse->nTab++;
1.1604 - addr = sqlite3VdbeAddOp(pParse->pVdbe, OP_OpenEphemeral,
1.1605 - pOrderBy->iECursor, pOrderBy->nExpr+1);
1.1606 - assert( p->addrOpenEphm[2] == -1 );
1.1607 - p->addrOpenEphm[2] = addr;
1.1608 - }
1.1609 -}
1.1610 -
1.1611 -#ifndef SQLITE_OMIT_COMPOUND_SELECT
1.1612 -/*
1.1613 -** Return the appropriate collating sequence for the iCol-th column of
1.1614 -** the result set for the compound-select statement "p". Return NULL if
1.1615 -** the column has no default collating sequence.
1.1616 -**
1.1617 -** The collating sequence for the compound select is taken from the
1.1618 -** left-most term of the select that has a collating sequence.
1.1619 -*/
1.1620 -static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){
1.1621 - CollSeq *pRet;
1.1622 - if( p->pPrior ){
1.1623 - pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
1.1624 - }else{
1.1625 - pRet = 0;
1.1626 - }
1.1627 - if( pRet==0 ){
1.1628 - pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
1.1629 - }
1.1630 - return pRet;
1.1631 -}
1.1632 -#endif /* SQLITE_OMIT_COMPOUND_SELECT */
1.1633 -
1.1634 -#ifndef SQLITE_OMIT_COMPOUND_SELECT
1.1635 -/*
1.1636 -** This routine is called to process a query that is really the union
1.1637 -** or intersection of two or more separate queries.
1.1638 -**
1.1639 -** "p" points to the right-most of the two queries. the query on the
1.1640 -** left is p->pPrior. The left query could also be a compound query
1.1641 -** in which case this routine will be called recursively.
1.1642 -**
1.1643 -** The results of the total query are to be written into a destination
1.1644 -** of type eDest with parameter iParm.
1.1645 -**
1.1646 -** Example 1: Consider a three-way compound SQL statement.
1.1647 -**
1.1648 -** SELECT a FROM t1 UNION SELECT b FROM t2 UNION SELECT c FROM t3
1.1649 -**
1.1650 -** This statement is parsed up as follows:
1.1651 -**
1.1652 -** SELECT c FROM t3
1.1653 -** |
1.1654 -** `-----> SELECT b FROM t2
1.1655 -** |
1.1656 -** `------> SELECT a FROM t1
1.1657 -**
1.1658 -** The arrows in the diagram above represent the Select.pPrior pointer.
1.1659 -** So if this routine is called with p equal to the t3 query, then
1.1660 -** pPrior will be the t2 query. p->op will be TK_UNION in this case.
1.1661 -**
1.1662 -** Notice that because of the way SQLite parses compound SELECTs, the
1.1663 -** individual selects always group from left to right.
1.1664 -*/
1.1665 -static int multiSelect(
1.1666 - Parse *pParse, /* Parsing context */
1.1667 - Select *p, /* The right-most of SELECTs to be coded */
1.1668 - int eDest, /* \___ Store query results as specified */
1.1669 - int iParm, /* / by these two parameters. */
1.1670 - char *aff /* If eDest is SRT_Union, the affinity string */
1.1671 -){
1.1672 - int rc = SQLITE_OK; /* Success code from a subroutine */
1.1673 - Select *pPrior; /* Another SELECT immediately to our left */
1.1674 - Vdbe *v; /* Generate code to this VDBE */
1.1675 - int nCol; /* Number of columns in the result set */
1.1676 - ExprList *pOrderBy; /* The ORDER BY clause on p */
1.1677 - int aSetP2[2]; /* Set P2 value of these op to number of columns */
1.1678 - int nSetP2 = 0; /* Number of slots in aSetP2[] used */
1.1679 -
1.1680 - /* Make sure there is no ORDER BY or LIMIT clause on prior SELECTs. Only
1.1681 - ** the last (right-most) SELECT in the series may have an ORDER BY or LIMIT.
1.1682 - */
1.1683 - if( p==0 || p->pPrior==0 ){
1.1684 - rc = 1;
1.1685 - goto multi_select_end;
1.1686 - }
1.1687 - pPrior = p->pPrior;
1.1688 - assert( pPrior->pRightmost!=pPrior );
1.1689 - assert( pPrior->pRightmost==p->pRightmost );
1.1690 - if( pPrior->pOrderBy ){
1.1691 - sqlite3ErrorMsg(pParse,"ORDER BY clause should come after %s not before",
1.1692 - selectOpName(p->op));
1.1693 - rc = 1;
1.1694 - goto multi_select_end;
1.1695 - }
1.1696 - if( pPrior->pLimit ){
1.1697 - sqlite3ErrorMsg(pParse,"LIMIT clause should come after %s not before",
1.1698 - selectOpName(p->op));
1.1699 - rc = 1;
1.1700 - goto multi_select_end;
1.1701 - }
1.1702 -
1.1703 - /* Make sure we have a valid query engine. If not, create a new one.
1.1704 - */
1.1705 - v = sqlite3GetVdbe(pParse);
1.1706 - if( v==0 ){
1.1707 - rc = 1;
1.1708 - goto multi_select_end;
1.1709 - }
1.1710 -
1.1711 - /* Create the destination temporary table if necessary
1.1712 - */
1.1713 - if( eDest==SRT_EphemTab ){
1.1714 - assert( p->pEList );
1.1715 - assert( nSetP2<sizeof(aSetP2)/sizeof(aSetP2[0]) );
1.1716 - aSetP2[nSetP2++] = sqlite3VdbeAddOp(v, OP_OpenEphemeral, iParm, 0);
1.1717 - eDest = SRT_Table;
1.1718 - }
1.1719 -
1.1720 - /* Generate code for the left and right SELECT statements.
1.1721 - */
1.1722 - pOrderBy = p->pOrderBy;
1.1723 - switch( p->op ){
1.1724 - case TK_ALL: {
1.1725 - if( pOrderBy==0 ){
1.1726 - int addr = 0;
1.1727 - assert( !pPrior->pLimit );
1.1728 - pPrior->pLimit = p->pLimit;
1.1729 - pPrior->pOffset = p->pOffset;
1.1730 - rc = sqlite3Select(pParse, pPrior, eDest, iParm, 0, 0, 0, aff);
1.1731 - p->pLimit = 0;
1.1732 - p->pOffset = 0;
1.1733 - if( rc ){
1.1734 - goto multi_select_end;
1.1735 - }
1.1736 - p->pPrior = 0;
1.1737 - p->iLimit = pPrior->iLimit;
1.1738 - p->iOffset = pPrior->iOffset;
1.1739 - if( p->iLimit>=0 ){
1.1740 - addr = sqlite3VdbeAddOp(v, OP_IfMemZero, p->iLimit, 0);
1.1741 - VdbeComment((v, "# Jump ahead if LIMIT reached"));
1.1742 - }
1.1743 - rc = sqlite3Select(pParse, p, eDest, iParm, 0, 0, 0, aff);
1.1744 - p->pPrior = pPrior;
1.1745 - if( rc ){
1.1746 - goto multi_select_end;
1.1747 - }
1.1748 - if( addr ){
1.1749 - sqlite3VdbeJumpHere(v, addr);
1.1750 - }
1.1751 - break;
1.1752 - }
1.1753 - /* For UNION ALL ... ORDER BY fall through to the next case */
1.1754 - }
1.1755 - case TK_EXCEPT:
1.1756 - case TK_UNION: {
1.1757 - int unionTab; /* Cursor number of the temporary table holding result */
1.1758 - int op = 0; /* One of the SRT_ operations to apply to self */
1.1759 - int priorOp; /* The SRT_ operation to apply to prior selects */
1.1760 - Expr *pLimit, *pOffset; /* Saved values of p->nLimit and p->nOffset */
1.1761 - int addr;
1.1762 -
1.1763 - priorOp = p->op==TK_ALL ? SRT_Table : SRT_Union;
1.1764 - if( eDest==priorOp && pOrderBy==0 && !p->pLimit && !p->pOffset ){
1.1765 - /* We can reuse a temporary table generated by a SELECT to our
1.1766 - ** right.
1.1767 - */
1.1768 - unionTab = iParm;
1.1769 - }else{
1.1770 - /* We will need to create our own temporary table to hold the
1.1771 - ** intermediate results.
1.1772 - */
1.1773 - unionTab = pParse->nTab++;
1.1774 - if( pOrderBy && matchOrderbyToColumn(pParse, p, pOrderBy, unionTab,1) ){
1.1775 - rc = 1;
1.1776 - goto multi_select_end;
1.1777 - }
1.1778 - addr = sqlite3VdbeAddOp(v, OP_OpenEphemeral, unionTab, 0);
1.1779 - if( priorOp==SRT_Table ){
1.1780 - assert( nSetP2<sizeof(aSetP2)/sizeof(aSetP2[0]) );
1.1781 - aSetP2[nSetP2++] = addr;
1.1782 - }else{
1.1783 - assert( p->addrOpenEphm[0] == -1 );
1.1784 - p->addrOpenEphm[0] = addr;
1.1785 - p->pRightmost->usesEphm = 1;
1.1786 - }
1.1787 - createSortingIndex(pParse, p, pOrderBy);
1.1788 - assert( p->pEList );
1.1789 - }
1.1790 -
1.1791 - /* Code the SELECT statements to our left
1.1792 - */
1.1793 - assert( !pPrior->pOrderBy );
1.1794 - rc = sqlite3Select(pParse, pPrior, priorOp, unionTab, 0, 0, 0, aff);
1.1795 - if( rc ){
1.1796 - goto multi_select_end;
1.1797 - }
1.1798 -
1.1799 - /* Code the current SELECT statement
1.1800 - */
1.1801 - switch( p->op ){
1.1802 - case TK_EXCEPT: op = SRT_Except; break;
1.1803 - case TK_UNION: op = SRT_Union; break;
1.1804 - case TK_ALL: op = SRT_Table; break;
1.1805 - }
1.1806 - p->pPrior = 0;
1.1807 - p->pOrderBy = 0;
1.1808 - p->disallowOrderBy = pOrderBy!=0;
1.1809 - pLimit = p->pLimit;
1.1810 - p->pLimit = 0;
1.1811 - pOffset = p->pOffset;
1.1812 - p->pOffset = 0;
1.1813 - rc = sqlite3Select(pParse, p, op, unionTab, 0, 0, 0, aff);
1.1814 - /* Query flattening in sqlite3Select() might refill p->pOrderBy.
1.1815 - ** Be sure to delete p->pOrderBy, therefore, to avoid a memory leak. */
1.1816 - sqlite3ExprListDelete(p->pOrderBy);
1.1817 - p->pPrior = pPrior;
1.1818 - p->pOrderBy = pOrderBy;
1.1819 - sqlite3ExprDelete(p->pLimit);
1.1820 - p->pLimit = pLimit;
1.1821 - p->pOffset = pOffset;
1.1822 - p->iLimit = -1;
1.1823 - p->iOffset = -1;
1.1824 - if( rc ){
1.1825 - goto multi_select_end;
1.1826 - }
1.1827 -
1.1828 -
1.1829 - /* Convert the data in the temporary table into whatever form
1.1830 - ** it is that we currently need.
1.1831 - */
1.1832 - if( eDest!=priorOp || unionTab!=iParm ){
1.1833 - int iCont, iBreak, iStart;
1.1834 - assert( p->pEList );
1.1835 - if( eDest==SRT_Callback ){
1.1836 - Select *pFirst = p;
1.1837 - while( pFirst->pPrior ) pFirst = pFirst->pPrior;
1.1838 - generateColumnNames(pParse, 0, pFirst->pEList);
1.1839 - }
1.1840 - iBreak = sqlite3VdbeMakeLabel(v);
1.1841 - iCont = sqlite3VdbeMakeLabel(v);
1.1842 - computeLimitRegisters(pParse, p, iBreak);
1.1843 - sqlite3VdbeAddOp(v, OP_Rewind, unionTab, iBreak);
1.1844 - iStart = sqlite3VdbeCurrentAddr(v);
1.1845 - rc = selectInnerLoop(pParse, p, p->pEList, unionTab, p->pEList->nExpr,
1.1846 - pOrderBy, -1, eDest, iParm,
1.1847 - iCont, iBreak, 0);
1.1848 - if( rc ){
1.1849 - rc = 1;
1.1850 - goto multi_select_end;
1.1851 - }
1.1852 - sqlite3VdbeResolveLabel(v, iCont);
1.1853 - sqlite3VdbeAddOp(v, OP_Next, unionTab, iStart);
1.1854 - sqlite3VdbeResolveLabel(v, iBreak);
1.1855 - sqlite3VdbeAddOp(v, OP_Close, unionTab, 0);
1.1856 - }
1.1857 - break;
1.1858 - }
1.1859 - case TK_INTERSECT: {
1.1860 - int tab1, tab2;
1.1861 - int iCont, iBreak, iStart;
1.1862 - Expr *pLimit, *pOffset;
1.1863 - int addr;
1.1864 -
1.1865 - /* INTERSECT is different from the others since it requires
1.1866 - ** two temporary tables. Hence it has its own case. Begin
1.1867 - ** by allocating the tables we will need.
1.1868 - */
1.1869 - tab1 = pParse->nTab++;
1.1870 - tab2 = pParse->nTab++;
1.1871 - if( pOrderBy && matchOrderbyToColumn(pParse,p,pOrderBy,tab1,1) ){
1.1872 - rc = 1;
1.1873 - goto multi_select_end;
1.1874 - }
1.1875 - createSortingIndex(pParse, p, pOrderBy);
1.1876 -
1.1877 - addr = sqlite3VdbeAddOp(v, OP_OpenEphemeral, tab1, 0);
1.1878 - assert( p->addrOpenEphm[0] == -1 );
1.1879 - p->addrOpenEphm[0] = addr;
1.1880 - p->pRightmost->usesEphm = 1;
1.1881 - assert( p->pEList );
1.1882 -
1.1883 - /* Code the SELECTs to our left into temporary table "tab1".
1.1884 - */
1.1885 - rc = sqlite3Select(pParse, pPrior, SRT_Union, tab1, 0, 0, 0, aff);
1.1886 - if( rc ){
1.1887 - goto multi_select_end;
1.1888 - }
1.1889 -
1.1890 - /* Code the current SELECT into temporary table "tab2"
1.1891 - */
1.1892 - addr = sqlite3VdbeAddOp(v, OP_OpenEphemeral, tab2, 0);
1.1893 - assert( p->addrOpenEphm[1] == -1 );
1.1894 - p->addrOpenEphm[1] = addr;
1.1895 - p->pPrior = 0;
1.1896 - pLimit = p->pLimit;
1.1897 - p->pLimit = 0;
1.1898 - pOffset = p->pOffset;
1.1899 - p->pOffset = 0;
1.1900 - rc = sqlite3Select(pParse, p, SRT_Union, tab2, 0, 0, 0, aff);
1.1901 - p->pPrior = pPrior;
1.1902 - sqlite3ExprDelete(p->pLimit);
1.1903 - p->pLimit = pLimit;
1.1904 - p->pOffset = pOffset;
1.1905 - if( rc ){
1.1906 - goto multi_select_end;
1.1907 - }
1.1908 -
1.1909 - /* Generate code to take the intersection of the two temporary
1.1910 - ** tables.
1.1911 - */
1.1912 - assert( p->pEList );
1.1913 - if( eDest==SRT_Callback ){
1.1914 - Select *pFirst = p;
1.1915 - while( pFirst->pPrior ) pFirst = pFirst->pPrior;
1.1916 - generateColumnNames(pParse, 0, pFirst->pEList);
1.1917 - }
1.1918 - iBreak = sqlite3VdbeMakeLabel(v);
1.1919 - iCont = sqlite3VdbeMakeLabel(v);
1.1920 - computeLimitRegisters(pParse, p, iBreak);
1.1921 - sqlite3VdbeAddOp(v, OP_Rewind, tab1, iBreak);
1.1922 - iStart = sqlite3VdbeAddOp(v, OP_RowKey, tab1, 0);
1.1923 - sqlite3VdbeAddOp(v, OP_NotFound, tab2, iCont);
1.1924 - rc = selectInnerLoop(pParse, p, p->pEList, tab1, p->pEList->nExpr,
1.1925 - pOrderBy, -1, eDest, iParm,
1.1926 - iCont, iBreak, 0);
1.1927 - if( rc ){
1.1928 - rc = 1;
1.1929 - goto multi_select_end;
1.1930 - }
1.1931 - sqlite3VdbeResolveLabel(v, iCont);
1.1932 - sqlite3VdbeAddOp(v, OP_Next, tab1, iStart);
1.1933 - sqlite3VdbeResolveLabel(v, iBreak);
1.1934 - sqlite3VdbeAddOp(v, OP_Close, tab2, 0);
1.1935 - sqlite3VdbeAddOp(v, OP_Close, tab1, 0);
1.1936 - break;
1.1937 - }
1.1938 - }
1.1939 -
1.1940 - /* Make sure all SELECTs in the statement have the same number of elements
1.1941 - ** in their result sets.
1.1942 - */
1.1943 - assert( p->pEList && pPrior->pEList );
1.1944 - if( p->pEList->nExpr!=pPrior->pEList->nExpr ){
1.1945 - sqlite3ErrorMsg(pParse, "SELECTs to the left and right of %s"
1.1946 - " do not have the same number of result columns", selectOpName(p->op));
1.1947 - rc = 1;
1.1948 - goto multi_select_end;
1.1949 - }
1.1950 -
1.1951 - /* Set the number of columns in temporary tables
1.1952 - */
1.1953 - nCol = p->pEList->nExpr;
1.1954 - while( nSetP2 ){
1.1955 - sqlite3VdbeChangeP2(v, aSetP2[--nSetP2], nCol);
1.1956 - }
1.1957 -
1.1958 - /* Compute collating sequences used by either the ORDER BY clause or
1.1959 - ** by any temporary tables needed to implement the compound select.
1.1960 - ** Attach the KeyInfo structure to all temporary tables. Invoke the
1.1961 - ** ORDER BY processing if there is an ORDER BY clause.
1.1962 - **
1.1963 - ** This section is run by the right-most SELECT statement only.
1.1964 - ** SELECT statements to the left always skip this part. The right-most
1.1965 - ** SELECT might also skip this part if it has no ORDER BY clause and
1.1966 - ** no temp tables are required.
1.1967 - */
1.1968 - if( pOrderBy || p->usesEphm ){
1.1969 - int i; /* Loop counter */
1.1970 - KeyInfo *pKeyInfo; /* Collating sequence for the result set */
1.1971 - Select *pLoop; /* For looping through SELECT statements */
1.1972 - int nKeyCol; /* Number of entries in pKeyInfo->aCol[] */
1.1973 - CollSeq **apColl; /* For looping through pKeyInfo->aColl[] */
1.1974 - CollSeq **aCopy; /* A copy of pKeyInfo->aColl[] */
1.1975 -
1.1976 - assert( p->pRightmost==p );
1.1977 - nKeyCol = nCol + (pOrderBy ? pOrderBy->nExpr : 0);
1.1978 - pKeyInfo = sqlite3DbMallocZero(pParse->db,
1.1979 - sizeof(*pKeyInfo)+nKeyCol*(sizeof(CollSeq*) + 1));
1.1980 - if( !pKeyInfo ){
1.1981 - rc = SQLITE_NOMEM;
1.1982 - goto multi_select_end;
1.1983 - }
1.1984 -
1.1985 - pKeyInfo->enc = ENC(pParse->db);
1.1986 - pKeyInfo->nField = nCol;
1.1987 -
1.1988 - for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
1.1989 - *apColl = multiSelectCollSeq(pParse, p, i);
1.1990 - if( 0==*apColl ){
1.1991 - *apColl = pParse->db->pDfltColl;
1.1992 - }
1.1993 - }
1.1994 -
1.1995 - for(pLoop=p; pLoop; pLoop=pLoop->pPrior){
1.1996 - for(i=0; i<2; i++){
1.1997 - int addr = pLoop->addrOpenEphm[i];
1.1998 - if( addr<0 ){
1.1999 - /* If [0] is unused then [1] is also unused. So we can
1.2000 - ** always safely abort as soon as the first unused slot is found */
1.2001 - assert( pLoop->addrOpenEphm[1]<0 );
1.2002 - break;
1.2003 - }
1.2004 - sqlite3VdbeChangeP2(v, addr, nCol);
1.2005 - sqlite3VdbeChangeP3(v, addr, (char*)pKeyInfo, P3_KEYINFO);
1.2006 - pLoop->addrOpenEphm[i] = -1;
1.2007 - }
1.2008 - }
1.2009 -
1.2010 - if( pOrderBy ){
1.2011 - struct ExprList_item *pOTerm = pOrderBy->a;
1.2012 - int nOrderByExpr = pOrderBy->nExpr;
1.2013 - int addr;
1.2014 - u8 *pSortOrder;
1.2015 -
1.2016 - /* Reuse the same pKeyInfo for the ORDER BY as was used above for
1.2017 - ** the compound select statements. Except we have to change out the
1.2018 - ** pKeyInfo->aColl[] values. Some of the aColl[] values will be
1.2019 - ** reused when constructing the pKeyInfo for the ORDER BY, so make
1.2020 - ** a copy. Sufficient space to hold both the nCol entries for
1.2021 - ** the compound select and the nOrderbyExpr entries for the ORDER BY
1.2022 - ** was allocated above. But we need to move the compound select
1.2023 - ** entries out of the way before constructing the ORDER BY entries.
1.2024 - ** Move the compound select entries into aCopy[] where they can be
1.2025 - ** accessed and reused when constructing the ORDER BY entries.
1.2026 - ** Because nCol might be greater than or less than nOrderByExpr
1.2027 - ** we have to use memmove() when doing the copy.
1.2028 - */
1.2029 - aCopy = &pKeyInfo->aColl[nOrderByExpr];
1.2030 - pSortOrder = pKeyInfo->aSortOrder = (u8*)&aCopy[nCol];
1.2031 - memmove(aCopy, pKeyInfo->aColl, nCol*sizeof(CollSeq*));
1.2032 -
1.2033 - apColl = pKeyInfo->aColl;
1.2034 - for(i=0; i<nOrderByExpr; i++, pOTerm++, apColl++, pSortOrder++){
1.2035 - Expr *pExpr = pOTerm->pExpr;
1.2036 - if( (pExpr->flags & EP_ExpCollate) ){
1.2037 - assert( pExpr->pColl!=0 );
1.2038 - *apColl = pExpr->pColl;
1.2039 - }else{
1.2040 - *apColl = aCopy[pExpr->iColumn];
1.2041 - }
1.2042 - *pSortOrder = pOTerm->sortOrder;
1.2043 - }
1.2044 - assert( p->pRightmost==p );
1.2045 - assert( p->addrOpenEphm[2]>=0 );
1.2046 - addr = p->addrOpenEphm[2];
1.2047 - sqlite3VdbeChangeP2(v, addr, p->pOrderBy->nExpr+2);
1.2048 - pKeyInfo->nField = nOrderByExpr;
1.2049 - sqlite3VdbeChangeP3(v, addr, (char*)pKeyInfo, P3_KEYINFO_HANDOFF);
1.2050 - pKeyInfo = 0;
1.2051 - generateSortTail(pParse, p, v, p->pEList->nExpr, eDest, iParm);
1.2052 - }
1.2053 -
1.2054 - sqlite3_free(pKeyInfo);
1.2055 - }
1.2056 -
1.2057 -multi_select_end:
1.2058 - return rc;
1.2059 -}
1.2060 -#endif /* SQLITE_OMIT_COMPOUND_SELECT */
1.2061 -
1.2062 -#ifndef SQLITE_OMIT_VIEW
1.2063 -/* Forward Declarations */
1.2064 -static void substExprList(sqlite3*, ExprList*, int, ExprList*);
1.2065 -static void substSelect(sqlite3*, Select *, int, ExprList *);
1.2066 -
1.2067 -/*
1.2068 -** Scan through the expression pExpr. Replace every reference to
1.2069 -** a column in table number iTable with a copy of the iColumn-th
1.2070 -** entry in pEList. (But leave references to the ROWID column
1.2071 -** unchanged.)
1.2072 -**
1.2073 -** This routine is part of the flattening procedure. A subquery
1.2074 -** whose result set is defined by pEList appears as entry in the
1.2075 -** FROM clause of a SELECT such that the VDBE cursor assigned to that
1.2076 -** FORM clause entry is iTable. This routine make the necessary
1.2077 -** changes to pExpr so that it refers directly to the source table
1.2078 -** of the subquery rather the result set of the subquery.
1.2079 -*/
1.2080 -static void substExpr(
1.2081 - sqlite3 *db, /* Report malloc errors to this connection */
1.2082 - Expr *pExpr, /* Expr in which substitution occurs */
1.2083 - int iTable, /* Table to be substituted */
1.2084 - ExprList *pEList /* Substitute expressions */
1.2085 -){
1.2086 - if( pExpr==0 ) return;
1.2087 - if( pExpr->op==TK_COLUMN && pExpr->iTable==iTable ){
1.2088 - if( pExpr->iColumn<0 ){
1.2089 - pExpr->op = TK_NULL;
1.2090 - }else{
1.2091 - Expr *pNew;
1.2092 - assert( pEList!=0 && pExpr->iColumn<pEList->nExpr );
1.2093 - assert( pExpr->pLeft==0 && pExpr->pRight==0 && pExpr->pList==0 );
1.2094 - pNew = pEList->a[pExpr->iColumn].pExpr;
1.2095 - assert( pNew!=0 );
1.2096 - pExpr->op = pNew->op;
1.2097 - assert( pExpr->pLeft==0 );
1.2098 - pExpr->pLeft = sqlite3ExprDup(db, pNew->pLeft);
1.2099 - assert( pExpr->pRight==0 );
1.2100 - pExpr->pRight = sqlite3ExprDup(db, pNew->pRight);
1.2101 - assert( pExpr->pList==0 );
1.2102 - pExpr->pList = sqlite3ExprListDup(db, pNew->pList);
1.2103 - pExpr->iTable = pNew->iTable;
1.2104 - pExpr->pTab = pNew->pTab;
1.2105 - pExpr->iColumn = pNew->iColumn;
1.2106 - pExpr->iAgg = pNew->iAgg;
1.2107 - sqlite3TokenCopy(db, &pExpr->token, &pNew->token);
1.2108 - sqlite3TokenCopy(db, &pExpr->span, &pNew->span);
1.2109 - pExpr->pSelect = sqlite3SelectDup(db, pNew->pSelect);
1.2110 - pExpr->flags = pNew->flags;
1.2111 - }
1.2112 - }else{
1.2113 - substExpr(db, pExpr->pLeft, iTable, pEList);
1.2114 - substExpr(db, pExpr->pRight, iTable, pEList);
1.2115 - substSelect(db, pExpr->pSelect, iTable, pEList);
1.2116 - substExprList(db, pExpr->pList, iTable, pEList);
1.2117 - }
1.2118 -}
1.2119 -static void substExprList(
1.2120 - sqlite3 *db, /* Report malloc errors here */
1.2121 - ExprList *pList, /* List to scan and in which to make substitutes */
1.2122 - int iTable, /* Table to be substituted */
1.2123 - ExprList *pEList /* Substitute values */
1.2124 -){
1.2125 - int i;
1.2126 - if( pList==0 ) return;
1.2127 - for(i=0; i<pList->nExpr; i++){
1.2128 - substExpr(db, pList->a[i].pExpr, iTable, pEList);
1.2129 - }
1.2130 -}
1.2131 -static void substSelect(
1.2132 - sqlite3 *db, /* Report malloc errors here */
1.2133 - Select *p, /* SELECT statement in which to make substitutions */
1.2134 - int iTable, /* Table to be replaced */
1.2135 - ExprList *pEList /* Substitute values */
1.2136 -){
1.2137 - if( !p ) return;
1.2138 - substExprList(db, p->pEList, iTable, pEList);
1.2139 - substExprList(db, p->pGroupBy, iTable, pEList);
1.2140 - substExprList(db, p->pOrderBy, iTable, pEList);
1.2141 - substExpr(db, p->pHaving, iTable, pEList);
1.2142 - substExpr(db, p->pWhere, iTable, pEList);
1.2143 - substSelect(db, p->pPrior, iTable, pEList);
1.2144 -}
1.2145 -#endif /* !defined(SQLITE_OMIT_VIEW) */
1.2146 -
1.2147 -#ifndef SQLITE_OMIT_VIEW
1.2148 -/*
1.2149 -** This routine attempts to flatten subqueries in order to speed
1.2150 -** execution. It returns 1 if it makes changes and 0 if no flattening
1.2151 -** occurs.
1.2152 -**
1.2153 -** To understand the concept of flattening, consider the following
1.2154 -** query:
1.2155 -**
1.2156 -** SELECT a FROM (SELECT x+y AS a FROM t1 WHERE z<100) WHERE a>5
1.2157 -**
1.2158 -** The default way of implementing this query is to execute the
1.2159 -** subquery first and store the results in a temporary table, then
1.2160 -** run the outer query on that temporary table. This requires two
1.2161 -** passes over the data. Furthermore, because the temporary table
1.2162 -** has no indices, the WHERE clause on the outer query cannot be
1.2163 -** optimized.
1.2164 -**
1.2165 -** This routine attempts to rewrite queries such as the above into
1.2166 -** a single flat select, like this:
1.2167 -**
1.2168 -** SELECT x+y AS a FROM t1 WHERE z<100 AND a>5
1.2169 -**
1.2170 -** The code generated for this simpification gives the same result
1.2171 -** but only has to scan the data once. And because indices might
1.2172 -** exist on the table t1, a complete scan of the data might be
1.2173 -** avoided.
1.2174 -**
1.2175 -** Flattening is only attempted if all of the following are true:
1.2176 -**
1.2177 -** (1) The subquery and the outer query do not both use aggregates.
1.2178 -**
1.2179 -** (2) The subquery is not an aggregate or the outer query is not a join.
1.2180 -**
1.2181 -** (3) The subquery is not the right operand of a left outer join, or
1.2182 -** the subquery is not itself a join. (Ticket #306)
1.2183 -**
1.2184 -** (4) The subquery is not DISTINCT or the outer query is not a join.
1.2185 -**
1.2186 -** (5) The subquery is not DISTINCT or the outer query does not use
1.2187 -** aggregates.
1.2188 -**
1.2189 -** (6) The subquery does not use aggregates or the outer query is not
1.2190 -** DISTINCT.
1.2191 -**
1.2192 -** (7) The subquery has a FROM clause.
1.2193 -**
1.2194 -** (8) The subquery does not use LIMIT or the outer query is not a join.
1.2195 -**
1.2196 -** (9) The subquery does not use LIMIT or the outer query does not use
1.2197 -** aggregates.
1.2198 -**
1.2199 -** (10) The subquery does not use aggregates or the outer query does not
1.2200 -** use LIMIT.
1.2201 -**
1.2202 -** (11) The subquery and the outer query do not both have ORDER BY clauses.
1.2203 -**
1.2204 -** (12) The subquery is not the right term of a LEFT OUTER JOIN or the
1.2205 -** subquery has no WHERE clause. (added by ticket #350)
1.2206 -**
1.2207 -** (13) The subquery and outer query do not both use LIMIT
1.2208 -**
1.2209 -** (14) The subquery does not use OFFSET
1.2210 -**
1.2211 -** (15) The outer query is not part of a compound select or the
1.2212 -** subquery does not have both an ORDER BY and a LIMIT clause.
1.2213 -** (See ticket #2339)
1.2214 -**
1.2215 -** In this routine, the "p" parameter is a pointer to the outer query.
1.2216 -** The subquery is p->pSrc->a[iFrom]. isAgg is true if the outer query
1.2217 -** uses aggregates and subqueryIsAgg is true if the subquery uses aggregates.
1.2218 -**
1.2219 -** If flattening is not attempted, this routine is a no-op and returns 0.
1.2220 -** If flattening is attempted this routine returns 1.
1.2221 -**
1.2222 -** All of the expression analysis must occur on both the outer query and
1.2223 -** the subquery before this routine runs.
1.2224 -*/
1.2225 -static int flattenSubquery(
1.2226 - sqlite3 *db, /* Database connection */
1.2227 - Select *p, /* The parent or outer SELECT statement */
1.2228 - int iFrom, /* Index in p->pSrc->a[] of the inner subquery */
1.2229 - int isAgg, /* True if outer SELECT uses aggregate functions */
1.2230 - int subqueryIsAgg /* True if the subquery uses aggregate functions */
1.2231 -){
1.2232 - Select *pSub; /* The inner query or "subquery" */
1.2233 - SrcList *pSrc; /* The FROM clause of the outer query */
1.2234 - SrcList *pSubSrc; /* The FROM clause of the subquery */
1.2235 - ExprList *pList; /* The result set of the outer query */
1.2236 - int iParent; /* VDBE cursor number of the pSub result set temp table */
1.2237 - int i; /* Loop counter */
1.2238 - Expr *pWhere; /* The WHERE clause */
1.2239 - struct SrcList_item *pSubitem; /* The subquery */
1.2240 -
1.2241 - /* Check to see if flattening is permitted. Return 0 if not.
1.2242 - */
1.2243 - if( p==0 ) return 0;
1.2244 - pSrc = p->pSrc;
1.2245 - assert( pSrc && iFrom>=0 && iFrom<pSrc->nSrc );
1.2246 - pSubitem = &pSrc->a[iFrom];
1.2247 - pSub = pSubitem->pSelect;
1.2248 - assert( pSub!=0 );
1.2249 - if( isAgg && subqueryIsAgg ) return 0; /* Restriction (1) */
1.2250 - if( subqueryIsAgg && pSrc->nSrc>1 ) return 0; /* Restriction (2) */
1.2251 - pSubSrc = pSub->pSrc;
1.2252 - assert( pSubSrc );
1.2253 - /* Prior to version 3.1.2, when LIMIT and OFFSET had to be simple constants,
1.2254 - ** not arbitrary expresssions, we allowed some combining of LIMIT and OFFSET
1.2255 - ** because they could be computed at compile-time. But when LIMIT and OFFSET
1.2256 - ** became arbitrary expressions, we were forced to add restrictions (13)
1.2257 - ** and (14). */
1.2258 - if( pSub->pLimit && p->pLimit ) return 0; /* Restriction (13) */
1.2259 - if( pSub->pOffset ) return 0; /* Restriction (14) */
1.2260 - if( p->pRightmost && pSub->pLimit && pSub->pOrderBy ){
1.2261 - return 0; /* Restriction (15) */
1.2262 - }
1.2263 - if( pSubSrc->nSrc==0 ) return 0; /* Restriction (7) */
1.2264 - if( (pSub->isDistinct || pSub->pLimit)
1.2265 - && (pSrc->nSrc>1 || isAgg) ){ /* Restrictions (4)(5)(8)(9) */
1.2266 - return 0;
1.2267 - }
1.2268 - if( p->isDistinct && subqueryIsAgg ) return 0; /* Restriction (6) */
1.2269 - if( (p->disallowOrderBy || p->pOrderBy) && pSub->pOrderBy ){
1.2270 - return 0; /* Restriction (11) */
1.2271 - }
1.2272 -
1.2273 - /* Restriction 3: If the subquery is a join, make sure the subquery is
1.2274 - ** not used as the right operand of an outer join. Examples of why this
1.2275 - ** is not allowed:
1.2276 - **
1.2277 - ** t1 LEFT OUTER JOIN (t2 JOIN t3)
1.2278 - **
1.2279 - ** If we flatten the above, we would get
1.2280 - **
1.2281 - ** (t1 LEFT OUTER JOIN t2) JOIN t3
1.2282 - **
1.2283 - ** which is not at all the same thing.
1.2284 - */
1.2285 - if( pSubSrc->nSrc>1 && (pSubitem->jointype & JT_OUTER)!=0 ){
1.2286 - return 0;
1.2287 - }
1.2288 -
1.2289 - /* Restriction 12: If the subquery is the right operand of a left outer
1.2290 - ** join, make sure the subquery has no WHERE clause.
1.2291 - ** An examples of why this is not allowed:
1.2292 - **
1.2293 - ** t1 LEFT OUTER JOIN (SELECT * FROM t2 WHERE t2.x>0)
1.2294 - **
1.2295 - ** If we flatten the above, we would get
1.2296 - **
1.2297 - ** (t1 LEFT OUTER JOIN t2) WHERE t2.x>0
1.2298 - **
1.2299 - ** But the t2.x>0 test will always fail on a NULL row of t2, which
1.2300 - ** effectively converts the OUTER JOIN into an INNER JOIN.
1.2301 - */
1.2302 - if( (pSubitem->jointype & JT_OUTER)!=0 && pSub->pWhere!=0 ){
1.2303 - return 0;
1.2304 - }
1.2305 -
1.2306 - /* If we reach this point, it means flattening is permitted for the
1.2307 - ** iFrom-th entry of the FROM clause in the outer query.
1.2308 - */
1.2309 -
1.2310 - /* Move all of the FROM elements of the subquery into the
1.2311 - ** the FROM clause of the outer query. Before doing this, remember
1.2312 - ** the cursor number for the original outer query FROM element in
1.2313 - ** iParent. The iParent cursor will never be used. Subsequent code
1.2314 - ** will scan expressions looking for iParent references and replace
1.2315 - ** those references with expressions that resolve to the subquery FROM
1.2316 - ** elements we are now copying in.
1.2317 - */
1.2318 - iParent = pSubitem->iCursor;
1.2319 - {
1.2320 - int nSubSrc = pSubSrc->nSrc;
1.2321 - int jointype = pSubitem->jointype;
1.2322 -
1.2323 - sqlite3DeleteTable(pSubitem->pTab);
1.2324 - sqlite3_free(pSubitem->zDatabase);
1.2325 - sqlite3_free(pSubitem->zName);
1.2326 - sqlite3_free(pSubitem->zAlias);
1.2327 - if( nSubSrc>1 ){
1.2328 - int extra = nSubSrc - 1;
1.2329 - for(i=1; i<nSubSrc; i++){
1.2330 - pSrc = sqlite3SrcListAppend(db, pSrc, 0, 0);
1.2331 - }
1.2332 - p->pSrc = pSrc;
1.2333 - for(i=pSrc->nSrc-1; i-extra>=iFrom; i--){
1.2334 - pSrc->a[i] = pSrc->a[i-extra];
1.2335 - }
1.2336 - }
1.2337 - for(i=0; i<nSubSrc; i++){
1.2338 - pSrc->a[i+iFrom] = pSubSrc->a[i];
1.2339 - memset(&pSubSrc->a[i], 0, sizeof(pSubSrc->a[i]));
1.2340 - }
1.2341 - pSrc->a[iFrom].jointype = jointype;
1.2342 - }
1.2343 -
1.2344 - /* Now begin substituting subquery result set expressions for
1.2345 - ** references to the iParent in the outer query.
1.2346 - **
1.2347 - ** Example:
1.2348 - **
1.2349 - ** SELECT a+5, b*10 FROM (SELECT x*3 AS a, y+10 AS b FROM t1) WHERE a>b;
1.2350 - ** \ \_____________ subquery __________/ /
1.2351 - ** \_____________________ outer query ______________________________/
1.2352 - **
1.2353 - ** We look at every expression in the outer query and every place we see
1.2354 - ** "a" we substitute "x*3" and every place we see "b" we substitute "y+10".
1.2355 - */
1.2356 - pList = p->pEList;
1.2357 - for(i=0; i<pList->nExpr; i++){
1.2358 - Expr *pExpr;
1.2359 - if( pList->a[i].zName==0 && (pExpr = pList->a[i].pExpr)->span.z!=0 ){
1.2360 - pList->a[i].zName =
1.2361 - sqlite3DbStrNDup(db, (char*)pExpr->span.z, pExpr->span.n);
1.2362 - }
1.2363 - }
1.2364 - substExprList(db, p->pEList, iParent, pSub->pEList);
1.2365 - if( isAgg ){
1.2366 - substExprList(db, p->pGroupBy, iParent, pSub->pEList);
1.2367 - substExpr(db, p->pHaving, iParent, pSub->pEList);
1.2368 - }
1.2369 - if( pSub->pOrderBy ){
1.2370 - assert( p->pOrderBy==0 );
1.2371 - p->pOrderBy = pSub->pOrderBy;
1.2372 - pSub->pOrderBy = 0;
1.2373 - }else if( p->pOrderBy ){
1.2374 - substExprList(db, p->pOrderBy, iParent, pSub->pEList);
1.2375 - }
1.2376 - if( pSub->pWhere ){
1.2377 - pWhere = sqlite3ExprDup(db, pSub->pWhere);
1.2378 - }else{
1.2379 - pWhere = 0;
1.2380 - }
1.2381 - if( subqueryIsAgg ){
1.2382 - assert( p->pHaving==0 );
1.2383 - p->pHaving = p->pWhere;
1.2384 - p->pWhere = pWhere;
1.2385 - substExpr(db, p->pHaving, iParent, pSub->pEList);
1.2386 - p->pHaving = sqlite3ExprAnd(db, p->pHaving,
1.2387 - sqlite3ExprDup(db, pSub->pHaving));
1.2388 - assert( p->pGroupBy==0 );
1.2389 - p->pGroupBy = sqlite3ExprListDup(db, pSub->pGroupBy);
1.2390 - }else{
1.2391 - substExpr(db, p->pWhere, iParent, pSub->pEList);
1.2392 - p->pWhere = sqlite3ExprAnd(db, p->pWhere, pWhere);
1.2393 - }
1.2394 -
1.2395 - /* The flattened query is distinct if either the inner or the
1.2396 - ** outer query is distinct.
1.2397 - */
1.2398 - p->isDistinct = p->isDistinct || pSub->isDistinct;
1.2399 -
1.2400 - /*
1.2401 - ** SELECT ... FROM (SELECT ... LIMIT a OFFSET b) LIMIT x OFFSET y;
1.2402 - **
1.2403 - ** One is tempted to try to add a and b to combine the limits. But this
1.2404 - ** does not work if either limit is negative.
1.2405 - */
1.2406 - if( pSub->pLimit ){
1.2407 - p->pLimit = pSub->pLimit;
1.2408 - pSub->pLimit = 0;
1.2409 - }
1.2410 -
1.2411 - /* Finially, delete what is left of the subquery and return
1.2412 - ** success.
1.2413 - */
1.2414 - sqlite3SelectDelete(pSub);
1.2415 - return 1;
1.2416 -}
1.2417 -#endif /* SQLITE_OMIT_VIEW */
1.2418 -
1.2419 -/*
1.2420 -** Analyze the SELECT statement passed in as an argument to see if it
1.2421 -** is a simple min() or max() query. If it is and this query can be
1.2422 -** satisfied using a single seek to the beginning or end of an index,
1.2423 -** then generate the code for this SELECT and return 1. If this is not a
1.2424 -** simple min() or max() query, then return 0;
1.2425 -**
1.2426 -** A simply min() or max() query looks like this:
1.2427 -**
1.2428 -** SELECT min(a) FROM table;
1.2429 -** SELECT max(a) FROM table;
1.2430 -**
1.2431 -** The query may have only a single table in its FROM argument. There
1.2432 -** can be no GROUP BY or HAVING or WHERE clauses. The result set must
1.2433 -** be the min() or max() of a single column of the table. The column
1.2434 -** in the min() or max() function must be indexed.
1.2435 -**
1.2436 -** The parameters to this routine are the same as for sqlite3Select().
1.2437 -** See the header comment on that routine for additional information.
1.2438 -*/
1.2439 -static int simpleMinMaxQuery(Parse *pParse, Select *p, int eDest, int iParm){
1.2440 - Expr *pExpr;
1.2441 - int iCol;
1.2442 - Table *pTab;
1.2443 - Index *pIdx;
1.2444 - int base;
1.2445 - Vdbe *v;
1.2446 - int seekOp;
1.2447 - ExprList *pEList, *pList, eList;
1.2448 - struct ExprList_item eListItem;
1.2449 - SrcList *pSrc;
1.2450 - int brk;
1.2451 - int iDb;
1.2452 -
1.2453 - /* Check to see if this query is a simple min() or max() query. Return
1.2454 - ** zero if it is not.
1.2455 - */
1.2456 - if( p->pGroupBy || p->pHaving || p->pWhere ) return 0;
1.2457 - pSrc = p->pSrc;
1.2458 - if( pSrc->nSrc!=1 ) return 0;
1.2459 - pEList = p->pEList;
1.2460 - if( pEList->nExpr!=1 ) return 0;
1.2461 - pExpr = pEList->a[0].pExpr;
1.2462 - if( pExpr->op!=TK_AGG_FUNCTION ) return 0;
1.2463 - pList = pExpr->pList;
1.2464 - if( pList==0 || pList->nExpr!=1 ) return 0;
1.2465 - if( pExpr->token.n!=3 ) return 0;
1.2466 - if( sqlite3StrNICmp((char*)pExpr->token.z,"min",3)==0 ){
1.2467 - seekOp = OP_Rewind;
1.2468 - }else if( sqlite3StrNICmp((char*)pExpr->token.z,"max",3)==0 ){
1.2469 - seekOp = OP_Last;
1.2470 - }else{
1.2471 - return 0;
1.2472 - }
1.2473 - pExpr = pList->a[0].pExpr;
1.2474 - if( pExpr->op!=TK_COLUMN ) return 0;
1.2475 - iCol = pExpr->iColumn;
1.2476 - pTab = pSrc->a[0].pTab;
1.2477 -
1.2478 - /* This optimization cannot be used with virtual tables. */
1.2479 - if( IsVirtual(pTab) ) return 0;
1.2480 -
1.2481 - /* If we get to here, it means the query is of the correct form.
1.2482 - ** Check to make sure we have an index and make pIdx point to the
1.2483 - ** appropriate index. If the min() or max() is on an INTEGER PRIMARY
1.2484 - ** key column, no index is necessary so set pIdx to NULL. If no
1.2485 - ** usable index is found, return 0.
1.2486 - */
1.2487 - if( iCol<0 ){
1.2488 - pIdx = 0;
1.2489 - }else{
1.2490 - CollSeq *pColl = sqlite3ExprCollSeq(pParse, pExpr);
1.2491 - if( pColl==0 ) return 0;
1.2492 - for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
1.2493 - assert( pIdx->nColumn>=1 );
1.2494 - if( pIdx->aiColumn[0]==iCol &&
1.2495 - 0==sqlite3StrICmp(pIdx->azColl[0], pColl->zName) ){
1.2496 - break;
1.2497 - }
1.2498 - }
1.2499 - if( pIdx==0 ) return 0;
1.2500 - }
1.2501 -
1.2502 - /* Identify column types if we will be using the callback. This
1.2503 - ** step is skipped if the output is going to a table or a memory cell.
1.2504 - ** The column names have already been generated in the calling function.
1.2505 - */
1.2506 - v = sqlite3GetVdbe(pParse);
1.2507 - if( v==0 ) return 0;
1.2508 -
1.2509 - /* If the output is destined for a temporary table, open that table.
1.2510 - */
1.2511 - if( eDest==SRT_EphemTab ){
1.2512 - sqlite3VdbeAddOp(v, OP_OpenEphemeral, iParm, 1);
1.2513 - }
1.2514 -
1.2515 - /* Generating code to find the min or the max. Basically all we have
1.2516 - ** to do is find the first or the last entry in the chosen index. If
1.2517 - ** the min() or max() is on the INTEGER PRIMARY KEY, then find the first
1.2518 - ** or last entry in the main table.
1.2519 - */
1.2520 - iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
1.2521 - assert( iDb>=0 || pTab->isEphem );
1.2522 - sqlite3CodeVerifySchema(pParse, iDb);
1.2523 - sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
1.2524 - base = pSrc->a[0].iCursor;
1.2525 - brk = sqlite3VdbeMakeLabel(v);
1.2526 - computeLimitRegisters(pParse, p, brk);
1.2527 - if( pSrc->a[0].pSelect==0 ){
1.2528 - sqlite3OpenTable(pParse, base, iDb, pTab, OP_OpenRead);
1.2529 - }
1.2530 - if( pIdx==0 ){
1.2531 - sqlite3VdbeAddOp(v, seekOp, base, 0);
1.2532 - }else{
1.2533 - /* Even though the cursor used to open the index here is closed
1.2534 - ** as soon as a single value has been read from it, allocate it
1.2535 - ** using (pParse->nTab++) to prevent the cursor id from being
1.2536 - ** reused. This is important for statements of the form
1.2537 - ** "INSERT INTO x SELECT max() FROM x".
1.2538 - */
1.2539 - int iIdx;
1.2540 - KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx);
1.2541 - iIdx = pParse->nTab++;
1.2542 - assert( pIdx->pSchema==pTab->pSchema );
1.2543 - sqlite3VdbeAddOp(v, OP_Integer, iDb, 0);
1.2544 - sqlite3VdbeOp3(v, OP_OpenRead, iIdx, pIdx->tnum,
1.2545 - (char*)pKey, P3_KEYINFO_HANDOFF);
1.2546 - if( seekOp==OP_Rewind ){
1.2547 - sqlite3VdbeAddOp(v, OP_Null, 0, 0);
1.2548 - sqlite3VdbeAddOp(v, OP_MakeRecord, 1, 0);
1.2549 - seekOp = OP_MoveGt;
1.2550 - }
1.2551 - if( pIdx->aSortOrder[0]==SQLITE_SO_DESC ){
1.2552 - /* Ticket #2514: invert the seek operator if we are using
1.2553 - ** a descending index. */
1.2554 - if( seekOp==OP_Last ){
1.2555 - seekOp = OP_Rewind;
1.2556 - }else{
1.2557 - assert( seekOp==OP_MoveGt );
1.2558 - seekOp = OP_MoveLt;
1.2559 - }
1.2560 - }
1.2561 - sqlite3VdbeAddOp(v, seekOp, iIdx, 0);
1.2562 - sqlite3VdbeAddOp(v, OP_IdxRowid, iIdx, 0);
1.2563 - sqlite3VdbeAddOp(v, OP_Close, iIdx, 0);
1.2564 - sqlite3VdbeAddOp(v, OP_MoveGe, base, 0);
1.2565 - }
1.2566 - eList.nExpr = 1;
1.2567 - memset(&eListItem, 0, sizeof(eListItem));
1.2568 - eList.a = &eListItem;
1.2569 - eList.a[0].pExpr = pExpr;
1.2570 - selectInnerLoop(pParse, p, &eList, 0, 0, 0, -1, eDest, iParm, brk, brk, 0);
1.2571 - sqlite3VdbeResolveLabel(v, brk);
1.2572 - sqlite3VdbeAddOp(v, OP_Close, base, 0);
1.2573 -
1.2574 - return 1;
1.2575 -}
1.2576 -
1.2577 -/*
1.2578 -** Analyze and ORDER BY or GROUP BY clause in a SELECT statement. Return
1.2579 -** the number of errors seen.
1.2580 -**
1.2581 -** An ORDER BY or GROUP BY is a list of expressions. If any expression
1.2582 -** is an integer constant, then that expression is replaced by the
1.2583 -** corresponding entry in the result set.
1.2584 -*/
1.2585 -static int processOrderGroupBy(
1.2586 - NameContext *pNC, /* Name context of the SELECT statement. */
1.2587 - ExprList *pOrderBy, /* The ORDER BY or GROUP BY clause to be processed */
1.2588 - const char *zType /* Either "ORDER" or "GROUP", as appropriate */
1.2589 -){
1.2590 - int i;
1.2591 - ExprList *pEList = pNC->pEList; /* The result set of the SELECT */
1.2592 - Parse *pParse = pNC->pParse; /* The result set of the SELECT */
1.2593 - assert( pEList );
1.2594 -
1.2595 - if( pOrderBy==0 ) return 0;
1.2596 - if( pOrderBy->nExpr>SQLITE_MAX_COLUMN ){
1.2597 - sqlite3ErrorMsg(pParse, "too many terms in %s BY clause", zType);
1.2598 - return 1;
1.2599 - }
1.2600 - for(i=0; i<pOrderBy->nExpr; i++){
1.2601 - int iCol;
1.2602 - Expr *pE = pOrderBy->a[i].pExpr;
1.2603 - if( sqlite3ExprIsInteger(pE, &iCol) ){
1.2604 - if( iCol>0 && iCol<=pEList->nExpr ){
1.2605 - CollSeq *pColl = pE->pColl;
1.2606 - int flags = pE->flags & EP_ExpCollate;
1.2607 - sqlite3ExprDelete(pE);
1.2608 - pE = sqlite3ExprDup(pParse->db, pEList->a[iCol-1].pExpr);
1.2609 - pOrderBy->a[i].pExpr = pE;
1.2610 - if( pColl && flags ){
1.2611 - pE->pColl = pColl;
1.2612 - pE->flags |= flags;
1.2613 - }
1.2614 - }else{
1.2615 - sqlite3ErrorMsg(pParse,
1.2616 - "%s BY column number %d out of range - should be "
1.2617 - "between 1 and %d", zType, iCol, pEList->nExpr);
1.2618 - return 1;
1.2619 - }
1.2620 - }
1.2621 - if( sqlite3ExprResolveNames(pNC, pE) ){
1.2622 - return 1;
1.2623 - }
1.2624 - }
1.2625 - return 0;
1.2626 -}
1.2627 -
1.2628 -/*
1.2629 -** This routine resolves any names used in the result set of the
1.2630 -** supplied SELECT statement. If the SELECT statement being resolved
1.2631 -** is a sub-select, then pOuterNC is a pointer to the NameContext
1.2632 -** of the parent SELECT.
1.2633 -*/
1.2634 -int sqlite3SelectResolve(
1.2635 - Parse *pParse, /* The parser context */
1.2636 - Select *p, /* The SELECT statement being coded. */
1.2637 - NameContext *pOuterNC /* The outer name context. May be NULL. */
1.2638 -){
1.2639 - ExprList *pEList; /* Result set. */
1.2640 - int i; /* For-loop variable used in multiple places */
1.2641 - NameContext sNC; /* Local name-context */
1.2642 - ExprList *pGroupBy; /* The group by clause */
1.2643 -
1.2644 - /* If this routine has run before, return immediately. */
1.2645 - if( p->isResolved ){
1.2646 - assert( !pOuterNC );
1.2647 - return SQLITE_OK;
1.2648 - }
1.2649 - p->isResolved = 1;
1.2650 -
1.2651 - /* If there have already been errors, do nothing. */
1.2652 - if( pParse->nErr>0 ){
1.2653 - return SQLITE_ERROR;
1.2654 - }
1.2655 -
1.2656 - /* Prepare the select statement. This call will allocate all cursors
1.2657 - ** required to handle the tables and subqueries in the FROM clause.
1.2658 - */
1.2659 - if( prepSelectStmt(pParse, p) ){
1.2660 - return SQLITE_ERROR;
1.2661 - }
1.2662 -
1.2663 - /* Resolve the expressions in the LIMIT and OFFSET clauses. These
1.2664 - ** are not allowed to refer to any names, so pass an empty NameContext.
1.2665 - */
1.2666 - memset(&sNC, 0, sizeof(sNC));
1.2667 - sNC.pParse = pParse;
1.2668 - if( sqlite3ExprResolveNames(&sNC, p->pLimit) ||
1.2669 - sqlite3ExprResolveNames(&sNC, p->pOffset) ){
1.2670 - return SQLITE_ERROR;
1.2671 - }
1.2672 -
1.2673 - /* Set up the local name-context to pass to ExprResolveNames() to
1.2674 - ** resolve the expression-list.
1.2675 - */
1.2676 - sNC.allowAgg = 1;
1.2677 - sNC.pSrcList = p->pSrc;
1.2678 - sNC.pNext = pOuterNC;
1.2679 -
1.2680 - /* Resolve names in the result set. */
1.2681 - pEList = p->pEList;
1.2682 - if( !pEList ) return SQLITE_ERROR;
1.2683 - for(i=0; i<pEList->nExpr; i++){
1.2684 - Expr *pX = pEList->a[i].pExpr;
1.2685 - if( sqlite3ExprResolveNames(&sNC, pX) ){
1.2686 - return SQLITE_ERROR;
1.2687 - }
1.2688 - }
1.2689 -
1.2690 - /* If there are no aggregate functions in the result-set, and no GROUP BY
1.2691 - ** expression, do not allow aggregates in any of the other expressions.
1.2692 - */
1.2693 - assert( !p->isAgg );
1.2694 - pGroupBy = p->pGroupBy;
1.2695 - if( pGroupBy || sNC.hasAgg ){
1.2696 - p->isAgg = 1;
1.2697 - }else{
1.2698 - sNC.allowAgg = 0;
1.2699 - }
1.2700 -
1.2701 - /* If a HAVING clause is present, then there must be a GROUP BY clause.
1.2702 - */
1.2703 - if( p->pHaving && !pGroupBy ){
1.2704 - sqlite3ErrorMsg(pParse, "a GROUP BY clause is required before HAVING");
1.2705 - return SQLITE_ERROR;
1.2706 - }
1.2707 -
1.2708 - /* Add the expression list to the name-context before parsing the
1.2709 - ** other expressions in the SELECT statement. This is so that
1.2710 - ** expressions in the WHERE clause (etc.) can refer to expressions by
1.2711 - ** aliases in the result set.
1.2712 - **
1.2713 - ** Minor point: If this is the case, then the expression will be
1.2714 - ** re-evaluated for each reference to it.
1.2715 - */
1.2716 - sNC.pEList = p->pEList;
1.2717 - if( sqlite3ExprResolveNames(&sNC, p->pWhere) ||
1.2718 - sqlite3ExprResolveNames(&sNC, p->pHaving) ){
1.2719 - return SQLITE_ERROR;
1.2720 - }
1.2721 - if( p->pPrior==0 ){
1.2722 - if( processOrderGroupBy(&sNC, p->pOrderBy, "ORDER") ||
1.2723 - processOrderGroupBy(&sNC, pGroupBy, "GROUP") ){
1.2724 - return SQLITE_ERROR;
1.2725 - }
1.2726 - }
1.2727 -
1.2728 - if( pParse->db->mallocFailed ){
1.2729 - return SQLITE_NOMEM;
1.2730 - }
1.2731 -
1.2732 - /* Make sure the GROUP BY clause does not contain aggregate functions.
1.2733 - */
1.2734 - if( pGroupBy ){
1.2735 - struct ExprList_item *pItem;
1.2736 -
1.2737 - for(i=0, pItem=pGroupBy->a; i<pGroupBy->nExpr; i++, pItem++){
1.2738 - if( ExprHasProperty(pItem->pExpr, EP_Agg) ){
1.2739 - sqlite3ErrorMsg(pParse, "aggregate functions are not allowed in "
1.2740 - "the GROUP BY clause");
1.2741 - return SQLITE_ERROR;
1.2742 - }
1.2743 - }
1.2744 - }
1.2745 -
1.2746 - /* If this is one SELECT of a compound, be sure to resolve names
1.2747 - ** in the other SELECTs.
1.2748 - */
1.2749 - if( p->pPrior ){
1.2750 - return sqlite3SelectResolve(pParse, p->pPrior, pOuterNC);
1.2751 - }else{
1.2752 - return SQLITE_OK;
1.2753 - }
1.2754 -}
1.2755 -
1.2756 -/*
1.2757 -** Reset the aggregate accumulator.
1.2758 -**
1.2759 -** The aggregate accumulator is a set of memory cells that hold
1.2760 -** intermediate results while calculating an aggregate. This
1.2761 -** routine simply stores NULLs in all of those memory cells.
1.2762 -*/
1.2763 -static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){
1.2764 - Vdbe *v = pParse->pVdbe;
1.2765 - int i;
1.2766 - struct AggInfo_func *pFunc;
1.2767 - if( pAggInfo->nFunc+pAggInfo->nColumn==0 ){
1.2768 - return;
1.2769 - }
1.2770 - for(i=0; i<pAggInfo->nColumn; i++){
1.2771 - sqlite3VdbeAddOp(v, OP_MemNull, pAggInfo->aCol[i].iMem, 0);
1.2772 - }
1.2773 - for(pFunc=pAggInfo->aFunc, i=0; i<pAggInfo->nFunc; i++, pFunc++){
1.2774 - sqlite3VdbeAddOp(v, OP_MemNull, pFunc->iMem, 0);
1.2775 - if( pFunc->iDistinct>=0 ){
1.2776 - Expr *pE = pFunc->pExpr;
1.2777 - if( pE->pList==0 || pE->pList->nExpr!=1 ){
1.2778 - sqlite3ErrorMsg(pParse, "DISTINCT in aggregate must be followed "
1.2779 - "by an expression");
1.2780 - pFunc->iDistinct = -1;
1.2781 - }else{
1.2782 - KeyInfo *pKeyInfo = keyInfoFromExprList(pParse, pE->pList);
1.2783 - sqlite3VdbeOp3(v, OP_OpenEphemeral, pFunc->iDistinct, 0,
1.2784 - (char*)pKeyInfo, P3_KEYINFO_HANDOFF);
1.2785 - }
1.2786 - }
1.2787 - }
1.2788 -}
1.2789 -
1.2790 -/*
1.2791 -** Invoke the OP_AggFinalize opcode for every aggregate function
1.2792 -** in the AggInfo structure.
1.2793 -*/
1.2794 -static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){
1.2795 - Vdbe *v = pParse->pVdbe;
1.2796 - int i;
1.2797 - struct AggInfo_func *pF;
1.2798 - for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
1.2799 - ExprList *pList = pF->pExpr->pList;
1.2800 - sqlite3VdbeOp3(v, OP_AggFinal, pF->iMem, pList ? pList->nExpr : 0,
1.2801 - (void*)pF->pFunc, P3_FUNCDEF);
1.2802 - }
1.2803 -}
1.2804 -
1.2805 -/*
1.2806 -** Update the accumulator memory cells for an aggregate based on
1.2807 -** the current cursor position.
1.2808 -*/
1.2809 -static void updateAccumulator(Parse *pParse, AggInfo *pAggInfo){
1.2810 - Vdbe *v = pParse->pVdbe;
1.2811 - int i;
1.2812 - struct AggInfo_func *pF;
1.2813 - struct AggInfo_col *pC;
1.2814 -
1.2815 - pAggInfo->directMode = 1;
1.2816 - for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
1.2817 - int nArg;
1.2818 - int addrNext = 0;
1.2819 - ExprList *pList = pF->pExpr->pList;
1.2820 - if( pList ){
1.2821 - nArg = pList->nExpr;
1.2822 - sqlite3ExprCodeExprList(pParse, pList);
1.2823 - }else{
1.2824 - nArg = 0;
1.2825 - }
1.2826 - if( pF->iDistinct>=0 ){
1.2827 - addrNext = sqlite3VdbeMakeLabel(v);
1.2828 - assert( nArg==1 );
1.2829 - codeDistinct(v, pF->iDistinct, addrNext, 1);
1.2830 - }
1.2831 - if( pF->pFunc->needCollSeq ){
1.2832 - CollSeq *pColl = 0;
1.2833 - struct ExprList_item *pItem;
1.2834 - int j;
1.2835 - assert( pList!=0 ); /* pList!=0 if pF->pFunc->needCollSeq is true */
1.2836 - for(j=0, pItem=pList->a; !pColl && j<nArg; j++, pItem++){
1.2837 - pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
1.2838 - }
1.2839 - if( !pColl ){
1.2840 - pColl = pParse->db->pDfltColl;
1.2841 - }
1.2842 - sqlite3VdbeOp3(v, OP_CollSeq, 0, 0, (char *)pColl, P3_COLLSEQ);
1.2843 - }
1.2844 - sqlite3VdbeOp3(v, OP_AggStep, pF->iMem, nArg, (void*)pF->pFunc, P3_FUNCDEF);
1.2845 - if( addrNext ){
1.2846 - sqlite3VdbeResolveLabel(v, addrNext);
1.2847 - }
1.2848 - }
1.2849 - for(i=0, pC=pAggInfo->aCol; i<pAggInfo->nAccumulator; i++, pC++){
1.2850 - sqlite3ExprCode(pParse, pC->pExpr);
1.2851 - sqlite3VdbeAddOp(v, OP_MemStore, pC->iMem, 1);
1.2852 - }
1.2853 - pAggInfo->directMode = 0;
1.2854 -}
1.2855 -
1.2856 -
1.2857 -/*
1.2858 -** Generate code for the given SELECT statement.
1.2859 -**
1.2860 -** The results are distributed in various ways depending on the
1.2861 -** value of eDest and iParm.
1.2862 -**
1.2863 -** eDest Value Result
1.2864 -** ------------ -------------------------------------------
1.2865 -** SRT_Callback Invoke the callback for each row of the result.
1.2866 -**
1.2867 -** SRT_Mem Store first result in memory cell iParm
1.2868 -**
1.2869 -** SRT_Set Store results as keys of table iParm.
1.2870 -**
1.2871 -** SRT_Union Store results as a key in a temporary table iParm
1.2872 -**
1.2873 -** SRT_Except Remove results from the temporary table iParm.
1.2874 -**
1.2875 -** SRT_Table Store results in temporary table iParm
1.2876 -**
1.2877 -** The table above is incomplete. Additional eDist value have be added
1.2878 -** since this comment was written. See the selectInnerLoop() function for
1.2879 -** a complete listing of the allowed values of eDest and their meanings.
1.2880 -**
1.2881 -** This routine returns the number of errors. If any errors are
1.2882 -** encountered, then an appropriate error message is left in
1.2883 -** pParse->zErrMsg.
1.2884 -**
1.2885 -** This routine does NOT free the Select structure passed in. The
1.2886 -** calling function needs to do that.
1.2887 -**
1.2888 -** The pParent, parentTab, and *pParentAgg fields are filled in if this
1.2889 -** SELECT is a subquery. This routine may try to combine this SELECT
1.2890 -** with its parent to form a single flat query. In so doing, it might
1.2891 -** change the parent query from a non-aggregate to an aggregate query.
1.2892 -** For that reason, the pParentAgg flag is passed as a pointer, so it
1.2893 -** can be changed.
1.2894 -**
1.2895 -** Example 1: The meaning of the pParent parameter.
1.2896 -**
1.2897 -** SELECT * FROM t1 JOIN (SELECT x, count(*) FROM t2) JOIN t3;
1.2898 -** \ \_______ subquery _______/ /
1.2899 -** \ /
1.2900 -** \____________________ outer query ___________________/
1.2901 -**
1.2902 -** This routine is called for the outer query first. For that call,
1.2903 -** pParent will be NULL. During the processing of the outer query, this
1.2904 -** routine is called recursively to handle the subquery. For the recursive
1.2905 -** call, pParent will point to the outer query. Because the subquery is
1.2906 -** the second element in a three-way join, the parentTab parameter will
1.2907 -** be 1 (the 2nd value of a 0-indexed array.)
1.2908 -*/
1.2909 -int sqlite3Select(
1.2910 - Parse *pParse, /* The parser context */
1.2911 - Select *p, /* The SELECT statement being coded. */
1.2912 - int eDest, /* How to dispose of the results */
1.2913 - int iParm, /* A parameter used by the eDest disposal method */
1.2914 - Select *pParent, /* Another SELECT for which this is a sub-query */
1.2915 - int parentTab, /* Index in pParent->pSrc of this query */
1.2916 - int *pParentAgg, /* True if pParent uses aggregate functions */
1.2917 - char *aff /* If eDest is SRT_Union, the affinity string */
1.2918 -){
1.2919 - int i, j; /* Loop counters */
1.2920 - WhereInfo *pWInfo; /* Return from sqlite3WhereBegin() */
1.2921 - Vdbe *v; /* The virtual machine under construction */
1.2922 - int isAgg; /* True for select lists like "count(*)" */
1.2923 - ExprList *pEList; /* List of columns to extract. */
1.2924 - SrcList *pTabList; /* List of tables to select from */
1.2925 - Expr *pWhere; /* The WHERE clause. May be NULL */
1.2926 - ExprList *pOrderBy; /* The ORDER BY clause. May be NULL */
1.2927 - ExprList *pGroupBy; /* The GROUP BY clause. May be NULL */
1.2928 - Expr *pHaving; /* The HAVING clause. May be NULL */
1.2929 - int isDistinct; /* True if the DISTINCT keyword is present */
1.2930 - int distinct; /* Table to use for the distinct set */
1.2931 - int rc = 1; /* Value to return from this function */
1.2932 - int addrSortIndex; /* Address of an OP_OpenEphemeral instruction */
1.2933 - AggInfo sAggInfo; /* Information used by aggregate queries */
1.2934 - int iEnd; /* Address of the end of the query */
1.2935 - sqlite3 *db; /* The database connection */
1.2936 -
1.2937 - db = pParse->db;
1.2938 - if( p==0 || db->mallocFailed || pParse->nErr ){
1.2939 - return 1;
1.2940 - }
1.2941 - if( sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1;
1.2942 - memset(&sAggInfo, 0, sizeof(sAggInfo));
1.2943 -
1.2944 -#ifndef SQLITE_OMIT_COMPOUND_SELECT
1.2945 - /* If there is are a sequence of queries, do the earlier ones first.
1.2946 - */
1.2947 - if( p->pPrior ){
1.2948 - if( p->pRightmost==0 ){
1.2949 - Select *pLoop;
1.2950 - int cnt = 0;
1.2951 - for(pLoop=p; pLoop; pLoop=pLoop->pPrior, cnt++){
1.2952 - pLoop->pRightmost = p;
1.2953 - }
1.2954 - if( SQLITE_MAX_COMPOUND_SELECT>0 && cnt>SQLITE_MAX_COMPOUND_SELECT ){
1.2955 - sqlite3ErrorMsg(pParse, "too many terms in compound SELECT");
1.2956 - return 1;
1.2957 - }
1.2958 - }
1.2959 - return multiSelect(pParse, p, eDest, iParm, aff);
1.2960 - }
1.2961 -#endif
1.2962 -
1.2963 - pOrderBy = p->pOrderBy;
1.2964 - if( IgnorableOrderby(eDest) ){
1.2965 - p->pOrderBy = 0;
1.2966 - }
1.2967 - if( sqlite3SelectResolve(pParse, p, 0) ){
1.2968 - goto select_end;
1.2969 - }
1.2970 - p->pOrderBy = pOrderBy;
1.2971 -
1.2972 - /* Make local copies of the parameters for this query.
1.2973 - */
1.2974 - pTabList = p->pSrc;
1.2975 - pWhere = p->pWhere;
1.2976 - pGroupBy = p->pGroupBy;
1.2977 - pHaving = p->pHaving;
1.2978 - isAgg = p->isAgg;
1.2979 - isDistinct = p->isDistinct;
1.2980 - pEList = p->pEList;
1.2981 - if( pEList==0 ) goto select_end;
1.2982 -
1.2983 - /*
1.2984 - ** Do not even attempt to generate any code if we have already seen
1.2985 - ** errors before this routine starts.
1.2986 - */
1.2987 - if( pParse->nErr>0 ) goto select_end;
1.2988 -
1.2989 - /* If writing to memory or generating a set
1.2990 - ** only a single column may be output.
1.2991 - */
1.2992 -#ifndef SQLITE_OMIT_SUBQUERY
1.2993 - if( checkForMultiColumnSelectError(pParse, eDest, pEList->nExpr) ){
1.2994 - goto select_end;
1.2995 - }
1.2996 -#endif
1.2997 -
1.2998 - /* ORDER BY is ignored for some destinations.
1.2999 - */
1.3000 - if( IgnorableOrderby(eDest) ){
1.3001 - pOrderBy = 0;
1.3002 - }
1.3003 -
1.3004 - /* Begin generating code.
1.3005 - */
1.3006 - v = sqlite3GetVdbe(pParse);
1.3007 - if( v==0 ) goto select_end;
1.3008 -
1.3009 - /* Generate code for all sub-queries in the FROM clause
1.3010 - */
1.3011 -#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
1.3012 - for(i=0; i<pTabList->nSrc; i++){
1.3013 - const char *zSavedAuthContext = 0;
1.3014 - int needRestoreContext;
1.3015 - struct SrcList_item *pItem = &pTabList->a[i];
1.3016 -
1.3017 - if( pItem->pSelect==0 || pItem->isPopulated ) continue;
1.3018 - if( pItem->zName!=0 ){
1.3019 - zSavedAuthContext = pParse->zAuthContext;
1.3020 - pParse->zAuthContext = pItem->zName;
1.3021 - needRestoreContext = 1;
1.3022 - }else{
1.3023 - needRestoreContext = 0;
1.3024 - }
1.3025 -#if defined(SQLITE_TEST) || SQLITE_MAX_EXPR_DEPTH>0
1.3026 - /* Increment Parse.nHeight by the height of the largest expression
1.3027 - ** tree refered to by this, the parent select. The child select
1.3028 - ** may contain expression trees of at most
1.3029 - ** (SQLITE_MAX_EXPR_DEPTH-Parse.nHeight) height. This is a bit
1.3030 - ** more conservative than necessary, but much easier than enforcing
1.3031 - ** an exact limit.
1.3032 - */
1.3033 - pParse->nHeight += sqlite3SelectExprHeight(p);
1.3034 -#endif
1.3035 - sqlite3Select(pParse, pItem->pSelect, SRT_EphemTab,
1.3036 - pItem->iCursor, p, i, &isAgg, 0);
1.3037 -#if defined(SQLITE_TEST) || SQLITE_MAX_EXPR_DEPTH>0
1.3038 - pParse->nHeight -= sqlite3SelectExprHeight(p);
1.3039 -#endif
1.3040 - if( needRestoreContext ){
1.3041 - pParse->zAuthContext = zSavedAuthContext;
1.3042 - }
1.3043 - pTabList = p->pSrc;
1.3044 - pWhere = p->pWhere;
1.3045 - if( !IgnorableOrderby(eDest) ){
1.3046 - pOrderBy = p->pOrderBy;
1.3047 - }
1.3048 - pGroupBy = p->pGroupBy;
1.3049 - pHaving = p->pHaving;
1.3050 - isDistinct = p->isDistinct;
1.3051 - }
1.3052 -#endif
1.3053 -
1.3054 - /* Check for the special case of a min() or max() function by itself
1.3055 - ** in the result set.
1.3056 - */
1.3057 - if( simpleMinMaxQuery(pParse, p, eDest, iParm) ){
1.3058 - rc = 0;
1.3059 - goto select_end;
1.3060 - }
1.3061 -
1.3062 - /* Check to see if this is a subquery that can be "flattened" into its parent.
1.3063 - ** If flattening is a possiblity, do so and return immediately.
1.3064 - */
1.3065 -#ifndef SQLITE_OMIT_VIEW
1.3066 - if( pParent && pParentAgg &&
1.3067 - flattenSubquery(db, pParent, parentTab, *pParentAgg, isAgg) ){
1.3068 - if( isAgg ) *pParentAgg = 1;
1.3069 - goto select_end;
1.3070 - }
1.3071 -#endif
1.3072 -
1.3073 - /* If there is an ORDER BY clause, then this sorting
1.3074 - ** index might end up being unused if the data can be
1.3075 - ** extracted in pre-sorted order. If that is the case, then the
1.3076 - ** OP_OpenEphemeral instruction will be changed to an OP_Noop once
1.3077 - ** we figure out that the sorting index is not needed. The addrSortIndex
1.3078 - ** variable is used to facilitate that change.
1.3079 - */
1.3080 - if( pOrderBy ){
1.3081 - KeyInfo *pKeyInfo;
1.3082 - if( pParse->nErr ){
1.3083 - goto select_end;
1.3084 - }
1.3085 - pKeyInfo = keyInfoFromExprList(pParse, pOrderBy);
1.3086 - pOrderBy->iECursor = pParse->nTab++;
1.3087 - p->addrOpenEphm[2] = addrSortIndex =
1.3088 - sqlite3VdbeOp3(v, OP_OpenEphemeral, pOrderBy->iECursor, pOrderBy->nExpr+2, (char*)pKeyInfo, P3_KEYINFO_HANDOFF);
1.3089 - }else{
1.3090 - addrSortIndex = -1;
1.3091 - }
1.3092 -
1.3093 - /* If the output is destined for a temporary table, open that table.
1.3094 - */
1.3095 - if( eDest==SRT_EphemTab ){
1.3096 - sqlite3VdbeAddOp(v, OP_OpenEphemeral, iParm, pEList->nExpr);
1.3097 - }
1.3098 -
1.3099 - /* Set the limiter.
1.3100 - */
1.3101 - iEnd = sqlite3VdbeMakeLabel(v);
1.3102 - computeLimitRegisters(pParse, p, iEnd);
1.3103 -
1.3104 - /* Open a virtual index to use for the distinct set.
1.3105 - */
1.3106 - if( isDistinct ){
1.3107 - KeyInfo *pKeyInfo;
1.3108 - distinct = pParse->nTab++;
1.3109 - pKeyInfo = keyInfoFromExprList(pParse, p->pEList);
1.3110 - sqlite3VdbeOp3(v, OP_OpenEphemeral, distinct, 0,
1.3111 - (char*)pKeyInfo, P3_KEYINFO_HANDOFF);
1.3112 - }else{
1.3113 - distinct = -1;
1.3114 - }
1.3115 -
1.3116 - /* Aggregate and non-aggregate queries are handled differently */
1.3117 - if( !isAgg && pGroupBy==0 ){
1.3118 - /* This case is for non-aggregate queries
1.3119 - ** Begin the database scan
1.3120 - */
1.3121 - pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, &pOrderBy);
1.3122 - if( pWInfo==0 ) goto select_end;
1.3123 -
1.3124 - /* If sorting index that was created by a prior OP_OpenEphemeral
1.3125 - ** instruction ended up not being needed, then change the OP_OpenEphemeral
1.3126 - ** into an OP_Noop.
1.3127 - */
1.3128 - if( addrSortIndex>=0 && pOrderBy==0 ){
1.3129 - sqlite3VdbeChangeToNoop(v, addrSortIndex, 1);
1.3130 - p->addrOpenEphm[2] = -1;
1.3131 - }
1.3132 -
1.3133 - /* Use the standard inner loop
1.3134 - */
1.3135 - if( selectInnerLoop(pParse, p, pEList, 0, 0, pOrderBy, distinct, eDest,
1.3136 - iParm, pWInfo->iContinue, pWInfo->iBreak, aff) ){
1.3137 - goto select_end;
1.3138 - }
1.3139 -
1.3140 - /* End the database scan loop.
1.3141 - */
1.3142 - sqlite3WhereEnd(pWInfo);
1.3143 - }else{
1.3144 - /* This is the processing for aggregate queries */
1.3145 - NameContext sNC; /* Name context for processing aggregate information */
1.3146 - int iAMem; /* First Mem address for storing current GROUP BY */
1.3147 - int iBMem; /* First Mem address for previous GROUP BY */
1.3148 - int iUseFlag; /* Mem address holding flag indicating that at least
1.3149 - ** one row of the input to the aggregator has been
1.3150 - ** processed */
1.3151 - int iAbortFlag; /* Mem address which causes query abort if positive */
1.3152 - int groupBySort; /* Rows come from source in GROUP BY order */
1.3153 -
1.3154 -
1.3155 - /* The following variables hold addresses or labels for parts of the
1.3156 - ** virtual machine program we are putting together */
1.3157 - int addrOutputRow; /* Start of subroutine that outputs a result row */
1.3158 - int addrSetAbort; /* Set the abort flag and return */
1.3159 - int addrInitializeLoop; /* Start of code that initializes the input loop */
1.3160 - int addrTopOfLoop; /* Top of the input loop */
1.3161 - int addrGroupByChange; /* Code that runs when any GROUP BY term changes */
1.3162 - int addrProcessRow; /* Code to process a single input row */
1.3163 - int addrEnd; /* End of all processing */
1.3164 - int addrSortingIdx; /* The OP_OpenEphemeral for the sorting index */
1.3165 - int addrReset; /* Subroutine for resetting the accumulator */
1.3166 -
1.3167 - addrEnd = sqlite3VdbeMakeLabel(v);
1.3168 -
1.3169 - /* Convert TK_COLUMN nodes into TK_AGG_COLUMN and make entries in
1.3170 - ** sAggInfo for all TK_AGG_FUNCTION nodes in expressions of the
1.3171 - ** SELECT statement.
1.3172 - */
1.3173 - memset(&sNC, 0, sizeof(sNC));
1.3174 - sNC.pParse = pParse;
1.3175 - sNC.pSrcList = pTabList;
1.3176 - sNC.pAggInfo = &sAggInfo;
1.3177 - sAggInfo.nSortingColumn = pGroupBy ? pGroupBy->nExpr+1 : 0;
1.3178 - sAggInfo.pGroupBy = pGroupBy;
1.3179 - if( sqlite3ExprAnalyzeAggList(&sNC, pEList) ){
1.3180 - goto select_end;
1.3181 - }
1.3182 - if( sqlite3ExprAnalyzeAggList(&sNC, pOrderBy) ){
1.3183 - goto select_end;
1.3184 - }
1.3185 - if( pHaving && sqlite3ExprAnalyzeAggregates(&sNC, pHaving) ){
1.3186 - goto select_end;
1.3187 - }
1.3188 - sAggInfo.nAccumulator = sAggInfo.nColumn;
1.3189 - for(i=0; i<sAggInfo.nFunc; i++){
1.3190 - if( sqlite3ExprAnalyzeAggList(&sNC, sAggInfo.aFunc[i].pExpr->pList) ){
1.3191 - goto select_end;
1.3192 - }
1.3193 - }
1.3194 - if( db->mallocFailed ) goto select_end;
1.3195 -
1.3196 - /* Processing for aggregates with GROUP BY is very different and
1.3197 - ** much more complex tha aggregates without a GROUP BY.
1.3198 - */
1.3199 - if( pGroupBy ){
1.3200 - KeyInfo *pKeyInfo; /* Keying information for the group by clause */
1.3201 -
1.3202 - /* Create labels that we will be needing
1.3203 - */
1.3204 -
1.3205 - addrInitializeLoop = sqlite3VdbeMakeLabel(v);
1.3206 - addrGroupByChange = sqlite3VdbeMakeLabel(v);
1.3207 - addrProcessRow = sqlite3VdbeMakeLabel(v);
1.3208 -
1.3209 - /* If there is a GROUP BY clause we might need a sorting index to
1.3210 - ** implement it. Allocate that sorting index now. If it turns out
1.3211 - ** that we do not need it after all, the OpenEphemeral instruction
1.3212 - ** will be converted into a Noop.
1.3213 - */
1.3214 - sAggInfo.sortingIdx = pParse->nTab++;
1.3215 - pKeyInfo = keyInfoFromExprList(pParse, pGroupBy);
1.3216 - addrSortingIdx =
1.3217 - sqlite3VdbeOp3(v, OP_OpenEphemeral, sAggInfo.sortingIdx,
1.3218 - sAggInfo.nSortingColumn,
1.3219 - (char*)pKeyInfo, P3_KEYINFO_HANDOFF);
1.3220 -
1.3221 - /* Initialize memory locations used by GROUP BY aggregate processing
1.3222 - */
1.3223 - iUseFlag = pParse->nMem++;
1.3224 - iAbortFlag = pParse->nMem++;
1.3225 - iAMem = pParse->nMem;
1.3226 - pParse->nMem += pGroupBy->nExpr;
1.3227 - iBMem = pParse->nMem;
1.3228 - pParse->nMem += pGroupBy->nExpr;
1.3229 - sqlite3VdbeAddOp(v, OP_MemInt, 0, iAbortFlag);
1.3230 - VdbeComment((v, "# clear abort flag"));
1.3231 - sqlite3VdbeAddOp(v, OP_MemInt, 0, iUseFlag);
1.3232 - VdbeComment((v, "# indicate accumulator empty"));
1.3233 - sqlite3VdbeAddOp(v, OP_Goto, 0, addrInitializeLoop);
1.3234 -
1.3235 - /* Generate a subroutine that outputs a single row of the result
1.3236 - ** set. This subroutine first looks at the iUseFlag. If iUseFlag
1.3237 - ** is less than or equal to zero, the subroutine is a no-op. If
1.3238 - ** the processing calls for the query to abort, this subroutine
1.3239 - ** increments the iAbortFlag memory location before returning in
1.3240 - ** order to signal the caller to abort.
1.3241 - */
1.3242 - addrSetAbort = sqlite3VdbeCurrentAddr(v);
1.3243 - sqlite3VdbeAddOp(v, OP_MemInt, 1, iAbortFlag);
1.3244 - VdbeComment((v, "# set abort flag"));
1.3245 - sqlite3VdbeAddOp(v, OP_Return, 0, 0);
1.3246 - addrOutputRow = sqlite3VdbeCurrentAddr(v);
1.3247 - sqlite3VdbeAddOp(v, OP_IfMemPos, iUseFlag, addrOutputRow+2);
1.3248 - VdbeComment((v, "# Groupby result generator entry point"));
1.3249 - sqlite3VdbeAddOp(v, OP_Return, 0, 0);
1.3250 - finalizeAggFunctions(pParse, &sAggInfo);
1.3251 - if( pHaving ){
1.3252 - sqlite3ExprIfFalse(pParse, pHaving, addrOutputRow+1, 1);
1.3253 - }
1.3254 - rc = selectInnerLoop(pParse, p, p->pEList, 0, 0, pOrderBy,
1.3255 - distinct, eDest, iParm,
1.3256 - addrOutputRow+1, addrSetAbort, aff);
1.3257 - if( rc ){
1.3258 - goto select_end;
1.3259 - }
1.3260 - sqlite3VdbeAddOp(v, OP_Return, 0, 0);
1.3261 - VdbeComment((v, "# end groupby result generator"));
1.3262 -
1.3263 - /* Generate a subroutine that will reset the group-by accumulator
1.3264 - */
1.3265 - addrReset = sqlite3VdbeCurrentAddr(v);
1.3266 - resetAccumulator(pParse, &sAggInfo);
1.3267 - sqlite3VdbeAddOp(v, OP_Return, 0, 0);
1.3268 -
1.3269 - /* Begin a loop that will extract all source rows in GROUP BY order.
1.3270 - ** This might involve two separate loops with an OP_Sort in between, or
1.3271 - ** it might be a single loop that uses an index to extract information
1.3272 - ** in the right order to begin with.
1.3273 - */
1.3274 - sqlite3VdbeResolveLabel(v, addrInitializeLoop);
1.3275 - sqlite3VdbeAddOp(v, OP_Gosub, 0, addrReset);
1.3276 - pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, &pGroupBy);
1.3277 - if( pWInfo==0 ) goto select_end;
1.3278 - if( pGroupBy==0 ){
1.3279 - /* The optimizer is able to deliver rows in group by order so
1.3280 - ** we do not have to sort. The OP_OpenEphemeral table will be
1.3281 - ** cancelled later because we still need to use the pKeyInfo
1.3282 - */
1.3283 - pGroupBy = p->pGroupBy;
1.3284 - groupBySort = 0;
1.3285 - }else{
1.3286 - /* Rows are coming out in undetermined order. We have to push
1.3287 - ** each row into a sorting index, terminate the first loop,
1.3288 - ** then loop over the sorting index in order to get the output
1.3289 - ** in sorted order
1.3290 - */
1.3291 - groupBySort = 1;
1.3292 - sqlite3ExprCodeExprList(pParse, pGroupBy);
1.3293 - sqlite3VdbeAddOp(v, OP_Sequence, sAggInfo.sortingIdx, 0);
1.3294 - j = pGroupBy->nExpr+1;
1.3295 - for(i=0; i<sAggInfo.nColumn; i++){
1.3296 - struct AggInfo_col *pCol = &sAggInfo.aCol[i];
1.3297 - if( pCol->iSorterColumn<j ) continue;
1.3298 - sqlite3ExprCodeGetColumn(v, pCol->pTab, pCol->iColumn, pCol->iTable);
1.3299 - j++;
1.3300 - }
1.3301 - sqlite3VdbeAddOp(v, OP_MakeRecord, j, 0);
1.3302 - sqlite3VdbeAddOp(v, OP_IdxInsert, sAggInfo.sortingIdx, 0);
1.3303 - sqlite3WhereEnd(pWInfo);
1.3304 - sqlite3VdbeAddOp(v, OP_Sort, sAggInfo.sortingIdx, addrEnd);
1.3305 - VdbeComment((v, "# GROUP BY sort"));
1.3306 - sAggInfo.useSortingIdx = 1;
1.3307 - }
1.3308 -
1.3309 - /* Evaluate the current GROUP BY terms and store in b0, b1, b2...
1.3310 - ** (b0 is memory location iBMem+0, b1 is iBMem+1, and so forth)
1.3311 - ** Then compare the current GROUP BY terms against the GROUP BY terms
1.3312 - ** from the previous row currently stored in a0, a1, a2...
1.3313 - */
1.3314 - addrTopOfLoop = sqlite3VdbeCurrentAddr(v);
1.3315 - for(j=0; j<pGroupBy->nExpr; j++){
1.3316 - if( groupBySort ){
1.3317 - sqlite3VdbeAddOp(v, OP_Column, sAggInfo.sortingIdx, j);
1.3318 - }else{
1.3319 - sAggInfo.directMode = 1;
1.3320 - sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr);
1.3321 - }
1.3322 - sqlite3VdbeAddOp(v, OP_MemStore, iBMem+j, j<pGroupBy->nExpr-1);
1.3323 - }
1.3324 - for(j=pGroupBy->nExpr-1; j>=0; j--){
1.3325 - if( j<pGroupBy->nExpr-1 ){
1.3326 - sqlite3VdbeAddOp(v, OP_MemLoad, iBMem+j, 0);
1.3327 - }
1.3328 - sqlite3VdbeAddOp(v, OP_MemLoad, iAMem+j, 0);
1.3329 - if( j==0 ){
1.3330 - sqlite3VdbeAddOp(v, OP_Eq, 0x200, addrProcessRow);
1.3331 - }else{
1.3332 - sqlite3VdbeAddOp(v, OP_Ne, 0x200, addrGroupByChange);
1.3333 - }
1.3334 - sqlite3VdbeChangeP3(v, -1, (void*)pKeyInfo->aColl[j], P3_COLLSEQ);
1.3335 - }
1.3336 -
1.3337 - /* Generate code that runs whenever the GROUP BY changes.
1.3338 - ** Change in the GROUP BY are detected by the previous code
1.3339 - ** block. If there were no changes, this block is skipped.
1.3340 - **
1.3341 - ** This code copies current group by terms in b0,b1,b2,...
1.3342 - ** over to a0,a1,a2. It then calls the output subroutine
1.3343 - ** and resets the aggregate accumulator registers in preparation
1.3344 - ** for the next GROUP BY batch.
1.3345 - */
1.3346 - sqlite3VdbeResolveLabel(v, addrGroupByChange);
1.3347 - for(j=0; j<pGroupBy->nExpr; j++){
1.3348 - sqlite3VdbeAddOp(v, OP_MemMove, iAMem+j, iBMem+j);
1.3349 - }
1.3350 - sqlite3VdbeAddOp(v, OP_Gosub, 0, addrOutputRow);
1.3351 - VdbeComment((v, "# output one row"));
1.3352 - sqlite3VdbeAddOp(v, OP_IfMemPos, iAbortFlag, addrEnd);
1.3353 - VdbeComment((v, "# check abort flag"));
1.3354 - sqlite3VdbeAddOp(v, OP_Gosub, 0, addrReset);
1.3355 - VdbeComment((v, "# reset accumulator"));
1.3356 -
1.3357 - /* Update the aggregate accumulators based on the content of
1.3358 - ** the current row
1.3359 - */
1.3360 - sqlite3VdbeResolveLabel(v, addrProcessRow);
1.3361 - updateAccumulator(pParse, &sAggInfo);
1.3362 - sqlite3VdbeAddOp(v, OP_MemInt, 1, iUseFlag);
1.3363 - VdbeComment((v, "# indicate data in accumulator"));
1.3364 -
1.3365 - /* End of the loop
1.3366 - */
1.3367 - if( groupBySort ){
1.3368 - sqlite3VdbeAddOp(v, OP_Next, sAggInfo.sortingIdx, addrTopOfLoop);
1.3369 - }else{
1.3370 - sqlite3WhereEnd(pWInfo);
1.3371 - sqlite3VdbeChangeToNoop(v, addrSortingIdx, 1);
1.3372 - }
1.3373 -
1.3374 - /* Output the final row of result
1.3375 - */
1.3376 - sqlite3VdbeAddOp(v, OP_Gosub, 0, addrOutputRow);
1.3377 - VdbeComment((v, "# output final row"));
1.3378 -
1.3379 - } /* endif pGroupBy */
1.3380 - else {
1.3381 - /* This case runs if the aggregate has no GROUP BY clause. The
1.3382 - ** processing is much simpler since there is only a single row
1.3383 - ** of output.
1.3384 - */
1.3385 - resetAccumulator(pParse, &sAggInfo);
1.3386 - pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0);
1.3387 - if( pWInfo==0 ) goto select_end;
1.3388 - updateAccumulator(pParse, &sAggInfo);
1.3389 - sqlite3WhereEnd(pWInfo);
1.3390 - finalizeAggFunctions(pParse, &sAggInfo);
1.3391 - pOrderBy = 0;
1.3392 - if( pHaving ){
1.3393 - sqlite3ExprIfFalse(pParse, pHaving, addrEnd, 1);
1.3394 - }
1.3395 - selectInnerLoop(pParse, p, p->pEList, 0, 0, 0, -1,
1.3396 - eDest, iParm, addrEnd, addrEnd, aff);
1.3397 - }
1.3398 - sqlite3VdbeResolveLabel(v, addrEnd);
1.3399 -
1.3400 - } /* endif aggregate query */
1.3401 -
1.3402 - /* If there is an ORDER BY clause, then we need to sort the results
1.3403 - ** and send them to the callback one by one.
1.3404 - */
1.3405 - if( pOrderBy ){
1.3406 - generateSortTail(pParse, p, v, pEList->nExpr, eDest, iParm);
1.3407 - }
1.3408 -
1.3409 -#ifndef SQLITE_OMIT_SUBQUERY
1.3410 - /* If this was a subquery, we have now converted the subquery into a
1.3411 - ** temporary table. So set the SrcList_item.isPopulated flag to prevent
1.3412 - ** this subquery from being evaluated again and to force the use of
1.3413 - ** the temporary table.
1.3414 - */
1.3415 - if( pParent ){
1.3416 - assert( pParent->pSrc->nSrc>parentTab );
1.3417 - assert( pParent->pSrc->a[parentTab].pSelect==p );
1.3418 - pParent->pSrc->a[parentTab].isPopulated = 1;
1.3419 - }
1.3420 -#endif
1.3421 -
1.3422 - /* Jump here to skip this query
1.3423 - */
1.3424 - sqlite3VdbeResolveLabel(v, iEnd);
1.3425 -
1.3426 - /* The SELECT was successfully coded. Set the return code to 0
1.3427 - ** to indicate no errors.
1.3428 - */
1.3429 - rc = 0;
1.3430 -
1.3431 - /* Control jumps to here if an error is encountered above, or upon
1.3432 - ** successful coding of the SELECT.
1.3433 - */
1.3434 -select_end:
1.3435 -
1.3436 - /* Identify column names if we will be using them in a callback. This
1.3437 - ** step is skipped if the output is going to some other destination.
1.3438 - */
1.3439 - if( rc==SQLITE_OK && eDest==SRT_Callback ){
1.3440 - generateColumnNames(pParse, pTabList, pEList);
1.3441 - }
1.3442 -
1.3443 - sqlite3_free(sAggInfo.aCol);
1.3444 - sqlite3_free(sAggInfo.aFunc);
1.3445 - return rc;
1.3446 -}
1.3447 -
1.3448 -#if defined(SQLITE_DEBUG)
1.3449 -/*
1.3450 -*******************************************************************************
1.3451 -** The following code is used for testing and debugging only. The code
1.3452 -** that follows does not appear in normal builds.
1.3453 -**
1.3454 -** These routines are used to print out the content of all or part of a
1.3455 -** parse structures such as Select or Expr. Such printouts are useful
1.3456 -** for helping to understand what is happening inside the code generator
1.3457 -** during the execution of complex SELECT statements.
1.3458 -**
1.3459 -** These routine are not called anywhere from within the normal
1.3460 -** code base. Then are intended to be called from within the debugger
1.3461 -** or from temporary "printf" statements inserted for debugging.
1.3462 -*/
1.3463 -void sqlite3PrintExpr(Expr *p){
1.3464 - if( p->token.z && p->token.n>0 ){
1.3465 - sqlite3DebugPrintf("(%.*s", p->token.n, p->token.z);
1.3466 - }else{
1.3467 - sqlite3DebugPrintf("(%d", p->op);
1.3468 - }
1.3469 - if( p->pLeft ){
1.3470 - sqlite3DebugPrintf(" ");
1.3471 - sqlite3PrintExpr(p->pLeft);
1.3472 - }
1.3473 - if( p->pRight ){
1.3474 - sqlite3DebugPrintf(" ");
1.3475 - sqlite3PrintExpr(p->pRight);
1.3476 - }
1.3477 - sqlite3DebugPrintf(")");
1.3478 -}
1.3479 -void sqlite3PrintExprList(ExprList *pList){
1.3480 - int i;
1.3481 - for(i=0; i<pList->nExpr; i++){
1.3482 - sqlite3PrintExpr(pList->a[i].pExpr);
1.3483 - if( i<pList->nExpr-1 ){
1.3484 - sqlite3DebugPrintf(", ");
1.3485 - }
1.3486 - }
1.3487 -}
1.3488 -void sqlite3PrintSelect(Select *p, int indent){
1.3489 - sqlite3DebugPrintf("%*sSELECT(%p) ", indent, "", p);
1.3490 - sqlite3PrintExprList(p->pEList);
1.3491 - sqlite3DebugPrintf("\n");
1.3492 - if( p->pSrc ){
1.3493 - char *zPrefix;
1.3494 - int i;
1.3495 - zPrefix = "FROM";
1.3496 - for(i=0; i<p->pSrc->nSrc; i++){
1.3497 - struct SrcList_item *pItem = &p->pSrc->a[i];
1.3498 - sqlite3DebugPrintf("%*s ", indent+6, zPrefix);
1.3499 - zPrefix = "";
1.3500 - if( pItem->pSelect ){
1.3501 - sqlite3DebugPrintf("(\n");
1.3502 - sqlite3PrintSelect(pItem->pSelect, indent+10);
1.3503 - sqlite3DebugPrintf("%*s)", indent+8, "");
1.3504 - }else if( pItem->zName ){
1.3505 - sqlite3DebugPrintf("%s", pItem->zName);
1.3506 - }
1.3507 - if( pItem->pTab ){
1.3508 - sqlite3DebugPrintf("(table: %s)", pItem->pTab->zName);
1.3509 - }
1.3510 - if( pItem->zAlias ){
1.3511 - sqlite3DebugPrintf(" AS %s", pItem->zAlias);
1.3512 - }
1.3513 - if( i<p->pSrc->nSrc-1 ){
1.3514 - sqlite3DebugPrintf(",");
1.3515 - }
1.3516 - sqlite3DebugPrintf("\n");
1.3517 - }
1.3518 - }
1.3519 - if( p->pWhere ){
1.3520 - sqlite3DebugPrintf("%*s WHERE ", indent, "");
1.3521 - sqlite3PrintExpr(p->pWhere);
1.3522 - sqlite3DebugPrintf("\n");
1.3523 - }
1.3524 - if( p->pGroupBy ){
1.3525 - sqlite3DebugPrintf("%*s GROUP BY ", indent, "");
1.3526 - sqlite3PrintExprList(p->pGroupBy);
1.3527 - sqlite3DebugPrintf("\n");
1.3528 - }
1.3529 - if( p->pHaving ){
1.3530 - sqlite3DebugPrintf("%*s HAVING ", indent, "");
1.3531 - sqlite3PrintExpr(p->pHaving);
1.3532 - sqlite3DebugPrintf("\n");
1.3533 - }
1.3534 - if( p->pOrderBy ){
1.3535 - sqlite3DebugPrintf("%*s ORDER BY ", indent, "");
1.3536 - sqlite3PrintExprList(p->pOrderBy);
1.3537 - sqlite3DebugPrintf("\n");
1.3538 - }
1.3539 -}
1.3540 -/* End of the structure debug printing code
1.3541 -*****************************************************************************/
1.3542 -#endif /* defined(SQLITE_TEST) || defined(SQLITE_DEBUG) */
