drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 1 | /* |
drh | b19a2bc | 2001-09-16 00:13:26 +0000 | [diff] [blame] | 2 | ** 2001 September 15 |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 3 | ** |
drh | b19a2bc | 2001-09-16 00:13:26 +0000 | [diff] [blame] | 4 | ** The author disclaims copyright to this source code. In place of |
| 5 | ** a legal notice, here is a blessing: |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 6 | ** |
drh | b19a2bc | 2001-09-16 00:13:26 +0000 | [diff] [blame] | 7 | ** May you do good and not evil. |
| 8 | ** May you find forgiveness for yourself and forgive others. |
| 9 | ** May you share freely, never taking more than you give. |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 10 | ** |
| 11 | ************************************************************************* |
| 12 | ** This file contains C code routines that are called by the parser |
drh | b19a2bc | 2001-09-16 00:13:26 +0000 | [diff] [blame] | 13 | ** to handle SELECT statements in SQLite. |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 14 | ** |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 15 | ** $Id: select.c,v 1.436 2008/06/25 00:12:41 drh Exp $ |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 16 | */ |
| 17 | #include "sqliteInt.h" |
| 18 | |
drh | 315555c | 2002-10-20 15:53:03 +0000 | [diff] [blame] | 19 | |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 20 | /* |
drh | eda639e | 2006-01-22 00:42:09 +0000 | [diff] [blame] | 21 | ** Delete all the content of a Select structure but do not deallocate |
| 22 | ** the select structure itself. |
| 23 | */ |
danielk1977 | f011300 | 2006-01-24 12:09:17 +0000 | [diff] [blame] | 24 | static void clearSelect(Select *p){ |
drh | eda639e | 2006-01-22 00:42:09 +0000 | [diff] [blame] | 25 | sqlite3ExprListDelete(p->pEList); |
| 26 | sqlite3SrcListDelete(p->pSrc); |
| 27 | sqlite3ExprDelete(p->pWhere); |
| 28 | sqlite3ExprListDelete(p->pGroupBy); |
| 29 | sqlite3ExprDelete(p->pHaving); |
| 30 | sqlite3ExprListDelete(p->pOrderBy); |
| 31 | sqlite3SelectDelete(p->pPrior); |
| 32 | sqlite3ExprDelete(p->pLimit); |
| 33 | sqlite3ExprDelete(p->pOffset); |
| 34 | } |
| 35 | |
drh | 1013c93 | 2008-01-06 00:25:21 +0000 | [diff] [blame] | 36 | /* |
| 37 | ** Initialize a SelectDest structure. |
| 38 | */ |
| 39 | void sqlite3SelectDestInit(SelectDest *pDest, int eDest, int iParm){ |
| 40 | pDest->eDest = eDest; |
| 41 | pDest->iParm = iParm; |
| 42 | pDest->affinity = 0; |
| 43 | pDest->iMem = 0; |
drh | ad27e76 | 2008-03-26 12:46:23 +0000 | [diff] [blame] | 44 | pDest->nMem = 0; |
drh | 1013c93 | 2008-01-06 00:25:21 +0000 | [diff] [blame] | 45 | } |
| 46 | |
drh | eda639e | 2006-01-22 00:42:09 +0000 | [diff] [blame] | 47 | |
| 48 | /* |
drh | 9bb61fe | 2000-06-05 16:01:39 +0000 | [diff] [blame] | 49 | ** Allocate a new Select structure and return a pointer to that |
| 50 | ** structure. |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 51 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 52 | Select *sqlite3SelectNew( |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 53 | Parse *pParse, /* Parsing context */ |
drh | daffd0e | 2001-04-11 14:28:42 +0000 | [diff] [blame] | 54 | ExprList *pEList, /* which columns to include in the result */ |
drh | ad3cab5 | 2002-05-24 02:04:32 +0000 | [diff] [blame] | 55 | SrcList *pSrc, /* the FROM clause -- which tables to scan */ |
drh | daffd0e | 2001-04-11 14:28:42 +0000 | [diff] [blame] | 56 | Expr *pWhere, /* the WHERE clause */ |
| 57 | ExprList *pGroupBy, /* the GROUP BY clause */ |
| 58 | Expr *pHaving, /* the HAVING clause */ |
| 59 | ExprList *pOrderBy, /* the ORDER BY clause */ |
drh | 9bbca4c | 2001-11-06 04:00:18 +0000 | [diff] [blame] | 60 | int isDistinct, /* true if the DISTINCT keyword is present */ |
danielk1977 | a2dc3b1 | 2005-02-05 12:48:48 +0000 | [diff] [blame] | 61 | Expr *pLimit, /* LIMIT value. NULL means not used */ |
| 62 | Expr *pOffset /* OFFSET value. NULL means no offset */ |
drh | 9bb61fe | 2000-06-05 16:01:39 +0000 | [diff] [blame] | 63 | ){ |
| 64 | Select *pNew; |
drh | eda639e | 2006-01-22 00:42:09 +0000 | [diff] [blame] | 65 | Select standin; |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 66 | sqlite3 *db = pParse->db; |
| 67 | pNew = sqlite3DbMallocZero(db, sizeof(*pNew) ); |
danielk1977 | a2dc3b1 | 2005-02-05 12:48:48 +0000 | [diff] [blame] | 68 | assert( !pOffset || pLimit ); /* Can't have OFFSET without LIMIT. */ |
drh | daffd0e | 2001-04-11 14:28:42 +0000 | [diff] [blame] | 69 | if( pNew==0 ){ |
drh | eda639e | 2006-01-22 00:42:09 +0000 | [diff] [blame] | 70 | pNew = &standin; |
| 71 | memset(pNew, 0, sizeof(*pNew)); |
| 72 | } |
| 73 | if( pEList==0 ){ |
danielk1977 | a1644fd | 2007-08-29 12:31:25 +0000 | [diff] [blame] | 74 | pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db,TK_ALL,0,0,0), 0); |
drh | eda639e | 2006-01-22 00:42:09 +0000 | [diff] [blame] | 75 | } |
| 76 | pNew->pEList = pEList; |
| 77 | pNew->pSrc = pSrc; |
| 78 | pNew->pWhere = pWhere; |
| 79 | pNew->pGroupBy = pGroupBy; |
| 80 | pNew->pHaving = pHaving; |
| 81 | pNew->pOrderBy = pOrderBy; |
| 82 | pNew->isDistinct = isDistinct; |
| 83 | pNew->op = TK_SELECT; |
drh | 8103b7d | 2007-02-24 13:23:51 +0000 | [diff] [blame] | 84 | assert( pOffset==0 || pLimit!=0 ); |
drh | eda639e | 2006-01-22 00:42:09 +0000 | [diff] [blame] | 85 | pNew->pLimit = pLimit; |
| 86 | pNew->pOffset = pOffset; |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 87 | pNew->addrOpenEphm[0] = -1; |
| 88 | pNew->addrOpenEphm[1] = -1; |
| 89 | pNew->addrOpenEphm[2] = -1; |
drh | eda639e | 2006-01-22 00:42:09 +0000 | [diff] [blame] | 90 | if( pNew==&standin) { |
| 91 | clearSelect(pNew); |
| 92 | pNew = 0; |
drh | daffd0e | 2001-04-11 14:28:42 +0000 | [diff] [blame] | 93 | } |
drh | 9bb61fe | 2000-06-05 16:01:39 +0000 | [diff] [blame] | 94 | return pNew; |
| 95 | } |
| 96 | |
| 97 | /* |
drh | eda639e | 2006-01-22 00:42:09 +0000 | [diff] [blame] | 98 | ** Delete the given Select structure and all of its substructures. |
| 99 | */ |
| 100 | void sqlite3SelectDelete(Select *p){ |
| 101 | if( p ){ |
| 102 | clearSelect(p); |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 103 | sqlite3_free(p); |
drh | eda639e | 2006-01-22 00:42:09 +0000 | [diff] [blame] | 104 | } |
| 105 | } |
| 106 | |
| 107 | /* |
drh | 01f3f25 | 2002-05-24 16:14:15 +0000 | [diff] [blame] | 108 | ** Given 1 to 3 identifiers preceeding the JOIN keyword, determine the |
| 109 | ** type of join. Return an integer constant that expresses that type |
| 110 | ** in terms of the following bit values: |
| 111 | ** |
| 112 | ** JT_INNER |
drh | 3dec223 | 2005-09-10 15:28:09 +0000 | [diff] [blame] | 113 | ** JT_CROSS |
drh | 01f3f25 | 2002-05-24 16:14:15 +0000 | [diff] [blame] | 114 | ** JT_OUTER |
| 115 | ** JT_NATURAL |
| 116 | ** JT_LEFT |
| 117 | ** JT_RIGHT |
| 118 | ** |
| 119 | ** A full outer join is the combination of JT_LEFT and JT_RIGHT. |
| 120 | ** |
| 121 | ** If an illegal or unsupported join type is seen, then still return |
| 122 | ** a join type, but put an error in the pParse structure. |
| 123 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 124 | int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){ |
drh | 01f3f25 | 2002-05-24 16:14:15 +0000 | [diff] [blame] | 125 | int jointype = 0; |
| 126 | Token *apAll[3]; |
| 127 | Token *p; |
drh | 5719628 | 2004-10-06 15:41:16 +0000 | [diff] [blame] | 128 | static const struct { |
drh | c182d16 | 2005-08-14 20:47:16 +0000 | [diff] [blame] | 129 | const char zKeyword[8]; |
drh | 290c194 | 2004-08-21 17:54:45 +0000 | [diff] [blame] | 130 | u8 nChar; |
| 131 | u8 code; |
drh | 01f3f25 | 2002-05-24 16:14:15 +0000 | [diff] [blame] | 132 | } keywords[] = { |
| 133 | { "natural", 7, JT_NATURAL }, |
drh | 195e696 | 2002-05-25 00:18:20 +0000 | [diff] [blame] | 134 | { "left", 4, JT_LEFT|JT_OUTER }, |
| 135 | { "right", 5, JT_RIGHT|JT_OUTER }, |
| 136 | { "full", 4, JT_LEFT|JT_RIGHT|JT_OUTER }, |
drh | 01f3f25 | 2002-05-24 16:14:15 +0000 | [diff] [blame] | 137 | { "outer", 5, JT_OUTER }, |
| 138 | { "inner", 5, JT_INNER }, |
drh | 3dec223 | 2005-09-10 15:28:09 +0000 | [diff] [blame] | 139 | { "cross", 5, JT_INNER|JT_CROSS }, |
drh | 01f3f25 | 2002-05-24 16:14:15 +0000 | [diff] [blame] | 140 | }; |
| 141 | int i, j; |
| 142 | apAll[0] = pA; |
| 143 | apAll[1] = pB; |
| 144 | apAll[2] = pC; |
drh | 195e696 | 2002-05-25 00:18:20 +0000 | [diff] [blame] | 145 | for(i=0; i<3 && apAll[i]; i++){ |
drh | 01f3f25 | 2002-05-24 16:14:15 +0000 | [diff] [blame] | 146 | p = apAll[i]; |
| 147 | for(j=0; j<sizeof(keywords)/sizeof(keywords[0]); j++){ |
| 148 | if( p->n==keywords[j].nChar |
drh | 2646da7 | 2005-12-09 20:02:05 +0000 | [diff] [blame] | 149 | && sqlite3StrNICmp((char*)p->z, keywords[j].zKeyword, p->n)==0 ){ |
drh | 01f3f25 | 2002-05-24 16:14:15 +0000 | [diff] [blame] | 150 | jointype |= keywords[j].code; |
| 151 | break; |
| 152 | } |
| 153 | } |
| 154 | if( j>=sizeof(keywords)/sizeof(keywords[0]) ){ |
| 155 | jointype |= JT_ERROR; |
| 156 | break; |
| 157 | } |
| 158 | } |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 159 | if( |
| 160 | (jointype & (JT_INNER|JT_OUTER))==(JT_INNER|JT_OUTER) || |
drh | 195e696 | 2002-05-25 00:18:20 +0000 | [diff] [blame] | 161 | (jointype & JT_ERROR)!=0 |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 162 | ){ |
drh | ae29ffb | 2004-09-25 14:39:18 +0000 | [diff] [blame] | 163 | const char *zSp1 = " "; |
| 164 | const char *zSp2 = " "; |
| 165 | if( pB==0 ){ zSp1++; } |
| 166 | if( pC==0 ){ zSp2++; } |
| 167 | sqlite3ErrorMsg(pParse, "unknown or unsupported join type: " |
| 168 | "%T%s%T%s%T", pA, zSp1, pB, zSp2, pC); |
drh | 01f3f25 | 2002-05-24 16:14:15 +0000 | [diff] [blame] | 169 | jointype = JT_INNER; |
drh | 195e696 | 2002-05-25 00:18:20 +0000 | [diff] [blame] | 170 | }else if( jointype & JT_RIGHT ){ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 171 | sqlite3ErrorMsg(pParse, |
drh | da93d23 | 2003-03-31 02:12:46 +0000 | [diff] [blame] | 172 | "RIGHT and FULL OUTER JOINs are not currently supported"); |
drh | 195e696 | 2002-05-25 00:18:20 +0000 | [diff] [blame] | 173 | jointype = JT_INNER; |
drh | 01f3f25 | 2002-05-24 16:14:15 +0000 | [diff] [blame] | 174 | } |
| 175 | return jointype; |
| 176 | } |
| 177 | |
| 178 | /* |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 179 | ** Return the index of a column in a table. Return -1 if the column |
| 180 | ** is not contained in the table. |
| 181 | */ |
| 182 | static int columnIndex(Table *pTab, const char *zCol){ |
| 183 | int i; |
| 184 | for(i=0; i<pTab->nCol; i++){ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 185 | if( sqlite3StrICmp(pTab->aCol[i].zName, zCol)==0 ) return i; |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 186 | } |
| 187 | return -1; |
| 188 | } |
| 189 | |
| 190 | /* |
drh | 91bb0ee | 2004-09-01 03:06:34 +0000 | [diff] [blame] | 191 | ** Set the value of a token to a '\000'-terminated string. |
| 192 | */ |
| 193 | static void setToken(Token *p, const char *z){ |
drh | 2646da7 | 2005-12-09 20:02:05 +0000 | [diff] [blame] | 194 | p->z = (u8*)z; |
danielk1977 | 261919c | 2005-12-06 12:52:59 +0000 | [diff] [blame] | 195 | p->n = z ? strlen(z) : 0; |
drh | 91bb0ee | 2004-09-01 03:06:34 +0000 | [diff] [blame] | 196 | p->dyn = 0; |
| 197 | } |
| 198 | |
drh | c182d16 | 2005-08-14 20:47:16 +0000 | [diff] [blame] | 199 | /* |
danielk1977 | f3b863e | 2007-06-24 06:32:17 +0000 | [diff] [blame] | 200 | ** Set the token to the double-quoted and escaped version of the string pointed |
| 201 | ** to by z. For example; |
| 202 | ** |
| 203 | ** {a"bc} -> {"a""bc"} |
| 204 | */ |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 205 | static void setQuotedToken(Parse *pParse, Token *p, const char *z){ |
danielk1977 | a686bfc | 2008-03-31 17:41:18 +0000 | [diff] [blame] | 206 | |
| 207 | /* Check if the string contains any " characters. If it does, then |
| 208 | ** this function will malloc space to create a quoted version of |
| 209 | ** the string in. Otherwise, save a call to sqlite3MPrintf() by |
| 210 | ** just copying the pointer to the string. |
| 211 | */ |
| 212 | const char *z2 = z; |
| 213 | while( *z2 ){ |
| 214 | if( *z2=='"' ) break; |
| 215 | z2++; |
| 216 | } |
| 217 | |
| 218 | if( *z2 ){ |
| 219 | /* String contains " characters - copy and quote the string. */ |
| 220 | p->z = (u8 *)sqlite3MPrintf(pParse->db, "\"%w\"", z); |
| 221 | if( p->z ){ |
| 222 | p->n = strlen((char *)p->z); |
| 223 | p->dyn = 1; |
| 224 | } |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 225 | }else{ |
danielk1977 | a686bfc | 2008-03-31 17:41:18 +0000 | [diff] [blame] | 226 | /* String contains no " characters - copy the pointer. */ |
| 227 | p->z = (u8*)z; |
| 228 | p->n = (z2 - z); |
| 229 | p->dyn = 0; |
danielk1977 | f3b863e | 2007-06-24 06:32:17 +0000 | [diff] [blame] | 230 | } |
| 231 | } |
| 232 | |
| 233 | /* |
drh | c182d16 | 2005-08-14 20:47:16 +0000 | [diff] [blame] | 234 | ** Create an expression node for an identifier with the name of zName |
| 235 | */ |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 236 | Expr *sqlite3CreateIdExpr(Parse *pParse, const char *zName){ |
drh | c182d16 | 2005-08-14 20:47:16 +0000 | [diff] [blame] | 237 | Token dummy; |
| 238 | setToken(&dummy, zName); |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 239 | return sqlite3PExpr(pParse, TK_ID, 0, 0, &dummy); |
drh | c182d16 | 2005-08-14 20:47:16 +0000 | [diff] [blame] | 240 | } |
| 241 | |
drh | 91bb0ee | 2004-09-01 03:06:34 +0000 | [diff] [blame] | 242 | /* |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 243 | ** Add a term to the WHERE expression in *ppExpr that requires the |
| 244 | ** zCol column to be equal in the two tables pTab1 and pTab2. |
| 245 | */ |
| 246 | static void addWhereTerm( |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 247 | Parse *pParse, /* Parsing context */ |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 248 | const char *zCol, /* Name of the column */ |
| 249 | const Table *pTab1, /* First table */ |
drh | 030530d | 2005-01-18 17:40:04 +0000 | [diff] [blame] | 250 | const char *zAlias1, /* Alias for first table. May be NULL */ |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 251 | const Table *pTab2, /* Second table */ |
drh | 030530d | 2005-01-18 17:40:04 +0000 | [diff] [blame] | 252 | const char *zAlias2, /* Alias for second table. May be NULL */ |
drh | 22d6a53 | 2005-09-19 21:05:48 +0000 | [diff] [blame] | 253 | int iRightJoinTable, /* VDBE cursor for the right table */ |
drh | ad27e76 | 2008-03-26 12:46:23 +0000 | [diff] [blame] | 254 | Expr **ppExpr, /* Add the equality term to this expression */ |
| 255 | int isOuterJoin /* True if dealing with an OUTER join */ |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 256 | ){ |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 257 | Expr *pE1a, *pE1b, *pE1c; |
| 258 | Expr *pE2a, *pE2b, *pE2c; |
| 259 | Expr *pE; |
| 260 | |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 261 | pE1a = sqlite3CreateIdExpr(pParse, zCol); |
| 262 | pE2a = sqlite3CreateIdExpr(pParse, zCol); |
drh | 030530d | 2005-01-18 17:40:04 +0000 | [diff] [blame] | 263 | if( zAlias1==0 ){ |
| 264 | zAlias1 = pTab1->zName; |
| 265 | } |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 266 | pE1b = sqlite3CreateIdExpr(pParse, zAlias1); |
drh | 030530d | 2005-01-18 17:40:04 +0000 | [diff] [blame] | 267 | if( zAlias2==0 ){ |
| 268 | zAlias2 = pTab2->zName; |
| 269 | } |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 270 | pE2b = sqlite3CreateIdExpr(pParse, zAlias2); |
| 271 | pE1c = sqlite3PExpr(pParse, TK_DOT, pE1b, pE1a, 0); |
| 272 | pE2c = sqlite3PExpr(pParse, TK_DOT, pE2b, pE2a, 0); |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 273 | pE = sqlite3PExpr(pParse, TK_EQ, pE1c, pE2c, 0); |
drh | ad27e76 | 2008-03-26 12:46:23 +0000 | [diff] [blame] | 274 | if( pE && isOuterJoin ){ |
drh | 206f3d9 | 2006-07-11 13:15:08 +0000 | [diff] [blame] | 275 | ExprSetProperty(pE, EP_FromJoin); |
| 276 | pE->iRightJoinTable = iRightJoinTable; |
| 277 | } |
drh | f4ce8ed | 2007-11-23 13:42:51 +0000 | [diff] [blame] | 278 | *ppExpr = sqlite3ExprAnd(pParse->db,*ppExpr, pE); |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 279 | } |
| 280 | |
| 281 | /* |
drh | 1f16230 | 2002-10-27 19:35:33 +0000 | [diff] [blame] | 282 | ** Set the EP_FromJoin property on all terms of the given expression. |
drh | 22d6a53 | 2005-09-19 21:05:48 +0000 | [diff] [blame] | 283 | ** And set the Expr.iRightJoinTable to iTable for every term in the |
| 284 | ** expression. |
drh | 1cc093c | 2002-06-24 22:01:57 +0000 | [diff] [blame] | 285 | ** |
drh | e78e828 | 2003-01-19 03:59:45 +0000 | [diff] [blame] | 286 | ** The EP_FromJoin property is used on terms of an expression to tell |
drh | 1cc093c | 2002-06-24 22:01:57 +0000 | [diff] [blame] | 287 | ** the LEFT OUTER JOIN processing logic that this term is part of the |
drh | 1f16230 | 2002-10-27 19:35:33 +0000 | [diff] [blame] | 288 | ** join restriction specified in the ON or USING clause and not a part |
| 289 | ** of the more general WHERE clause. These terms are moved over to the |
| 290 | ** WHERE clause during join processing but we need to remember that they |
| 291 | ** originated in the ON or USING clause. |
drh | 22d6a53 | 2005-09-19 21:05:48 +0000 | [diff] [blame] | 292 | ** |
| 293 | ** The Expr.iRightJoinTable tells the WHERE clause processing that the |
| 294 | ** expression depends on table iRightJoinTable even if that table is not |
| 295 | ** explicitly mentioned in the expression. That information is needed |
| 296 | ** for cases like this: |
| 297 | ** |
| 298 | ** SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.b AND t1.x=5 |
| 299 | ** |
| 300 | ** The where clause needs to defer the handling of the t1.x=5 |
| 301 | ** term until after the t2 loop of the join. In that way, a |
| 302 | ** NULL t2 row will be inserted whenever t1.x!=5. If we do not |
| 303 | ** defer the handling of t1.x=5, it will be processed immediately |
| 304 | ** after the t1 loop and rows with t1.x!=5 will never appear in |
| 305 | ** the output, which is incorrect. |
drh | 1cc093c | 2002-06-24 22:01:57 +0000 | [diff] [blame] | 306 | */ |
drh | 22d6a53 | 2005-09-19 21:05:48 +0000 | [diff] [blame] | 307 | static void setJoinExpr(Expr *p, int iTable){ |
drh | 1cc093c | 2002-06-24 22:01:57 +0000 | [diff] [blame] | 308 | while( p ){ |
drh | 1f16230 | 2002-10-27 19:35:33 +0000 | [diff] [blame] | 309 | ExprSetProperty(p, EP_FromJoin); |
drh | 22d6a53 | 2005-09-19 21:05:48 +0000 | [diff] [blame] | 310 | p->iRightJoinTable = iTable; |
| 311 | setJoinExpr(p->pLeft, iTable); |
drh | 1cc093c | 2002-06-24 22:01:57 +0000 | [diff] [blame] | 312 | p = p->pRight; |
| 313 | } |
| 314 | } |
| 315 | |
| 316 | /* |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 317 | ** This routine processes the join information for a SELECT statement. |
| 318 | ** ON and USING clauses are converted into extra terms of the WHERE clause. |
| 319 | ** NATURAL joins also create extra WHERE clause terms. |
| 320 | ** |
drh | 91bb0ee | 2004-09-01 03:06:34 +0000 | [diff] [blame] | 321 | ** The terms of a FROM clause are contained in the Select.pSrc structure. |
| 322 | ** The left most table is the first entry in Select.pSrc. The right-most |
| 323 | ** table is the last entry. The join operator is held in the entry to |
| 324 | ** the left. Thus entry 0 contains the join operator for the join between |
| 325 | ** entries 0 and 1. Any ON or USING clauses associated with the join are |
| 326 | ** also attached to the left entry. |
| 327 | ** |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 328 | ** This routine returns the number of errors encountered. |
| 329 | */ |
| 330 | static int sqliteProcessJoin(Parse *pParse, Select *p){ |
drh | 91bb0ee | 2004-09-01 03:06:34 +0000 | [diff] [blame] | 331 | SrcList *pSrc; /* All tables in the FROM clause */ |
| 332 | int i, j; /* Loop counters */ |
| 333 | struct SrcList_item *pLeft; /* Left table being joined */ |
| 334 | struct SrcList_item *pRight; /* Right table being joined */ |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 335 | |
drh | 91bb0ee | 2004-09-01 03:06:34 +0000 | [diff] [blame] | 336 | pSrc = p->pSrc; |
| 337 | pLeft = &pSrc->a[0]; |
| 338 | pRight = &pLeft[1]; |
| 339 | for(i=0; i<pSrc->nSrc-1; i++, pRight++, pLeft++){ |
| 340 | Table *pLeftTab = pLeft->pTab; |
| 341 | Table *pRightTab = pRight->pTab; |
drh | ad27e76 | 2008-03-26 12:46:23 +0000 | [diff] [blame] | 342 | int isOuter; |
drh | 91bb0ee | 2004-09-01 03:06:34 +0000 | [diff] [blame] | 343 | |
| 344 | if( pLeftTab==0 || pRightTab==0 ) continue; |
drh | ad27e76 | 2008-03-26 12:46:23 +0000 | [diff] [blame] | 345 | isOuter = (pRight->jointype & JT_OUTER)!=0; |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 346 | |
| 347 | /* When the NATURAL keyword is present, add WHERE clause terms for |
| 348 | ** every column that the two tables have in common. |
| 349 | */ |
drh | 61dfc31 | 2006-12-16 16:25:15 +0000 | [diff] [blame] | 350 | if( pRight->jointype & JT_NATURAL ){ |
| 351 | if( pRight->pOn || pRight->pUsing ){ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 352 | sqlite3ErrorMsg(pParse, "a NATURAL join may not have " |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 353 | "an ON or USING clause", 0); |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 354 | return 1; |
| 355 | } |
drh | 91bb0ee | 2004-09-01 03:06:34 +0000 | [diff] [blame] | 356 | for(j=0; j<pLeftTab->nCol; j++){ |
| 357 | char *zName = pLeftTab->aCol[j].zName; |
| 358 | if( columnIndex(pRightTab, zName)>=0 ){ |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 359 | addWhereTerm(pParse, zName, pLeftTab, pLeft->zAlias, |
drh | 22d6a53 | 2005-09-19 21:05:48 +0000 | [diff] [blame] | 360 | pRightTab, pRight->zAlias, |
drh | ad27e76 | 2008-03-26 12:46:23 +0000 | [diff] [blame] | 361 | pRight->iCursor, &p->pWhere, isOuter); |
drh | 22d6a53 | 2005-09-19 21:05:48 +0000 | [diff] [blame] | 362 | |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 363 | } |
| 364 | } |
| 365 | } |
| 366 | |
| 367 | /* Disallow both ON and USING clauses in the same join |
| 368 | */ |
drh | 61dfc31 | 2006-12-16 16:25:15 +0000 | [diff] [blame] | 369 | if( pRight->pOn && pRight->pUsing ){ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 370 | sqlite3ErrorMsg(pParse, "cannot have both ON and USING " |
drh | da93d23 | 2003-03-31 02:12:46 +0000 | [diff] [blame] | 371 | "clauses in the same join"); |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 372 | return 1; |
| 373 | } |
| 374 | |
| 375 | /* Add the ON clause to the end of the WHERE clause, connected by |
drh | 91bb0ee | 2004-09-01 03:06:34 +0000 | [diff] [blame] | 376 | ** an AND operator. |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 377 | */ |
drh | 61dfc31 | 2006-12-16 16:25:15 +0000 | [diff] [blame] | 378 | if( pRight->pOn ){ |
drh | ad27e76 | 2008-03-26 12:46:23 +0000 | [diff] [blame] | 379 | if( isOuter ) setJoinExpr(pRight->pOn, pRight->iCursor); |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 380 | p->pWhere = sqlite3ExprAnd(pParse->db, p->pWhere, pRight->pOn); |
drh | 61dfc31 | 2006-12-16 16:25:15 +0000 | [diff] [blame] | 381 | pRight->pOn = 0; |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 382 | } |
| 383 | |
| 384 | /* Create extra terms on the WHERE clause for each column named |
| 385 | ** in the USING clause. Example: If the two tables to be joined are |
| 386 | ** A and B and the USING clause names X, Y, and Z, then add this |
| 387 | ** to the WHERE clause: A.X=B.X AND A.Y=B.Y AND A.Z=B.Z |
| 388 | ** Report an error if any column mentioned in the USING clause is |
| 389 | ** not contained in both tables to be joined. |
| 390 | */ |
drh | 61dfc31 | 2006-12-16 16:25:15 +0000 | [diff] [blame] | 391 | if( pRight->pUsing ){ |
| 392 | IdList *pList = pRight->pUsing; |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 393 | for(j=0; j<pList->nId; j++){ |
drh | 91bb0ee | 2004-09-01 03:06:34 +0000 | [diff] [blame] | 394 | char *zName = pList->a[j].zName; |
| 395 | if( columnIndex(pLeftTab, zName)<0 || columnIndex(pRightTab, zName)<0 ){ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 396 | sqlite3ErrorMsg(pParse, "cannot join using column %s - column " |
drh | 91bb0ee | 2004-09-01 03:06:34 +0000 | [diff] [blame] | 397 | "not present in both tables", zName); |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 398 | return 1; |
| 399 | } |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 400 | addWhereTerm(pParse, zName, pLeftTab, pLeft->zAlias, |
drh | 22d6a53 | 2005-09-19 21:05:48 +0000 | [diff] [blame] | 401 | pRightTab, pRight->zAlias, |
drh | ad27e76 | 2008-03-26 12:46:23 +0000 | [diff] [blame] | 402 | pRight->iCursor, &p->pWhere, isOuter); |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 403 | } |
| 404 | } |
| 405 | } |
| 406 | return 0; |
| 407 | } |
| 408 | |
| 409 | /* |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 410 | ** Insert code into "v" that will push the record on the top of the |
| 411 | ** stack into the sorter. |
| 412 | */ |
drh | d59ba6c | 2006-01-08 05:02:54 +0000 | [diff] [blame] | 413 | static void pushOntoSorter( |
| 414 | Parse *pParse, /* Parser context */ |
| 415 | ExprList *pOrderBy, /* The ORDER BY clause */ |
drh | b765411 | 2008-01-12 12:48:07 +0000 | [diff] [blame] | 416 | Select *pSelect, /* The whole SELECT statement */ |
| 417 | int regData /* Register holding data to be sorted */ |
drh | d59ba6c | 2006-01-08 05:02:54 +0000 | [diff] [blame] | 418 | ){ |
| 419 | Vdbe *v = pParse->pVdbe; |
drh | 892d317 | 2008-01-10 03:46:36 +0000 | [diff] [blame] | 420 | int nExpr = pOrderBy->nExpr; |
| 421 | int regBase = sqlite3GetTempRange(pParse, nExpr+2); |
| 422 | int regRecord = sqlite3GetTempReg(pParse); |
drh | 191b54c | 2008-04-15 12:14:21 +0000 | [diff] [blame] | 423 | sqlite3ExprCodeExprList(pParse, pOrderBy, regBase, 0); |
drh | 892d317 | 2008-01-10 03:46:36 +0000 | [diff] [blame] | 424 | sqlite3VdbeAddOp2(v, OP_Sequence, pOrderBy->iECursor, regBase+nExpr); |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 425 | sqlite3ExprCodeMove(pParse, regData, regBase+nExpr+1, 1); |
drh | 1db639c | 2008-01-17 02:36:28 +0000 | [diff] [blame] | 426 | sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nExpr + 2, regRecord); |
drh | 892d317 | 2008-01-10 03:46:36 +0000 | [diff] [blame] | 427 | sqlite3VdbeAddOp2(v, OP_IdxInsert, pOrderBy->iECursor, regRecord); |
| 428 | sqlite3ReleaseTempReg(pParse, regRecord); |
| 429 | sqlite3ReleaseTempRange(pParse, regBase, nExpr+2); |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 430 | if( pSelect->iLimit ){ |
drh | 15007a9 | 2006-01-08 18:10:17 +0000 | [diff] [blame] | 431 | int addr1, addr2; |
drh | b765411 | 2008-01-12 12:48:07 +0000 | [diff] [blame] | 432 | int iLimit; |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 433 | if( pSelect->iOffset ){ |
drh | b765411 | 2008-01-12 12:48:07 +0000 | [diff] [blame] | 434 | iLimit = pSelect->iOffset+1; |
| 435 | }else{ |
| 436 | iLimit = pSelect->iLimit; |
| 437 | } |
| 438 | addr1 = sqlite3VdbeAddOp1(v, OP_IfZero, iLimit); |
| 439 | sqlite3VdbeAddOp2(v, OP_AddImm, iLimit, -1); |
drh | 3c84ddf | 2008-01-09 02:15:38 +0000 | [diff] [blame] | 440 | addr2 = sqlite3VdbeAddOp0(v, OP_Goto); |
drh | d59ba6c | 2006-01-08 05:02:54 +0000 | [diff] [blame] | 441 | sqlite3VdbeJumpHere(v, addr1); |
drh | 3c84ddf | 2008-01-09 02:15:38 +0000 | [diff] [blame] | 442 | sqlite3VdbeAddOp1(v, OP_Last, pOrderBy->iECursor); |
| 443 | sqlite3VdbeAddOp1(v, OP_Delete, pOrderBy->iECursor); |
drh | 15007a9 | 2006-01-08 18:10:17 +0000 | [diff] [blame] | 444 | sqlite3VdbeJumpHere(v, addr2); |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 445 | pSelect->iLimit = 0; |
drh | d59ba6c | 2006-01-08 05:02:54 +0000 | [diff] [blame] | 446 | } |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 447 | } |
| 448 | |
| 449 | /* |
drh | ec7429a | 2005-10-06 16:53:14 +0000 | [diff] [blame] | 450 | ** Add code to implement the OFFSET |
drh | ea48eb2 | 2004-07-19 23:16:38 +0000 | [diff] [blame] | 451 | */ |
drh | ec7429a | 2005-10-06 16:53:14 +0000 | [diff] [blame] | 452 | static void codeOffset( |
drh | bab39e1 | 2004-07-19 23:38:11 +0000 | [diff] [blame] | 453 | Vdbe *v, /* Generate code into this VM */ |
drh | ea48eb2 | 2004-07-19 23:16:38 +0000 | [diff] [blame] | 454 | Select *p, /* The SELECT statement being coded */ |
drh | b765411 | 2008-01-12 12:48:07 +0000 | [diff] [blame] | 455 | int iContinue /* Jump here to skip the current record */ |
drh | ea48eb2 | 2004-07-19 23:16:38 +0000 | [diff] [blame] | 456 | ){ |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 457 | if( p->iOffset && iContinue!=0 ){ |
drh | 15007a9 | 2006-01-08 18:10:17 +0000 | [diff] [blame] | 458 | int addr; |
drh | 8558cde | 2008-01-05 05:20:10 +0000 | [diff] [blame] | 459 | sqlite3VdbeAddOp2(v, OP_AddImm, p->iOffset, -1); |
drh | 3c84ddf | 2008-01-09 02:15:38 +0000 | [diff] [blame] | 460 | addr = sqlite3VdbeAddOp1(v, OP_IfNeg, p->iOffset); |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 461 | sqlite3VdbeAddOp2(v, OP_Goto, 0, iContinue); |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 462 | VdbeComment((v, "skip OFFSET records")); |
drh | 15007a9 | 2006-01-08 18:10:17 +0000 | [diff] [blame] | 463 | sqlite3VdbeJumpHere(v, addr); |
drh | ea48eb2 | 2004-07-19 23:16:38 +0000 | [diff] [blame] | 464 | } |
drh | ea48eb2 | 2004-07-19 23:16:38 +0000 | [diff] [blame] | 465 | } |
| 466 | |
| 467 | /* |
drh | 9875715 | 2008-01-09 23:04:12 +0000 | [diff] [blame] | 468 | ** Add code that will check to make sure the N registers starting at iMem |
| 469 | ** form a distinct entry. iTab is a sorting index that holds previously |
drh | a2a49dc | 2008-01-02 14:28:13 +0000 | [diff] [blame] | 470 | ** seen combinations of the N values. A new entry is made in iTab |
| 471 | ** if the current N values are new. |
| 472 | ** |
| 473 | ** A jump to addrRepeat is made and the N+1 values are popped from the |
| 474 | ** stack if the top N elements are not distinct. |
| 475 | */ |
| 476 | static void codeDistinct( |
drh | 2dcef11 | 2008-01-12 19:03:48 +0000 | [diff] [blame] | 477 | Parse *pParse, /* Parsing and code generating context */ |
drh | a2a49dc | 2008-01-02 14:28:13 +0000 | [diff] [blame] | 478 | int iTab, /* A sorting index used to test for distinctness */ |
| 479 | int addrRepeat, /* Jump to here if not distinct */ |
drh | 477df4b | 2008-01-05 18:48:24 +0000 | [diff] [blame] | 480 | int N, /* Number of elements */ |
drh | a2a49dc | 2008-01-02 14:28:13 +0000 | [diff] [blame] | 481 | int iMem /* First element */ |
| 482 | ){ |
drh | 2dcef11 | 2008-01-12 19:03:48 +0000 | [diff] [blame] | 483 | Vdbe *v; |
| 484 | int r1; |
| 485 | |
| 486 | v = pParse->pVdbe; |
| 487 | r1 = sqlite3GetTempReg(pParse); |
drh | 1db639c | 2008-01-17 02:36:28 +0000 | [diff] [blame] | 488 | sqlite3VdbeAddOp3(v, OP_MakeRecord, iMem, N, r1); |
drh | 2dcef11 | 2008-01-12 19:03:48 +0000 | [diff] [blame] | 489 | sqlite3VdbeAddOp3(v, OP_Found, iTab, addrRepeat, r1); |
| 490 | sqlite3VdbeAddOp2(v, OP_IdxInsert, iTab, r1); |
| 491 | sqlite3ReleaseTempReg(pParse, r1); |
drh | a2a49dc | 2008-01-02 14:28:13 +0000 | [diff] [blame] | 492 | } |
| 493 | |
| 494 | /* |
drh | e305f43 | 2007-05-09 22:56:39 +0000 | [diff] [blame] | 495 | ** Generate an error message when a SELECT is used within a subexpression |
| 496 | ** (example: "a IN (SELECT * FROM table)") but it has more than 1 result |
| 497 | ** column. We do this in a subroutine because the error occurs in multiple |
| 498 | ** places. |
| 499 | */ |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 500 | static int checkForMultiColumnSelectError( |
| 501 | Parse *pParse, /* Parse context. */ |
| 502 | SelectDest *pDest, /* Destination of SELECT results */ |
| 503 | int nExpr /* Number of result columns returned by SELECT */ |
| 504 | ){ |
| 505 | int eDest = pDest->eDest; |
drh | e305f43 | 2007-05-09 22:56:39 +0000 | [diff] [blame] | 506 | if( nExpr>1 && (eDest==SRT_Mem || eDest==SRT_Set) ){ |
| 507 | sqlite3ErrorMsg(pParse, "only a single result allowed for " |
| 508 | "a SELECT that is part of an expression"); |
| 509 | return 1; |
| 510 | }else{ |
| 511 | return 0; |
| 512 | } |
| 513 | } |
drh | c99130f | 2005-09-11 11:56:27 +0000 | [diff] [blame] | 514 | |
| 515 | /* |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 516 | ** This routine generates the code for the inside of the inner loop |
| 517 | ** of a SELECT. |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 518 | ** |
drh | 38640e1 | 2002-07-05 21:42:36 +0000 | [diff] [blame] | 519 | ** If srcTab and nColumn are both zero, then the pEList expressions |
| 520 | ** are evaluated in order to get the data for this row. If nColumn>0 |
| 521 | ** then data is pulled from srcTab and pEList is used only to get the |
| 522 | ** datatypes for each column. |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 523 | */ |
drh | d2b3e23 | 2008-01-23 14:51:49 +0000 | [diff] [blame] | 524 | static void selectInnerLoop( |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 525 | Parse *pParse, /* The parser context */ |
drh | df199a2 | 2002-06-14 22:38:41 +0000 | [diff] [blame] | 526 | Select *p, /* The complete select statement being coded */ |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 527 | ExprList *pEList, /* List of values being extracted */ |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 528 | int srcTab, /* Pull data from this table */ |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 529 | int nColumn, /* Number of columns in the source table */ |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 530 | ExprList *pOrderBy, /* If not NULL, sort results using this key */ |
| 531 | int distinct, /* If >=0, make sure results are distinct */ |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 532 | SelectDest *pDest, /* How to dispose of the results */ |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 533 | int iContinue, /* Jump here to continue with next row */ |
danielk1977 | 84ac9d0 | 2004-05-18 09:58:06 +0000 | [diff] [blame] | 534 | int iBreak, /* Jump here to break out of the inner loop */ |
| 535 | char *aff /* affinity string if eDest is SRT_Union */ |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 536 | ){ |
| 537 | Vdbe *v = pParse->pVdbe; |
drh | d847eaa | 2008-01-17 17:15:56 +0000 | [diff] [blame] | 538 | int i; |
drh | ea48eb2 | 2004-07-19 23:16:38 +0000 | [diff] [blame] | 539 | int hasDistinct; /* True if the DISTINCT keyword is present */ |
drh | d847eaa | 2008-01-17 17:15:56 +0000 | [diff] [blame] | 540 | int regResult; /* Start of memory holding result set */ |
| 541 | int eDest = pDest->eDest; /* How to dispose of results */ |
| 542 | int iParm = pDest->iParm; /* First argument to disposal method */ |
| 543 | int nResultCol; /* Number of result columns */ |
drh | 38640e1 | 2002-07-05 21:42:36 +0000 | [diff] [blame] | 544 | |
drh | d2b3e23 | 2008-01-23 14:51:49 +0000 | [diff] [blame] | 545 | if( v==0 ) return; |
drh | 38640e1 | 2002-07-05 21:42:36 +0000 | [diff] [blame] | 546 | assert( pEList!=0 ); |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 547 | |
drh | df199a2 | 2002-06-14 22:38:41 +0000 | [diff] [blame] | 548 | /* If there was a LIMIT clause on the SELECT statement, then do the check |
| 549 | ** to see if this row should be output. |
| 550 | */ |
drh | eda639e | 2006-01-22 00:42:09 +0000 | [diff] [blame] | 551 | hasDistinct = distinct>=0 && pEList->nExpr>0; |
drh | ea48eb2 | 2004-07-19 23:16:38 +0000 | [diff] [blame] | 552 | if( pOrderBy==0 && !hasDistinct ){ |
drh | b765411 | 2008-01-12 12:48:07 +0000 | [diff] [blame] | 553 | codeOffset(v, p, iContinue); |
drh | df199a2 | 2002-06-14 22:38:41 +0000 | [diff] [blame] | 554 | } |
| 555 | |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 556 | /* Pull the requested columns. |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 557 | */ |
drh | 38640e1 | 2002-07-05 21:42:36 +0000 | [diff] [blame] | 558 | if( nColumn>0 ){ |
drh | d847eaa | 2008-01-17 17:15:56 +0000 | [diff] [blame] | 559 | nResultCol = nColumn; |
drh | a2a49dc | 2008-01-02 14:28:13 +0000 | [diff] [blame] | 560 | }else{ |
drh | d847eaa | 2008-01-17 17:15:56 +0000 | [diff] [blame] | 561 | nResultCol = pEList->nExpr; |
drh | a2a49dc | 2008-01-02 14:28:13 +0000 | [diff] [blame] | 562 | } |
drh | 1ece732 | 2008-02-06 23:52:36 +0000 | [diff] [blame] | 563 | if( pDest->iMem==0 ){ |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 564 | pDest->iMem = pParse->nMem+1; |
drh | ad27e76 | 2008-03-26 12:46:23 +0000 | [diff] [blame] | 565 | pDest->nMem = nResultCol; |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 566 | pParse->nMem += nResultCol; |
drh | ad27e76 | 2008-03-26 12:46:23 +0000 | [diff] [blame] | 567 | }else if( pDest->nMem!=nResultCol ){ |
drh | 995ae27 | 2008-03-26 12:50:14 +0000 | [diff] [blame] | 568 | /* This happens when two SELECTs of a compound SELECT have differing |
| 569 | ** numbers of result columns. The error message will be generated by |
| 570 | ** a higher-level routine. */ |
drh | ad27e76 | 2008-03-26 12:46:23 +0000 | [diff] [blame] | 571 | return; |
drh | 1013c93 | 2008-01-06 00:25:21 +0000 | [diff] [blame] | 572 | } |
drh | 1ece732 | 2008-02-06 23:52:36 +0000 | [diff] [blame] | 573 | regResult = pDest->iMem; |
drh | a2a49dc | 2008-01-02 14:28:13 +0000 | [diff] [blame] | 574 | if( nColumn>0 ){ |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 575 | for(i=0; i<nColumn; i++){ |
drh | d847eaa | 2008-01-17 17:15:56 +0000 | [diff] [blame] | 576 | sqlite3VdbeAddOp3(v, OP_Column, srcTab, i, regResult+i); |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 577 | } |
danielk1977 | 9ed1dfa | 2008-01-02 17:11:14 +0000 | [diff] [blame] | 578 | }else if( eDest!=SRT_Exists ){ |
| 579 | /* If the destination is an EXISTS(...) expression, the actual |
| 580 | ** values returned by the SELECT are not required. |
| 581 | */ |
drh | 191b54c | 2008-04-15 12:14:21 +0000 | [diff] [blame] | 582 | sqlite3ExprCodeExprList(pParse, pEList, regResult, eDest==SRT_Callback); |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 583 | } |
drh | d847eaa | 2008-01-17 17:15:56 +0000 | [diff] [blame] | 584 | nColumn = nResultCol; |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 585 | |
drh | daffd0e | 2001-04-11 14:28:42 +0000 | [diff] [blame] | 586 | /* If the DISTINCT keyword was present on the SELECT statement |
| 587 | ** and this row has been seen before, then do not make this row |
| 588 | ** part of the result. |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 589 | */ |
drh | ea48eb2 | 2004-07-19 23:16:38 +0000 | [diff] [blame] | 590 | if( hasDistinct ){ |
drh | f887540 | 2006-03-17 13:56:34 +0000 | [diff] [blame] | 591 | assert( pEList!=0 ); |
| 592 | assert( pEList->nExpr==nColumn ); |
drh | d847eaa | 2008-01-17 17:15:56 +0000 | [diff] [blame] | 593 | codeDistinct(pParse, distinct, iContinue, nColumn, regResult); |
drh | ea48eb2 | 2004-07-19 23:16:38 +0000 | [diff] [blame] | 594 | if( pOrderBy==0 ){ |
drh | b765411 | 2008-01-12 12:48:07 +0000 | [diff] [blame] | 595 | codeOffset(v, p, iContinue); |
drh | ea48eb2 | 2004-07-19 23:16:38 +0000 | [diff] [blame] | 596 | } |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 597 | } |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 598 | |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 599 | if( checkForMultiColumnSelectError(pParse, pDest, pEList->nExpr) ){ |
drh | d2b3e23 | 2008-01-23 14:51:49 +0000 | [diff] [blame] | 600 | return; |
drh | e305f43 | 2007-05-09 22:56:39 +0000 | [diff] [blame] | 601 | } |
| 602 | |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 603 | switch( eDest ){ |
| 604 | /* In this mode, write each query result to the key of the temporary |
| 605 | ** table iParm. |
| 606 | */ |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 607 | #ifndef SQLITE_OMIT_COMPOUND_SELECT |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 608 | case SRT_Union: { |
drh | 9cbf342 | 2008-01-17 16:22:13 +0000 | [diff] [blame] | 609 | int r1; |
| 610 | r1 = sqlite3GetTempReg(pParse); |
drh | d847eaa | 2008-01-17 17:15:56 +0000 | [diff] [blame] | 611 | sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nColumn, r1); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 612 | if( aff ){ |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 613 | sqlite3VdbeChangeP4(v, -1, aff, P4_STATIC); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 614 | } |
drh | 9cbf342 | 2008-01-17 16:22:13 +0000 | [diff] [blame] | 615 | sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, r1); |
| 616 | sqlite3ReleaseTempReg(pParse, r1); |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 617 | break; |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 618 | } |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 619 | |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 620 | /* Construct a record from the query result, but instead of |
| 621 | ** saving that record, use it as a key to delete elements from |
| 622 | ** the temporary table iParm. |
| 623 | */ |
| 624 | case SRT_Except: { |
drh | e14006d | 2008-03-25 17:23:32 +0000 | [diff] [blame] | 625 | sqlite3VdbeAddOp3(v, OP_IdxDelete, iParm, regResult, nColumn); |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 626 | break; |
| 627 | } |
danielk1977 | 5338a5f | 2005-01-20 13:03:10 +0000 | [diff] [blame] | 628 | #endif |
| 629 | |
| 630 | /* Store the result as data using a unique key. |
| 631 | */ |
| 632 | case SRT_Table: |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 633 | case SRT_EphemTab: { |
drh | b765411 | 2008-01-12 12:48:07 +0000 | [diff] [blame] | 634 | int r1 = sqlite3GetTempReg(pParse); |
drh | d847eaa | 2008-01-17 17:15:56 +0000 | [diff] [blame] | 635 | sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nColumn, r1); |
danielk1977 | 5338a5f | 2005-01-20 13:03:10 +0000 | [diff] [blame] | 636 | if( pOrderBy ){ |
drh | b765411 | 2008-01-12 12:48:07 +0000 | [diff] [blame] | 637 | pushOntoSorter(pParse, pOrderBy, p, r1); |
danielk1977 | 5338a5f | 2005-01-20 13:03:10 +0000 | [diff] [blame] | 638 | }else{ |
drh | b765411 | 2008-01-12 12:48:07 +0000 | [diff] [blame] | 639 | int r2 = sqlite3GetTempReg(pParse); |
| 640 | sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, r2); |
| 641 | sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, r2); |
| 642 | sqlite3VdbeChangeP5(v, OPFLAG_APPEND); |
| 643 | sqlite3ReleaseTempReg(pParse, r2); |
danielk1977 | 5338a5f | 2005-01-20 13:03:10 +0000 | [diff] [blame] | 644 | } |
drh | b765411 | 2008-01-12 12:48:07 +0000 | [diff] [blame] | 645 | sqlite3ReleaseTempReg(pParse, r1); |
danielk1977 | 5338a5f | 2005-01-20 13:03:10 +0000 | [diff] [blame] | 646 | break; |
| 647 | } |
drh | 5974a30 | 2000-06-07 14:42:26 +0000 | [diff] [blame] | 648 | |
danielk1977 | 93758c8 | 2005-01-21 08:13:14 +0000 | [diff] [blame] | 649 | #ifndef SQLITE_OMIT_SUBQUERY |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 650 | /* If we are creating a set for an "expr IN (SELECT ...)" construct, |
| 651 | ** then there should be a single item on the stack. Write this |
| 652 | ** item into the set table with bogus data. |
| 653 | */ |
| 654 | case SRT_Set: { |
drh | 52b36ca | 2004-01-14 13:38:54 +0000 | [diff] [blame] | 655 | int addr2; |
danielk1977 | e014a83 | 2004-05-17 10:48:57 +0000 | [diff] [blame] | 656 | |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 657 | assert( nColumn==1 ); |
drh | d847eaa | 2008-01-17 17:15:56 +0000 | [diff] [blame] | 658 | addr2 = sqlite3VdbeAddOp1(v, OP_IsNull, regResult); |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 659 | p->affinity = sqlite3CompareAffinity(pEList->a[0].pExpr, pDest->affinity); |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 660 | if( pOrderBy ){ |
drh | de941c6 | 2005-08-28 01:34:21 +0000 | [diff] [blame] | 661 | /* At first glance you would think we could optimize out the |
| 662 | ** ORDER BY in this case since the order of entries in the set |
| 663 | ** does not matter. But there might be a LIMIT clause, in which |
| 664 | ** case the order does matter */ |
drh | d847eaa | 2008-01-17 17:15:56 +0000 | [diff] [blame] | 665 | pushOntoSorter(pParse, pOrderBy, p, regResult); |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 666 | }else{ |
drh | b765411 | 2008-01-12 12:48:07 +0000 | [diff] [blame] | 667 | int r1 = sqlite3GetTempReg(pParse); |
drh | d847eaa | 2008-01-17 17:15:56 +0000 | [diff] [blame] | 668 | sqlite3VdbeAddOp4(v, OP_MakeRecord, regResult, 1, r1, &p->affinity, 1); |
drh | da250ea | 2008-04-01 05:07:14 +0000 | [diff] [blame] | 669 | sqlite3ExprCacheAffinityChange(pParse, regResult, 1); |
drh | b765411 | 2008-01-12 12:48:07 +0000 | [diff] [blame] | 670 | sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, r1); |
| 671 | sqlite3ReleaseTempReg(pParse, r1); |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 672 | } |
drh | d654be8 | 2005-09-20 17:42:23 +0000 | [diff] [blame] | 673 | sqlite3VdbeJumpHere(v, addr2); |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 674 | break; |
| 675 | } |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 676 | |
drh | 504b698 | 2006-01-22 21:52:56 +0000 | [diff] [blame] | 677 | /* If any row exist in the result set, record that fact and abort. |
drh | ec7429a | 2005-10-06 16:53:14 +0000 | [diff] [blame] | 678 | */ |
| 679 | case SRT_Exists: { |
drh | 4c58312 | 2008-01-04 22:01:03 +0000 | [diff] [blame] | 680 | sqlite3VdbeAddOp2(v, OP_Integer, 1, iParm); |
drh | ec7429a | 2005-10-06 16:53:14 +0000 | [diff] [blame] | 681 | /* The LIMIT clause will terminate the loop for us */ |
| 682 | break; |
| 683 | } |
| 684 | |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 685 | /* If this is a scalar select that is part of an expression, then |
| 686 | ** store the results in the appropriate memory cell and break out |
| 687 | ** of the scan loop. |
| 688 | */ |
| 689 | case SRT_Mem: { |
| 690 | assert( nColumn==1 ); |
| 691 | if( pOrderBy ){ |
drh | d847eaa | 2008-01-17 17:15:56 +0000 | [diff] [blame] | 692 | pushOntoSorter(pParse, pOrderBy, p, regResult); |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 693 | }else{ |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 694 | sqlite3ExprCodeMove(pParse, regResult, iParm, 1); |
drh | ec7429a | 2005-10-06 16:53:14 +0000 | [diff] [blame] | 695 | /* The LIMIT clause will jump out of the loop for us */ |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 696 | } |
| 697 | break; |
| 698 | } |
danielk1977 | 93758c8 | 2005-01-21 08:13:14 +0000 | [diff] [blame] | 699 | #endif /* #ifndef SQLITE_OMIT_SUBQUERY */ |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 700 | |
drh | c182d16 | 2005-08-14 20:47:16 +0000 | [diff] [blame] | 701 | /* Send the data to the callback function or to a subroutine. In the |
| 702 | ** case of a subroutine, the subroutine itself is responsible for |
| 703 | ** popping the data from the stack. |
drh | f46f905 | 2002-06-22 02:33:38 +0000 | [diff] [blame] | 704 | */ |
drh | e00ee6e | 2008-06-20 15:24:01 +0000 | [diff] [blame] | 705 | case SRT_Coroutine: |
drh | 9d2985c | 2005-09-08 01:58:42 +0000 | [diff] [blame] | 706 | case SRT_Callback: { |
drh | f46f905 | 2002-06-22 02:33:38 +0000 | [diff] [blame] | 707 | if( pOrderBy ){ |
drh | b765411 | 2008-01-12 12:48:07 +0000 | [diff] [blame] | 708 | int r1 = sqlite3GetTempReg(pParse); |
drh | d847eaa | 2008-01-17 17:15:56 +0000 | [diff] [blame] | 709 | sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nColumn, r1); |
drh | b765411 | 2008-01-12 12:48:07 +0000 | [diff] [blame] | 710 | pushOntoSorter(pParse, pOrderBy, p, r1); |
| 711 | sqlite3ReleaseTempReg(pParse, r1); |
drh | e00ee6e | 2008-06-20 15:24:01 +0000 | [diff] [blame] | 712 | }else if( eDest==SRT_Coroutine ){ |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 713 | sqlite3VdbeAddOp1(v, OP_Yield, pDest->iParm); |
drh | c182d16 | 2005-08-14 20:47:16 +0000 | [diff] [blame] | 714 | }else{ |
drh | d847eaa | 2008-01-17 17:15:56 +0000 | [diff] [blame] | 715 | sqlite3VdbeAddOp2(v, OP_ResultRow, regResult, nColumn); |
drh | da250ea | 2008-04-01 05:07:14 +0000 | [diff] [blame] | 716 | sqlite3ExprCacheAffinityChange(pParse, regResult, nColumn); |
drh | ac82fcf | 2002-09-08 17:23:41 +0000 | [diff] [blame] | 717 | } |
drh | 142e30d | 2002-08-28 03:00:58 +0000 | [diff] [blame] | 718 | break; |
| 719 | } |
| 720 | |
danielk1977 | 6a67fe8 | 2005-02-04 04:07:16 +0000 | [diff] [blame] | 721 | #if !defined(SQLITE_OMIT_TRIGGER) |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 722 | /* Discard the results. This is used for SELECT statements inside |
| 723 | ** the body of a TRIGGER. The purpose of such selects is to call |
| 724 | ** user-defined functions that have side effects. We do not care |
| 725 | ** about the actual results of the select. |
| 726 | */ |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 727 | default: { |
drh | f46f905 | 2002-06-22 02:33:38 +0000 | [diff] [blame] | 728 | assert( eDest==SRT_Discard ); |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 729 | break; |
| 730 | } |
danielk1977 | 93758c8 | 2005-01-21 08:13:14 +0000 | [diff] [blame] | 731 | #endif |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 732 | } |
drh | ec7429a | 2005-10-06 16:53:14 +0000 | [diff] [blame] | 733 | |
| 734 | /* Jump to the end of the loop if the LIMIT is reached. |
| 735 | */ |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 736 | if( p->iLimit && pOrderBy==0 ){ |
drh | 8558cde | 2008-01-05 05:20:10 +0000 | [diff] [blame] | 737 | sqlite3VdbeAddOp2(v, OP_AddImm, p->iLimit, -1); |
drh | 3c84ddf | 2008-01-09 02:15:38 +0000 | [diff] [blame] | 738 | sqlite3VdbeAddOp2(v, OP_IfZero, p->iLimit, iBreak); |
drh | ec7429a | 2005-10-06 16:53:14 +0000 | [diff] [blame] | 739 | } |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 740 | } |
| 741 | |
| 742 | /* |
drh | dece1a8 | 2005-08-31 18:20:00 +0000 | [diff] [blame] | 743 | ** Given an expression list, generate a KeyInfo structure that records |
| 744 | ** the collating sequence for each expression in that expression list. |
| 745 | ** |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 746 | ** If the ExprList is an ORDER BY or GROUP BY clause then the resulting |
| 747 | ** KeyInfo structure is appropriate for initializing a virtual index to |
| 748 | ** implement that clause. If the ExprList is the result set of a SELECT |
| 749 | ** then the KeyInfo structure is appropriate for initializing a virtual |
| 750 | ** index to implement a DISTINCT test. |
| 751 | ** |
drh | dece1a8 | 2005-08-31 18:20:00 +0000 | [diff] [blame] | 752 | ** Space to hold the KeyInfo structure is obtain from malloc. The calling |
| 753 | ** function is responsible for seeing that this structure is eventually |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 754 | ** freed. Add the KeyInfo structure to the P4 field of an opcode using |
| 755 | ** P4_KEYINFO_HANDOFF is the usual way of dealing with this. |
drh | dece1a8 | 2005-08-31 18:20:00 +0000 | [diff] [blame] | 756 | */ |
| 757 | static KeyInfo *keyInfoFromExprList(Parse *pParse, ExprList *pList){ |
| 758 | sqlite3 *db = pParse->db; |
| 759 | int nExpr; |
| 760 | KeyInfo *pInfo; |
| 761 | struct ExprList_item *pItem; |
| 762 | int i; |
| 763 | |
| 764 | nExpr = pList->nExpr; |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 765 | pInfo = sqlite3DbMallocZero(db, sizeof(*pInfo) + nExpr*(sizeof(CollSeq*)+1) ); |
drh | dece1a8 | 2005-08-31 18:20:00 +0000 | [diff] [blame] | 766 | if( pInfo ){ |
drh | 2646da7 | 2005-12-09 20:02:05 +0000 | [diff] [blame] | 767 | pInfo->aSortOrder = (u8*)&pInfo->aColl[nExpr]; |
drh | dece1a8 | 2005-08-31 18:20:00 +0000 | [diff] [blame] | 768 | pInfo->nField = nExpr; |
danielk1977 | 14db266 | 2006-01-09 16:12:04 +0000 | [diff] [blame] | 769 | pInfo->enc = ENC(db); |
drh | dece1a8 | 2005-08-31 18:20:00 +0000 | [diff] [blame] | 770 | for(i=0, pItem=pList->a; i<nExpr; i++, pItem++){ |
| 771 | CollSeq *pColl; |
| 772 | pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr); |
| 773 | if( !pColl ){ |
| 774 | pColl = db->pDfltColl; |
| 775 | } |
| 776 | pInfo->aColl[i] = pColl; |
| 777 | pInfo->aSortOrder[i] = pItem->sortOrder; |
| 778 | } |
| 779 | } |
| 780 | return pInfo; |
| 781 | } |
| 782 | |
| 783 | |
| 784 | /* |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 785 | ** If the inner loop was generated using a non-null pOrderBy argument, |
| 786 | ** then the results were placed in a sorter. After the loop is terminated |
| 787 | ** we need to run the sorter and output the results. The following |
| 788 | ** routine generates the code needed to do that. |
| 789 | */ |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 790 | static void generateSortTail( |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 791 | Parse *pParse, /* Parsing context */ |
| 792 | Select *p, /* The SELECT statement */ |
| 793 | Vdbe *v, /* Generate code into this VDBE */ |
| 794 | int nColumn, /* Number of columns of data */ |
| 795 | SelectDest *pDest /* Write the sorted results here */ |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 796 | ){ |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 797 | int brk = sqlite3VdbeMakeLabel(v); |
| 798 | int cont = sqlite3VdbeMakeLabel(v); |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 799 | int addr; |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 800 | int iTab; |
drh | 61fc595 | 2007-04-01 23:49:51 +0000 | [diff] [blame] | 801 | int pseudoTab = 0; |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 802 | ExprList *pOrderBy = p->pOrderBy; |
drh | ffbc308 | 2004-05-21 01:29:06 +0000 | [diff] [blame] | 803 | |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 804 | int eDest = pDest->eDest; |
| 805 | int iParm = pDest->iParm; |
| 806 | |
drh | 2d401ab | 2008-01-10 23:50:11 +0000 | [diff] [blame] | 807 | int regRow; |
| 808 | int regRowid; |
| 809 | |
drh | 9d2985c | 2005-09-08 01:58:42 +0000 | [diff] [blame] | 810 | iTab = pOrderBy->iECursor; |
drh | e00ee6e | 2008-06-20 15:24:01 +0000 | [diff] [blame] | 811 | if( eDest==SRT_Callback || eDest==SRT_Coroutine ){ |
drh | cdd536f | 2006-03-17 00:04:03 +0000 | [diff] [blame] | 812 | pseudoTab = pParse->nTab++; |
danielk1977 | cd3e8f7 | 2008-03-25 09:47:35 +0000 | [diff] [blame] | 813 | sqlite3VdbeAddOp2(v, OP_SetNumColumns, 0, nColumn); |
danielk1977 | 9882d99 | 2008-03-27 17:59:01 +0000 | [diff] [blame] | 814 | sqlite3VdbeAddOp2(v, OP_OpenPseudo, pseudoTab, eDest==SRT_Callback); |
drh | cdd536f | 2006-03-17 00:04:03 +0000 | [diff] [blame] | 815 | } |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 816 | addr = 1 + sqlite3VdbeAddOp2(v, OP_Sort, iTab, brk); |
drh | b765411 | 2008-01-12 12:48:07 +0000 | [diff] [blame] | 817 | codeOffset(v, p, cont); |
drh | 2d401ab | 2008-01-10 23:50:11 +0000 | [diff] [blame] | 818 | regRow = sqlite3GetTempReg(pParse); |
| 819 | regRowid = sqlite3GetTempReg(pParse); |
| 820 | sqlite3VdbeAddOp3(v, OP_Column, iTab, pOrderBy->nExpr + 1, regRow); |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 821 | switch( eDest ){ |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 822 | case SRT_Table: |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 823 | case SRT_EphemTab: { |
drh | 2d401ab | 2008-01-10 23:50:11 +0000 | [diff] [blame] | 824 | sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, regRowid); |
| 825 | sqlite3VdbeAddOp3(v, OP_Insert, iParm, regRow, regRowid); |
| 826 | sqlite3VdbeChangeP5(v, OPFLAG_APPEND); |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 827 | break; |
| 828 | } |
danielk1977 | 93758c8 | 2005-01-21 08:13:14 +0000 | [diff] [blame] | 829 | #ifndef SQLITE_OMIT_SUBQUERY |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 830 | case SRT_Set: { |
drh | 2d401ab | 2008-01-10 23:50:11 +0000 | [diff] [blame] | 831 | int j1; |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 832 | assert( nColumn==1 ); |
drh | 2d401ab | 2008-01-10 23:50:11 +0000 | [diff] [blame] | 833 | j1 = sqlite3VdbeAddOp1(v, OP_IsNull, regRow); |
danielk1977 | a7a8e14 | 2008-02-13 18:25:27 +0000 | [diff] [blame] | 834 | sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, 1, regRowid, &p->affinity, 1); |
drh | da250ea | 2008-04-01 05:07:14 +0000 | [diff] [blame] | 835 | sqlite3ExprCacheAffinityChange(pParse, regRow, 1); |
danielk1977 | a7a8e14 | 2008-02-13 18:25:27 +0000 | [diff] [blame] | 836 | sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, regRowid); |
drh | 6a288a3 | 2008-01-07 19:20:24 +0000 | [diff] [blame] | 837 | sqlite3VdbeJumpHere(v, j1); |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 838 | break; |
| 839 | } |
| 840 | case SRT_Mem: { |
| 841 | assert( nColumn==1 ); |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 842 | sqlite3ExprCodeMove(pParse, regRow, iParm, 1); |
drh | ec7429a | 2005-10-06 16:53:14 +0000 | [diff] [blame] | 843 | /* The LIMIT clause will terminate the loop for us */ |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 844 | break; |
| 845 | } |
danielk1977 | 93758c8 | 2005-01-21 08:13:14 +0000 | [diff] [blame] | 846 | #endif |
drh | ce665cf | 2004-05-21 03:01:58 +0000 | [diff] [blame] | 847 | case SRT_Callback: |
drh | e00ee6e | 2008-06-20 15:24:01 +0000 | [diff] [blame] | 848 | case SRT_Coroutine: { |
drh | ac82fcf | 2002-09-08 17:23:41 +0000 | [diff] [blame] | 849 | int i; |
drh | 2d401ab | 2008-01-10 23:50:11 +0000 | [diff] [blame] | 850 | sqlite3VdbeAddOp2(v, OP_Integer, 1, regRowid); |
| 851 | sqlite3VdbeAddOp3(v, OP_Insert, pseudoTab, regRow, regRowid); |
drh | ac82fcf | 2002-09-08 17:23:41 +0000 | [diff] [blame] | 852 | for(i=0; i<nColumn; i++){ |
danielk1977 | 9882d99 | 2008-03-27 17:59:01 +0000 | [diff] [blame] | 853 | assert( regRow!=pDest->iMem+i ); |
drh | 1013c93 | 2008-01-06 00:25:21 +0000 | [diff] [blame] | 854 | sqlite3VdbeAddOp3(v, OP_Column, pseudoTab, i, pDest->iMem+i); |
drh | ac82fcf | 2002-09-08 17:23:41 +0000 | [diff] [blame] | 855 | } |
drh | ce665cf | 2004-05-21 03:01:58 +0000 | [diff] [blame] | 856 | if( eDest==SRT_Callback ){ |
drh | 1013c93 | 2008-01-06 00:25:21 +0000 | [diff] [blame] | 857 | sqlite3VdbeAddOp2(v, OP_ResultRow, pDest->iMem, nColumn); |
drh | da250ea | 2008-04-01 05:07:14 +0000 | [diff] [blame] | 858 | sqlite3ExprCacheAffinityChange(pParse, pDest->iMem, nColumn); |
drh | e00ee6e | 2008-06-20 15:24:01 +0000 | [diff] [blame] | 859 | }else if( eDest==SRT_Coroutine ){ |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 860 | sqlite3VdbeAddOp1(v, OP_Yield, pDest->iParm); |
drh | ce665cf | 2004-05-21 03:01:58 +0000 | [diff] [blame] | 861 | } |
drh | ac82fcf | 2002-09-08 17:23:41 +0000 | [diff] [blame] | 862 | break; |
| 863 | } |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 864 | default: { |
drh | f46f905 | 2002-06-22 02:33:38 +0000 | [diff] [blame] | 865 | /* Do nothing */ |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 866 | break; |
| 867 | } |
| 868 | } |
drh | 2d401ab | 2008-01-10 23:50:11 +0000 | [diff] [blame] | 869 | sqlite3ReleaseTempReg(pParse, regRow); |
| 870 | sqlite3ReleaseTempReg(pParse, regRowid); |
drh | ec7429a | 2005-10-06 16:53:14 +0000 | [diff] [blame] | 871 | |
| 872 | /* Jump to the end of the loop when the LIMIT is reached |
| 873 | */ |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 874 | if( p->iLimit ){ |
drh | 8558cde | 2008-01-05 05:20:10 +0000 | [diff] [blame] | 875 | sqlite3VdbeAddOp2(v, OP_AddImm, p->iLimit, -1); |
drh | 3c84ddf | 2008-01-09 02:15:38 +0000 | [diff] [blame] | 876 | sqlite3VdbeAddOp2(v, OP_IfZero, p->iLimit, brk); |
drh | ec7429a | 2005-10-06 16:53:14 +0000 | [diff] [blame] | 877 | } |
| 878 | |
| 879 | /* The bottom of the loop |
| 880 | */ |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 881 | sqlite3VdbeResolveLabel(v, cont); |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 882 | sqlite3VdbeAddOp2(v, OP_Next, iTab, addr); |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 883 | sqlite3VdbeResolveLabel(v, brk); |
drh | e00ee6e | 2008-06-20 15:24:01 +0000 | [diff] [blame] | 884 | if( eDest==SRT_Callback || eDest==SRT_Coroutine ){ |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 885 | sqlite3VdbeAddOp2(v, OP_Close, pseudoTab, 0); |
drh | cdd536f | 2006-03-17 00:04:03 +0000 | [diff] [blame] | 886 | } |
| 887 | |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 888 | } |
| 889 | |
| 890 | /* |
danielk1977 | 517eb64 | 2004-06-07 10:00:31 +0000 | [diff] [blame] | 891 | ** Return a pointer to a string containing the 'declaration type' of the |
| 892 | ** expression pExpr. The string may be treated as static by the caller. |
drh | e78e828 | 2003-01-19 03:59:45 +0000 | [diff] [blame] | 893 | ** |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 894 | ** The declaration type is the exact datatype definition extracted from the |
| 895 | ** original CREATE TABLE statement if the expression is a column. The |
| 896 | ** declaration type for a ROWID field is INTEGER. Exactly when an expression |
| 897 | ** is considered a column can be complex in the presence of subqueries. The |
| 898 | ** result-set expression in all of the following SELECT statements is |
| 899 | ** considered a column by this function. |
| 900 | ** |
| 901 | ** SELECT col FROM tbl; |
| 902 | ** SELECT (SELECT col FROM tbl; |
| 903 | ** SELECT (SELECT col FROM tbl); |
| 904 | ** SELECT abc FROM (SELECT col AS abc FROM tbl); |
danielk1977 | 517eb64 | 2004-06-07 10:00:31 +0000 | [diff] [blame] | 905 | ** |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 906 | ** The declaration type for any expression other than a column is NULL. |
danielk1977 | 517eb64 | 2004-06-07 10:00:31 +0000 | [diff] [blame] | 907 | */ |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 908 | static const char *columnType( |
| 909 | NameContext *pNC, |
| 910 | Expr *pExpr, |
| 911 | const char **pzOriginDb, |
| 912 | const char **pzOriginTab, |
| 913 | const char **pzOriginCol |
| 914 | ){ |
| 915 | char const *zType = 0; |
| 916 | char const *zOriginDb = 0; |
| 917 | char const *zOriginTab = 0; |
| 918 | char const *zOriginCol = 0; |
danielk1977 | 517eb64 | 2004-06-07 10:00:31 +0000 | [diff] [blame] | 919 | int j; |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 920 | if( pExpr==0 || pNC->pSrcList==0 ) return 0; |
danielk1977 | 5338a5f | 2005-01-20 13:03:10 +0000 | [diff] [blame] | 921 | |
danielk1977 | 00e279d | 2004-06-21 07:36:32 +0000 | [diff] [blame] | 922 | switch( pExpr->op ){ |
drh | 30bcf5d | 2006-04-07 13:50:37 +0000 | [diff] [blame] | 923 | case TK_AGG_COLUMN: |
danielk1977 | 00e279d | 2004-06-21 07:36:32 +0000 | [diff] [blame] | 924 | case TK_COLUMN: { |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 925 | /* The expression is a column. Locate the table the column is being |
| 926 | ** extracted from in NameContext.pSrcList. This table may be real |
| 927 | ** database table or a subquery. |
| 928 | */ |
| 929 | Table *pTab = 0; /* Table structure column is extracted from */ |
| 930 | Select *pS = 0; /* Select the column is extracted from */ |
| 931 | int iCol = pExpr->iColumn; /* Index of column in pTab */ |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 932 | while( pNC && !pTab ){ |
| 933 | SrcList *pTabList = pNC->pSrcList; |
| 934 | for(j=0;j<pTabList->nSrc && pTabList->a[j].iCursor!=pExpr->iTable;j++); |
| 935 | if( j<pTabList->nSrc ){ |
| 936 | pTab = pTabList->a[j].pTab; |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 937 | pS = pTabList->a[j].pSelect; |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 938 | }else{ |
| 939 | pNC = pNC->pNext; |
| 940 | } |
| 941 | } |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 942 | |
drh | 7e62779 | 2005-04-29 02:10:00 +0000 | [diff] [blame] | 943 | if( pTab==0 ){ |
| 944 | /* FIX ME: |
| 945 | ** This can occurs if you have something like "SELECT new.x;" inside |
| 946 | ** a trigger. In other words, if you reference the special "new" |
| 947 | ** table in the result set of a select. We do not have a good way |
| 948 | ** to find the actual table type, so call it "TEXT". This is really |
| 949 | ** something of a bug, but I do not know how to fix it. |
| 950 | ** |
| 951 | ** This code does not produce the correct answer - it just prevents |
| 952 | ** a segfault. See ticket #1229. |
| 953 | */ |
| 954 | zType = "TEXT"; |
| 955 | break; |
| 956 | } |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 957 | |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 958 | assert( pTab ); |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 959 | if( pS ){ |
| 960 | /* The "table" is actually a sub-select or a view in the FROM clause |
| 961 | ** of the SELECT statement. Return the declaration type and origin |
| 962 | ** data for the result-set column of the sub-select. |
| 963 | */ |
| 964 | if( iCol>=0 && iCol<pS->pEList->nExpr ){ |
| 965 | /* If iCol is less than zero, then the expression requests the |
| 966 | ** rowid of the sub-select or view. This expression is legal (see |
| 967 | ** test case misc2.2.2) - it always evaluates to NULL. |
| 968 | */ |
| 969 | NameContext sNC; |
| 970 | Expr *p = pS->pEList->a[iCol].pExpr; |
| 971 | sNC.pSrcList = pS->pSrc; |
| 972 | sNC.pNext = 0; |
| 973 | sNC.pParse = pNC->pParse; |
| 974 | zType = columnType(&sNC, p, &zOriginDb, &zOriginTab, &zOriginCol); |
| 975 | } |
danielk1977 | 4b2688a | 2006-06-20 11:01:07 +0000 | [diff] [blame] | 976 | }else if( pTab->pSchema ){ |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 977 | /* A real table */ |
| 978 | assert( !pS ); |
| 979 | if( iCol<0 ) iCol = pTab->iPKey; |
| 980 | assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) ); |
| 981 | if( iCol<0 ){ |
| 982 | zType = "INTEGER"; |
| 983 | zOriginCol = "rowid"; |
| 984 | }else{ |
| 985 | zType = pTab->aCol[iCol].zType; |
| 986 | zOriginCol = pTab->aCol[iCol].zName; |
| 987 | } |
| 988 | zOriginTab = pTab->zName; |
| 989 | if( pNC->pParse ){ |
| 990 | int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema); |
| 991 | zOriginDb = pNC->pParse->db->aDb[iDb].zName; |
| 992 | } |
danielk1977 | 00e279d | 2004-06-21 07:36:32 +0000 | [diff] [blame] | 993 | } |
| 994 | break; |
danielk1977 | 517eb64 | 2004-06-07 10:00:31 +0000 | [diff] [blame] | 995 | } |
danielk1977 | 93758c8 | 2005-01-21 08:13:14 +0000 | [diff] [blame] | 996 | #ifndef SQLITE_OMIT_SUBQUERY |
danielk1977 | 00e279d | 2004-06-21 07:36:32 +0000 | [diff] [blame] | 997 | case TK_SELECT: { |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 998 | /* The expression is a sub-select. Return the declaration type and |
| 999 | ** origin info for the single column in the result set of the SELECT |
| 1000 | ** statement. |
| 1001 | */ |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 1002 | NameContext sNC; |
danielk1977 | 00e279d | 2004-06-21 07:36:32 +0000 | [diff] [blame] | 1003 | Select *pS = pExpr->pSelect; |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 1004 | Expr *p = pS->pEList->a[0].pExpr; |
| 1005 | sNC.pSrcList = pS->pSrc; |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 1006 | sNC.pNext = pNC; |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 1007 | sNC.pParse = pNC->pParse; |
| 1008 | zType = columnType(&sNC, p, &zOriginDb, &zOriginTab, &zOriginCol); |
danielk1977 | 00e279d | 2004-06-21 07:36:32 +0000 | [diff] [blame] | 1009 | break; |
danielk1977 | 517eb64 | 2004-06-07 10:00:31 +0000 | [diff] [blame] | 1010 | } |
danielk1977 | 93758c8 | 2005-01-21 08:13:14 +0000 | [diff] [blame] | 1011 | #endif |
danielk1977 | 517eb64 | 2004-06-07 10:00:31 +0000 | [diff] [blame] | 1012 | } |
danielk1977 | 00e279d | 2004-06-21 07:36:32 +0000 | [diff] [blame] | 1013 | |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 1014 | if( pzOriginDb ){ |
| 1015 | assert( pzOriginTab && pzOriginCol ); |
| 1016 | *pzOriginDb = zOriginDb; |
| 1017 | *pzOriginTab = zOriginTab; |
| 1018 | *pzOriginCol = zOriginCol; |
| 1019 | } |
danielk1977 | 517eb64 | 2004-06-07 10:00:31 +0000 | [diff] [blame] | 1020 | return zType; |
| 1021 | } |
| 1022 | |
| 1023 | /* |
| 1024 | ** Generate code that will tell the VDBE the declaration types of columns |
| 1025 | ** in the result set. |
drh | fcb78a4 | 2003-01-18 20:11:05 +0000 | [diff] [blame] | 1026 | */ |
| 1027 | static void generateColumnTypes( |
| 1028 | Parse *pParse, /* Parser context */ |
drh | fcb78a4 | 2003-01-18 20:11:05 +0000 | [diff] [blame] | 1029 | SrcList *pTabList, /* List of tables */ |
| 1030 | ExprList *pEList /* Expressions defining the result set */ |
| 1031 | ){ |
drh | 3f91357 | 2008-03-22 01:07:17 +0000 | [diff] [blame] | 1032 | #ifndef SQLITE_OMIT_DECLTYPE |
drh | fcb78a4 | 2003-01-18 20:11:05 +0000 | [diff] [blame] | 1033 | Vdbe *v = pParse->pVdbe; |
danielk1977 | 517eb64 | 2004-06-07 10:00:31 +0000 | [diff] [blame] | 1034 | int i; |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 1035 | NameContext sNC; |
| 1036 | sNC.pSrcList = pTabList; |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 1037 | sNC.pParse = pParse; |
drh | fcb78a4 | 2003-01-18 20:11:05 +0000 | [diff] [blame] | 1038 | for(i=0; i<pEList->nExpr; i++){ |
| 1039 | Expr *p = pEList->a[i].pExpr; |
drh | 3f91357 | 2008-03-22 01:07:17 +0000 | [diff] [blame] | 1040 | const char *zType; |
| 1041 | #ifdef SQLITE_ENABLE_COLUMN_METADATA |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 1042 | const char *zOrigDb = 0; |
| 1043 | const char *zOrigTab = 0; |
| 1044 | const char *zOrigCol = 0; |
drh | 3f91357 | 2008-03-22 01:07:17 +0000 | [diff] [blame] | 1045 | zType = columnType(&sNC, p, &zOrigDb, &zOrigTab, &zOrigCol); |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 1046 | |
drh | 85b623f | 2007-12-13 21:54:09 +0000 | [diff] [blame] | 1047 | /* The vdbe must make its own copy of the column-type and other |
danielk1977 | 4b1ae99 | 2006-02-10 03:06:10 +0000 | [diff] [blame] | 1048 | ** column specific strings, in case the schema is reset before this |
| 1049 | ** virtual machine is deleted. |
danielk1977 | fbcd585 | 2004-06-15 02:44:18 +0000 | [diff] [blame] | 1050 | */ |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 1051 | sqlite3VdbeSetColName(v, i, COLNAME_DATABASE, zOrigDb, P4_TRANSIENT); |
| 1052 | sqlite3VdbeSetColName(v, i, COLNAME_TABLE, zOrigTab, P4_TRANSIENT); |
| 1053 | sqlite3VdbeSetColName(v, i, COLNAME_COLUMN, zOrigCol, P4_TRANSIENT); |
drh | 3f91357 | 2008-03-22 01:07:17 +0000 | [diff] [blame] | 1054 | #else |
| 1055 | zType = columnType(&sNC, p, 0, 0, 0); |
| 1056 | #endif |
| 1057 | sqlite3VdbeSetColName(v, i, COLNAME_DECLTYPE, zType, P4_TRANSIENT); |
drh | fcb78a4 | 2003-01-18 20:11:05 +0000 | [diff] [blame] | 1058 | } |
drh | 3f91357 | 2008-03-22 01:07:17 +0000 | [diff] [blame] | 1059 | #endif /* SQLITE_OMIT_DECLTYPE */ |
drh | fcb78a4 | 2003-01-18 20:11:05 +0000 | [diff] [blame] | 1060 | } |
| 1061 | |
| 1062 | /* |
| 1063 | ** Generate code that will tell the VDBE the names of columns |
| 1064 | ** in the result set. This information is used to provide the |
drh | fcabd46 | 2004-02-20 14:50:58 +0000 | [diff] [blame] | 1065 | ** azCol[] values in the callback. |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 1066 | */ |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 1067 | static void generateColumnNames( |
| 1068 | Parse *pParse, /* Parser context */ |
drh | ad3cab5 | 2002-05-24 02:04:32 +0000 | [diff] [blame] | 1069 | SrcList *pTabList, /* List of tables */ |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 1070 | ExprList *pEList /* Expressions defining the result set */ |
| 1071 | ){ |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1072 | Vdbe *v = pParse->pVdbe; |
drh | 6a3ea0e | 2003-05-02 14:32:12 +0000 | [diff] [blame] | 1073 | int i, j; |
drh | 9bb575f | 2004-09-06 17:24:11 +0000 | [diff] [blame] | 1074 | sqlite3 *db = pParse->db; |
drh | fcabd46 | 2004-02-20 14:50:58 +0000 | [diff] [blame] | 1075 | int fullNames, shortNames; |
| 1076 | |
drh | fe2093d | 2005-01-20 22:48:47 +0000 | [diff] [blame] | 1077 | #ifndef SQLITE_OMIT_EXPLAIN |
danielk1977 | 3cf8606 | 2004-05-26 10:11:05 +0000 | [diff] [blame] | 1078 | /* If this is an EXPLAIN, skip this step */ |
| 1079 | if( pParse->explain ){ |
danielk1977 | 61de0d1 | 2004-05-27 23:56:16 +0000 | [diff] [blame] | 1080 | return; |
danielk1977 | 3cf8606 | 2004-05-26 10:11:05 +0000 | [diff] [blame] | 1081 | } |
danielk1977 | 5338a5f | 2005-01-20 13:03:10 +0000 | [diff] [blame] | 1082 | #endif |
danielk1977 | 3cf8606 | 2004-05-26 10:11:05 +0000 | [diff] [blame] | 1083 | |
drh | d650275 | 2004-02-16 03:44:01 +0000 | [diff] [blame] | 1084 | assert( v!=0 ); |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 1085 | if( pParse->colNamesSet || v==0 || db->mallocFailed ) return; |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1086 | pParse->colNamesSet = 1; |
drh | fcabd46 | 2004-02-20 14:50:58 +0000 | [diff] [blame] | 1087 | fullNames = (db->flags & SQLITE_FullColNames)!=0; |
| 1088 | shortNames = (db->flags & SQLITE_ShortColNames)!=0; |
danielk1977 | 22322fd | 2004-05-25 23:35:17 +0000 | [diff] [blame] | 1089 | sqlite3VdbeSetNumCols(v, pEList->nExpr); |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 1090 | for(i=0; i<pEList->nExpr; i++){ |
| 1091 | Expr *p; |
drh | 5a38705 | 2003-01-11 14:19:51 +0000 | [diff] [blame] | 1092 | p = pEList->a[i].pExpr; |
| 1093 | if( p==0 ) continue; |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 1094 | if( pEList->a[i].zName ){ |
| 1095 | char *zName = pEList->a[i].zName; |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 1096 | sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, strlen(zName)); |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 1097 | continue; |
| 1098 | } |
drh | fa173a7 | 2002-07-10 21:26:00 +0000 | [diff] [blame] | 1099 | if( p->op==TK_COLUMN && pTabList ){ |
drh | 6a3ea0e | 2003-05-02 14:32:12 +0000 | [diff] [blame] | 1100 | Table *pTab; |
drh | 9766587 | 2002-02-13 23:22:53 +0000 | [diff] [blame] | 1101 | char *zCol; |
drh | 8aff101 | 2001-12-22 14:49:24 +0000 | [diff] [blame] | 1102 | int iCol = p->iColumn; |
drh | 6a3ea0e | 2003-05-02 14:32:12 +0000 | [diff] [blame] | 1103 | for(j=0; j<pTabList->nSrc && pTabList->a[j].iCursor!=p->iTable; j++){} |
| 1104 | assert( j<pTabList->nSrc ); |
| 1105 | pTab = pTabList->a[j].pTab; |
drh | 8aff101 | 2001-12-22 14:49:24 +0000 | [diff] [blame] | 1106 | if( iCol<0 ) iCol = pTab->iPKey; |
drh | 9766587 | 2002-02-13 23:22:53 +0000 | [diff] [blame] | 1107 | assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) ); |
drh | b136320 | 2002-06-26 02:45:03 +0000 | [diff] [blame] | 1108 | if( iCol<0 ){ |
drh | 47a6db2 | 2005-01-18 16:02:40 +0000 | [diff] [blame] | 1109 | zCol = "rowid"; |
drh | b136320 | 2002-06-26 02:45:03 +0000 | [diff] [blame] | 1110 | }else{ |
| 1111 | zCol = pTab->aCol[iCol].zName; |
drh | b136320 | 2002-06-26 02:45:03 +0000 | [diff] [blame] | 1112 | } |
drh | fcabd46 | 2004-02-20 14:50:58 +0000 | [diff] [blame] | 1113 | if( !shortNames && !fullNames && p->span.z && p->span.z[0] ){ |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 1114 | sqlite3VdbeSetColName(v, i, COLNAME_NAME, (char*)p->span.z, p->span.n); |
drh | fcabd46 | 2004-02-20 14:50:58 +0000 | [diff] [blame] | 1115 | }else if( fullNames || (!shortNames && pTabList->nSrc>1) ){ |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 1116 | char *zName = 0; |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 1117 | char *zTab; |
| 1118 | |
drh | 6a3ea0e | 2003-05-02 14:32:12 +0000 | [diff] [blame] | 1119 | zTab = pTabList->a[j].zAlias; |
drh | fcabd46 | 2004-02-20 14:50:58 +0000 | [diff] [blame] | 1120 | if( fullNames || zTab==0 ) zTab = pTab->zName; |
drh | f93339d | 2006-01-03 15:16:26 +0000 | [diff] [blame] | 1121 | sqlite3SetString(&zName, zTab, ".", zCol, (char*)0); |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 1122 | sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, P4_DYNAMIC); |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 1123 | }else{ |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 1124 | sqlite3VdbeSetColName(v, i, COLNAME_NAME, zCol, strlen(zCol)); |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 1125 | } |
drh | 6977fea | 2002-10-22 23:38:04 +0000 | [diff] [blame] | 1126 | }else if( p->span.z && p->span.z[0] ){ |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 1127 | sqlite3VdbeSetColName(v, i, COLNAME_NAME, (char*)p->span.z, p->span.n); |
danielk1977 | 3cf8606 | 2004-05-26 10:11:05 +0000 | [diff] [blame] | 1128 | /* sqlite3VdbeCompressSpace(v, addr); */ |
drh | 1bee3d7 | 2001-10-15 00:44:35 +0000 | [diff] [blame] | 1129 | }else{ |
| 1130 | char zName[30]; |
| 1131 | assert( p->op!=TK_COLUMN || pTabList==0 ); |
drh | 5bb3eb9 | 2007-05-04 13:15:55 +0000 | [diff] [blame] | 1132 | sqlite3_snprintf(sizeof(zName), zName, "column%d", i+1); |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 1133 | sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, 0); |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 1134 | } |
| 1135 | } |
danielk1977 | 76d505b | 2004-05-28 13:13:02 +0000 | [diff] [blame] | 1136 | generateColumnTypes(pParse, pTabList, pEList); |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 1137 | } |
| 1138 | |
danielk1977 | 93758c8 | 2005-01-21 08:13:14 +0000 | [diff] [blame] | 1139 | #ifndef SQLITE_OMIT_COMPOUND_SELECT |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 1140 | /* |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1141 | ** Name of the connection operator, used for error messages. |
| 1142 | */ |
| 1143 | static const char *selectOpName(int id){ |
| 1144 | char *z; |
| 1145 | switch( id ){ |
| 1146 | case TK_ALL: z = "UNION ALL"; break; |
| 1147 | case TK_INTERSECT: z = "INTERSECT"; break; |
| 1148 | case TK_EXCEPT: z = "EXCEPT"; break; |
| 1149 | default: z = "UNION"; break; |
| 1150 | } |
| 1151 | return z; |
| 1152 | } |
danielk1977 | 93758c8 | 2005-01-21 08:13:14 +0000 | [diff] [blame] | 1153 | #endif /* SQLITE_OMIT_COMPOUND_SELECT */ |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1154 | |
| 1155 | /* |
drh | 315555c | 2002-10-20 15:53:03 +0000 | [diff] [blame] | 1156 | ** Forward declaration |
| 1157 | */ |
drh | 9b3187e | 2005-01-18 14:45:47 +0000 | [diff] [blame] | 1158 | static int prepSelectStmt(Parse*, Select*); |
drh | 315555c | 2002-10-20 15:53:03 +0000 | [diff] [blame] | 1159 | |
| 1160 | /* |
drh | 22f70c3 | 2002-02-18 01:17:00 +0000 | [diff] [blame] | 1161 | ** Given a SELECT statement, generate a Table structure that describes |
| 1162 | ** the result set of that SELECT. |
| 1163 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 1164 | Table *sqlite3ResultSetOfSelect(Parse *pParse, char *zTabName, Select *pSelect){ |
drh | 22f70c3 | 2002-02-18 01:17:00 +0000 | [diff] [blame] | 1165 | Table *pTab; |
drh | b733d03 | 2004-01-24 20:18:12 +0000 | [diff] [blame] | 1166 | int i, j; |
drh | 22f70c3 | 2002-02-18 01:17:00 +0000 | [diff] [blame] | 1167 | ExprList *pEList; |
drh | 290c194 | 2004-08-21 17:54:45 +0000 | [diff] [blame] | 1168 | Column *aCol, *pCol; |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 1169 | sqlite3 *db = pParse->db; |
drh | 22f70c3 | 2002-02-18 01:17:00 +0000 | [diff] [blame] | 1170 | |
drh | 9237825 | 2006-03-26 01:21:22 +0000 | [diff] [blame] | 1171 | while( pSelect->pPrior ) pSelect = pSelect->pPrior; |
drh | 9b3187e | 2005-01-18 14:45:47 +0000 | [diff] [blame] | 1172 | if( prepSelectStmt(pParse, pSelect) ){ |
drh | 22f70c3 | 2002-02-18 01:17:00 +0000 | [diff] [blame] | 1173 | return 0; |
| 1174 | } |
danielk1977 | 142bdf4 | 2005-01-30 11:11:44 +0000 | [diff] [blame] | 1175 | if( sqlite3SelectResolve(pParse, pSelect, 0) ){ |
| 1176 | return 0; |
| 1177 | } |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 1178 | pTab = sqlite3DbMallocZero(db, sizeof(Table) ); |
drh | 22f70c3 | 2002-02-18 01:17:00 +0000 | [diff] [blame] | 1179 | if( pTab==0 ){ |
| 1180 | return 0; |
| 1181 | } |
drh | ed8a3bb | 2005-06-06 21:19:56 +0000 | [diff] [blame] | 1182 | pTab->nRef = 1; |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 1183 | pTab->zName = zTabName ? sqlite3DbStrDup(db, zTabName) : 0; |
drh | 22f70c3 | 2002-02-18 01:17:00 +0000 | [diff] [blame] | 1184 | pEList = pSelect->pEList; |
| 1185 | pTab->nCol = pEList->nExpr; |
drh | 417be79 | 2002-03-03 18:59:40 +0000 | [diff] [blame] | 1186 | assert( pTab->nCol>0 ); |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 1187 | pTab->aCol = aCol = sqlite3DbMallocZero(db, sizeof(pTab->aCol[0])*pTab->nCol); |
drh | 290c194 | 2004-08-21 17:54:45 +0000 | [diff] [blame] | 1188 | for(i=0, pCol=aCol; i<pTab->nCol; i++, pCol++){ |
drh | 79d5f63 | 2005-01-18 17:20:10 +0000 | [diff] [blame] | 1189 | Expr *p, *pR; |
danielk1977 | 517eb64 | 2004-06-07 10:00:31 +0000 | [diff] [blame] | 1190 | char *zType; |
drh | 91bb0ee | 2004-09-01 03:06:34 +0000 | [diff] [blame] | 1191 | char *zName; |
drh | 2564ef9 | 2006-09-29 14:01:04 +0000 | [diff] [blame] | 1192 | int nName; |
danielk1977 | b3bf556 | 2006-01-10 17:58:23 +0000 | [diff] [blame] | 1193 | CollSeq *pColl; |
drh | 79d5f63 | 2005-01-18 17:20:10 +0000 | [diff] [blame] | 1194 | int cnt; |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 1195 | NameContext sNC; |
drh | 79d5f63 | 2005-01-18 17:20:10 +0000 | [diff] [blame] | 1196 | |
| 1197 | /* Get an appropriate name for the column |
| 1198 | */ |
| 1199 | p = pEList->a[i].pExpr; |
drh | 290c194 | 2004-08-21 17:54:45 +0000 | [diff] [blame] | 1200 | assert( p->pRight==0 || p->pRight->token.z==0 || p->pRight->token.z[0]!=0 ); |
drh | 91bb0ee | 2004-09-01 03:06:34 +0000 | [diff] [blame] | 1201 | if( (zName = pEList->a[i].zName)!=0 ){ |
drh | 79d5f63 | 2005-01-18 17:20:10 +0000 | [diff] [blame] | 1202 | /* If the column contains an "AS <name>" phrase, use <name> as the name */ |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 1203 | zName = sqlite3DbStrDup(db, zName); |
danielk1977 | 517eb64 | 2004-06-07 10:00:31 +0000 | [diff] [blame] | 1204 | }else if( p->op==TK_DOT |
drh | 79d5f63 | 2005-01-18 17:20:10 +0000 | [diff] [blame] | 1205 | && (pR=p->pRight)!=0 && pR->token.z && pR->token.z[0] ){ |
| 1206 | /* For columns of the from A.B use B as the name */ |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 1207 | zName = sqlite3MPrintf(db, "%T", &pR->token); |
drh | b733d03 | 2004-01-24 20:18:12 +0000 | [diff] [blame] | 1208 | }else if( p->span.z && p->span.z[0] ){ |
drh | 79d5f63 | 2005-01-18 17:20:10 +0000 | [diff] [blame] | 1209 | /* Use the original text of the column expression as its name */ |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 1210 | zName = sqlite3MPrintf(db, "%T", &p->span); |
drh | 22f70c3 | 2002-02-18 01:17:00 +0000 | [diff] [blame] | 1211 | }else{ |
drh | 79d5f63 | 2005-01-18 17:20:10 +0000 | [diff] [blame] | 1212 | /* If all else fails, make up a name */ |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 1213 | zName = sqlite3MPrintf(db, "column%d", i+1); |
drh | 22f70c3 | 2002-02-18 01:17:00 +0000 | [diff] [blame] | 1214 | } |
danielk1977 | 7751940 | 2007-08-30 11:48:31 +0000 | [diff] [blame] | 1215 | if( !zName || db->mallocFailed ){ |
| 1216 | db->mallocFailed = 1; |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 1217 | sqlite3_free(zName); |
danielk1977 | a04a34f | 2007-04-16 15:06:25 +0000 | [diff] [blame] | 1218 | sqlite3DeleteTable(pTab); |
drh | dd5b2fa | 2005-03-28 03:39:55 +0000 | [diff] [blame] | 1219 | return 0; |
| 1220 | } |
danielk1977 | 7751940 | 2007-08-30 11:48:31 +0000 | [diff] [blame] | 1221 | sqlite3Dequote(zName); |
drh | 79d5f63 | 2005-01-18 17:20:10 +0000 | [diff] [blame] | 1222 | |
| 1223 | /* Make sure the column name is unique. If the name is not unique, |
| 1224 | ** append a integer to the name so that it becomes unique. |
| 1225 | */ |
drh | 2564ef9 | 2006-09-29 14:01:04 +0000 | [diff] [blame] | 1226 | nName = strlen(zName); |
drh | 79d5f63 | 2005-01-18 17:20:10 +0000 | [diff] [blame] | 1227 | for(j=cnt=0; j<i; j++){ |
| 1228 | if( sqlite3StrICmp(aCol[j].zName, zName)==0 ){ |
drh | 2564ef9 | 2006-09-29 14:01:04 +0000 | [diff] [blame] | 1229 | zName[nName] = 0; |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 1230 | zName = sqlite3MPrintf(db, "%z:%d", zName, ++cnt); |
drh | 79d5f63 | 2005-01-18 17:20:10 +0000 | [diff] [blame] | 1231 | j = -1; |
drh | dd5b2fa | 2005-03-28 03:39:55 +0000 | [diff] [blame] | 1232 | if( zName==0 ) break; |
drh | 79d5f63 | 2005-01-18 17:20:10 +0000 | [diff] [blame] | 1233 | } |
| 1234 | } |
drh | 91bb0ee | 2004-09-01 03:06:34 +0000 | [diff] [blame] | 1235 | pCol->zName = zName; |
danielk1977 | 517eb64 | 2004-06-07 10:00:31 +0000 | [diff] [blame] | 1236 | |
drh | 79d5f63 | 2005-01-18 17:20:10 +0000 | [diff] [blame] | 1237 | /* Get the typename, type affinity, and collating sequence for the |
| 1238 | ** column. |
| 1239 | */ |
drh | c43e8be | 2005-05-16 22:37:54 +0000 | [diff] [blame] | 1240 | memset(&sNC, 0, sizeof(sNC)); |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 1241 | sNC.pSrcList = pSelect->pSrc; |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 1242 | zType = sqlite3DbStrDup(db, columnType(&sNC, p, 0, 0, 0)); |
drh | 290c194 | 2004-08-21 17:54:45 +0000 | [diff] [blame] | 1243 | pCol->zType = zType; |
danielk1977 | c60e9b8 | 2005-01-31 12:42:29 +0000 | [diff] [blame] | 1244 | pCol->affinity = sqlite3ExprAffinity(p); |
danielk1977 | b3bf556 | 2006-01-10 17:58:23 +0000 | [diff] [blame] | 1245 | pColl = sqlite3ExprCollSeq(pParse, p); |
| 1246 | if( pColl ){ |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 1247 | pCol->zColl = sqlite3DbStrDup(db, pColl->zName); |
danielk1977 | 0202b29 | 2004-06-09 09:55:16 +0000 | [diff] [blame] | 1248 | } |
drh | 22f70c3 | 2002-02-18 01:17:00 +0000 | [diff] [blame] | 1249 | } |
| 1250 | pTab->iPKey = -1; |
| 1251 | return pTab; |
| 1252 | } |
| 1253 | |
| 1254 | /* |
drh | 9b3187e | 2005-01-18 14:45:47 +0000 | [diff] [blame] | 1255 | ** Prepare a SELECT statement for processing by doing the following |
| 1256 | ** things: |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1257 | ** |
drh | 9b3187e | 2005-01-18 14:45:47 +0000 | [diff] [blame] | 1258 | ** (1) Make sure VDBE cursor numbers have been assigned to every |
| 1259 | ** element of the FROM clause. |
| 1260 | ** |
| 1261 | ** (2) Fill in the pTabList->a[].pTab fields in the SrcList that |
| 1262 | ** defines FROM clause. When views appear in the FROM clause, |
drh | 63eb5f2 | 2003-04-29 16:20:44 +0000 | [diff] [blame] | 1263 | ** fill pTabList->a[].pSelect with a copy of the SELECT statement |
| 1264 | ** that implements the view. A copy is made of the view's SELECT |
| 1265 | ** statement so that we can freely modify or delete that statement |
| 1266 | ** without worrying about messing up the presistent representation |
| 1267 | ** of the view. |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1268 | ** |
drh | 9b3187e | 2005-01-18 14:45:47 +0000 | [diff] [blame] | 1269 | ** (3) Add terms to the WHERE clause to accomodate the NATURAL keyword |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 1270 | ** on joins and the ON and USING clause of joins. |
| 1271 | ** |
drh | 9b3187e | 2005-01-18 14:45:47 +0000 | [diff] [blame] | 1272 | ** (4) Scan the list of columns in the result set (pEList) looking |
drh | 5447322 | 2002-04-04 02:10:55 +0000 | [diff] [blame] | 1273 | ** for instances of the "*" operator or the TABLE.* operator. |
| 1274 | ** If found, expand each "*" to be every column in every table |
| 1275 | ** and TABLE.* to be every column in TABLE. |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1276 | ** |
| 1277 | ** Return 0 on success. If there are problems, leave an error message |
| 1278 | ** in pParse and return non-zero. |
| 1279 | */ |
drh | 9b3187e | 2005-01-18 14:45:47 +0000 | [diff] [blame] | 1280 | static int prepSelectStmt(Parse *pParse, Select *p){ |
drh | 5447322 | 2002-04-04 02:10:55 +0000 | [diff] [blame] | 1281 | int i, j, k, rc; |
drh | ad3cab5 | 2002-05-24 02:04:32 +0000 | [diff] [blame] | 1282 | SrcList *pTabList; |
drh | daffd0e | 2001-04-11 14:28:42 +0000 | [diff] [blame] | 1283 | ExprList *pEList; |
drh | 290c194 | 2004-08-21 17:54:45 +0000 | [diff] [blame] | 1284 | struct SrcList_item *pFrom; |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 1285 | sqlite3 *db = pParse->db; |
drh | daffd0e | 2001-04-11 14:28:42 +0000 | [diff] [blame] | 1286 | |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 1287 | if( p==0 || p->pSrc==0 || db->mallocFailed ){ |
drh | 6f7adc8 | 2006-01-11 21:41:20 +0000 | [diff] [blame] | 1288 | return 1; |
| 1289 | } |
drh | daffd0e | 2001-04-11 14:28:42 +0000 | [diff] [blame] | 1290 | pTabList = p->pSrc; |
| 1291 | pEList = p->pEList; |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1292 | |
drh | 9b3187e | 2005-01-18 14:45:47 +0000 | [diff] [blame] | 1293 | /* Make sure cursor numbers have been assigned to all entries in |
| 1294 | ** the FROM clause of the SELECT statement. |
| 1295 | */ |
| 1296 | sqlite3SrcListAssignCursors(pParse, p->pSrc); |
| 1297 | |
| 1298 | /* Look up every table named in the FROM clause of the select. If |
| 1299 | ** an entry of the FROM clause is a subquery instead of a table or view, |
| 1300 | ** then create a transient table structure to describe the subquery. |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1301 | */ |
drh | 290c194 | 2004-08-21 17:54:45 +0000 | [diff] [blame] | 1302 | for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){ |
danielk1977 | f011300 | 2006-01-24 12:09:17 +0000 | [diff] [blame] | 1303 | Table *pTab; |
drh | 9b3187e | 2005-01-18 14:45:47 +0000 | [diff] [blame] | 1304 | if( pFrom->pTab!=0 ){ |
| 1305 | /* This statement has already been prepared. There is no need |
| 1306 | ** to go further. */ |
| 1307 | assert( i==0 ); |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1308 | return 0; |
| 1309 | } |
drh | 290c194 | 2004-08-21 17:54:45 +0000 | [diff] [blame] | 1310 | if( pFrom->zName==0 ){ |
danielk1977 | 93758c8 | 2005-01-21 08:13:14 +0000 | [diff] [blame] | 1311 | #ifndef SQLITE_OMIT_SUBQUERY |
drh | 22f70c3 | 2002-02-18 01:17:00 +0000 | [diff] [blame] | 1312 | /* A sub-query in the FROM clause of a SELECT */ |
drh | 290c194 | 2004-08-21 17:54:45 +0000 | [diff] [blame] | 1313 | assert( pFrom->pSelect!=0 ); |
| 1314 | if( pFrom->zAlias==0 ){ |
drh | 91bb0ee | 2004-09-01 03:06:34 +0000 | [diff] [blame] | 1315 | pFrom->zAlias = |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 1316 | sqlite3MPrintf(db, "sqlite_subquery_%p_", (void*)pFrom->pSelect); |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 1317 | } |
drh | ed8a3bb | 2005-06-06 21:19:56 +0000 | [diff] [blame] | 1318 | assert( pFrom->pTab==0 ); |
drh | 290c194 | 2004-08-21 17:54:45 +0000 | [diff] [blame] | 1319 | pFrom->pTab = pTab = |
| 1320 | sqlite3ResultSetOfSelect(pParse, pFrom->zAlias, pFrom->pSelect); |
drh | 22f70c3 | 2002-02-18 01:17:00 +0000 | [diff] [blame] | 1321 | if( pTab==0 ){ |
| 1322 | return 1; |
| 1323 | } |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 1324 | /* The isEphem flag indicates that the Table structure has been |
drh | 5cf590c | 2003-04-24 01:45:04 +0000 | [diff] [blame] | 1325 | ** dynamically allocated and may be freed at any time. In other words, |
| 1326 | ** pTab is not pointing to a persistent table structure that defines |
| 1327 | ** part of the schema. */ |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 1328 | pTab->isEphem = 1; |
danielk1977 | 93758c8 | 2005-01-21 08:13:14 +0000 | [diff] [blame] | 1329 | #endif |
drh | 22f70c3 | 2002-02-18 01:17:00 +0000 | [diff] [blame] | 1330 | }else{ |
drh | a76b5df | 2002-02-23 02:32:10 +0000 | [diff] [blame] | 1331 | /* An ordinary table or view name in the FROM clause */ |
drh | ed8a3bb | 2005-06-06 21:19:56 +0000 | [diff] [blame] | 1332 | assert( pFrom->pTab==0 ); |
drh | 290c194 | 2004-08-21 17:54:45 +0000 | [diff] [blame] | 1333 | pFrom->pTab = pTab = |
drh | ca42411 | 2008-01-25 15:04:48 +0000 | [diff] [blame] | 1334 | sqlite3LocateTable(pParse,0,pFrom->zName,pFrom->zDatabase); |
drh | a76b5df | 2002-02-23 02:32:10 +0000 | [diff] [blame] | 1335 | if( pTab==0 ){ |
drh | 22f70c3 | 2002-02-18 01:17:00 +0000 | [diff] [blame] | 1336 | return 1; |
| 1337 | } |
drh | ed8a3bb | 2005-06-06 21:19:56 +0000 | [diff] [blame] | 1338 | pTab->nRef++; |
danielk1977 | 93626f4 | 2006-06-20 13:07:27 +0000 | [diff] [blame] | 1339 | #if !defined(SQLITE_OMIT_VIEW) || !defined (SQLITE_OMIT_VIRTUALTABLE) |
| 1340 | if( pTab->pSelect || IsVirtual(pTab) ){ |
drh | 63eb5f2 | 2003-04-29 16:20:44 +0000 | [diff] [blame] | 1341 | /* We reach here if the named table is a really a view */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 1342 | if( sqlite3ViewGetColumnNames(pParse, pTab) ){ |
drh | 417be79 | 2002-03-03 18:59:40 +0000 | [diff] [blame] | 1343 | return 1; |
| 1344 | } |
drh | 290c194 | 2004-08-21 17:54:45 +0000 | [diff] [blame] | 1345 | /* If pFrom->pSelect!=0 it means we are dealing with a |
drh | 63eb5f2 | 2003-04-29 16:20:44 +0000 | [diff] [blame] | 1346 | ** view within a view. The SELECT structure has already been |
| 1347 | ** copied by the outer view so we can skip the copy step here |
| 1348 | ** in the inner view. |
| 1349 | */ |
drh | 290c194 | 2004-08-21 17:54:45 +0000 | [diff] [blame] | 1350 | if( pFrom->pSelect==0 ){ |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 1351 | pFrom->pSelect = sqlite3SelectDup(db, pTab->pSelect); |
drh | 63eb5f2 | 2003-04-29 16:20:44 +0000 | [diff] [blame] | 1352 | } |
drh | a76b5df | 2002-02-23 02:32:10 +0000 | [diff] [blame] | 1353 | } |
danielk1977 | 93758c8 | 2005-01-21 08:13:14 +0000 | [diff] [blame] | 1354 | #endif |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1355 | } |
| 1356 | } |
| 1357 | |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 1358 | /* Process NATURAL keywords, and ON and USING clauses of joins. |
| 1359 | */ |
| 1360 | if( sqliteProcessJoin(pParse, p) ) return 1; |
| 1361 | |
drh | 7c917d1 | 2001-12-16 20:05:05 +0000 | [diff] [blame] | 1362 | /* For every "*" that occurs in the column list, insert the names of |
drh | 5447322 | 2002-04-04 02:10:55 +0000 | [diff] [blame] | 1363 | ** all columns in all tables. And for every TABLE.* insert the names |
| 1364 | ** of all columns in TABLE. The parser inserted a special expression |
drh | 7c917d1 | 2001-12-16 20:05:05 +0000 | [diff] [blame] | 1365 | ** with the TK_ALL operator for each "*" that it found in the column list. |
| 1366 | ** The following code just has to locate the TK_ALL expressions and expand |
| 1367 | ** each one to the list of all columns in all tables. |
drh | 5447322 | 2002-04-04 02:10:55 +0000 | [diff] [blame] | 1368 | ** |
| 1369 | ** The first loop just checks to see if there are any "*" operators |
| 1370 | ** that need expanding. |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1371 | */ |
drh | 7c917d1 | 2001-12-16 20:05:05 +0000 | [diff] [blame] | 1372 | for(k=0; k<pEList->nExpr; k++){ |
drh | 5447322 | 2002-04-04 02:10:55 +0000 | [diff] [blame] | 1373 | Expr *pE = pEList->a[k].pExpr; |
| 1374 | if( pE->op==TK_ALL ) break; |
| 1375 | if( pE->op==TK_DOT && pE->pRight && pE->pRight->op==TK_ALL |
| 1376 | && pE->pLeft && pE->pLeft->op==TK_ID ) break; |
drh | 7c917d1 | 2001-12-16 20:05:05 +0000 | [diff] [blame] | 1377 | } |
drh | 5447322 | 2002-04-04 02:10:55 +0000 | [diff] [blame] | 1378 | rc = 0; |
drh | 7c917d1 | 2001-12-16 20:05:05 +0000 | [diff] [blame] | 1379 | if( k<pEList->nExpr ){ |
drh | 5447322 | 2002-04-04 02:10:55 +0000 | [diff] [blame] | 1380 | /* |
| 1381 | ** If we get here it means the result set contains one or more "*" |
| 1382 | ** operators that need to be expanded. Loop through each expression |
| 1383 | ** in the result set and expand them one by one. |
| 1384 | */ |
drh | 7c917d1 | 2001-12-16 20:05:05 +0000 | [diff] [blame] | 1385 | struct ExprList_item *a = pEList->a; |
| 1386 | ExprList *pNew = 0; |
drh | d70dc52 | 2005-06-06 16:34:33 +0000 | [diff] [blame] | 1387 | int flags = pParse->db->flags; |
| 1388 | int longNames = (flags & SQLITE_FullColNames)!=0 && |
| 1389 | (flags & SQLITE_ShortColNames)==0; |
| 1390 | |
drh | 7c917d1 | 2001-12-16 20:05:05 +0000 | [diff] [blame] | 1391 | for(k=0; k<pEList->nExpr; k++){ |
drh | 5447322 | 2002-04-04 02:10:55 +0000 | [diff] [blame] | 1392 | Expr *pE = a[k].pExpr; |
| 1393 | if( pE->op!=TK_ALL && |
| 1394 | (pE->op!=TK_DOT || pE->pRight==0 || pE->pRight->op!=TK_ALL) ){ |
| 1395 | /* This particular expression does not need to be expanded. |
| 1396 | */ |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 1397 | pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr, 0); |
danielk1977 | 261919c | 2005-12-06 12:52:59 +0000 | [diff] [blame] | 1398 | if( pNew ){ |
| 1399 | pNew->a[pNew->nExpr-1].zName = a[k].zName; |
| 1400 | }else{ |
| 1401 | rc = 1; |
| 1402 | } |
drh | 7c917d1 | 2001-12-16 20:05:05 +0000 | [diff] [blame] | 1403 | a[k].pExpr = 0; |
| 1404 | a[k].zName = 0; |
| 1405 | }else{ |
drh | 5447322 | 2002-04-04 02:10:55 +0000 | [diff] [blame] | 1406 | /* This expression is a "*" or a "TABLE.*" and needs to be |
| 1407 | ** expanded. */ |
| 1408 | int tableSeen = 0; /* Set to 1 when TABLE matches */ |
drh | cf55b7a | 2004-07-20 01:45:19 +0000 | [diff] [blame] | 1409 | char *zTName; /* text of name of TABLE */ |
drh | 5447322 | 2002-04-04 02:10:55 +0000 | [diff] [blame] | 1410 | if( pE->op==TK_DOT && pE->pLeft ){ |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 1411 | zTName = sqlite3NameFromToken(db, &pE->pLeft->token); |
drh | 5447322 | 2002-04-04 02:10:55 +0000 | [diff] [blame] | 1412 | }else{ |
drh | cf55b7a | 2004-07-20 01:45:19 +0000 | [diff] [blame] | 1413 | zTName = 0; |
drh | 5447322 | 2002-04-04 02:10:55 +0000 | [diff] [blame] | 1414 | } |
drh | 290c194 | 2004-08-21 17:54:45 +0000 | [diff] [blame] | 1415 | for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){ |
| 1416 | Table *pTab = pFrom->pTab; |
| 1417 | char *zTabName = pFrom->zAlias; |
drh | 5447322 | 2002-04-04 02:10:55 +0000 | [diff] [blame] | 1418 | if( zTabName==0 || zTabName[0]==0 ){ |
| 1419 | zTabName = pTab->zName; |
| 1420 | } |
drh | cf55b7a | 2004-07-20 01:45:19 +0000 | [diff] [blame] | 1421 | if( zTName && (zTabName==0 || zTabName[0]==0 || |
| 1422 | sqlite3StrICmp(zTName, zTabName)!=0) ){ |
drh | 5447322 | 2002-04-04 02:10:55 +0000 | [diff] [blame] | 1423 | continue; |
| 1424 | } |
| 1425 | tableSeen = 1; |
drh | 7c917d1 | 2001-12-16 20:05:05 +0000 | [diff] [blame] | 1426 | for(j=0; j<pTab->nCol; j++){ |
danielk1977 | f011300 | 2006-01-24 12:09:17 +0000 | [diff] [blame] | 1427 | Expr *pExpr, *pRight; |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 1428 | char *zName = pTab->aCol[j].zName; |
| 1429 | |
danielk1977 | 034ca14 | 2007-06-26 10:38:54 +0000 | [diff] [blame] | 1430 | /* If a column is marked as 'hidden' (currently only possible |
| 1431 | ** for virtual tables), do not include it in the expanded |
| 1432 | ** result-set list. |
| 1433 | */ |
| 1434 | if( IsHiddenColumn(&pTab->aCol[j]) ){ |
| 1435 | assert(IsVirtual(pTab)); |
| 1436 | continue; |
| 1437 | } |
| 1438 | |
drh | 91bb0ee | 2004-09-01 03:06:34 +0000 | [diff] [blame] | 1439 | if( i>0 ){ |
| 1440 | struct SrcList_item *pLeft = &pTabList->a[i-1]; |
drh | 61dfc31 | 2006-12-16 16:25:15 +0000 | [diff] [blame] | 1441 | if( (pLeft[1].jointype & JT_NATURAL)!=0 && |
drh | 91bb0ee | 2004-09-01 03:06:34 +0000 | [diff] [blame] | 1442 | columnIndex(pLeft->pTab, zName)>=0 ){ |
| 1443 | /* In a NATURAL join, omit the join columns from the |
| 1444 | ** table on the right */ |
| 1445 | continue; |
| 1446 | } |
drh | 61dfc31 | 2006-12-16 16:25:15 +0000 | [diff] [blame] | 1447 | if( sqlite3IdListIndex(pLeft[1].pUsing, zName)>=0 ){ |
drh | 91bb0ee | 2004-09-01 03:06:34 +0000 | [diff] [blame] | 1448 | /* In a join with a USING clause, omit columns in the |
| 1449 | ** using clause from the table on the right. */ |
| 1450 | continue; |
| 1451 | } |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 1452 | } |
danielk1977 | a1644fd | 2007-08-29 12:31:25 +0000 | [diff] [blame] | 1453 | pRight = sqlite3PExpr(pParse, TK_ID, 0, 0, 0); |
drh | 22f70c3 | 2002-02-18 01:17:00 +0000 | [diff] [blame] | 1454 | if( pRight==0 ) break; |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 1455 | setQuotedToken(pParse, &pRight->token, zName); |
drh | d70dc52 | 2005-06-06 16:34:33 +0000 | [diff] [blame] | 1456 | if( zTabName && (longNames || pTabList->nSrc>1) ){ |
danielk1977 | a1644fd | 2007-08-29 12:31:25 +0000 | [diff] [blame] | 1457 | Expr *pLeft = sqlite3PExpr(pParse, TK_ID, 0, 0, 0); |
| 1458 | pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight, 0); |
drh | 22f70c3 | 2002-02-18 01:17:00 +0000 | [diff] [blame] | 1459 | if( pExpr==0 ) break; |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 1460 | setQuotedToken(pParse, &pLeft->token, zTabName); |
| 1461 | setToken(&pExpr->span, |
| 1462 | sqlite3MPrintf(db, "%s.%s", zTabName, zName)); |
drh | 6977fea | 2002-10-22 23:38:04 +0000 | [diff] [blame] | 1463 | pExpr->span.dyn = 1; |
| 1464 | pExpr->token.z = 0; |
| 1465 | pExpr->token.n = 0; |
| 1466 | pExpr->token.dyn = 0; |
drh | 7c917d1 | 2001-12-16 20:05:05 +0000 | [diff] [blame] | 1467 | }else{ |
drh | 22f70c3 | 2002-02-18 01:17:00 +0000 | [diff] [blame] | 1468 | pExpr = pRight; |
drh | 6977fea | 2002-10-22 23:38:04 +0000 | [diff] [blame] | 1469 | pExpr->span = pExpr->token; |
danielk1977 | f3b863e | 2007-06-24 06:32:17 +0000 | [diff] [blame] | 1470 | pExpr->span.dyn = 0; |
drh | 7c917d1 | 2001-12-16 20:05:05 +0000 | [diff] [blame] | 1471 | } |
drh | d70dc52 | 2005-06-06 16:34:33 +0000 | [diff] [blame] | 1472 | if( longNames ){ |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 1473 | pNew = sqlite3ExprListAppend(pParse, pNew, pExpr, &pExpr->span); |
drh | d70dc52 | 2005-06-06 16:34:33 +0000 | [diff] [blame] | 1474 | }else{ |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 1475 | pNew = sqlite3ExprListAppend(pParse, pNew, pExpr, &pRight->token); |
drh | d70dc52 | 2005-06-06 16:34:33 +0000 | [diff] [blame] | 1476 | } |
drh | 7c917d1 | 2001-12-16 20:05:05 +0000 | [diff] [blame] | 1477 | } |
drh | 17e24df | 2001-11-06 14:10:41 +0000 | [diff] [blame] | 1478 | } |
drh | 5447322 | 2002-04-04 02:10:55 +0000 | [diff] [blame] | 1479 | if( !tableSeen ){ |
drh | cf55b7a | 2004-07-20 01:45:19 +0000 | [diff] [blame] | 1480 | if( zTName ){ |
| 1481 | sqlite3ErrorMsg(pParse, "no such table: %s", zTName); |
drh | f5db2d3 | 2002-06-06 23:42:27 +0000 | [diff] [blame] | 1482 | }else{ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 1483 | sqlite3ErrorMsg(pParse, "no tables specified"); |
drh | f5db2d3 | 2002-06-06 23:42:27 +0000 | [diff] [blame] | 1484 | } |
drh | 5447322 | 2002-04-04 02:10:55 +0000 | [diff] [blame] | 1485 | rc = 1; |
| 1486 | } |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 1487 | sqlite3_free(zTName); |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1488 | } |
| 1489 | } |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 1490 | sqlite3ExprListDelete(pEList); |
drh | 7c917d1 | 2001-12-16 20:05:05 +0000 | [diff] [blame] | 1491 | p->pEList = pNew; |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1492 | } |
drh | bb4957f | 2008-03-20 14:03:29 +0000 | [diff] [blame] | 1493 | #if SQLITE_MAX_COLUMN |
| 1494 | if( p->pEList && p->pEList->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){ |
drh | e5c941b | 2007-05-08 13:58:26 +0000 | [diff] [blame] | 1495 | sqlite3ErrorMsg(pParse, "too many columns in result set"); |
| 1496 | rc = SQLITE_ERROR; |
| 1497 | } |
drh | bb4957f | 2008-03-20 14:03:29 +0000 | [diff] [blame] | 1498 | #endif |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 1499 | if( db->mallocFailed ){ |
danielk1977 | f3b863e | 2007-06-24 06:32:17 +0000 | [diff] [blame] | 1500 | rc = SQLITE_NOMEM; |
| 1501 | } |
drh | 5447322 | 2002-04-04 02:10:55 +0000 | [diff] [blame] | 1502 | return rc; |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1503 | } |
| 1504 | |
drh | ff78bd2 | 2002-02-27 01:47:11 +0000 | [diff] [blame] | 1505 | /* |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 1506 | ** pE is a pointer to an expression which is a single term in |
| 1507 | ** ORDER BY or GROUP BY clause. |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1508 | ** |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 1509 | ** At the point this routine is called, we already know that the |
| 1510 | ** ORDER BY term is not an integer index into the result set. That |
| 1511 | ** casee is handled by the calling routine. |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 1512 | ** |
| 1513 | ** If pE is a well-formed expression and the SELECT statement |
| 1514 | ** is not compound, then return 0. This indicates to the |
| 1515 | ** caller that it should sort by the value of the ORDER BY |
| 1516 | ** expression. |
| 1517 | ** |
| 1518 | ** If the SELECT is compound, then attempt to match pE against |
| 1519 | ** result set columns in the left-most SELECT statement. Return |
| 1520 | ** the index i of the matching column, as an indication to the |
| 1521 | ** caller that it should sort by the i-th column. If there is |
| 1522 | ** no match, return -1 and leave an error message in pParse. |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1523 | */ |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 1524 | static int matchOrderByTermToExprList( |
| 1525 | Parse *pParse, /* Parsing context for error messages */ |
| 1526 | Select *pSelect, /* The SELECT statement with the ORDER BY clause */ |
| 1527 | Expr *pE, /* The specific ORDER BY term */ |
| 1528 | int idx, /* When ORDER BY term is this */ |
| 1529 | int isCompound, /* True if this is a compound SELECT */ |
| 1530 | u8 *pHasAgg /* True if expression contains aggregate functions */ |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1531 | ){ |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 1532 | int i; /* Loop counter */ |
| 1533 | ExprList *pEList; /* The columns of the result set */ |
| 1534 | NameContext nc; /* Name context for resolving pE */ |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1535 | |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 1536 | assert( sqlite3ExprIsInteger(pE, &i)==0 ); |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 1537 | pEList = pSelect->pEList; |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 1538 | |
| 1539 | /* If the term is a simple identifier that try to match that identifier |
| 1540 | ** against a column name in the result set. |
| 1541 | */ |
| 1542 | if( pE->op==TK_ID || (pE->op==TK_STRING && pE->token.z[0]!='\'') ){ |
| 1543 | sqlite3 *db = pParse->db; |
| 1544 | char *zCol = sqlite3NameFromToken(db, &pE->token); |
drh | ef0bea9 | 2007-12-14 16:11:09 +0000 | [diff] [blame] | 1545 | if( zCol==0 ){ |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 1546 | return -1; |
| 1547 | } |
| 1548 | for(i=0; i<pEList->nExpr; i++){ |
| 1549 | char *zAs = pEList->a[i].zName; |
| 1550 | if( zAs!=0 && sqlite3StrICmp(zAs, zCol)==0 ){ |
| 1551 | sqlite3_free(zCol); |
| 1552 | return i+1; |
| 1553 | } |
| 1554 | } |
| 1555 | sqlite3_free(zCol); |
| 1556 | } |
| 1557 | |
| 1558 | /* Resolve all names in the ORDER BY term expression |
| 1559 | */ |
| 1560 | memset(&nc, 0, sizeof(nc)); |
| 1561 | nc.pParse = pParse; |
| 1562 | nc.pSrcList = pSelect->pSrc; |
| 1563 | nc.pEList = pEList; |
| 1564 | nc.allowAgg = 1; |
| 1565 | nc.nErr = 0; |
| 1566 | if( sqlite3ExprResolveNames(&nc, pE) ){ |
drh | 1e28129 | 2007-12-13 03:45:07 +0000 | [diff] [blame] | 1567 | if( isCompound ){ |
| 1568 | sqlite3ErrorClear(pParse); |
| 1569 | return 0; |
| 1570 | }else{ |
| 1571 | return -1; |
| 1572 | } |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 1573 | } |
| 1574 | if( nc.hasAgg && pHasAgg ){ |
| 1575 | *pHasAgg = 1; |
| 1576 | } |
| 1577 | |
| 1578 | /* For a compound SELECT, we need to try to match the ORDER BY |
| 1579 | ** expression against an expression in the result set |
| 1580 | */ |
| 1581 | if( isCompound ){ |
| 1582 | for(i=0; i<pEList->nExpr; i++){ |
| 1583 | if( sqlite3ExprCompare(pEList->a[i].pExpr, pE) ){ |
| 1584 | return i+1; |
| 1585 | } |
| 1586 | } |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 1587 | } |
drh | 1e28129 | 2007-12-13 03:45:07 +0000 | [diff] [blame] | 1588 | return 0; |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 1589 | } |
| 1590 | |
| 1591 | |
| 1592 | /* |
| 1593 | ** Analyze and ORDER BY or GROUP BY clause in a simple SELECT statement. |
| 1594 | ** Return the number of errors seen. |
| 1595 | ** |
| 1596 | ** Every term of the ORDER BY or GROUP BY clause needs to be an |
| 1597 | ** expression. If any expression is an integer constant, then |
| 1598 | ** that expression is replaced by the corresponding |
| 1599 | ** expression from the result set. |
| 1600 | */ |
| 1601 | static int processOrderGroupBy( |
| 1602 | Parse *pParse, /* Parsing context. Leave error messages here */ |
| 1603 | Select *pSelect, /* The SELECT statement containing the clause */ |
| 1604 | ExprList *pOrderBy, /* The ORDER BY or GROUP BY clause to be processed */ |
| 1605 | int isOrder, /* 1 for ORDER BY. 0 for GROUP BY */ |
| 1606 | u8 *pHasAgg /* Set to TRUE if any term contains an aggregate */ |
| 1607 | ){ |
| 1608 | int i; |
| 1609 | sqlite3 *db = pParse->db; |
| 1610 | ExprList *pEList; |
| 1611 | |
danielk1977 | 15cdbeb | 2008-01-23 15:44:51 +0000 | [diff] [blame] | 1612 | if( pOrderBy==0 || pParse->db->mallocFailed ) return 0; |
drh | bb4957f | 2008-03-20 14:03:29 +0000 | [diff] [blame] | 1613 | #if SQLITE_MAX_COLUMN |
| 1614 | if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){ |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 1615 | const char *zType = isOrder ? "ORDER" : "GROUP"; |
| 1616 | sqlite3ErrorMsg(pParse, "too many terms in %s BY clause", zType); |
drh | 4c77431 | 2007-12-08 21:10:20 +0000 | [diff] [blame] | 1617 | return 1; |
| 1618 | } |
drh | bb4957f | 2008-03-20 14:03:29 +0000 | [diff] [blame] | 1619 | #endif |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 1620 | pEList = pSelect->pEList; |
| 1621 | if( pEList==0 ){ |
| 1622 | return 0; |
| 1623 | } |
| 1624 | for(i=0; i<pOrderBy->nExpr; i++){ |
| 1625 | int iCol; |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1626 | Expr *pE = pOrderBy->a[i].pExpr; |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 1627 | if( sqlite3ExprIsInteger(pE, &iCol) ){ |
| 1628 | if( iCol<=0 || iCol>pEList->nExpr ){ |
| 1629 | const char *zType = isOrder ? "ORDER" : "GROUP"; |
| 1630 | sqlite3ErrorMsg(pParse, |
| 1631 | "%r %s BY term out of range - should be " |
| 1632 | "between 1 and %d", i+1, zType, pEList->nExpr); |
| 1633 | return 1; |
| 1634 | } |
| 1635 | }else{ |
| 1636 | iCol = matchOrderByTermToExprList(pParse, pSelect, pE, i+1, 0, pHasAgg); |
| 1637 | if( iCol<0 ){ |
| 1638 | return 1; |
| 1639 | } |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 1640 | } |
| 1641 | if( iCol>0 ){ |
| 1642 | CollSeq *pColl = pE->pColl; |
| 1643 | int flags = pE->flags & EP_ExpCollate; |
| 1644 | sqlite3ExprDelete(pE); |
| 1645 | pE = sqlite3ExprDup(db, pEList->a[iCol-1].pExpr); |
| 1646 | pOrderBy->a[i].pExpr = pE; |
danielk1977 | 15cdbeb | 2008-01-23 15:44:51 +0000 | [diff] [blame] | 1647 | if( pE && pColl && flags ){ |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 1648 | pE->pColl = pColl; |
| 1649 | pE->flags |= flags; |
| 1650 | } |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1651 | } |
| 1652 | } |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 1653 | return 0; |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1654 | } |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 1655 | |
| 1656 | /* |
| 1657 | ** Analyze and ORDER BY or GROUP BY clause in a SELECT statement. Return |
| 1658 | ** the number of errors seen. |
| 1659 | ** |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 1660 | ** If iTable>0 then make the N-th term of the ORDER BY clause refer to |
| 1661 | ** the N-th column of table iTable. |
| 1662 | ** |
| 1663 | ** If iTable==0 then transform each term of the ORDER BY clause to refer |
| 1664 | ** to a column of the result set by number. |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 1665 | */ |
| 1666 | static int processCompoundOrderBy( |
| 1667 | Parse *pParse, /* Parsing context. Leave error messages here */ |
| 1668 | Select *pSelect, /* The SELECT statement containing the ORDER BY */ |
| 1669 | int iTable /* Output table for compound SELECT statements */ |
| 1670 | ){ |
| 1671 | int i; |
| 1672 | ExprList *pOrderBy; |
| 1673 | ExprList *pEList; |
drh | 1e28129 | 2007-12-13 03:45:07 +0000 | [diff] [blame] | 1674 | sqlite3 *db; |
| 1675 | int moreToDo = 1; |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 1676 | |
| 1677 | pOrderBy = pSelect->pOrderBy; |
| 1678 | if( pOrderBy==0 ) return 0; |
drh | bb4957f | 2008-03-20 14:03:29 +0000 | [diff] [blame] | 1679 | db = pParse->db; |
| 1680 | #if SQLITE_MAX_COLUMN |
| 1681 | if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){ |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 1682 | sqlite3ErrorMsg(pParse, "too many terms in ORDER BY clause"); |
| 1683 | return 1; |
| 1684 | } |
drh | bb4957f | 2008-03-20 14:03:29 +0000 | [diff] [blame] | 1685 | #endif |
drh | 1e28129 | 2007-12-13 03:45:07 +0000 | [diff] [blame] | 1686 | for(i=0; i<pOrderBy->nExpr; i++){ |
| 1687 | pOrderBy->a[i].done = 0; |
| 1688 | } |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 1689 | while( pSelect->pPrior ){ |
| 1690 | pSelect = pSelect->pPrior; |
| 1691 | } |
drh | 1e28129 | 2007-12-13 03:45:07 +0000 | [diff] [blame] | 1692 | while( pSelect && moreToDo ){ |
| 1693 | moreToDo = 0; |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 1694 | pEList = pSelect->pEList; |
| 1695 | if( pEList==0 ){ |
| 1696 | return 1; |
| 1697 | } |
drh | 1e28129 | 2007-12-13 03:45:07 +0000 | [diff] [blame] | 1698 | for(i=0; i<pOrderBy->nExpr; i++){ |
danielk1977 | ac55926 | 2008-01-23 17:13:40 +0000 | [diff] [blame] | 1699 | int iCol = -1; |
drh | 8f0ecaa | 2007-12-14 17:24:39 +0000 | [diff] [blame] | 1700 | Expr *pE, *pDup; |
drh | 1e28129 | 2007-12-13 03:45:07 +0000 | [diff] [blame] | 1701 | if( pOrderBy->a[i].done ) continue; |
| 1702 | pE = pOrderBy->a[i].pExpr; |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 1703 | if( sqlite3ExprIsInteger(pE, &iCol) ){ |
| 1704 | if( iCol<0 || iCol>pEList->nExpr ){ |
| 1705 | sqlite3ErrorMsg(pParse, |
| 1706 | "%r ORDER BY term out of range - should be " |
| 1707 | "between 1 and %d", i+1, pEList->nExpr); |
| 1708 | return 1; |
| 1709 | } |
| 1710 | }else{ |
| 1711 | pDup = sqlite3ExprDup(db, pE); |
| 1712 | if( !db->mallocFailed ){ |
| 1713 | assert(pDup); |
| 1714 | iCol = matchOrderByTermToExprList(pParse, pSelect, pDup, i+1, 1, 0); |
| 1715 | } |
| 1716 | sqlite3ExprDelete(pDup); |
| 1717 | if( iCol<0 ){ |
| 1718 | return 1; |
| 1719 | } |
drh | 1e28129 | 2007-12-13 03:45:07 +0000 | [diff] [blame] | 1720 | } |
| 1721 | if( iCol>0 ){ |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 1722 | if( iTable ){ |
| 1723 | pE->op = TK_COLUMN; |
| 1724 | pE->iTable = iTable; |
| 1725 | pE->iAgg = -1; |
| 1726 | pE->iColumn = iCol-1; |
| 1727 | pE->pTab = 0; |
| 1728 | }else{ |
| 1729 | pE->op = TK_INTEGER; |
| 1730 | pE->flags |= EP_IntValue; |
| 1731 | pE->iTable = iCol; |
| 1732 | } |
drh | 1e28129 | 2007-12-13 03:45:07 +0000 | [diff] [blame] | 1733 | pOrderBy->a[i].done = 1; |
| 1734 | }else{ |
| 1735 | moreToDo = 1; |
| 1736 | } |
| 1737 | } |
| 1738 | pSelect = pSelect->pNext; |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 1739 | } |
| 1740 | for(i=0; i<pOrderBy->nExpr; i++){ |
drh | 1e28129 | 2007-12-13 03:45:07 +0000 | [diff] [blame] | 1741 | if( pOrderBy->a[i].done==0 ){ |
| 1742 | sqlite3ErrorMsg(pParse, "%r ORDER BY term does not match any " |
| 1743 | "column in the result set", i+1); |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 1744 | return 1; |
| 1745 | } |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 1746 | } |
| 1747 | return 0; |
| 1748 | } |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1749 | |
| 1750 | /* |
| 1751 | ** Get a VDBE for the given parser context. Create a new one if necessary. |
| 1752 | ** If an error occurs, return NULL and leave a message in pParse. |
| 1753 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 1754 | Vdbe *sqlite3GetVdbe(Parse *pParse){ |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1755 | Vdbe *v = pParse->pVdbe; |
| 1756 | if( v==0 ){ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 1757 | v = pParse->pVdbe = sqlite3VdbeCreate(pParse->db); |
drh | 949f9cd | 2008-01-12 21:35:57 +0000 | [diff] [blame] | 1758 | #ifndef SQLITE_OMIT_TRACE |
| 1759 | if( v ){ |
| 1760 | sqlite3VdbeAddOp0(v, OP_Trace); |
| 1761 | } |
| 1762 | #endif |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1763 | } |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1764 | return v; |
| 1765 | } |
drh | fcb78a4 | 2003-01-18 20:11:05 +0000 | [diff] [blame] | 1766 | |
drh | 15007a9 | 2006-01-08 18:10:17 +0000 | [diff] [blame] | 1767 | |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1768 | /* |
drh | 7b58dae | 2003-07-20 01:16:46 +0000 | [diff] [blame] | 1769 | ** Compute the iLimit and iOffset fields of the SELECT based on the |
drh | ec7429a | 2005-10-06 16:53:14 +0000 | [diff] [blame] | 1770 | ** pLimit and pOffset expressions. pLimit and pOffset hold the expressions |
drh | 7b58dae | 2003-07-20 01:16:46 +0000 | [diff] [blame] | 1771 | ** that appear in the original SQL statement after the LIMIT and OFFSET |
danielk1977 | a2dc3b1 | 2005-02-05 12:48:48 +0000 | [diff] [blame] | 1772 | ** keywords. Or NULL if those keywords are omitted. iLimit and iOffset |
| 1773 | ** are the integer memory register numbers for counters used to compute |
| 1774 | ** the limit and offset. If there is no limit and/or offset, then |
| 1775 | ** iLimit and iOffset are negative. |
drh | 7b58dae | 2003-07-20 01:16:46 +0000 | [diff] [blame] | 1776 | ** |
drh | d59ba6c | 2006-01-08 05:02:54 +0000 | [diff] [blame] | 1777 | ** This routine changes the values of iLimit and iOffset only if |
drh | ec7429a | 2005-10-06 16:53:14 +0000 | [diff] [blame] | 1778 | ** a limit or offset is defined by pLimit and pOffset. iLimit and |
drh | 7b58dae | 2003-07-20 01:16:46 +0000 | [diff] [blame] | 1779 | ** iOffset should have been preset to appropriate default values |
| 1780 | ** (usually but not always -1) prior to calling this routine. |
drh | ec7429a | 2005-10-06 16:53:14 +0000 | [diff] [blame] | 1781 | ** Only if pLimit!=0 or pOffset!=0 do the limit registers get |
drh | 7b58dae | 2003-07-20 01:16:46 +0000 | [diff] [blame] | 1782 | ** redefined. The UNION ALL operator uses this property to force |
| 1783 | ** the reuse of the same limit and offset registers across multiple |
| 1784 | ** SELECT statements. |
| 1785 | */ |
drh | ec7429a | 2005-10-06 16:53:14 +0000 | [diff] [blame] | 1786 | static void computeLimitRegisters(Parse *pParse, Select *p, int iBreak){ |
drh | 02afc86 | 2006-01-20 18:10:57 +0000 | [diff] [blame] | 1787 | Vdbe *v = 0; |
| 1788 | int iLimit = 0; |
drh | 15007a9 | 2006-01-08 18:10:17 +0000 | [diff] [blame] | 1789 | int iOffset; |
drh | b765411 | 2008-01-12 12:48:07 +0000 | [diff] [blame] | 1790 | int addr1; |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 1791 | if( p->iLimit ) return; |
drh | 15007a9 | 2006-01-08 18:10:17 +0000 | [diff] [blame] | 1792 | |
drh | 7b58dae | 2003-07-20 01:16:46 +0000 | [diff] [blame] | 1793 | /* |
drh | 7b58dae | 2003-07-20 01:16:46 +0000 | [diff] [blame] | 1794 | ** "LIMIT -1" always shows all rows. There is some |
| 1795 | ** contraversy about what the correct behavior should be. |
| 1796 | ** The current implementation interprets "LIMIT 0" to mean |
| 1797 | ** no rows. |
| 1798 | */ |
danielk1977 | a2dc3b1 | 2005-02-05 12:48:48 +0000 | [diff] [blame] | 1799 | if( p->pLimit ){ |
drh | 0a07c10 | 2008-01-03 18:03:08 +0000 | [diff] [blame] | 1800 | p->iLimit = iLimit = ++pParse->nMem; |
drh | 15007a9 | 2006-01-08 18:10:17 +0000 | [diff] [blame] | 1801 | v = sqlite3GetVdbe(pParse); |
drh | 7b58dae | 2003-07-20 01:16:46 +0000 | [diff] [blame] | 1802 | if( v==0 ) return; |
drh | b765411 | 2008-01-12 12:48:07 +0000 | [diff] [blame] | 1803 | sqlite3ExprCode(pParse, p->pLimit, iLimit); |
| 1804 | sqlite3VdbeAddOp1(v, OP_MustBeInt, iLimit); |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 1805 | VdbeComment((v, "LIMIT counter")); |
drh | 3c84ddf | 2008-01-09 02:15:38 +0000 | [diff] [blame] | 1806 | sqlite3VdbeAddOp2(v, OP_IfZero, iLimit, iBreak); |
drh | 7b58dae | 2003-07-20 01:16:46 +0000 | [diff] [blame] | 1807 | } |
danielk1977 | a2dc3b1 | 2005-02-05 12:48:48 +0000 | [diff] [blame] | 1808 | if( p->pOffset ){ |
drh | 0a07c10 | 2008-01-03 18:03:08 +0000 | [diff] [blame] | 1809 | p->iOffset = iOffset = ++pParse->nMem; |
drh | b765411 | 2008-01-12 12:48:07 +0000 | [diff] [blame] | 1810 | if( p->pLimit ){ |
| 1811 | pParse->nMem++; /* Allocate an extra register for limit+offset */ |
| 1812 | } |
drh | 15007a9 | 2006-01-08 18:10:17 +0000 | [diff] [blame] | 1813 | v = sqlite3GetVdbe(pParse); |
drh | 7b58dae | 2003-07-20 01:16:46 +0000 | [diff] [blame] | 1814 | if( v==0 ) return; |
drh | b765411 | 2008-01-12 12:48:07 +0000 | [diff] [blame] | 1815 | sqlite3ExprCode(pParse, p->pOffset, iOffset); |
| 1816 | sqlite3VdbeAddOp1(v, OP_MustBeInt, iOffset); |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 1817 | VdbeComment((v, "OFFSET counter")); |
drh | 3c84ddf | 2008-01-09 02:15:38 +0000 | [diff] [blame] | 1818 | addr1 = sqlite3VdbeAddOp1(v, OP_IfPos, iOffset); |
drh | b765411 | 2008-01-12 12:48:07 +0000 | [diff] [blame] | 1819 | sqlite3VdbeAddOp2(v, OP_Integer, 0, iOffset); |
drh | 15007a9 | 2006-01-08 18:10:17 +0000 | [diff] [blame] | 1820 | sqlite3VdbeJumpHere(v, addr1); |
drh | d59ba6c | 2006-01-08 05:02:54 +0000 | [diff] [blame] | 1821 | if( p->pLimit ){ |
drh | b765411 | 2008-01-12 12:48:07 +0000 | [diff] [blame] | 1822 | sqlite3VdbeAddOp3(v, OP_Add, iLimit, iOffset, iOffset+1); |
| 1823 | VdbeComment((v, "LIMIT+OFFSET")); |
| 1824 | addr1 = sqlite3VdbeAddOp1(v, OP_IfPos, iLimit); |
| 1825 | sqlite3VdbeAddOp2(v, OP_Integer, -1, iOffset+1); |
| 1826 | sqlite3VdbeJumpHere(v, addr1); |
drh | d59ba6c | 2006-01-08 05:02:54 +0000 | [diff] [blame] | 1827 | } |
drh | 7b58dae | 2003-07-20 01:16:46 +0000 | [diff] [blame] | 1828 | } |
| 1829 | } |
| 1830 | |
| 1831 | /* |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 1832 | ** Allocate a virtual index to use for sorting. |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 1833 | */ |
drh | 4db38a7 | 2005-09-01 12:16:28 +0000 | [diff] [blame] | 1834 | static void createSortingIndex(Parse *pParse, Select *p, ExprList *pOrderBy){ |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 1835 | if( pOrderBy ){ |
| 1836 | int addr; |
drh | 9d2985c | 2005-09-08 01:58:42 +0000 | [diff] [blame] | 1837 | assert( pOrderBy->iECursor==0 ); |
| 1838 | pOrderBy->iECursor = pParse->nTab++; |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 1839 | addr = sqlite3VdbeAddOp2(pParse->pVdbe, OP_OpenEphemeral, |
drh | 9d2985c | 2005-09-08 01:58:42 +0000 | [diff] [blame] | 1840 | pOrderBy->iECursor, pOrderBy->nExpr+1); |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 1841 | assert( p->addrOpenEphm[2] == -1 ); |
| 1842 | p->addrOpenEphm[2] = addr; |
drh | 736c22b | 2004-05-21 02:14:24 +0000 | [diff] [blame] | 1843 | } |
danielk1977 | dc1bdc4 | 2004-06-11 10:51:27 +0000 | [diff] [blame] | 1844 | } |
| 1845 | |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 1846 | #ifndef SQLITE_OMIT_COMPOUND_SELECT |
drh | fbc4ee7 | 2004-08-29 01:31:05 +0000 | [diff] [blame] | 1847 | /* |
drh | fbc4ee7 | 2004-08-29 01:31:05 +0000 | [diff] [blame] | 1848 | ** Return the appropriate collating sequence for the iCol-th column of |
| 1849 | ** the result set for the compound-select statement "p". Return NULL if |
| 1850 | ** the column has no default collating sequence. |
| 1851 | ** |
| 1852 | ** The collating sequence for the compound select is taken from the |
| 1853 | ** left-most term of the select that has a collating sequence. |
| 1854 | */ |
danielk1977 | dc1bdc4 | 2004-06-11 10:51:27 +0000 | [diff] [blame] | 1855 | static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){ |
drh | fbc4ee7 | 2004-08-29 01:31:05 +0000 | [diff] [blame] | 1856 | CollSeq *pRet; |
danielk1977 | dc1bdc4 | 2004-06-11 10:51:27 +0000 | [diff] [blame] | 1857 | if( p->pPrior ){ |
| 1858 | pRet = multiSelectCollSeq(pParse, p->pPrior, iCol); |
drh | fbc4ee7 | 2004-08-29 01:31:05 +0000 | [diff] [blame] | 1859 | }else{ |
| 1860 | pRet = 0; |
danielk1977 | dc1bdc4 | 2004-06-11 10:51:27 +0000 | [diff] [blame] | 1861 | } |
drh | fbc4ee7 | 2004-08-29 01:31:05 +0000 | [diff] [blame] | 1862 | if( pRet==0 ){ |
danielk1977 | dc1bdc4 | 2004-06-11 10:51:27 +0000 | [diff] [blame] | 1863 | pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr); |
| 1864 | } |
| 1865 | return pRet; |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 1866 | } |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 1867 | #endif /* SQLITE_OMIT_COMPOUND_SELECT */ |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 1868 | |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 1869 | /* Forward reference */ |
| 1870 | static int multiSelectOrderBy( |
| 1871 | Parse *pParse, /* Parsing context */ |
| 1872 | Select *p, /* The right-most of SELECTs to be coded */ |
| 1873 | SelectDest *pDest, /* What to do with query results */ |
| 1874 | char *aff /* If eDest is SRT_Union, the affinity string */ |
| 1875 | ); |
| 1876 | |
| 1877 | |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 1878 | #ifndef SQLITE_OMIT_COMPOUND_SELECT |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 1879 | /* |
drh | 16ee60f | 2008-06-20 18:13:25 +0000 | [diff] [blame] | 1880 | ** This routine is called to process a compound query form from |
| 1881 | ** two or more separate queries using UNION, UNION ALL, EXCEPT, or |
| 1882 | ** INTERSECT |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 1883 | ** |
drh | e78e828 | 2003-01-19 03:59:45 +0000 | [diff] [blame] | 1884 | ** "p" points to the right-most of the two queries. the query on the |
| 1885 | ** left is p->pPrior. The left query could also be a compound query |
| 1886 | ** in which case this routine will be called recursively. |
| 1887 | ** |
| 1888 | ** The results of the total query are to be written into a destination |
| 1889 | ** of type eDest with parameter iParm. |
| 1890 | ** |
| 1891 | ** Example 1: Consider a three-way compound SQL statement. |
| 1892 | ** |
| 1893 | ** SELECT a FROM t1 UNION SELECT b FROM t2 UNION SELECT c FROM t3 |
| 1894 | ** |
| 1895 | ** This statement is parsed up as follows: |
| 1896 | ** |
| 1897 | ** SELECT c FROM t3 |
| 1898 | ** | |
| 1899 | ** `-----> SELECT b FROM t2 |
| 1900 | ** | |
jplyon | 4b11c6d | 2004-01-19 04:57:53 +0000 | [diff] [blame] | 1901 | ** `------> SELECT a FROM t1 |
drh | e78e828 | 2003-01-19 03:59:45 +0000 | [diff] [blame] | 1902 | ** |
| 1903 | ** The arrows in the diagram above represent the Select.pPrior pointer. |
| 1904 | ** So if this routine is called with p equal to the t3 query, then |
| 1905 | ** pPrior will be the t2 query. p->op will be TK_UNION in this case. |
| 1906 | ** |
| 1907 | ** Notice that because of the way SQLite parses compound SELECTs, the |
| 1908 | ** individual selects always group from left to right. |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 1909 | */ |
danielk1977 | 84ac9d0 | 2004-05-18 09:58:06 +0000 | [diff] [blame] | 1910 | static int multiSelect( |
drh | fbc4ee7 | 2004-08-29 01:31:05 +0000 | [diff] [blame] | 1911 | Parse *pParse, /* Parsing context */ |
| 1912 | Select *p, /* The right-most of SELECTs to be coded */ |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 1913 | SelectDest *pDest, /* What to do with query results */ |
drh | fbc4ee7 | 2004-08-29 01:31:05 +0000 | [diff] [blame] | 1914 | char *aff /* If eDest is SRT_Union, the affinity string */ |
danielk1977 | 84ac9d0 | 2004-05-18 09:58:06 +0000 | [diff] [blame] | 1915 | ){ |
drh | fbc4ee7 | 2004-08-29 01:31:05 +0000 | [diff] [blame] | 1916 | int rc = SQLITE_OK; /* Success code from a subroutine */ |
| 1917 | Select *pPrior; /* Another SELECT immediately to our left */ |
| 1918 | Vdbe *v; /* Generate code to this VDBE */ |
drh | 8cdbf83 | 2004-08-29 16:25:03 +0000 | [diff] [blame] | 1919 | int nCol; /* Number of columns in the result set */ |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 1920 | ExprList *pOrderBy; /* The ORDER BY clause on p */ |
| 1921 | int aSetP2[2]; /* Set P2 value of these op to number of columns */ |
| 1922 | int nSetP2 = 0; /* Number of slots in aSetP2[] used */ |
drh | 1013c93 | 2008-01-06 00:25:21 +0000 | [diff] [blame] | 1923 | SelectDest dest; /* Alternative data destination */ |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 1924 | |
drh | 7b58dae | 2003-07-20 01:16:46 +0000 | [diff] [blame] | 1925 | /* Make sure there is no ORDER BY or LIMIT clause on prior SELECTs. Only |
drh | fbc4ee7 | 2004-08-29 01:31:05 +0000 | [diff] [blame] | 1926 | ** the last (right-most) SELECT in the series may have an ORDER BY or LIMIT. |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 1927 | */ |
danielk1977 | 84ac9d0 | 2004-05-18 09:58:06 +0000 | [diff] [blame] | 1928 | if( p==0 || p->pPrior==0 ){ |
| 1929 | rc = 1; |
| 1930 | goto multi_select_end; |
| 1931 | } |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1932 | pPrior = p->pPrior; |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 1933 | assert( pPrior->pRightmost!=pPrior ); |
| 1934 | assert( pPrior->pRightmost==p->pRightmost ); |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1935 | if( pPrior->pOrderBy ){ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 1936 | sqlite3ErrorMsg(pParse,"ORDER BY clause should come after %s not before", |
drh | da93d23 | 2003-03-31 02:12:46 +0000 | [diff] [blame] | 1937 | selectOpName(p->op)); |
danielk1977 | 84ac9d0 | 2004-05-18 09:58:06 +0000 | [diff] [blame] | 1938 | rc = 1; |
| 1939 | goto multi_select_end; |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 1940 | } |
danielk1977 | a2dc3b1 | 2005-02-05 12:48:48 +0000 | [diff] [blame] | 1941 | if( pPrior->pLimit ){ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 1942 | sqlite3ErrorMsg(pParse,"LIMIT clause should come after %s not before", |
drh | 7b58dae | 2003-07-20 01:16:46 +0000 | [diff] [blame] | 1943 | selectOpName(p->op)); |
danielk1977 | 84ac9d0 | 2004-05-18 09:58:06 +0000 | [diff] [blame] | 1944 | rc = 1; |
| 1945 | goto multi_select_end; |
drh | 7b58dae | 2003-07-20 01:16:46 +0000 | [diff] [blame] | 1946 | } |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 1947 | |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1948 | /* Make sure we have a valid query engine. If not, create a new one. |
| 1949 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 1950 | v = sqlite3GetVdbe(pParse); |
danielk1977 | 84ac9d0 | 2004-05-18 09:58:06 +0000 | [diff] [blame] | 1951 | if( v==0 ){ |
| 1952 | rc = 1; |
| 1953 | goto multi_select_end; |
| 1954 | } |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1955 | |
drh | 1cc3d75 | 2002-03-23 00:31:29 +0000 | [diff] [blame] | 1956 | /* Create the destination temporary table if necessary |
| 1957 | */ |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 1958 | dest = *pDest; |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 1959 | if( dest.eDest==SRT_EphemTab ){ |
danielk1977 | b4964b7 | 2004-05-18 01:23:38 +0000 | [diff] [blame] | 1960 | assert( p->pEList ); |
drh | f6e369a | 2008-06-24 12:46:30 +0000 | [diff] [blame] | 1961 | sqlite3VdbeAddOp2(v, OP_OpenEphemeral, dest.iParm, p->pEList->nExpr); |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 1962 | dest.eDest = SRT_Table; |
drh | 1cc3d75 | 2002-03-23 00:31:29 +0000 | [diff] [blame] | 1963 | } |
| 1964 | |
drh | f6e369a | 2008-06-24 12:46:30 +0000 | [diff] [blame] | 1965 | /* Make sure all SELECTs in the statement have the same number of elements |
| 1966 | ** in their result sets. |
| 1967 | */ |
| 1968 | assert( p->pEList && pPrior->pEList ); |
| 1969 | if( p->pEList->nExpr!=pPrior->pEList->nExpr ){ |
| 1970 | sqlite3ErrorMsg(pParse, "SELECTs to the left and right of %s" |
| 1971 | " do not have the same number of result columns", selectOpName(p->op)); |
| 1972 | rc = 1; |
| 1973 | goto multi_select_end; |
| 1974 | } |
| 1975 | |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 1976 | #if 1 |
drh | f6e369a | 2008-06-24 12:46:30 +0000 | [diff] [blame] | 1977 | if( p->pOrderBy ){ |
| 1978 | return multiSelectOrderBy(pParse, p, pDest, aff); |
| 1979 | } |
| 1980 | #endif |
| 1981 | |
drh | f46f905 | 2002-06-22 02:33:38 +0000 | [diff] [blame] | 1982 | /* Generate code for the left and right SELECT statements. |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1983 | */ |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 1984 | pOrderBy = p->pOrderBy; |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 1985 | switch( p->op ){ |
drh | f46f905 | 2002-06-22 02:33:38 +0000 | [diff] [blame] | 1986 | case TK_ALL: { |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 1987 | if( pOrderBy==0 ){ |
drh | ec7429a | 2005-10-06 16:53:14 +0000 | [diff] [blame] | 1988 | int addr = 0; |
danielk1977 | a2dc3b1 | 2005-02-05 12:48:48 +0000 | [diff] [blame] | 1989 | assert( !pPrior->pLimit ); |
| 1990 | pPrior->pLimit = p->pLimit; |
| 1991 | pPrior->pOffset = p->pOffset; |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 1992 | rc = sqlite3Select(pParse, pPrior, &dest, 0, 0, 0, aff); |
danielk1977 | ad68cb6 | 2006-01-05 14:22:33 +0000 | [diff] [blame] | 1993 | p->pLimit = 0; |
| 1994 | p->pOffset = 0; |
danielk1977 | 84ac9d0 | 2004-05-18 09:58:06 +0000 | [diff] [blame] | 1995 | if( rc ){ |
| 1996 | goto multi_select_end; |
| 1997 | } |
drh | f46f905 | 2002-06-22 02:33:38 +0000 | [diff] [blame] | 1998 | p->pPrior = 0; |
drh | 7b58dae | 2003-07-20 01:16:46 +0000 | [diff] [blame] | 1999 | p->iLimit = pPrior->iLimit; |
| 2000 | p->iOffset = pPrior->iOffset; |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2001 | if( p->iLimit ){ |
drh | 3c84ddf | 2008-01-09 02:15:38 +0000 | [diff] [blame] | 2002 | addr = sqlite3VdbeAddOp1(v, OP_IfZero, p->iLimit); |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 2003 | VdbeComment((v, "Jump ahead if LIMIT reached")); |
drh | ec7429a | 2005-10-06 16:53:14 +0000 | [diff] [blame] | 2004 | } |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 2005 | rc = sqlite3Select(pParse, p, &dest, 0, 0, 0, aff); |
drh | f46f905 | 2002-06-22 02:33:38 +0000 | [diff] [blame] | 2006 | p->pPrior = pPrior; |
danielk1977 | 84ac9d0 | 2004-05-18 09:58:06 +0000 | [diff] [blame] | 2007 | if( rc ){ |
| 2008 | goto multi_select_end; |
| 2009 | } |
drh | ec7429a | 2005-10-06 16:53:14 +0000 | [diff] [blame] | 2010 | if( addr ){ |
| 2011 | sqlite3VdbeJumpHere(v, addr); |
| 2012 | } |
drh | f46f905 | 2002-06-22 02:33:38 +0000 | [diff] [blame] | 2013 | break; |
| 2014 | } |
| 2015 | /* For UNION ALL ... ORDER BY fall through to the next case */ |
| 2016 | } |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 2017 | case TK_EXCEPT: |
| 2018 | case TK_UNION: { |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 2019 | int unionTab; /* Cursor number of the temporary table holding result */ |
danielk1977 | 742f947 | 2004-06-16 12:02:43 +0000 | [diff] [blame] | 2020 | int op = 0; /* One of the SRT_ operations to apply to self */ |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 2021 | int priorOp; /* The SRT_ operation to apply to prior selects */ |
danielk1977 | a2dc3b1 | 2005-02-05 12:48:48 +0000 | [diff] [blame] | 2022 | Expr *pLimit, *pOffset; /* Saved values of p->nLimit and p->nOffset */ |
danielk1977 | dc1bdc4 | 2004-06-11 10:51:27 +0000 | [diff] [blame] | 2023 | int addr; |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 2024 | SelectDest uniondest; |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 2025 | |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 2026 | priorOp = p->op==TK_ALL ? SRT_Table : SRT_Union; |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 2027 | if( dest.eDest==priorOp && pOrderBy==0 && !p->pLimit && !p->pOffset ){ |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 2028 | /* We can reuse a temporary table generated by a SELECT to our |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 2029 | ** right. |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 2030 | */ |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 2031 | unionTab = dest.iParm; |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 2032 | }else{ |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 2033 | /* We will need to create our own temporary table to hold the |
| 2034 | ** intermediate results. |
| 2035 | */ |
| 2036 | unionTab = pParse->nTab++; |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 2037 | if( processCompoundOrderBy(pParse, p, unionTab) ){ |
danielk1977 | 84ac9d0 | 2004-05-18 09:58:06 +0000 | [diff] [blame] | 2038 | rc = 1; |
| 2039 | goto multi_select_end; |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 2040 | } |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 2041 | addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, unionTab, 0); |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 2042 | if( priorOp==SRT_Table ){ |
| 2043 | assert( nSetP2<sizeof(aSetP2)/sizeof(aSetP2[0]) ); |
| 2044 | aSetP2[nSetP2++] = addr; |
| 2045 | }else{ |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 2046 | assert( p->addrOpenEphm[0] == -1 ); |
| 2047 | p->addrOpenEphm[0] = addr; |
| 2048 | p->pRightmost->usesEphm = 1; |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 2049 | } |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 2050 | createSortingIndex(pParse, p, pOrderBy); |
danielk1977 | 84ac9d0 | 2004-05-18 09:58:06 +0000 | [diff] [blame] | 2051 | assert( p->pEList ); |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 2052 | } |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 2053 | |
| 2054 | /* Code the SELECT statements to our left |
| 2055 | */ |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 2056 | assert( !pPrior->pOrderBy ); |
drh | 1013c93 | 2008-01-06 00:25:21 +0000 | [diff] [blame] | 2057 | sqlite3SelectDestInit(&uniondest, priorOp, unionTab); |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 2058 | rc = sqlite3Select(pParse, pPrior, &uniondest, 0, 0, 0, aff); |
danielk1977 | 84ac9d0 | 2004-05-18 09:58:06 +0000 | [diff] [blame] | 2059 | if( rc ){ |
| 2060 | goto multi_select_end; |
| 2061 | } |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 2062 | |
| 2063 | /* Code the current SELECT statement |
| 2064 | */ |
| 2065 | switch( p->op ){ |
| 2066 | case TK_EXCEPT: op = SRT_Except; break; |
| 2067 | case TK_UNION: op = SRT_Union; break; |
| 2068 | case TK_ALL: op = SRT_Table; break; |
| 2069 | } |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 2070 | p->pPrior = 0; |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 2071 | p->pOrderBy = 0; |
drh | 4b14b4d | 2005-09-19 17:35:53 +0000 | [diff] [blame] | 2072 | p->disallowOrderBy = pOrderBy!=0; |
danielk1977 | a2dc3b1 | 2005-02-05 12:48:48 +0000 | [diff] [blame] | 2073 | pLimit = p->pLimit; |
| 2074 | p->pLimit = 0; |
| 2075 | pOffset = p->pOffset; |
| 2076 | p->pOffset = 0; |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 2077 | uniondest.eDest = op; |
| 2078 | rc = sqlite3Select(pParse, p, &uniondest, 0, 0, 0, aff); |
drh | 5bd1bf2 | 2007-06-15 15:31:49 +0000 | [diff] [blame] | 2079 | /* Query flattening in sqlite3Select() might refill p->pOrderBy. |
| 2080 | ** Be sure to delete p->pOrderBy, therefore, to avoid a memory leak. */ |
| 2081 | sqlite3ExprListDelete(p->pOrderBy); |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 2082 | p->pPrior = pPrior; |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 2083 | p->pOrderBy = pOrderBy; |
danielk1977 | a2dc3b1 | 2005-02-05 12:48:48 +0000 | [diff] [blame] | 2084 | sqlite3ExprDelete(p->pLimit); |
| 2085 | p->pLimit = pLimit; |
| 2086 | p->pOffset = pOffset; |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2087 | p->iLimit = 0; |
| 2088 | p->iOffset = 0; |
danielk1977 | 84ac9d0 | 2004-05-18 09:58:06 +0000 | [diff] [blame] | 2089 | if( rc ){ |
| 2090 | goto multi_select_end; |
| 2091 | } |
| 2092 | |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 2093 | |
| 2094 | /* Convert the data in the temporary table into whatever form |
| 2095 | ** it is that we currently need. |
| 2096 | */ |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 2097 | if( dest.eDest!=priorOp || unionTab!=dest.iParm ){ |
drh | 6b56344 | 2001-11-07 16:48:26 +0000 | [diff] [blame] | 2098 | int iCont, iBreak, iStart; |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 2099 | assert( p->pEList ); |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 2100 | if( dest.eDest==SRT_Callback ){ |
drh | 9237825 | 2006-03-26 01:21:22 +0000 | [diff] [blame] | 2101 | Select *pFirst = p; |
| 2102 | while( pFirst->pPrior ) pFirst = pFirst->pPrior; |
| 2103 | generateColumnNames(pParse, 0, pFirst->pEList); |
drh | 41202cc | 2002-04-23 17:10:18 +0000 | [diff] [blame] | 2104 | } |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2105 | iBreak = sqlite3VdbeMakeLabel(v); |
| 2106 | iCont = sqlite3VdbeMakeLabel(v); |
drh | ec7429a | 2005-10-06 16:53:14 +0000 | [diff] [blame] | 2107 | computeLimitRegisters(pParse, p, iBreak); |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 2108 | sqlite3VdbeAddOp2(v, OP_Rewind, unionTab, iBreak); |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2109 | iStart = sqlite3VdbeCurrentAddr(v); |
drh | d2b3e23 | 2008-01-23 14:51:49 +0000 | [diff] [blame] | 2110 | selectInnerLoop(pParse, p, p->pEList, unionTab, p->pEList->nExpr, |
| 2111 | pOrderBy, -1, &dest, iCont, iBreak, 0); |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2112 | sqlite3VdbeResolveLabel(v, iCont); |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 2113 | sqlite3VdbeAddOp2(v, OP_Next, unionTab, iStart); |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2114 | sqlite3VdbeResolveLabel(v, iBreak); |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 2115 | sqlite3VdbeAddOp2(v, OP_Close, unionTab, 0); |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 2116 | } |
| 2117 | break; |
| 2118 | } |
| 2119 | case TK_INTERSECT: { |
| 2120 | int tab1, tab2; |
drh | 6b56344 | 2001-11-07 16:48:26 +0000 | [diff] [blame] | 2121 | int iCont, iBreak, iStart; |
danielk1977 | a2dc3b1 | 2005-02-05 12:48:48 +0000 | [diff] [blame] | 2122 | Expr *pLimit, *pOffset; |
danielk1977 | dc1bdc4 | 2004-06-11 10:51:27 +0000 | [diff] [blame] | 2123 | int addr; |
drh | 1013c93 | 2008-01-06 00:25:21 +0000 | [diff] [blame] | 2124 | SelectDest intersectdest; |
drh | 9cbf342 | 2008-01-17 16:22:13 +0000 | [diff] [blame] | 2125 | int r1; |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 2126 | |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 2127 | /* INTERSECT is different from the others since it requires |
drh | 6206d50 | 2000-06-19 19:09:08 +0000 | [diff] [blame] | 2128 | ** two temporary tables. Hence it has its own case. Begin |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 2129 | ** by allocating the tables we will need. |
| 2130 | */ |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 2131 | tab1 = pParse->nTab++; |
| 2132 | tab2 = pParse->nTab++; |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 2133 | if( processCompoundOrderBy(pParse, p, tab1) ){ |
danielk1977 | 84ac9d0 | 2004-05-18 09:58:06 +0000 | [diff] [blame] | 2134 | rc = 1; |
| 2135 | goto multi_select_end; |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 2136 | } |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 2137 | createSortingIndex(pParse, p, pOrderBy); |
danielk1977 | dc1bdc4 | 2004-06-11 10:51:27 +0000 | [diff] [blame] | 2138 | |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 2139 | addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab1, 0); |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 2140 | assert( p->addrOpenEphm[0] == -1 ); |
| 2141 | p->addrOpenEphm[0] = addr; |
| 2142 | p->pRightmost->usesEphm = 1; |
danielk1977 | 84ac9d0 | 2004-05-18 09:58:06 +0000 | [diff] [blame] | 2143 | assert( p->pEList ); |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 2144 | |
| 2145 | /* Code the SELECTs to our left into temporary table "tab1". |
| 2146 | */ |
drh | 1013c93 | 2008-01-06 00:25:21 +0000 | [diff] [blame] | 2147 | sqlite3SelectDestInit(&intersectdest, SRT_Union, tab1); |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 2148 | rc = sqlite3Select(pParse, pPrior, &intersectdest, 0, 0, 0, aff); |
danielk1977 | 84ac9d0 | 2004-05-18 09:58:06 +0000 | [diff] [blame] | 2149 | if( rc ){ |
| 2150 | goto multi_select_end; |
| 2151 | } |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 2152 | |
| 2153 | /* Code the current SELECT into temporary table "tab2" |
| 2154 | */ |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 2155 | addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab2, 0); |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 2156 | assert( p->addrOpenEphm[1] == -1 ); |
| 2157 | p->addrOpenEphm[1] = addr; |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 2158 | p->pPrior = 0; |
danielk1977 | a2dc3b1 | 2005-02-05 12:48:48 +0000 | [diff] [blame] | 2159 | pLimit = p->pLimit; |
| 2160 | p->pLimit = 0; |
| 2161 | pOffset = p->pOffset; |
| 2162 | p->pOffset = 0; |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 2163 | intersectdest.iParm = tab2; |
| 2164 | rc = sqlite3Select(pParse, p, &intersectdest, 0, 0, 0, aff); |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 2165 | p->pPrior = pPrior; |
danielk1977 | a2dc3b1 | 2005-02-05 12:48:48 +0000 | [diff] [blame] | 2166 | sqlite3ExprDelete(p->pLimit); |
| 2167 | p->pLimit = pLimit; |
| 2168 | p->pOffset = pOffset; |
danielk1977 | 84ac9d0 | 2004-05-18 09:58:06 +0000 | [diff] [blame] | 2169 | if( rc ){ |
| 2170 | goto multi_select_end; |
| 2171 | } |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 2172 | |
| 2173 | /* Generate code to take the intersection of the two temporary |
| 2174 | ** tables. |
| 2175 | */ |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 2176 | assert( p->pEList ); |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 2177 | if( dest.eDest==SRT_Callback ){ |
drh | 9237825 | 2006-03-26 01:21:22 +0000 | [diff] [blame] | 2178 | Select *pFirst = p; |
| 2179 | while( pFirst->pPrior ) pFirst = pFirst->pPrior; |
| 2180 | generateColumnNames(pParse, 0, pFirst->pEList); |
drh | 41202cc | 2002-04-23 17:10:18 +0000 | [diff] [blame] | 2181 | } |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2182 | iBreak = sqlite3VdbeMakeLabel(v); |
| 2183 | iCont = sqlite3VdbeMakeLabel(v); |
drh | ec7429a | 2005-10-06 16:53:14 +0000 | [diff] [blame] | 2184 | computeLimitRegisters(pParse, p, iBreak); |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 2185 | sqlite3VdbeAddOp2(v, OP_Rewind, tab1, iBreak); |
drh | 9cbf342 | 2008-01-17 16:22:13 +0000 | [diff] [blame] | 2186 | r1 = sqlite3GetTempReg(pParse); |
| 2187 | iStart = sqlite3VdbeAddOp2(v, OP_RowKey, tab1, r1); |
| 2188 | sqlite3VdbeAddOp3(v, OP_NotFound, tab2, iCont, r1); |
| 2189 | sqlite3ReleaseTempReg(pParse, r1); |
drh | d2b3e23 | 2008-01-23 14:51:49 +0000 | [diff] [blame] | 2190 | selectInnerLoop(pParse, p, p->pEList, tab1, p->pEList->nExpr, |
| 2191 | pOrderBy, -1, &dest, iCont, iBreak, 0); |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2192 | sqlite3VdbeResolveLabel(v, iCont); |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 2193 | sqlite3VdbeAddOp2(v, OP_Next, tab1, iStart); |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2194 | sqlite3VdbeResolveLabel(v, iBreak); |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 2195 | sqlite3VdbeAddOp2(v, OP_Close, tab2, 0); |
| 2196 | sqlite3VdbeAddOp2(v, OP_Close, tab1, 0); |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 2197 | break; |
| 2198 | } |
| 2199 | } |
drh | 8cdbf83 | 2004-08-29 16:25:03 +0000 | [diff] [blame] | 2200 | |
drh | 8cdbf83 | 2004-08-29 16:25:03 +0000 | [diff] [blame] | 2201 | /* Set the number of columns in temporary tables |
| 2202 | */ |
| 2203 | nCol = p->pEList->nExpr; |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 2204 | while( nSetP2 ){ |
| 2205 | sqlite3VdbeChangeP2(v, aSetP2[--nSetP2], nCol); |
drh | 8cdbf83 | 2004-08-29 16:25:03 +0000 | [diff] [blame] | 2206 | } |
| 2207 | |
drh | fbc4ee7 | 2004-08-29 01:31:05 +0000 | [diff] [blame] | 2208 | /* Compute collating sequences used by either the ORDER BY clause or |
| 2209 | ** by any temporary tables needed to implement the compound select. |
| 2210 | ** Attach the KeyInfo structure to all temporary tables. Invoke the |
| 2211 | ** ORDER BY processing if there is an ORDER BY clause. |
drh | 8cdbf83 | 2004-08-29 16:25:03 +0000 | [diff] [blame] | 2212 | ** |
| 2213 | ** This section is run by the right-most SELECT statement only. |
| 2214 | ** SELECT statements to the left always skip this part. The right-most |
| 2215 | ** SELECT might also skip this part if it has no ORDER BY clause and |
| 2216 | ** no temp tables are required. |
drh | fbc4ee7 | 2004-08-29 01:31:05 +0000 | [diff] [blame] | 2217 | */ |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 2218 | if( pOrderBy || p->usesEphm ){ |
drh | fbc4ee7 | 2004-08-29 01:31:05 +0000 | [diff] [blame] | 2219 | int i; /* Loop counter */ |
| 2220 | KeyInfo *pKeyInfo; /* Collating sequence for the result set */ |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 2221 | Select *pLoop; /* For looping through SELECT statements */ |
drh | 1e31e0b | 2006-08-11 19:08:27 +0000 | [diff] [blame] | 2222 | int nKeyCol; /* Number of entries in pKeyInfo->aCol[] */ |
drh | f68d7d1 | 2007-05-03 13:02:26 +0000 | [diff] [blame] | 2223 | CollSeq **apColl; /* For looping through pKeyInfo->aColl[] */ |
| 2224 | CollSeq **aCopy; /* A copy of pKeyInfo->aColl[] */ |
drh | fbc4ee7 | 2004-08-29 01:31:05 +0000 | [diff] [blame] | 2225 | |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 2226 | assert( p->pRightmost==p ); |
drh | 1e31e0b | 2006-08-11 19:08:27 +0000 | [diff] [blame] | 2227 | nKeyCol = nCol + (pOrderBy ? pOrderBy->nExpr : 0); |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 2228 | pKeyInfo = sqlite3DbMallocZero(pParse->db, |
| 2229 | sizeof(*pKeyInfo)+nKeyCol*(sizeof(CollSeq*) + 1)); |
danielk1977 | dc1bdc4 | 2004-06-11 10:51:27 +0000 | [diff] [blame] | 2230 | if( !pKeyInfo ){ |
| 2231 | rc = SQLITE_NOMEM; |
| 2232 | goto multi_select_end; |
| 2233 | } |
| 2234 | |
danielk1977 | 14db266 | 2006-01-09 16:12:04 +0000 | [diff] [blame] | 2235 | pKeyInfo->enc = ENC(pParse->db); |
danielk1977 | dc1bdc4 | 2004-06-11 10:51:27 +0000 | [diff] [blame] | 2236 | pKeyInfo->nField = nCol; |
| 2237 | |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 2238 | for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){ |
| 2239 | *apColl = multiSelectCollSeq(pParse, p, i); |
| 2240 | if( 0==*apColl ){ |
| 2241 | *apColl = pParse->db->pDfltColl; |
danielk1977 | dc1bdc4 | 2004-06-11 10:51:27 +0000 | [diff] [blame] | 2242 | } |
| 2243 | } |
| 2244 | |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 2245 | for(pLoop=p; pLoop; pLoop=pLoop->pPrior){ |
| 2246 | for(i=0; i<2; i++){ |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 2247 | int addr = pLoop->addrOpenEphm[i]; |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 2248 | if( addr<0 ){ |
| 2249 | /* If [0] is unused then [1] is also unused. So we can |
| 2250 | ** always safely abort as soon as the first unused slot is found */ |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 2251 | assert( pLoop->addrOpenEphm[1]<0 ); |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 2252 | break; |
| 2253 | } |
| 2254 | sqlite3VdbeChangeP2(v, addr, nCol); |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 2255 | sqlite3VdbeChangeP4(v, addr, (char*)pKeyInfo, P4_KEYINFO); |
drh | 0ee5a1e | 2007-01-26 19:04:00 +0000 | [diff] [blame] | 2256 | pLoop->addrOpenEphm[i] = -1; |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 2257 | } |
danielk1977 | dc1bdc4 | 2004-06-11 10:51:27 +0000 | [diff] [blame] | 2258 | } |
| 2259 | |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 2260 | if( pOrderBy ){ |
| 2261 | struct ExprList_item *pOTerm = pOrderBy->a; |
drh | 4efc083 | 2005-11-16 13:47:50 +0000 | [diff] [blame] | 2262 | int nOrderByExpr = pOrderBy->nExpr; |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 2263 | int addr; |
drh | 4db38a7 | 2005-09-01 12:16:28 +0000 | [diff] [blame] | 2264 | u8 *pSortOrder; |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 2265 | |
drh | f68d7d1 | 2007-05-03 13:02:26 +0000 | [diff] [blame] | 2266 | /* Reuse the same pKeyInfo for the ORDER BY as was used above for |
| 2267 | ** the compound select statements. Except we have to change out the |
| 2268 | ** pKeyInfo->aColl[] values. Some of the aColl[] values will be |
| 2269 | ** reused when constructing the pKeyInfo for the ORDER BY, so make |
| 2270 | ** a copy. Sufficient space to hold both the nCol entries for |
| 2271 | ** the compound select and the nOrderbyExpr entries for the ORDER BY |
| 2272 | ** was allocated above. But we need to move the compound select |
| 2273 | ** entries out of the way before constructing the ORDER BY entries. |
| 2274 | ** Move the compound select entries into aCopy[] where they can be |
| 2275 | ** accessed and reused when constructing the ORDER BY entries. |
| 2276 | ** Because nCol might be greater than or less than nOrderByExpr |
| 2277 | ** we have to use memmove() when doing the copy. |
| 2278 | */ |
drh | 1e31e0b | 2006-08-11 19:08:27 +0000 | [diff] [blame] | 2279 | aCopy = &pKeyInfo->aColl[nOrderByExpr]; |
drh | 4efc083 | 2005-11-16 13:47:50 +0000 | [diff] [blame] | 2280 | pSortOrder = pKeyInfo->aSortOrder = (u8*)&aCopy[nCol]; |
drh | f68d7d1 | 2007-05-03 13:02:26 +0000 | [diff] [blame] | 2281 | memmove(aCopy, pKeyInfo->aColl, nCol*sizeof(CollSeq*)); |
| 2282 | |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 2283 | apColl = pKeyInfo->aColl; |
drh | 4efc083 | 2005-11-16 13:47:50 +0000 | [diff] [blame] | 2284 | for(i=0; i<nOrderByExpr; i++, pOTerm++, apColl++, pSortOrder++){ |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 2285 | Expr *pExpr = pOTerm->pExpr; |
drh | 8b4c40d | 2007-02-01 23:02:45 +0000 | [diff] [blame] | 2286 | if( (pExpr->flags & EP_ExpCollate) ){ |
| 2287 | assert( pExpr->pColl!=0 ); |
| 2288 | *apColl = pExpr->pColl; |
danielk1977 | dc1bdc4 | 2004-06-11 10:51:27 +0000 | [diff] [blame] | 2289 | }else{ |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 2290 | *apColl = aCopy[pExpr->iColumn]; |
danielk1977 | dc1bdc4 | 2004-06-11 10:51:27 +0000 | [diff] [blame] | 2291 | } |
drh | 4db38a7 | 2005-09-01 12:16:28 +0000 | [diff] [blame] | 2292 | *pSortOrder = pOTerm->sortOrder; |
danielk1977 | dc1bdc4 | 2004-06-11 10:51:27 +0000 | [diff] [blame] | 2293 | } |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 2294 | assert( p->pRightmost==p ); |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 2295 | assert( p->addrOpenEphm[2]>=0 ); |
| 2296 | addr = p->addrOpenEphm[2]; |
danielk1977 | a670b22 | 2007-05-14 16:50:48 +0000 | [diff] [blame] | 2297 | sqlite3VdbeChangeP2(v, addr, p->pOrderBy->nExpr+2); |
drh | 4efc083 | 2005-11-16 13:47:50 +0000 | [diff] [blame] | 2298 | pKeyInfo->nField = nOrderByExpr; |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 2299 | sqlite3VdbeChangeP4(v, addr, (char*)pKeyInfo, P4_KEYINFO_HANDOFF); |
drh | 4db38a7 | 2005-09-01 12:16:28 +0000 | [diff] [blame] | 2300 | pKeyInfo = 0; |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 2301 | generateSortTail(pParse, p, v, p->pEList->nExpr, &dest); |
danielk1977 | dc1bdc4 | 2004-06-11 10:51:27 +0000 | [diff] [blame] | 2302 | } |
| 2303 | |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 2304 | sqlite3_free(pKeyInfo); |
danielk1977 | 84ac9d0 | 2004-05-18 09:58:06 +0000 | [diff] [blame] | 2305 | } |
danielk1977 | dc1bdc4 | 2004-06-11 10:51:27 +0000 | [diff] [blame] | 2306 | |
| 2307 | multi_select_end: |
drh | 1013c93 | 2008-01-06 00:25:21 +0000 | [diff] [blame] | 2308 | pDest->iMem = dest.iMem; |
drh | ad27e76 | 2008-03-26 12:46:23 +0000 | [diff] [blame] | 2309 | pDest->nMem = dest.nMem; |
danielk1977 | 84ac9d0 | 2004-05-18 09:58:06 +0000 | [diff] [blame] | 2310 | return rc; |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 2311 | } |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 2312 | #endif /* SQLITE_OMIT_COMPOUND_SELECT */ |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 2313 | |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2314 | /* |
| 2315 | ** Code an output subroutine for a coroutine implementation of a |
| 2316 | ** SELECT statment. |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2317 | ** |
| 2318 | ** The data to be output is contained in pIn->iMem. There are |
| 2319 | ** pIn->nMem columns to be output. pDest is where the output should |
| 2320 | ** be sent. |
| 2321 | ** |
| 2322 | ** regReturn is the number of the register holding the subroutine |
| 2323 | ** return address. |
| 2324 | ** |
| 2325 | ** If regPrev>0 then it is a the first register in a vector that |
| 2326 | ** records the previous output. mem[regPrev] is a flag that is false |
| 2327 | ** if there has been no previous output. If regPrev>0 then code is |
| 2328 | ** generated to suppress duplicates. pKeyInfo is used for comparing |
| 2329 | ** keys. |
| 2330 | ** |
| 2331 | ** If the LIMIT found in p->iLimit is reached, jump immediately to |
| 2332 | ** iBreak. |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2333 | */ |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2334 | static int generateOutputSubroutine( |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2335 | Parse *pParse, /* Parsing context */ |
| 2336 | Select *p, /* The SELECT statement */ |
| 2337 | SelectDest *pIn, /* Coroutine supplying data */ |
| 2338 | SelectDest *pDest, /* Where to send the data */ |
| 2339 | int regReturn, /* The return address register */ |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2340 | int regPrev, /* Previous result register. No uniqueness if 0 */ |
| 2341 | KeyInfo *pKeyInfo, /* For comparing with previous entry */ |
| 2342 | int p4type, /* The p4 type for pKeyInfo */ |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2343 | int iBreak /* Jump here if we hit the LIMIT */ |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2344 | ){ |
| 2345 | Vdbe *v = pParse->pVdbe; |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2346 | int iContinue; |
| 2347 | int addr; |
| 2348 | if( v==0 ) return 0; |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2349 | |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2350 | addr = sqlite3VdbeCurrentAddr(v); |
| 2351 | iContinue = sqlite3VdbeMakeLabel(v); |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2352 | |
| 2353 | /* Suppress duplicates for UNION, EXCEPT, and INTERSECT |
| 2354 | */ |
| 2355 | if( regPrev ){ |
| 2356 | int j1, j2; |
| 2357 | j1 = sqlite3VdbeAddOp1(v, OP_IfNot, regPrev); |
| 2358 | j2 = sqlite3VdbeAddOp4(v, OP_Compare, pIn->iMem, regPrev+1, pIn->nMem, |
| 2359 | (char*)pKeyInfo, p4type); |
| 2360 | sqlite3VdbeAddOp3(v, OP_Jump, j2+2, iContinue, j2+2); |
| 2361 | sqlite3VdbeJumpHere(v, j1); |
| 2362 | sqlite3ExprCodeCopy(pParse, pIn->iMem, regPrev+1, pIn->nMem); |
| 2363 | sqlite3VdbeAddOp2(v, OP_Integer, 1, regPrev); |
| 2364 | } |
| 2365 | |
| 2366 | /* Suppress the the first OFFSET entries if there is an OFFSET clause |
| 2367 | */ |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2368 | codeOffset(v, p, iContinue); |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2369 | |
| 2370 | switch( pDest->eDest ){ |
| 2371 | /* Store the result as data using a unique key. |
| 2372 | */ |
| 2373 | case SRT_Table: |
| 2374 | case SRT_EphemTab: { |
| 2375 | int r1 = sqlite3GetTempReg(pParse); |
| 2376 | int r2 = sqlite3GetTempReg(pParse); |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2377 | sqlite3VdbeAddOp3(v, OP_MakeRecord, pIn->iMem, pIn->nMem, r1); |
| 2378 | sqlite3VdbeAddOp2(v, OP_NewRowid, pDest->iParm, r2); |
| 2379 | sqlite3VdbeAddOp3(v, OP_Insert, pDest->iParm, r1, r2); |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2380 | sqlite3VdbeChangeP5(v, OPFLAG_APPEND); |
| 2381 | sqlite3ReleaseTempReg(pParse, r2); |
| 2382 | sqlite3ReleaseTempReg(pParse, r1); |
| 2383 | break; |
| 2384 | } |
| 2385 | |
| 2386 | #ifndef SQLITE_OMIT_SUBQUERY |
| 2387 | /* If we are creating a set for an "expr IN (SELECT ...)" construct, |
| 2388 | ** then there should be a single item on the stack. Write this |
| 2389 | ** item into the set table with bogus data. |
| 2390 | */ |
| 2391 | case SRT_Set: { |
| 2392 | int addr2, r1; |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2393 | assert( pIn->nMem==1 ); |
| 2394 | addr2 = sqlite3VdbeAddOp1(v, OP_IsNull, pIn->iMem); |
| 2395 | p->affinity = |
| 2396 | sqlite3CompareAffinity(p->pEList->a[0].pExpr, pDest->affinity); |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2397 | r1 = sqlite3GetTempReg(pParse); |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2398 | sqlite3VdbeAddOp4(v, OP_MakeRecord, pIn->iMem, 1, r1, &p->affinity, 1); |
| 2399 | sqlite3ExprCacheAffinityChange(pParse, pIn->iMem, 1); |
| 2400 | sqlite3VdbeAddOp2(v, OP_IdxInsert, pDest->iParm, r1); |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2401 | sqlite3ReleaseTempReg(pParse, r1); |
| 2402 | sqlite3VdbeJumpHere(v, addr2); |
| 2403 | break; |
| 2404 | } |
| 2405 | |
| 2406 | /* If any row exist in the result set, record that fact and abort. |
| 2407 | */ |
| 2408 | case SRT_Exists: { |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2409 | sqlite3VdbeAddOp2(v, OP_Integer, 1, pDest->iParm); |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2410 | /* The LIMIT clause will terminate the loop for us */ |
| 2411 | break; |
| 2412 | } |
| 2413 | |
| 2414 | /* If this is a scalar select that is part of an expression, then |
| 2415 | ** store the results in the appropriate memory cell and break out |
| 2416 | ** of the scan loop. |
| 2417 | */ |
| 2418 | case SRT_Mem: { |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2419 | assert( pIn->nMem==1 ); |
| 2420 | sqlite3ExprCodeMove(pParse, pIn->iMem, pDest->iParm, 1); |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2421 | /* The LIMIT clause will jump out of the loop for us */ |
| 2422 | break; |
| 2423 | } |
| 2424 | #endif /* #ifndef SQLITE_OMIT_SUBQUERY */ |
| 2425 | |
| 2426 | /* Send the data to the callback function or to a subroutine. In the |
| 2427 | ** case of a subroutine, the subroutine itself is responsible for |
| 2428 | ** popping the data from the stack. |
| 2429 | */ |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2430 | case SRT_Coroutine: { |
| 2431 | if( pDest->iMem==0 ){ |
| 2432 | pDest->iMem = sqlite3GetTempRange(pParse, pIn->nMem); |
| 2433 | pDest->nMem = pIn->nMem; |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2434 | } |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2435 | sqlite3ExprCodeMove(pParse, pIn->iMem, pDest->iMem, pDest->nMem); |
| 2436 | sqlite3VdbeAddOp1(v, OP_Yield, pDest->iParm); |
| 2437 | break; |
| 2438 | } |
| 2439 | |
| 2440 | case SRT_Callback: { |
| 2441 | sqlite3VdbeAddOp2(v, OP_ResultRow, pIn->iMem, pIn->nMem); |
| 2442 | sqlite3ExprCacheAffinityChange(pParse, pIn->iMem, pIn->nMem); |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2443 | break; |
| 2444 | } |
| 2445 | |
| 2446 | #if !defined(SQLITE_OMIT_TRIGGER) |
| 2447 | /* Discard the results. This is used for SELECT statements inside |
| 2448 | ** the body of a TRIGGER. The purpose of such selects is to call |
| 2449 | ** user-defined functions that have side effects. We do not care |
| 2450 | ** about the actual results of the select. |
| 2451 | */ |
| 2452 | default: { |
| 2453 | break; |
| 2454 | } |
| 2455 | #endif |
| 2456 | } |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2457 | |
| 2458 | /* Jump to the end of the loop if the LIMIT is reached. |
| 2459 | */ |
| 2460 | if( p->iLimit ){ |
| 2461 | sqlite3VdbeAddOp2(v, OP_AddImm, p->iLimit, -1); |
| 2462 | sqlite3VdbeAddOp2(v, OP_IfZero, p->iLimit, iBreak); |
| 2463 | } |
| 2464 | |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2465 | /* Generate the subroutine return |
| 2466 | */ |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2467 | sqlite3VdbeResolveLabel(v, iContinue); |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2468 | sqlite3VdbeAddOp1(v, OP_Return, regReturn); |
| 2469 | |
| 2470 | return addr; |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2471 | } |
| 2472 | |
| 2473 | /* |
| 2474 | ** Alternative compound select code generator for cases when there |
| 2475 | ** is an ORDER BY clause. |
| 2476 | ** |
| 2477 | ** We assume a query of the following form: |
| 2478 | ** |
| 2479 | ** <selectA> <operator> <selectB> ORDER BY <orderbylist> |
| 2480 | ** |
| 2481 | ** <operator> is one of UNION ALL, UNION, EXCEPT, or INTERSECT. The idea |
| 2482 | ** is to code both <selectA> and <selectB> with the ORDER BY clause as |
| 2483 | ** co-routines. Then run the co-routines in parallel and merge the results |
| 2484 | ** into the output. In addition to the two coroutines (called selectA and |
| 2485 | ** selectB) there are 7 subroutines: |
| 2486 | ** |
| 2487 | ** outA: Move the output of the selectA coroutine into the output |
| 2488 | ** of the compound query. |
| 2489 | ** |
| 2490 | ** outB: Move the output of the selectB coroutine into the output |
| 2491 | ** of the compound query. (Only generated for UNION and |
| 2492 | ** UNION ALL. EXCEPT and INSERTSECT never output a row that |
| 2493 | ** appears only in B.) |
| 2494 | ** |
| 2495 | ** AltB: Called when there is data from both coroutines and A<B. |
| 2496 | ** |
| 2497 | ** AeqB: Called when there is data from both coroutines and A==B. |
| 2498 | ** |
| 2499 | ** AgtB: Called when there is data from both coroutines and A>B. |
| 2500 | ** |
| 2501 | ** EofA: Called when data is exhausted from selectA. |
| 2502 | ** |
| 2503 | ** EofB: Called when data is exhausted from selectB. |
| 2504 | ** |
| 2505 | ** The implementation of the latter five subroutines depend on which |
| 2506 | ** <operator> is used: |
| 2507 | ** |
| 2508 | ** |
| 2509 | ** UNION ALL UNION EXCEPT INTERSECT |
| 2510 | ** ------------- ----------------- -------------- ----------------- |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2511 | ** AltB: outA, nextA outA, nextA outA, nextA nextA |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2512 | ** |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2513 | ** AeqB: outA, nextA nextA nextA outA, nextA |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2514 | ** |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2515 | ** AgtB: outB, nextB outB, nextB nextB nextB |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2516 | ** |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2517 | ** EofA: outB, nextB outB, nextB halt halt |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2518 | ** |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2519 | ** EofB: outA, nextA outA, nextA outA, nextA halt |
| 2520 | ** |
| 2521 | ** In the AltB, AeqB, and AgtB subroutines, an EOF on A following nextA |
| 2522 | ** causes an immediate jump to EofA and an EOF on B following nextB causes |
| 2523 | ** an immediate jump to EofB. Within EofA and EofB, and EOF on entry or |
| 2524 | ** following nextX causes a jump to the end of the select processing. |
| 2525 | ** |
| 2526 | ** Duplicate removal in the UNION, EXCEPT, and INTERSECT cases is handled |
| 2527 | ** within the output subroutine. The regPrev register set holds the previously |
| 2528 | ** output value. A comparison is made against this value and the output |
| 2529 | ** is skipped if the next results would be the same as the previous. |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2530 | ** |
| 2531 | ** The implementation plan is to implement the two coroutines and seven |
| 2532 | ** subroutines first, then put the control logic at the bottom. Like this: |
| 2533 | ** |
| 2534 | ** goto Init |
| 2535 | ** coA: coroutine for left query (A) |
| 2536 | ** coB: coroutine for right query (B) |
| 2537 | ** outA: output one row of A |
| 2538 | ** outB: output one row of B (UNION and UNION ALL only) |
| 2539 | ** EofA: ... |
| 2540 | ** EofB: ... |
| 2541 | ** AltB: ... |
| 2542 | ** AeqB: ... |
| 2543 | ** AgtB: ... |
| 2544 | ** Init: initialize coroutine registers |
| 2545 | ** yield coA |
| 2546 | ** if eof(A) goto EofA |
| 2547 | ** yield coB |
| 2548 | ** if eof(B) goto EofB |
| 2549 | ** Cmpr: Compare A, B |
| 2550 | ** Jump AltB, AeqB, AgtB |
| 2551 | ** End: ... |
| 2552 | ** |
| 2553 | ** We call AltB, AeqB, AgtB, EofA, and EofB "subroutines" but they are not |
| 2554 | ** actually called using Gosub and they do not Return. EofA and EofB loop |
| 2555 | ** until all data is exhausted then jump to the "end" labe. AltB, AeqB, |
| 2556 | ** and AgtB jump to either L2 or to one of EofA or EofB. |
| 2557 | */ |
| 2558 | static int multiSelectOrderBy( |
| 2559 | Parse *pParse, /* Parsing context */ |
| 2560 | Select *p, /* The right-most of SELECTs to be coded */ |
| 2561 | SelectDest *pDest, /* What to do with query results */ |
| 2562 | char *aff /* If eDest is SRT_Union, the affinity string */ |
| 2563 | ){ |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2564 | int i, j; /* Loop counters */ |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2565 | Select *pPrior; /* Another SELECT immediately to our left */ |
| 2566 | Vdbe *v; /* Generate code to this VDBE */ |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2567 | SelectDest destA; /* Destination for coroutine A */ |
| 2568 | SelectDest destB; /* Destination for coroutine B */ |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2569 | int regAddrA; /* Address register for select-A coroutine */ |
| 2570 | int regEofA; /* Flag to indicate when select-A is complete */ |
| 2571 | int regAddrB; /* Address register for select-B coroutine */ |
| 2572 | int regEofB; /* Flag to indicate when select-B is complete */ |
| 2573 | int addrSelectA; /* Address of the select-A coroutine */ |
| 2574 | int addrSelectB; /* Address of the select-B coroutine */ |
| 2575 | int regOutA; /* Address register for the output-A subroutine */ |
| 2576 | int regOutB; /* Address register for the output-B subroutine */ |
| 2577 | int addrOutA; /* Address of the output-A subroutine */ |
| 2578 | int addrOutB; /* Address of the output-B subroutine */ |
| 2579 | int addrEofA; /* Address of the select-A-exhausted subroutine */ |
| 2580 | int addrEofB; /* Address of the select-B-exhausted subroutine */ |
| 2581 | int addrAltB; /* Address of the A<B subroutine */ |
| 2582 | int addrAeqB; /* Address of the A==B subroutine */ |
| 2583 | int addrAgtB; /* Address of the A>B subroutine */ |
| 2584 | int regLimitA; /* Limit register for select-A */ |
| 2585 | int regLimitB; /* Limit register for select-A */ |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2586 | int regPrev; /* A range of registers to hold previous output */ |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2587 | int savedLimit; /* Saved value of p->iLimit */ |
| 2588 | int savedOffset; /* Saved value of p->iOffset */ |
| 2589 | int labelCmpr; /* Label for the start of the merge algorithm */ |
| 2590 | int labelEnd; /* Label for the end of the overall SELECT stmt */ |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2591 | int j1; /* Jump instructions that get retargetted */ |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2592 | int op; /* One of TK_ALL, TK_UNION, TK_EXCEPT, TK_INTERSECT */ |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2593 | KeyInfo *pKeyDup; /* Comparison information for duplicate removal */ |
| 2594 | KeyInfo *pKeyMerge; /* Comparison information for merging rows */ |
| 2595 | sqlite3 *db; /* Database connection */ |
| 2596 | ExprList *pOrderBy; /* The ORDER BY clause */ |
| 2597 | int nOrderBy; /* Number of terms in the ORDER BY clause */ |
| 2598 | int *aPermute; /* Mapping from ORDER BY terms to result set columns */ |
| 2599 | u8 NotUsed; /* Dummy variables */ |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2600 | |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2601 | assert( p->pOrderBy!=0 ); |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2602 | db = pParse->db; |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2603 | v = pParse->pVdbe; |
| 2604 | if( v==0 ) return SQLITE_NOMEM; |
| 2605 | labelEnd = sqlite3VdbeMakeLabel(v); |
| 2606 | labelCmpr = sqlite3VdbeMakeLabel(v); |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2607 | |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2608 | |
| 2609 | /* Patch up the ORDER BY clause |
| 2610 | */ |
| 2611 | op = p->op; |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2612 | pPrior = p->pPrior; |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2613 | assert( pPrior->pOrderBy==0 ); |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2614 | pOrderBy = p->pOrderBy; |
| 2615 | if( pOrderBy ){ |
| 2616 | if( processCompoundOrderBy(pParse, p, 0) ){ |
| 2617 | return SQLITE_ERROR; |
| 2618 | } |
| 2619 | nOrderBy = pOrderBy->nExpr; |
| 2620 | }else{ |
| 2621 | nOrderBy = 0; |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2622 | } |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2623 | /* For operators other than UNION ALL we have to make sure that |
| 2624 | ** the ORDER BY clause covers every term of the result set. Add |
| 2625 | ** terms to the ORDER BY clause as necessary. |
| 2626 | */ |
| 2627 | if( op!=TK_ALL ){ |
| 2628 | for(i=1; db->mallocFailed==0 && i<=p->pEList->nExpr; i++){ |
| 2629 | for(j=0; j<nOrderBy; j++){ |
| 2630 | Expr *pTerm = pOrderBy->a[j].pExpr; |
| 2631 | assert( pTerm->op==TK_INTEGER ); |
| 2632 | assert( (pTerm->flags & EP_IntValue)!=0 ); |
| 2633 | if( pTerm->iTable==i ) break; |
| 2634 | } |
| 2635 | if( j==nOrderBy ){ |
| 2636 | Expr *pNew = sqlite3PExpr(pParse, TK_INTEGER, 0, 0, 0); |
| 2637 | if( pNew==0 ) return SQLITE_NOMEM; |
| 2638 | pNew->flags |= EP_IntValue; |
| 2639 | pNew->iTable = i; |
| 2640 | pOrderBy = sqlite3ExprListAppend(pParse, pOrderBy, pNew, 0); |
| 2641 | nOrderBy++; |
| 2642 | } |
| 2643 | } |
| 2644 | } |
| 2645 | |
| 2646 | /* Compute the comparison permutation and keyinfo that is used with |
| 2647 | ** the permutation in order to comparisons to determine if the next |
| 2648 | ** row of results comes from selectA or selectB. Also add explicit |
| 2649 | ** collations to the ORDER BY clause terms so that when the subqueries |
| 2650 | ** to the right and the left are evaluated, they use the correct |
| 2651 | ** collation. |
| 2652 | */ |
| 2653 | aPermute = sqlite3DbMallocRaw(db, sizeof(int)*nOrderBy); |
| 2654 | if( aPermute ){ |
| 2655 | for(i=0; i<nOrderBy; i++){ |
| 2656 | Expr *pTerm = pOrderBy->a[i].pExpr; |
| 2657 | assert( pTerm->op==TK_INTEGER ); |
| 2658 | assert( (pTerm->flags & EP_IntValue)!=0 ); |
| 2659 | aPermute[i] = pTerm->iTable-1; |
| 2660 | assert( aPermute[i]>=0 && aPermute[i]<p->pEList->nExpr ); |
| 2661 | } |
| 2662 | pKeyMerge = |
| 2663 | sqlite3DbMallocRaw(db, sizeof(*pKeyMerge)+nOrderBy*(sizeof(CollSeq*)+1)); |
| 2664 | if( pKeyMerge ){ |
| 2665 | pKeyMerge->aSortOrder = (u8*)&pKeyMerge->aColl[nOrderBy]; |
| 2666 | pKeyMerge->nField = nOrderBy; |
| 2667 | pKeyMerge->enc = ENC(db); |
| 2668 | for(i=0; i<nOrderBy; i++){ |
| 2669 | CollSeq *pColl; |
| 2670 | Expr *pTerm = pOrderBy->a[i].pExpr; |
| 2671 | if( pTerm->flags & EP_ExpCollate ){ |
| 2672 | pColl = pTerm->pColl; |
| 2673 | }else{ |
| 2674 | pColl = multiSelectCollSeq(pParse, p, aPermute[i]); |
| 2675 | pTerm->flags |= EP_ExpCollate; |
| 2676 | pTerm->pColl = pColl; |
| 2677 | } |
| 2678 | pKeyMerge->aColl[i] = pColl; |
| 2679 | pKeyMerge->aSortOrder[i] = pOrderBy->a[i].sortOrder; |
| 2680 | } |
| 2681 | } |
| 2682 | }else{ |
| 2683 | pKeyMerge = 0; |
| 2684 | } |
| 2685 | |
| 2686 | /* Reattach the ORDER BY clause to the query. |
| 2687 | */ |
| 2688 | p->pOrderBy = pOrderBy; |
| 2689 | pPrior->pOrderBy = sqlite3ExprListDup(pParse->db, pOrderBy); |
| 2690 | |
| 2691 | /* Allocate a range of temporary registers and the KeyInfo needed |
| 2692 | ** for the logic that removes duplicate result rows when the |
| 2693 | ** operator is UNION, EXCEPT, or INTERSECT (but not UNION ALL). |
| 2694 | */ |
| 2695 | if( op==TK_ALL ){ |
| 2696 | regPrev = 0; |
| 2697 | }else{ |
| 2698 | int nExpr = p->pEList->nExpr; |
| 2699 | assert( nOrderBy>=nExpr ); |
| 2700 | regPrev = sqlite3GetTempRange(pParse, nExpr+1); |
| 2701 | sqlite3VdbeAddOp2(v, OP_Integer, 0, regPrev); |
| 2702 | pKeyDup = sqlite3DbMallocZero(db, |
| 2703 | sizeof(*pKeyDup) + nExpr*(sizeof(CollSeq*)+1) ); |
| 2704 | if( pKeyDup ){ |
| 2705 | pKeyDup->aSortOrder = (u8*)&pKeyDup->aColl[nExpr]; |
| 2706 | pKeyDup->nField = nExpr; |
| 2707 | pKeyDup->enc = ENC(db); |
| 2708 | for(i=0; i<nExpr; i++){ |
| 2709 | pKeyDup->aColl[i] = multiSelectCollSeq(pParse, p, i); |
| 2710 | pKeyDup->aSortOrder[i] = 0; |
| 2711 | } |
| 2712 | } |
| 2713 | } |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2714 | |
| 2715 | /* Separate the left and the right query from one another |
| 2716 | */ |
| 2717 | p->pPrior = 0; |
| 2718 | pPrior->pRightmost = 0; |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2719 | processOrderGroupBy(pParse, p, p->pOrderBy, 1, &NotUsed); |
| 2720 | if( pPrior->pPrior==0 ){ |
| 2721 | processOrderGroupBy(pParse, pPrior, pPrior->pOrderBy, 1, &NotUsed); |
| 2722 | } |
| 2723 | |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2724 | /* Compute the limit registers */ |
| 2725 | computeLimitRegisters(pParse, p, labelEnd); |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2726 | if( p->iLimit && op==TK_ALL ){ |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2727 | regLimitA = ++pParse->nMem; |
| 2728 | regLimitB = ++pParse->nMem; |
| 2729 | sqlite3VdbeAddOp2(v, OP_Copy, p->iOffset ? p->iOffset+1 : p->iLimit, |
| 2730 | regLimitA); |
| 2731 | sqlite3VdbeAddOp2(v, OP_Copy, regLimitA, regLimitB); |
| 2732 | }else{ |
| 2733 | regLimitA = regLimitB = 0; |
| 2734 | } |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2735 | sqlite3ExprDelete(p->pLimit); |
| 2736 | p->pLimit = 0; |
| 2737 | sqlite3ExprDelete(p->pOffset); |
| 2738 | p->pOffset = 0; |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2739 | |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2740 | regAddrA = ++pParse->nMem; |
| 2741 | regEofA = ++pParse->nMem; |
| 2742 | regAddrB = ++pParse->nMem; |
| 2743 | regEofB = ++pParse->nMem; |
| 2744 | regOutA = ++pParse->nMem; |
| 2745 | regOutB = ++pParse->nMem; |
| 2746 | sqlite3SelectDestInit(&destA, SRT_Coroutine, regAddrA); |
| 2747 | sqlite3SelectDestInit(&destB, SRT_Coroutine, regAddrB); |
| 2748 | |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2749 | /* Jump past the various subroutines and coroutines to the main |
| 2750 | ** merge loop |
| 2751 | */ |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2752 | j1 = sqlite3VdbeAddOp0(v, OP_Goto); |
| 2753 | addrSelectA = sqlite3VdbeCurrentAddr(v); |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2754 | |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2755 | |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2756 | /* Generate a coroutine to evaluate the SELECT statement to the |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2757 | ** left of the compound operator - the "A" select. |
| 2758 | */ |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2759 | VdbeNoopComment((v, "Begin coroutine for left SELECT")); |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2760 | pPrior->iLimit = regLimitA; |
| 2761 | sqlite3Select(pParse, pPrior, &destA, 0, 0, 0, 0); |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2762 | sqlite3VdbeAddOp2(v, OP_Integer, 1, regEofA); |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2763 | sqlite3VdbeAddOp1(v, OP_Yield, regAddrA); |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2764 | VdbeNoopComment((v, "End coroutine for left SELECT")); |
| 2765 | |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2766 | /* Generate a coroutine to evaluate the SELECT statement on |
| 2767 | ** the right - the "B" select |
| 2768 | */ |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2769 | addrSelectB = sqlite3VdbeCurrentAddr(v); |
| 2770 | VdbeNoopComment((v, "Begin coroutine for right SELECT")); |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2771 | savedLimit = p->iLimit; |
| 2772 | savedOffset = p->iOffset; |
| 2773 | p->iLimit = regLimitB; |
| 2774 | p->iOffset = 0; |
| 2775 | sqlite3Select(pParse, p, &destB, 0, 0, 0, 0); |
| 2776 | p->iLimit = savedLimit; |
| 2777 | p->iOffset = savedOffset; |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2778 | sqlite3VdbeAddOp2(v, OP_Integer, 1, regEofB); |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2779 | sqlite3VdbeAddOp1(v, OP_Yield, regAddrB); |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2780 | VdbeNoopComment((v, "End coroutine for right SELECT")); |
| 2781 | |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2782 | /* Generate a subroutine that outputs the current row of the A |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2783 | ** select as the next output row of the compound select. |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2784 | */ |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2785 | VdbeNoopComment((v, "Output routine for A")); |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2786 | addrOutA = generateOutputSubroutine(pParse, |
| 2787 | p, &destA, pDest, regOutA, |
| 2788 | regPrev, pKeyDup, P4_KEYINFO_HANDOFF, labelEnd); |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2789 | |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2790 | /* Generate a subroutine that outputs the current row of the B |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2791 | ** select as the next output row of the compound select. |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2792 | */ |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2793 | if( op==TK_ALL || op==TK_UNION ){ |
| 2794 | VdbeNoopComment((v, "Output routine for B")); |
| 2795 | addrOutB = generateOutputSubroutine(pParse, |
| 2796 | p, &destB, pDest, regOutB, |
| 2797 | regPrev, pKeyDup, P4_KEYINFO_STATIC, labelEnd); |
| 2798 | } |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2799 | |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2800 | /* Generate a subroutine to run when the results from select A |
| 2801 | ** are exhausted and only data in select B remains. |
| 2802 | */ |
| 2803 | VdbeNoopComment((v, "eof-A subroutine")); |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2804 | if( op==TK_EXCEPT || op==TK_INTERSECT ){ |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2805 | addrEofA = sqlite3VdbeAddOp2(v, OP_Goto, 0, labelEnd); |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2806 | }else{ |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2807 | addrEofA = sqlite3VdbeAddOp2(v, OP_If, regEofB, labelEnd); |
| 2808 | sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB); |
| 2809 | sqlite3VdbeAddOp1(v, OP_Yield, regAddrB); |
| 2810 | sqlite3VdbeAddOp2(v, OP_Goto, 0, addrEofA); |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2811 | } |
| 2812 | |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2813 | /* Generate a subroutine to run when the results from select B |
| 2814 | ** are exhausted and only data in select A remains. |
| 2815 | */ |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2816 | if( op==TK_INTERSECT ){ |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2817 | addrEofB = addrEofA; |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2818 | }else{ |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2819 | VdbeNoopComment((v, "eof-B subroutine")); |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2820 | addrEofB = sqlite3VdbeAddOp2(v, OP_If, regEofA, labelEnd); |
| 2821 | sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA); |
| 2822 | sqlite3VdbeAddOp1(v, OP_Yield, regAddrA); |
| 2823 | sqlite3VdbeAddOp2(v, OP_Goto, 0, addrEofB); |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2824 | } |
| 2825 | |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2826 | /* Generate code to handle the case of A<B |
| 2827 | */ |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2828 | VdbeNoopComment((v, "A-lt-B subroutine")); |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2829 | addrAltB = sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA); |
| 2830 | sqlite3VdbeAddOp1(v, OP_Yield, regAddrA); |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2831 | sqlite3VdbeAddOp2(v, OP_If, regEofA, addrEofA); |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2832 | sqlite3VdbeAddOp2(v, OP_Goto, 0, labelCmpr); |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2833 | |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2834 | /* Generate code to handle the case of A==B |
| 2835 | */ |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2836 | if( op==TK_ALL ){ |
| 2837 | addrAeqB = addrAltB; |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2838 | }else if( op==TK_INTERSECT ){ |
| 2839 | addrAeqB = addrAltB; |
| 2840 | addrAltB++; |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2841 | }else{ |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2842 | VdbeNoopComment((v, "A-eq-B subroutine")); |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2843 | addrAeqB = |
| 2844 | sqlite3VdbeAddOp1(v, OP_Yield, regAddrA); |
| 2845 | sqlite3VdbeAddOp2(v, OP_If, regEofA, addrEofA); |
| 2846 | sqlite3VdbeAddOp2(v, OP_Goto, 0, labelCmpr); |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2847 | } |
| 2848 | |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2849 | /* Generate code to handle the case of A>B |
| 2850 | */ |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2851 | VdbeNoopComment((v, "A-gt-B subroutine")); |
| 2852 | addrAgtB = sqlite3VdbeCurrentAddr(v); |
| 2853 | if( op==TK_ALL || op==TK_UNION ){ |
| 2854 | sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB); |
| 2855 | } |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2856 | sqlite3VdbeAddOp1(v, OP_Yield, regAddrB); |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2857 | sqlite3VdbeAddOp2(v, OP_If, regEofB, addrEofB); |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2858 | sqlite3VdbeAddOp2(v, OP_Goto, 0, labelCmpr); |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2859 | |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2860 | /* This code runs once to initialize everything. |
| 2861 | */ |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2862 | sqlite3VdbeJumpHere(v, j1); |
| 2863 | sqlite3VdbeAddOp2(v, OP_Integer, 0, regEofA); |
| 2864 | sqlite3VdbeAddOp2(v, OP_Integer, 0, regEofB); |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2865 | sqlite3VdbeAddOp2(v, OP_Gosub, regAddrA, addrSelectA); |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2866 | sqlite3VdbeAddOp2(v, OP_Gosub, regAddrB, addrSelectB); |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2867 | sqlite3VdbeAddOp2(v, OP_If, regEofA, addrEofA); |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2868 | sqlite3VdbeAddOp2(v, OP_If, regEofB, addrEofB); |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2869 | |
| 2870 | /* Implement the main merge loop |
| 2871 | */ |
| 2872 | sqlite3VdbeResolveLabel(v, labelCmpr); |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2873 | sqlite3VdbeAddOp4(v, OP_Permutation, 0, 0, 0, (char*)aPermute, P4_INTARRAY); |
| 2874 | sqlite3VdbeAddOp4(v, OP_Compare, destA.iMem, destB.iMem, nOrderBy, |
| 2875 | (char*)pKeyMerge, P4_KEYINFO_HANDOFF); |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2876 | sqlite3VdbeAddOp3(v, OP_Jump, addrAltB, addrAeqB, addrAgtB); |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2877 | |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2878 | /* Release temporary registers |
| 2879 | */ |
| 2880 | if( regPrev ){ |
| 2881 | sqlite3ReleaseTempRange(pParse, regPrev, nOrderBy+1); |
| 2882 | } |
| 2883 | |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2884 | /* Jump to the this point in order to terminate the query. |
| 2885 | */ |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2886 | sqlite3VdbeResolveLabel(v, labelEnd); |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2887 | |
| 2888 | /* Set the number of output columns |
| 2889 | */ |
| 2890 | if( pDest->eDest==SRT_Callback ){ |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2891 | Select *pFirst = pPrior; |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2892 | while( pFirst->pPrior ) pFirst = pFirst->pPrior; |
| 2893 | generateColumnNames(pParse, 0, pFirst->pEList); |
| 2894 | } |
| 2895 | |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame^] | 2896 | /* Reassembly the compound query so that it will be freed correctly |
| 2897 | ** by the calling function */ |
| 2898 | p->pPrior = pPrior; |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2899 | |
drh | 92b01d5 | 2008-06-24 00:32:35 +0000 | [diff] [blame] | 2900 | /*** TBD: Insert subroutine calls to close cursors on incomplete |
| 2901 | **** subqueries ****/ |
| 2902 | return SQLITE_OK; |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2903 | } |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2904 | |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 2905 | #ifndef SQLITE_OMIT_VIEW |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 2906 | /* Forward Declarations */ |
| 2907 | static void substExprList(sqlite3*, ExprList*, int, ExprList*); |
| 2908 | static void substSelect(sqlite3*, Select *, int, ExprList *); |
| 2909 | |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 2910 | /* |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 2911 | ** Scan through the expression pExpr. Replace every reference to |
drh | 6a3ea0e | 2003-05-02 14:32:12 +0000 | [diff] [blame] | 2912 | ** a column in table number iTable with a copy of the iColumn-th |
drh | 84e5920 | 2002-03-14 14:33:31 +0000 | [diff] [blame] | 2913 | ** entry in pEList. (But leave references to the ROWID column |
drh | 6a3ea0e | 2003-05-02 14:32:12 +0000 | [diff] [blame] | 2914 | ** unchanged.) |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 2915 | ** |
| 2916 | ** This routine is part of the flattening procedure. A subquery |
| 2917 | ** whose result set is defined by pEList appears as entry in the |
| 2918 | ** FROM clause of a SELECT such that the VDBE cursor assigned to that |
| 2919 | ** FORM clause entry is iTable. This routine make the necessary |
| 2920 | ** changes to pExpr so that it refers directly to the source table |
| 2921 | ** of the subquery rather the result set of the subquery. |
| 2922 | */ |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 2923 | static void substExpr( |
| 2924 | sqlite3 *db, /* Report malloc errors to this connection */ |
| 2925 | Expr *pExpr, /* Expr in which substitution occurs */ |
| 2926 | int iTable, /* Table to be substituted */ |
| 2927 | ExprList *pEList /* Substitute expressions */ |
| 2928 | ){ |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 2929 | if( pExpr==0 ) return; |
drh | 50350a1 | 2004-02-13 16:22:22 +0000 | [diff] [blame] | 2930 | if( pExpr->op==TK_COLUMN && pExpr->iTable==iTable ){ |
| 2931 | if( pExpr->iColumn<0 ){ |
| 2932 | pExpr->op = TK_NULL; |
| 2933 | }else{ |
| 2934 | Expr *pNew; |
| 2935 | assert( pEList!=0 && pExpr->iColumn<pEList->nExpr ); |
| 2936 | assert( pExpr->pLeft==0 && pExpr->pRight==0 && pExpr->pList==0 ); |
| 2937 | pNew = pEList->a[pExpr->iColumn].pExpr; |
| 2938 | assert( pNew!=0 ); |
| 2939 | pExpr->op = pNew->op; |
drh | 50350a1 | 2004-02-13 16:22:22 +0000 | [diff] [blame] | 2940 | assert( pExpr->pLeft==0 ); |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 2941 | pExpr->pLeft = sqlite3ExprDup(db, pNew->pLeft); |
drh | 50350a1 | 2004-02-13 16:22:22 +0000 | [diff] [blame] | 2942 | assert( pExpr->pRight==0 ); |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 2943 | pExpr->pRight = sqlite3ExprDup(db, pNew->pRight); |
drh | 50350a1 | 2004-02-13 16:22:22 +0000 | [diff] [blame] | 2944 | assert( pExpr->pList==0 ); |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 2945 | pExpr->pList = sqlite3ExprListDup(db, pNew->pList); |
drh | 50350a1 | 2004-02-13 16:22:22 +0000 | [diff] [blame] | 2946 | pExpr->iTable = pNew->iTable; |
danielk1977 | fbbe005 | 2006-06-21 07:02:33 +0000 | [diff] [blame] | 2947 | pExpr->pTab = pNew->pTab; |
drh | 50350a1 | 2004-02-13 16:22:22 +0000 | [diff] [blame] | 2948 | pExpr->iColumn = pNew->iColumn; |
| 2949 | pExpr->iAgg = pNew->iAgg; |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 2950 | sqlite3TokenCopy(db, &pExpr->token, &pNew->token); |
| 2951 | sqlite3TokenCopy(db, &pExpr->span, &pNew->span); |
| 2952 | pExpr->pSelect = sqlite3SelectDup(db, pNew->pSelect); |
danielk1977 | a1cb183 | 2005-02-12 08:59:55 +0000 | [diff] [blame] | 2953 | pExpr->flags = pNew->flags; |
drh | 50350a1 | 2004-02-13 16:22:22 +0000 | [diff] [blame] | 2954 | } |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 2955 | }else{ |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 2956 | substExpr(db, pExpr->pLeft, iTable, pEList); |
| 2957 | substExpr(db, pExpr->pRight, iTable, pEList); |
| 2958 | substSelect(db, pExpr->pSelect, iTable, pEList); |
| 2959 | substExprList(db, pExpr->pList, iTable, pEList); |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 2960 | } |
| 2961 | } |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 2962 | static void substExprList( |
| 2963 | sqlite3 *db, /* Report malloc errors here */ |
| 2964 | ExprList *pList, /* List to scan and in which to make substitutes */ |
| 2965 | int iTable, /* Table to be substituted */ |
| 2966 | ExprList *pEList /* Substitute values */ |
| 2967 | ){ |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 2968 | int i; |
| 2969 | if( pList==0 ) return; |
| 2970 | for(i=0; i<pList->nExpr; i++){ |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 2971 | substExpr(db, pList->a[i].pExpr, iTable, pEList); |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 2972 | } |
| 2973 | } |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 2974 | static void substSelect( |
| 2975 | sqlite3 *db, /* Report malloc errors here */ |
| 2976 | Select *p, /* SELECT statement in which to make substitutions */ |
| 2977 | int iTable, /* Table to be replaced */ |
| 2978 | ExprList *pEList /* Substitute values */ |
| 2979 | ){ |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 2980 | if( !p ) return; |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 2981 | substExprList(db, p->pEList, iTable, pEList); |
| 2982 | substExprList(db, p->pGroupBy, iTable, pEList); |
| 2983 | substExprList(db, p->pOrderBy, iTable, pEList); |
| 2984 | substExpr(db, p->pHaving, iTable, pEList); |
| 2985 | substExpr(db, p->pWhere, iTable, pEList); |
| 2986 | substSelect(db, p->pPrior, iTable, pEList); |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 2987 | } |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 2988 | #endif /* !defined(SQLITE_OMIT_VIEW) */ |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 2989 | |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 2990 | #ifndef SQLITE_OMIT_VIEW |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 2991 | /* |
drh | 1350b03 | 2002-02-27 19:00:20 +0000 | [diff] [blame] | 2992 | ** This routine attempts to flatten subqueries in order to speed |
| 2993 | ** execution. It returns 1 if it makes changes and 0 if no flattening |
| 2994 | ** occurs. |
| 2995 | ** |
| 2996 | ** To understand the concept of flattening, consider the following |
| 2997 | ** query: |
| 2998 | ** |
| 2999 | ** SELECT a FROM (SELECT x+y AS a FROM t1 WHERE z<100) WHERE a>5 |
| 3000 | ** |
| 3001 | ** The default way of implementing this query is to execute the |
| 3002 | ** subquery first and store the results in a temporary table, then |
| 3003 | ** run the outer query on that temporary table. This requires two |
| 3004 | ** passes over the data. Furthermore, because the temporary table |
| 3005 | ** has no indices, the WHERE clause on the outer query cannot be |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 3006 | ** optimized. |
drh | 1350b03 | 2002-02-27 19:00:20 +0000 | [diff] [blame] | 3007 | ** |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 3008 | ** This routine attempts to rewrite queries such as the above into |
drh | 1350b03 | 2002-02-27 19:00:20 +0000 | [diff] [blame] | 3009 | ** a single flat select, like this: |
| 3010 | ** |
| 3011 | ** SELECT x+y AS a FROM t1 WHERE z<100 AND a>5 |
| 3012 | ** |
| 3013 | ** The code generated for this simpification gives the same result |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 3014 | ** but only has to scan the data once. And because indices might |
| 3015 | ** exist on the table t1, a complete scan of the data might be |
| 3016 | ** avoided. |
drh | 1350b03 | 2002-02-27 19:00:20 +0000 | [diff] [blame] | 3017 | ** |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 3018 | ** Flattening is only attempted if all of the following are true: |
drh | 1350b03 | 2002-02-27 19:00:20 +0000 | [diff] [blame] | 3019 | ** |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 3020 | ** (1) The subquery and the outer query do not both use aggregates. |
drh | 1350b03 | 2002-02-27 19:00:20 +0000 | [diff] [blame] | 3021 | ** |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 3022 | ** (2) The subquery is not an aggregate or the outer query is not a join. |
| 3023 | ** |
drh | 8af4d3a | 2003-05-06 20:35:16 +0000 | [diff] [blame] | 3024 | ** (3) The subquery is not the right operand of a left outer join, or |
| 3025 | ** the subquery is not itself a join. (Ticket #306) |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 3026 | ** |
| 3027 | ** (4) The subquery is not DISTINCT or the outer query is not a join. |
| 3028 | ** |
| 3029 | ** (5) The subquery is not DISTINCT or the outer query does not use |
| 3030 | ** aggregates. |
| 3031 | ** |
| 3032 | ** (6) The subquery does not use aggregates or the outer query is not |
| 3033 | ** DISTINCT. |
| 3034 | ** |
drh | 08192d5 | 2002-04-30 19:20:28 +0000 | [diff] [blame] | 3035 | ** (7) The subquery has a FROM clause. |
| 3036 | ** |
drh | df199a2 | 2002-06-14 22:38:41 +0000 | [diff] [blame] | 3037 | ** (8) The subquery does not use LIMIT or the outer query is not a join. |
| 3038 | ** |
| 3039 | ** (9) The subquery does not use LIMIT or the outer query does not use |
| 3040 | ** aggregates. |
| 3041 | ** |
| 3042 | ** (10) The subquery does not use aggregates or the outer query does not |
| 3043 | ** use LIMIT. |
| 3044 | ** |
drh | 174b619 | 2002-12-03 02:22:52 +0000 | [diff] [blame] | 3045 | ** (11) The subquery and the outer query do not both have ORDER BY clauses. |
| 3046 | ** |
drh | 3fc673e | 2003-06-16 00:40:34 +0000 | [diff] [blame] | 3047 | ** (12) The subquery is not the right term of a LEFT OUTER JOIN or the |
| 3048 | ** subquery has no WHERE clause. (added by ticket #350) |
| 3049 | ** |
drh | ac83963 | 2006-01-21 22:19:54 +0000 | [diff] [blame] | 3050 | ** (13) The subquery and outer query do not both use LIMIT |
| 3051 | ** |
| 3052 | ** (14) The subquery does not use OFFSET |
| 3053 | ** |
drh | ad91c6c | 2007-05-06 20:04:24 +0000 | [diff] [blame] | 3054 | ** (15) The outer query is not part of a compound select or the |
| 3055 | ** subquery does not have both an ORDER BY and a LIMIT clause. |
| 3056 | ** (See ticket #2339) |
| 3057 | ** |
drh | c52e355 | 2008-02-15 14:33:03 +0000 | [diff] [blame] | 3058 | ** (16) The outer query is not an aggregate or the subquery does |
| 3059 | ** not contain ORDER BY. (Ticket #2942) This used to not matter |
| 3060 | ** until we introduced the group_concat() function. |
| 3061 | ** |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 3062 | ** In this routine, the "p" parameter is a pointer to the outer query. |
| 3063 | ** The subquery is p->pSrc->a[iFrom]. isAgg is true if the outer query |
| 3064 | ** uses aggregates and subqueryIsAgg is true if the subquery uses aggregates. |
| 3065 | ** |
drh | 665de47 | 2003-03-31 13:36:09 +0000 | [diff] [blame] | 3066 | ** If flattening is not attempted, this routine is a no-op and returns 0. |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 3067 | ** If flattening is attempted this routine returns 1. |
| 3068 | ** |
| 3069 | ** All of the expression analysis must occur on both the outer query and |
| 3070 | ** the subquery before this routine runs. |
drh | 1350b03 | 2002-02-27 19:00:20 +0000 | [diff] [blame] | 3071 | */ |
drh | 8c74a8c | 2002-08-25 19:20:40 +0000 | [diff] [blame] | 3072 | static int flattenSubquery( |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 3073 | sqlite3 *db, /* Database connection */ |
drh | 8c74a8c | 2002-08-25 19:20:40 +0000 | [diff] [blame] | 3074 | Select *p, /* The parent or outer SELECT statement */ |
| 3075 | int iFrom, /* Index in p->pSrc->a[] of the inner subquery */ |
| 3076 | int isAgg, /* True if outer SELECT uses aggregate functions */ |
| 3077 | int subqueryIsAgg /* True if the subquery uses aggregate functions */ |
| 3078 | ){ |
drh | 0bb2810 | 2002-05-08 11:54:14 +0000 | [diff] [blame] | 3079 | Select *pSub; /* The inner query or "subquery" */ |
drh | ad3cab5 | 2002-05-24 02:04:32 +0000 | [diff] [blame] | 3080 | SrcList *pSrc; /* The FROM clause of the outer query */ |
| 3081 | SrcList *pSubSrc; /* The FROM clause of the subquery */ |
drh | 0bb2810 | 2002-05-08 11:54:14 +0000 | [diff] [blame] | 3082 | ExprList *pList; /* The result set of the outer query */ |
drh | 6a3ea0e | 2003-05-02 14:32:12 +0000 | [diff] [blame] | 3083 | int iParent; /* VDBE cursor number of the pSub result set temp table */ |
drh | 91bb0ee | 2004-09-01 03:06:34 +0000 | [diff] [blame] | 3084 | int i; /* Loop counter */ |
| 3085 | Expr *pWhere; /* The WHERE clause */ |
| 3086 | struct SrcList_item *pSubitem; /* The subquery */ |
drh | 1350b03 | 2002-02-27 19:00:20 +0000 | [diff] [blame] | 3087 | |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 3088 | /* Check to see if flattening is permitted. Return 0 if not. |
| 3089 | */ |
| 3090 | if( p==0 ) return 0; |
| 3091 | pSrc = p->pSrc; |
drh | ad3cab5 | 2002-05-24 02:04:32 +0000 | [diff] [blame] | 3092 | assert( pSrc && iFrom>=0 && iFrom<pSrc->nSrc ); |
drh | 91bb0ee | 2004-09-01 03:06:34 +0000 | [diff] [blame] | 3093 | pSubitem = &pSrc->a[iFrom]; |
| 3094 | pSub = pSubitem->pSelect; |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 3095 | assert( pSub!=0 ); |
drh | ac83963 | 2006-01-21 22:19:54 +0000 | [diff] [blame] | 3096 | if( isAgg && subqueryIsAgg ) return 0; /* Restriction (1) */ |
| 3097 | if( subqueryIsAgg && pSrc->nSrc>1 ) return 0; /* Restriction (2) */ |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 3098 | pSubSrc = pSub->pSrc; |
| 3099 | assert( pSubSrc ); |
drh | ac83963 | 2006-01-21 22:19:54 +0000 | [diff] [blame] | 3100 | /* Prior to version 3.1.2, when LIMIT and OFFSET had to be simple constants, |
| 3101 | ** not arbitrary expresssions, we allowed some combining of LIMIT and OFFSET |
| 3102 | ** because they could be computed at compile-time. But when LIMIT and OFFSET |
| 3103 | ** became arbitrary expressions, we were forced to add restrictions (13) |
| 3104 | ** and (14). */ |
| 3105 | if( pSub->pLimit && p->pLimit ) return 0; /* Restriction (13) */ |
| 3106 | if( pSub->pOffset ) return 0; /* Restriction (14) */ |
drh | ad91c6c | 2007-05-06 20:04:24 +0000 | [diff] [blame] | 3107 | if( p->pRightmost && pSub->pLimit && pSub->pOrderBy ){ |
| 3108 | return 0; /* Restriction (15) */ |
| 3109 | } |
drh | ac83963 | 2006-01-21 22:19:54 +0000 | [diff] [blame] | 3110 | if( pSubSrc->nSrc==0 ) return 0; /* Restriction (7) */ |
| 3111 | if( (pSub->isDistinct || pSub->pLimit) |
| 3112 | && (pSrc->nSrc>1 || isAgg) ){ /* Restrictions (4)(5)(8)(9) */ |
| 3113 | return 0; |
drh | df199a2 | 2002-06-14 22:38:41 +0000 | [diff] [blame] | 3114 | } |
drh | ac83963 | 2006-01-21 22:19:54 +0000 | [diff] [blame] | 3115 | if( p->isDistinct && subqueryIsAgg ) return 0; /* Restriction (6) */ |
| 3116 | if( (p->disallowOrderBy || p->pOrderBy) && pSub->pOrderBy ){ |
| 3117 | return 0; /* Restriction (11) */ |
| 3118 | } |
drh | c52e355 | 2008-02-15 14:33:03 +0000 | [diff] [blame] | 3119 | if( isAgg && pSub->pOrderBy ) return 0; /* Restriction (16) */ |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 3120 | |
drh | 8af4d3a | 2003-05-06 20:35:16 +0000 | [diff] [blame] | 3121 | /* Restriction 3: If the subquery is a join, make sure the subquery is |
| 3122 | ** not used as the right operand of an outer join. Examples of why this |
| 3123 | ** is not allowed: |
| 3124 | ** |
| 3125 | ** t1 LEFT OUTER JOIN (t2 JOIN t3) |
| 3126 | ** |
| 3127 | ** If we flatten the above, we would get |
| 3128 | ** |
| 3129 | ** (t1 LEFT OUTER JOIN t2) JOIN t3 |
| 3130 | ** |
| 3131 | ** which is not at all the same thing. |
| 3132 | */ |
drh | 61dfc31 | 2006-12-16 16:25:15 +0000 | [diff] [blame] | 3133 | if( pSubSrc->nSrc>1 && (pSubitem->jointype & JT_OUTER)!=0 ){ |
drh | 8af4d3a | 2003-05-06 20:35:16 +0000 | [diff] [blame] | 3134 | return 0; |
| 3135 | } |
| 3136 | |
drh | 3fc673e | 2003-06-16 00:40:34 +0000 | [diff] [blame] | 3137 | /* Restriction 12: If the subquery is the right operand of a left outer |
| 3138 | ** join, make sure the subquery has no WHERE clause. |
| 3139 | ** An examples of why this is not allowed: |
| 3140 | ** |
| 3141 | ** t1 LEFT OUTER JOIN (SELECT * FROM t2 WHERE t2.x>0) |
| 3142 | ** |
| 3143 | ** If we flatten the above, we would get |
| 3144 | ** |
| 3145 | ** (t1 LEFT OUTER JOIN t2) WHERE t2.x>0 |
| 3146 | ** |
| 3147 | ** But the t2.x>0 test will always fail on a NULL row of t2, which |
| 3148 | ** effectively converts the OUTER JOIN into an INNER JOIN. |
| 3149 | */ |
drh | 61dfc31 | 2006-12-16 16:25:15 +0000 | [diff] [blame] | 3150 | if( (pSubitem->jointype & JT_OUTER)!=0 && pSub->pWhere!=0 ){ |
drh | 3fc673e | 2003-06-16 00:40:34 +0000 | [diff] [blame] | 3151 | return 0; |
| 3152 | } |
| 3153 | |
drh | 0bb2810 | 2002-05-08 11:54:14 +0000 | [diff] [blame] | 3154 | /* If we reach this point, it means flattening is permitted for the |
drh | 63eb5f2 | 2003-04-29 16:20:44 +0000 | [diff] [blame] | 3155 | ** iFrom-th entry of the FROM clause in the outer query. |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 3156 | */ |
drh | c31c2eb | 2003-05-02 16:04:17 +0000 | [diff] [blame] | 3157 | |
| 3158 | /* Move all of the FROM elements of the subquery into the |
| 3159 | ** the FROM clause of the outer query. Before doing this, remember |
| 3160 | ** the cursor number for the original outer query FROM element in |
| 3161 | ** iParent. The iParent cursor will never be used. Subsequent code |
| 3162 | ** will scan expressions looking for iParent references and replace |
| 3163 | ** those references with expressions that resolve to the subquery FROM |
| 3164 | ** elements we are now copying in. |
| 3165 | */ |
drh | 91bb0ee | 2004-09-01 03:06:34 +0000 | [diff] [blame] | 3166 | iParent = pSubitem->iCursor; |
drh | c31c2eb | 2003-05-02 16:04:17 +0000 | [diff] [blame] | 3167 | { |
| 3168 | int nSubSrc = pSubSrc->nSrc; |
drh | 91bb0ee | 2004-09-01 03:06:34 +0000 | [diff] [blame] | 3169 | int jointype = pSubitem->jointype; |
drh | c31c2eb | 2003-05-02 16:04:17 +0000 | [diff] [blame] | 3170 | |
danielk1977 | a04a34f | 2007-04-16 15:06:25 +0000 | [diff] [blame] | 3171 | sqlite3DeleteTable(pSubitem->pTab); |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 3172 | sqlite3_free(pSubitem->zDatabase); |
| 3173 | sqlite3_free(pSubitem->zName); |
| 3174 | sqlite3_free(pSubitem->zAlias); |
drh | cfa063b | 2007-11-21 15:24:00 +0000 | [diff] [blame] | 3175 | pSubitem->pTab = 0; |
| 3176 | pSubitem->zDatabase = 0; |
| 3177 | pSubitem->zName = 0; |
| 3178 | pSubitem->zAlias = 0; |
drh | c31c2eb | 2003-05-02 16:04:17 +0000 | [diff] [blame] | 3179 | if( nSubSrc>1 ){ |
| 3180 | int extra = nSubSrc - 1; |
| 3181 | for(i=1; i<nSubSrc; i++){ |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 3182 | pSrc = sqlite3SrcListAppend(db, pSrc, 0, 0); |
drh | cfa063b | 2007-11-21 15:24:00 +0000 | [diff] [blame] | 3183 | if( pSrc==0 ){ |
| 3184 | p->pSrc = 0; |
| 3185 | return 1; |
| 3186 | } |
drh | c31c2eb | 2003-05-02 16:04:17 +0000 | [diff] [blame] | 3187 | } |
| 3188 | p->pSrc = pSrc; |
| 3189 | for(i=pSrc->nSrc-1; i-extra>=iFrom; i--){ |
| 3190 | pSrc->a[i] = pSrc->a[i-extra]; |
| 3191 | } |
| 3192 | } |
| 3193 | for(i=0; i<nSubSrc; i++){ |
| 3194 | pSrc->a[i+iFrom] = pSubSrc->a[i]; |
| 3195 | memset(&pSubSrc->a[i], 0, sizeof(pSubSrc->a[i])); |
| 3196 | } |
drh | 61dfc31 | 2006-12-16 16:25:15 +0000 | [diff] [blame] | 3197 | pSrc->a[iFrom].jointype = jointype; |
drh | c31c2eb | 2003-05-02 16:04:17 +0000 | [diff] [blame] | 3198 | } |
| 3199 | |
| 3200 | /* Now begin substituting subquery result set expressions for |
| 3201 | ** references to the iParent in the outer query. |
| 3202 | ** |
| 3203 | ** Example: |
| 3204 | ** |
| 3205 | ** SELECT a+5, b*10 FROM (SELECT x*3 AS a, y+10 AS b FROM t1) WHERE a>b; |
| 3206 | ** \ \_____________ subquery __________/ / |
| 3207 | ** \_____________________ outer query ______________________________/ |
| 3208 | ** |
| 3209 | ** We look at every expression in the outer query and every place we see |
| 3210 | ** "a" we substitute "x*3" and every place we see "b" we substitute "y+10". |
| 3211 | */ |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 3212 | pList = p->pEList; |
| 3213 | for(i=0; i<pList->nExpr; i++){ |
drh | 6977fea | 2002-10-22 23:38:04 +0000 | [diff] [blame] | 3214 | Expr *pExpr; |
| 3215 | if( pList->a[i].zName==0 && (pExpr = pList->a[i].pExpr)->span.z!=0 ){ |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 3216 | pList->a[i].zName = |
| 3217 | sqlite3DbStrNDup(db, (char*)pExpr->span.z, pExpr->span.n); |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 3218 | } |
| 3219 | } |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 3220 | substExprList(db, p->pEList, iParent, pSub->pEList); |
drh | 1b2e032 | 2002-03-03 02:49:51 +0000 | [diff] [blame] | 3221 | if( isAgg ){ |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 3222 | substExprList(db, p->pGroupBy, iParent, pSub->pEList); |
| 3223 | substExpr(db, p->pHaving, iParent, pSub->pEList); |
drh | 1b2e032 | 2002-03-03 02:49:51 +0000 | [diff] [blame] | 3224 | } |
drh | 174b619 | 2002-12-03 02:22:52 +0000 | [diff] [blame] | 3225 | if( pSub->pOrderBy ){ |
| 3226 | assert( p->pOrderBy==0 ); |
| 3227 | p->pOrderBy = pSub->pOrderBy; |
| 3228 | pSub->pOrderBy = 0; |
drh | 174b619 | 2002-12-03 02:22:52 +0000 | [diff] [blame] | 3229 | }else if( p->pOrderBy ){ |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 3230 | substExprList(db, p->pOrderBy, iParent, pSub->pEList); |
drh | 174b619 | 2002-12-03 02:22:52 +0000 | [diff] [blame] | 3231 | } |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 3232 | if( pSub->pWhere ){ |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 3233 | pWhere = sqlite3ExprDup(db, pSub->pWhere); |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 3234 | }else{ |
| 3235 | pWhere = 0; |
| 3236 | } |
| 3237 | if( subqueryIsAgg ){ |
| 3238 | assert( p->pHaving==0 ); |
drh | 1b2e032 | 2002-03-03 02:49:51 +0000 | [diff] [blame] | 3239 | p->pHaving = p->pWhere; |
| 3240 | p->pWhere = pWhere; |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 3241 | substExpr(db, p->pHaving, iParent, pSub->pEList); |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 3242 | p->pHaving = sqlite3ExprAnd(db, p->pHaving, |
| 3243 | sqlite3ExprDup(db, pSub->pHaving)); |
drh | 1b2e032 | 2002-03-03 02:49:51 +0000 | [diff] [blame] | 3244 | assert( p->pGroupBy==0 ); |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 3245 | p->pGroupBy = sqlite3ExprListDup(db, pSub->pGroupBy); |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 3246 | }else{ |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 3247 | substExpr(db, p->pWhere, iParent, pSub->pEList); |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 3248 | p->pWhere = sqlite3ExprAnd(db, p->pWhere, pWhere); |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 3249 | } |
drh | c31c2eb | 2003-05-02 16:04:17 +0000 | [diff] [blame] | 3250 | |
| 3251 | /* The flattened query is distinct if either the inner or the |
| 3252 | ** outer query is distinct. |
| 3253 | */ |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 3254 | p->isDistinct = p->isDistinct || pSub->isDistinct; |
drh | 8c74a8c | 2002-08-25 19:20:40 +0000 | [diff] [blame] | 3255 | |
danielk1977 | a58fdfb | 2005-02-08 07:50:40 +0000 | [diff] [blame] | 3256 | /* |
| 3257 | ** SELECT ... FROM (SELECT ... LIMIT a OFFSET b) LIMIT x OFFSET y; |
drh | ac83963 | 2006-01-21 22:19:54 +0000 | [diff] [blame] | 3258 | ** |
| 3259 | ** One is tempted to try to add a and b to combine the limits. But this |
| 3260 | ** does not work if either limit is negative. |
danielk1977 | a58fdfb | 2005-02-08 07:50:40 +0000 | [diff] [blame] | 3261 | */ |
danielk1977 | a2dc3b1 | 2005-02-05 12:48:48 +0000 | [diff] [blame] | 3262 | if( pSub->pLimit ){ |
| 3263 | p->pLimit = pSub->pLimit; |
| 3264 | pSub->pLimit = 0; |
drh | df199a2 | 2002-06-14 22:38:41 +0000 | [diff] [blame] | 3265 | } |
drh | 8c74a8c | 2002-08-25 19:20:40 +0000 | [diff] [blame] | 3266 | |
drh | c31c2eb | 2003-05-02 16:04:17 +0000 | [diff] [blame] | 3267 | /* Finially, delete what is left of the subquery and return |
| 3268 | ** success. |
| 3269 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 3270 | sqlite3SelectDelete(pSub); |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 3271 | return 1; |
| 3272 | } |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 3273 | #endif /* SQLITE_OMIT_VIEW */ |
drh | 1350b03 | 2002-02-27 19:00:20 +0000 | [diff] [blame] | 3274 | |
| 3275 | /* |
danielk1977 | a9d1ccb | 2008-01-05 17:39:29 +0000 | [diff] [blame] | 3276 | ** Analyze the SELECT statement passed as an argument to see if it |
drh | 08c88eb | 2008-04-10 13:33:18 +0000 | [diff] [blame] | 3277 | ** is a min() or max() query. Return WHERE_ORDERBY_MIN or WHERE_ORDERBY_MAX if |
danielk1977 | a9d1ccb | 2008-01-05 17:39:29 +0000 | [diff] [blame] | 3278 | ** it is, or 0 otherwise. At present, a query is considered to be |
| 3279 | ** a min()/max() query if: |
| 3280 | ** |
danielk1977 | 738bdcf | 2008-01-07 10:16:40 +0000 | [diff] [blame] | 3281 | ** 1. There is a single object in the FROM clause. |
| 3282 | ** |
| 3283 | ** 2. There is a single expression in the result set, and it is |
| 3284 | ** either min(x) or max(x), where x is a column reference. |
danielk1977 | a9d1ccb | 2008-01-05 17:39:29 +0000 | [diff] [blame] | 3285 | */ |
| 3286 | static int minMaxQuery(Parse *pParse, Select *p){ |
| 3287 | Expr *pExpr; |
| 3288 | ExprList *pEList = p->pEList; |
| 3289 | |
drh | 08c88eb | 2008-04-10 13:33:18 +0000 | [diff] [blame] | 3290 | if( pEList->nExpr!=1 ) return WHERE_ORDERBY_NORMAL; |
danielk1977 | a9d1ccb | 2008-01-05 17:39:29 +0000 | [diff] [blame] | 3291 | pExpr = pEList->a[0].pExpr; |
| 3292 | pEList = pExpr->pList; |
| 3293 | if( pExpr->op!=TK_AGG_FUNCTION || pEList==0 || pEList->nExpr!=1 ) return 0; |
drh | 08c88eb | 2008-04-10 13:33:18 +0000 | [diff] [blame] | 3294 | if( pEList->a[0].pExpr->op!=TK_AGG_COLUMN ) return WHERE_ORDERBY_NORMAL; |
| 3295 | if( pExpr->token.n!=3 ) return WHERE_ORDERBY_NORMAL; |
danielk1977 | a9d1ccb | 2008-01-05 17:39:29 +0000 | [diff] [blame] | 3296 | if( sqlite3StrNICmp((char*)pExpr->token.z,"min",3)==0 ){ |
drh | 08c88eb | 2008-04-10 13:33:18 +0000 | [diff] [blame] | 3297 | return WHERE_ORDERBY_MIN; |
danielk1977 | a9d1ccb | 2008-01-05 17:39:29 +0000 | [diff] [blame] | 3298 | }else if( sqlite3StrNICmp((char*)pExpr->token.z,"max",3)==0 ){ |
drh | 08c88eb | 2008-04-10 13:33:18 +0000 | [diff] [blame] | 3299 | return WHERE_ORDERBY_MAX; |
danielk1977 | a9d1ccb | 2008-01-05 17:39:29 +0000 | [diff] [blame] | 3300 | } |
drh | 08c88eb | 2008-04-10 13:33:18 +0000 | [diff] [blame] | 3301 | return WHERE_ORDERBY_NORMAL; |
danielk1977 | a9d1ccb | 2008-01-05 17:39:29 +0000 | [diff] [blame] | 3302 | } |
| 3303 | |
| 3304 | /* |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 3305 | ** This routine resolves any names used in the result set of the |
| 3306 | ** supplied SELECT statement. If the SELECT statement being resolved |
| 3307 | ** is a sub-select, then pOuterNC is a pointer to the NameContext |
| 3308 | ** of the parent SELECT. |
| 3309 | */ |
| 3310 | int sqlite3SelectResolve( |
| 3311 | Parse *pParse, /* The parser context */ |
| 3312 | Select *p, /* The SELECT statement being coded. */ |
| 3313 | NameContext *pOuterNC /* The outer name context. May be NULL. */ |
| 3314 | ){ |
| 3315 | ExprList *pEList; /* Result set. */ |
| 3316 | int i; /* For-loop variable used in multiple places */ |
| 3317 | NameContext sNC; /* Local name-context */ |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3318 | ExprList *pGroupBy; /* The group by clause */ |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 3319 | |
| 3320 | /* If this routine has run before, return immediately. */ |
| 3321 | if( p->isResolved ){ |
| 3322 | assert( !pOuterNC ); |
| 3323 | return SQLITE_OK; |
| 3324 | } |
| 3325 | p->isResolved = 1; |
| 3326 | |
| 3327 | /* If there have already been errors, do nothing. */ |
| 3328 | if( pParse->nErr>0 ){ |
| 3329 | return SQLITE_ERROR; |
| 3330 | } |
| 3331 | |
| 3332 | /* Prepare the select statement. This call will allocate all cursors |
| 3333 | ** required to handle the tables and subqueries in the FROM clause. |
| 3334 | */ |
| 3335 | if( prepSelectStmt(pParse, p) ){ |
| 3336 | return SQLITE_ERROR; |
| 3337 | } |
| 3338 | |
danielk1977 | a2dc3b1 | 2005-02-05 12:48:48 +0000 | [diff] [blame] | 3339 | /* Resolve the expressions in the LIMIT and OFFSET clauses. These |
| 3340 | ** are not allowed to refer to any names, so pass an empty NameContext. |
| 3341 | */ |
drh | ffe07b2 | 2005-11-03 00:41:17 +0000 | [diff] [blame] | 3342 | memset(&sNC, 0, sizeof(sNC)); |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 3343 | sNC.pParse = pParse; |
danielk1977 | a2dc3b1 | 2005-02-05 12:48:48 +0000 | [diff] [blame] | 3344 | if( sqlite3ExprResolveNames(&sNC, p->pLimit) || |
| 3345 | sqlite3ExprResolveNames(&sNC, p->pOffset) ){ |
| 3346 | return SQLITE_ERROR; |
| 3347 | } |
| 3348 | |
| 3349 | /* Set up the local name-context to pass to ExprResolveNames() to |
| 3350 | ** resolve the expression-list. |
| 3351 | */ |
| 3352 | sNC.allowAgg = 1; |
| 3353 | sNC.pSrcList = p->pSrc; |
| 3354 | sNC.pNext = pOuterNC; |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 3355 | |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 3356 | /* Resolve names in the result set. */ |
| 3357 | pEList = p->pEList; |
| 3358 | if( !pEList ) return SQLITE_ERROR; |
| 3359 | for(i=0; i<pEList->nExpr; i++){ |
| 3360 | Expr *pX = pEList->a[i].pExpr; |
| 3361 | if( sqlite3ExprResolveNames(&sNC, pX) ){ |
| 3362 | return SQLITE_ERROR; |
| 3363 | } |
| 3364 | } |
| 3365 | |
| 3366 | /* If there are no aggregate functions in the result-set, and no GROUP BY |
| 3367 | ** expression, do not allow aggregates in any of the other expressions. |
| 3368 | */ |
| 3369 | assert( !p->isAgg ); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3370 | pGroupBy = p->pGroupBy; |
| 3371 | if( pGroupBy || sNC.hasAgg ){ |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 3372 | p->isAgg = 1; |
| 3373 | }else{ |
| 3374 | sNC.allowAgg = 0; |
| 3375 | } |
| 3376 | |
| 3377 | /* If a HAVING clause is present, then there must be a GROUP BY clause. |
| 3378 | */ |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3379 | if( p->pHaving && !pGroupBy ){ |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 3380 | sqlite3ErrorMsg(pParse, "a GROUP BY clause is required before HAVING"); |
| 3381 | return SQLITE_ERROR; |
| 3382 | } |
| 3383 | |
| 3384 | /* Add the expression list to the name-context before parsing the |
| 3385 | ** other expressions in the SELECT statement. This is so that |
| 3386 | ** expressions in the WHERE clause (etc.) can refer to expressions by |
| 3387 | ** aliases in the result set. |
| 3388 | ** |
| 3389 | ** Minor point: If this is the case, then the expression will be |
| 3390 | ** re-evaluated for each reference to it. |
| 3391 | */ |
| 3392 | sNC.pEList = p->pEList; |
| 3393 | if( sqlite3ExprResolveNames(&sNC, p->pWhere) || |
drh | 994c80a | 2007-04-12 21:25:01 +0000 | [diff] [blame] | 3394 | sqlite3ExprResolveNames(&sNC, p->pHaving) ){ |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 3395 | return SQLITE_ERROR; |
| 3396 | } |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 3397 | if( p->pPrior==0 ){ |
danielk1977 | 01874bf | 2007-12-13 07:58:50 +0000 | [diff] [blame] | 3398 | if( processOrderGroupBy(pParse, p, p->pOrderBy, 1, &sNC.hasAgg) ){ |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 3399 | return SQLITE_ERROR; |
| 3400 | } |
drh | 4c77431 | 2007-12-08 21:10:20 +0000 | [diff] [blame] | 3401 | } |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 3402 | if( processOrderGroupBy(pParse, p, pGroupBy, 0, &sNC.hasAgg) ){ |
drh | 4c77431 | 2007-12-08 21:10:20 +0000 | [diff] [blame] | 3403 | return SQLITE_ERROR; |
drh | 994c80a | 2007-04-12 21:25:01 +0000 | [diff] [blame] | 3404 | } |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 3405 | |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 3406 | if( pParse->db->mallocFailed ){ |
danielk1977 | 9afe689 | 2007-05-31 08:20:43 +0000 | [diff] [blame] | 3407 | return SQLITE_NOMEM; |
| 3408 | } |
| 3409 | |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3410 | /* Make sure the GROUP BY clause does not contain aggregate functions. |
| 3411 | */ |
| 3412 | if( pGroupBy ){ |
| 3413 | struct ExprList_item *pItem; |
| 3414 | |
| 3415 | for(i=0, pItem=pGroupBy->a; i<pGroupBy->nExpr; i++, pItem++){ |
| 3416 | if( ExprHasProperty(pItem->pExpr, EP_Agg) ){ |
| 3417 | sqlite3ErrorMsg(pParse, "aggregate functions are not allowed in " |
| 3418 | "the GROUP BY clause"); |
| 3419 | return SQLITE_ERROR; |
| 3420 | } |
| 3421 | } |
| 3422 | } |
| 3423 | |
drh | f6bbe02 | 2006-10-13 15:34:16 +0000 | [diff] [blame] | 3424 | /* If this is one SELECT of a compound, be sure to resolve names |
| 3425 | ** in the other SELECTs. |
| 3426 | */ |
| 3427 | if( p->pPrior ){ |
| 3428 | return sqlite3SelectResolve(pParse, p->pPrior, pOuterNC); |
| 3429 | }else{ |
| 3430 | return SQLITE_OK; |
| 3431 | } |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 3432 | } |
| 3433 | |
| 3434 | /* |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3435 | ** Reset the aggregate accumulator. |
| 3436 | ** |
| 3437 | ** The aggregate accumulator is a set of memory cells that hold |
| 3438 | ** intermediate results while calculating an aggregate. This |
| 3439 | ** routine simply stores NULLs in all of those memory cells. |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 3440 | */ |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3441 | static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){ |
| 3442 | Vdbe *v = pParse->pVdbe; |
| 3443 | int i; |
drh | c99130f | 2005-09-11 11:56:27 +0000 | [diff] [blame] | 3444 | struct AggInfo_func *pFunc; |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3445 | if( pAggInfo->nFunc+pAggInfo->nColumn==0 ){ |
| 3446 | return; |
| 3447 | } |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3448 | for(i=0; i<pAggInfo->nColumn; i++){ |
drh | 4c58312 | 2008-01-04 22:01:03 +0000 | [diff] [blame] | 3449 | sqlite3VdbeAddOp2(v, OP_Null, 0, pAggInfo->aCol[i].iMem); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3450 | } |
drh | c99130f | 2005-09-11 11:56:27 +0000 | [diff] [blame] | 3451 | for(pFunc=pAggInfo->aFunc, i=0; i<pAggInfo->nFunc; i++, pFunc++){ |
drh | 4c58312 | 2008-01-04 22:01:03 +0000 | [diff] [blame] | 3452 | sqlite3VdbeAddOp2(v, OP_Null, 0, pFunc->iMem); |
drh | c99130f | 2005-09-11 11:56:27 +0000 | [diff] [blame] | 3453 | if( pFunc->iDistinct>=0 ){ |
| 3454 | Expr *pE = pFunc->pExpr; |
| 3455 | if( pE->pList==0 || pE->pList->nExpr!=1 ){ |
| 3456 | sqlite3ErrorMsg(pParse, "DISTINCT in aggregate must be followed " |
| 3457 | "by an expression"); |
| 3458 | pFunc->iDistinct = -1; |
| 3459 | }else{ |
| 3460 | KeyInfo *pKeyInfo = keyInfoFromExprList(pParse, pE->pList); |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 3461 | sqlite3VdbeAddOp4(v, OP_OpenEphemeral, pFunc->iDistinct, 0, 0, |
| 3462 | (char*)pKeyInfo, P4_KEYINFO_HANDOFF); |
drh | c99130f | 2005-09-11 11:56:27 +0000 | [diff] [blame] | 3463 | } |
| 3464 | } |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3465 | } |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 3466 | } |
| 3467 | |
| 3468 | /* |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3469 | ** Invoke the OP_AggFinalize opcode for every aggregate function |
| 3470 | ** in the AggInfo structure. |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 3471 | */ |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3472 | static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){ |
| 3473 | Vdbe *v = pParse->pVdbe; |
| 3474 | int i; |
| 3475 | struct AggInfo_func *pF; |
| 3476 | for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){ |
drh | a10a34b | 2005-09-07 22:09:48 +0000 | [diff] [blame] | 3477 | ExprList *pList = pF->pExpr->pList; |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 3478 | sqlite3VdbeAddOp4(v, OP_AggFinal, pF->iMem, pList ? pList->nExpr : 0, 0, |
| 3479 | (void*)pF->pFunc, P4_FUNCDEF); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3480 | } |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 3481 | } |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3482 | |
| 3483 | /* |
| 3484 | ** Update the accumulator memory cells for an aggregate based on |
| 3485 | ** the current cursor position. |
| 3486 | */ |
| 3487 | static void updateAccumulator(Parse *pParse, AggInfo *pAggInfo){ |
| 3488 | Vdbe *v = pParse->pVdbe; |
| 3489 | int i; |
| 3490 | struct AggInfo_func *pF; |
| 3491 | struct AggInfo_col *pC; |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3492 | |
| 3493 | pAggInfo->directMode = 1; |
| 3494 | for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){ |
| 3495 | int nArg; |
drh | c99130f | 2005-09-11 11:56:27 +0000 | [diff] [blame] | 3496 | int addrNext = 0; |
drh | 9875715 | 2008-01-09 23:04:12 +0000 | [diff] [blame] | 3497 | int regAgg; |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3498 | ExprList *pList = pF->pExpr->pList; |
| 3499 | if( pList ){ |
| 3500 | nArg = pList->nExpr; |
drh | 892d317 | 2008-01-10 03:46:36 +0000 | [diff] [blame] | 3501 | regAgg = sqlite3GetTempRange(pParse, nArg); |
drh | 191b54c | 2008-04-15 12:14:21 +0000 | [diff] [blame] | 3502 | sqlite3ExprCodeExprList(pParse, pList, regAgg, 0); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3503 | }else{ |
| 3504 | nArg = 0; |
drh | 9875715 | 2008-01-09 23:04:12 +0000 | [diff] [blame] | 3505 | regAgg = 0; |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3506 | } |
drh | c99130f | 2005-09-11 11:56:27 +0000 | [diff] [blame] | 3507 | if( pF->iDistinct>=0 ){ |
| 3508 | addrNext = sqlite3VdbeMakeLabel(v); |
| 3509 | assert( nArg==1 ); |
drh | 2dcef11 | 2008-01-12 19:03:48 +0000 | [diff] [blame] | 3510 | codeDistinct(pParse, pF->iDistinct, addrNext, 1, regAgg); |
drh | c99130f | 2005-09-11 11:56:27 +0000 | [diff] [blame] | 3511 | } |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3512 | if( pF->pFunc->needCollSeq ){ |
| 3513 | CollSeq *pColl = 0; |
| 3514 | struct ExprList_item *pItem; |
| 3515 | int j; |
drh | 43617e9 | 2006-03-06 20:55:46 +0000 | [diff] [blame] | 3516 | assert( pList!=0 ); /* pList!=0 if pF->pFunc->needCollSeq is true */ |
| 3517 | for(j=0, pItem=pList->a; !pColl && j<nArg; j++, pItem++){ |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3518 | pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr); |
| 3519 | } |
| 3520 | if( !pColl ){ |
| 3521 | pColl = pParse->db->pDfltColl; |
| 3522 | } |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 3523 | sqlite3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3524 | } |
drh | 9875715 | 2008-01-09 23:04:12 +0000 | [diff] [blame] | 3525 | sqlite3VdbeAddOp4(v, OP_AggStep, 0, regAgg, pF->iMem, |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 3526 | (void*)pF->pFunc, P4_FUNCDEF); |
drh | 9875715 | 2008-01-09 23:04:12 +0000 | [diff] [blame] | 3527 | sqlite3VdbeChangeP5(v, nArg); |
drh | 892d317 | 2008-01-10 03:46:36 +0000 | [diff] [blame] | 3528 | sqlite3ReleaseTempRange(pParse, regAgg, nArg); |
drh | da250ea | 2008-04-01 05:07:14 +0000 | [diff] [blame] | 3529 | sqlite3ExprCacheAffinityChange(pParse, regAgg, nArg); |
drh | c99130f | 2005-09-11 11:56:27 +0000 | [diff] [blame] | 3530 | if( addrNext ){ |
| 3531 | sqlite3VdbeResolveLabel(v, addrNext); |
| 3532 | } |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3533 | } |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3534 | for(i=0, pC=pAggInfo->aCol; i<pAggInfo->nAccumulator; i++, pC++){ |
drh | 389a1ad | 2008-01-03 23:44:53 +0000 | [diff] [blame] | 3535 | sqlite3ExprCode(pParse, pC->pExpr, pC->iMem); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3536 | } |
| 3537 | pAggInfo->directMode = 0; |
| 3538 | } |
| 3539 | |
drh | e265b08 | 2008-05-01 17:03:49 +0000 | [diff] [blame] | 3540 | #if 0 |
danielk1977 | 8f2c54e | 2008-01-01 19:02:09 +0000 | [diff] [blame] | 3541 | /* |
| 3542 | ** This function is used when a SELECT statement is used to create a |
| 3543 | ** temporary table for iterating through when running an INSTEAD OF |
| 3544 | ** UPDATE or INSTEAD OF DELETE trigger. |
| 3545 | ** |
| 3546 | ** If possible, the SELECT statement is modified so that NULL values |
| 3547 | ** are stored in the temporary table for all columns for which the |
| 3548 | ** corresponding bit in argument mask is not set. If mask takes the |
| 3549 | ** special value 0xffffffff, then all columns are populated. |
| 3550 | */ |
drh | d2b3e23 | 2008-01-23 14:51:49 +0000 | [diff] [blame] | 3551 | void sqlite3SelectMask(Parse *pParse, Select *p, u32 mask){ |
danielk1977 | cdf3020 | 2008-01-24 14:27:44 +0000 | [diff] [blame] | 3552 | if( p && !p->pPrior && !p->isDistinct && mask!=0xffffffff ){ |
danielk1977 | 8f2c54e | 2008-01-01 19:02:09 +0000 | [diff] [blame] | 3553 | ExprList *pEList; |
| 3554 | int i; |
drh | d2b3e23 | 2008-01-23 14:51:49 +0000 | [diff] [blame] | 3555 | sqlite3SelectResolve(pParse, p, 0); |
danielk1977 | 8f2c54e | 2008-01-01 19:02:09 +0000 | [diff] [blame] | 3556 | pEList = p->pEList; |
danielk1977 | cdf3020 | 2008-01-24 14:27:44 +0000 | [diff] [blame] | 3557 | for(i=0; pEList && i<pEList->nExpr && i<32; i++){ |
danielk1977 | 8f2c54e | 2008-01-01 19:02:09 +0000 | [diff] [blame] | 3558 | if( !(mask&((u32)1<<i)) ){ |
| 3559 | sqlite3ExprDelete(pEList->a[i].pExpr); |
| 3560 | pEList->a[i].pExpr = sqlite3Expr(pParse->db, TK_NULL, 0, 0, 0); |
| 3561 | } |
| 3562 | } |
| 3563 | } |
danielk1977 | 8f2c54e | 2008-01-01 19:02:09 +0000 | [diff] [blame] | 3564 | } |
| 3565 | #endif |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3566 | |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 3567 | /* |
drh | 9bb61fe | 2000-06-05 16:01:39 +0000 | [diff] [blame] | 3568 | ** Generate code for the given SELECT statement. |
| 3569 | ** |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 3570 | ** The results are distributed in various ways depending on the |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 3571 | ** contents of the SelectDest structure pointed to by argument pDest |
| 3572 | ** as follows: |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 3573 | ** |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 3574 | ** pDest->eDest Result |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 3575 | ** ------------ ------------------------------------------- |
| 3576 | ** SRT_Callback Invoke the callback for each row of the result. |
| 3577 | ** |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 3578 | ** SRT_Mem Store first result in memory cell pDest->iParm |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 3579 | ** |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 3580 | ** SRT_Set Store non-null results as keys of table pDest->iParm. |
| 3581 | ** Apply the affinity pDest->affinity before storing them. |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 3582 | ** |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 3583 | ** SRT_Union Store results as a key in a temporary table pDest->iParm. |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 3584 | ** |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 3585 | ** SRT_Except Remove results from the temporary table pDest->iParm. |
drh | c4a3c77 | 2001-04-04 11:48:57 +0000 | [diff] [blame] | 3586 | ** |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 3587 | ** SRT_Table Store results in temporary table pDest->iParm |
drh | 9bb61fe | 2000-06-05 16:01:39 +0000 | [diff] [blame] | 3588 | ** |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 3589 | ** SRT_EphemTab Create an temporary table pDest->iParm and store |
| 3590 | ** the result there. The cursor is left open after |
| 3591 | ** returning. |
| 3592 | ** |
drh | e00ee6e | 2008-06-20 15:24:01 +0000 | [diff] [blame] | 3593 | ** SRT_Coroutine Invoke a co-routine to compute a single row of |
| 3594 | ** the result |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 3595 | ** |
| 3596 | ** SRT_Exists Store a 1 in memory cell pDest->iParm if the result |
| 3597 | ** set is not empty. |
| 3598 | ** |
| 3599 | ** SRT_Discard Throw the results away. |
| 3600 | ** |
| 3601 | ** See the selectInnerLoop() function for a canonical listing of the |
| 3602 | ** allowed values of eDest and their meanings. |
drh | e78e828 | 2003-01-19 03:59:45 +0000 | [diff] [blame] | 3603 | ** |
drh | 9bb61fe | 2000-06-05 16:01:39 +0000 | [diff] [blame] | 3604 | ** This routine returns the number of errors. If any errors are |
| 3605 | ** encountered, then an appropriate error message is left in |
| 3606 | ** pParse->zErrMsg. |
| 3607 | ** |
| 3608 | ** This routine does NOT free the Select structure passed in. The |
| 3609 | ** calling function needs to do that. |
drh | 1b2e032 | 2002-03-03 02:49:51 +0000 | [diff] [blame] | 3610 | ** |
| 3611 | ** The pParent, parentTab, and *pParentAgg fields are filled in if this |
| 3612 | ** SELECT is a subquery. This routine may try to combine this SELECT |
| 3613 | ** with its parent to form a single flat query. In so doing, it might |
| 3614 | ** change the parent query from a non-aggregate to an aggregate query. |
| 3615 | ** For that reason, the pParentAgg flag is passed as a pointer, so it |
| 3616 | ** can be changed. |
drh | e78e828 | 2003-01-19 03:59:45 +0000 | [diff] [blame] | 3617 | ** |
| 3618 | ** Example 1: The meaning of the pParent parameter. |
| 3619 | ** |
| 3620 | ** SELECT * FROM t1 JOIN (SELECT x, count(*) FROM t2) JOIN t3; |
| 3621 | ** \ \_______ subquery _______/ / |
| 3622 | ** \ / |
| 3623 | ** \____________________ outer query ___________________/ |
| 3624 | ** |
| 3625 | ** This routine is called for the outer query first. For that call, |
| 3626 | ** pParent will be NULL. During the processing of the outer query, this |
| 3627 | ** routine is called recursively to handle the subquery. For the recursive |
| 3628 | ** call, pParent will point to the outer query. Because the subquery is |
| 3629 | ** the second element in a three-way join, the parentTab parameter will |
| 3630 | ** be 1 (the 2nd value of a 0-indexed array.) |
drh | 9bb61fe | 2000-06-05 16:01:39 +0000 | [diff] [blame] | 3631 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 3632 | int sqlite3Select( |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 3633 | Parse *pParse, /* The parser context */ |
drh | 9bb61fe | 2000-06-05 16:01:39 +0000 | [diff] [blame] | 3634 | Select *p, /* The SELECT statement being coded. */ |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 3635 | SelectDest *pDest, /* What to do with the query results */ |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 3636 | Select *pParent, /* Another SELECT for which this is a sub-query */ |
| 3637 | int parentTab, /* Index in pParent->pSrc of this query */ |
danielk1977 | 84ac9d0 | 2004-05-18 09:58:06 +0000 | [diff] [blame] | 3638 | int *pParentAgg, /* True if pParent uses aggregate functions */ |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 3639 | char *aff /* If eDest is SRT_Union, the affinity string */ |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 3640 | ){ |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3641 | int i, j; /* Loop counters */ |
| 3642 | WhereInfo *pWInfo; /* Return from sqlite3WhereBegin() */ |
| 3643 | Vdbe *v; /* The virtual machine under construction */ |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 3644 | int isAgg; /* True for select lists like "count(*)" */ |
drh | a2e0004 | 2002-01-22 03:13:42 +0000 | [diff] [blame] | 3645 | ExprList *pEList; /* List of columns to extract. */ |
drh | ad3cab5 | 2002-05-24 02:04:32 +0000 | [diff] [blame] | 3646 | SrcList *pTabList; /* List of tables to select from */ |
drh | 9bb61fe | 2000-06-05 16:01:39 +0000 | [diff] [blame] | 3647 | Expr *pWhere; /* The WHERE clause. May be NULL */ |
| 3648 | ExprList *pOrderBy; /* The ORDER BY clause. May be NULL */ |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 3649 | ExprList *pGroupBy; /* The GROUP BY clause. May be NULL */ |
| 3650 | Expr *pHaving; /* The HAVING clause. May be NULL */ |
drh | 19a775c | 2000-06-05 18:54:46 +0000 | [diff] [blame] | 3651 | int isDistinct; /* True if the DISTINCT keyword is present */ |
| 3652 | int distinct; /* Table to use for the distinct set */ |
drh | 1d83f05 | 2002-02-17 00:30:36 +0000 | [diff] [blame] | 3653 | int rc = 1; /* Value to return from this function */ |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 3654 | int addrSortIndex; /* Address of an OP_OpenEphemeral instruction */ |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3655 | AggInfo sAggInfo; /* Information used by aggregate queries */ |
drh | ec7429a | 2005-10-06 16:53:14 +0000 | [diff] [blame] | 3656 | int iEnd; /* Address of the end of the query */ |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 3657 | sqlite3 *db; /* The database connection */ |
drh | 9bb61fe | 2000-06-05 16:01:39 +0000 | [diff] [blame] | 3658 | |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 3659 | db = pParse->db; |
| 3660 | if( p==0 || db->mallocFailed || pParse->nErr ){ |
drh | 6f7adc8 | 2006-01-11 21:41:20 +0000 | [diff] [blame] | 3661 | return 1; |
| 3662 | } |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 3663 | if( sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1; |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3664 | memset(&sAggInfo, 0, sizeof(sAggInfo)); |
drh | daffd0e | 2001-04-11 14:28:42 +0000 | [diff] [blame] | 3665 | |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 3666 | pOrderBy = p->pOrderBy; |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 3667 | if( IgnorableOrderby(pDest) ){ |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 3668 | p->pOrderBy = 0; |
danielk1977 | 9ed1dfa | 2008-01-02 17:11:14 +0000 | [diff] [blame] | 3669 | |
| 3670 | /* In these cases the DISTINCT operator makes no difference to the |
| 3671 | ** results, so remove it if it were specified. |
| 3672 | */ |
| 3673 | assert(pDest->eDest==SRT_Exists || pDest->eDest==SRT_Union || |
| 3674 | pDest->eDest==SRT_Except || pDest->eDest==SRT_Discard); |
| 3675 | p->isDistinct = 0; |
drh | 9a99334 | 2007-12-13 02:45:31 +0000 | [diff] [blame] | 3676 | } |
| 3677 | if( sqlite3SelectResolve(pParse, p, 0) ){ |
| 3678 | goto select_end; |
| 3679 | } |
| 3680 | p->pOrderBy = pOrderBy; |
| 3681 | |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 3682 | #ifndef SQLITE_OMIT_COMPOUND_SELECT |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 3683 | /* If there is are a sequence of queries, do the earlier ones first. |
| 3684 | */ |
| 3685 | if( p->pPrior ){ |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 3686 | if( p->pRightmost==0 ){ |
drh | 1e28129 | 2007-12-13 03:45:07 +0000 | [diff] [blame] | 3687 | Select *pLoop, *pRight = 0; |
drh | 0325d87 | 2007-06-07 10:55:35 +0000 | [diff] [blame] | 3688 | int cnt = 0; |
drh | bb4957f | 2008-03-20 14:03:29 +0000 | [diff] [blame] | 3689 | int mxSelect; |
drh | 0325d87 | 2007-06-07 10:55:35 +0000 | [diff] [blame] | 3690 | for(pLoop=p; pLoop; pLoop=pLoop->pPrior, cnt++){ |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 3691 | pLoop->pRightmost = p; |
drh | 1e28129 | 2007-12-13 03:45:07 +0000 | [diff] [blame] | 3692 | pLoop->pNext = pRight; |
| 3693 | pRight = pLoop; |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 3694 | } |
drh | bb4957f | 2008-03-20 14:03:29 +0000 | [diff] [blame] | 3695 | mxSelect = db->aLimit[SQLITE_LIMIT_COMPOUND_SELECT]; |
| 3696 | if( mxSelect && cnt>mxSelect ){ |
drh | 0325d87 | 2007-06-07 10:55:35 +0000 | [diff] [blame] | 3697 | sqlite3ErrorMsg(pParse, "too many terms in compound SELECT"); |
| 3698 | return 1; |
| 3699 | } |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 3700 | } |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 3701 | return multiSelect(pParse, p, pDest, aff); |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 3702 | } |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 3703 | #endif |
drh | 82c3d63 | 2000-06-06 21:56:07 +0000 | [diff] [blame] | 3704 | |
| 3705 | /* Make local copies of the parameters for this query. |
| 3706 | */ |
drh | 9bb61fe | 2000-06-05 16:01:39 +0000 | [diff] [blame] | 3707 | pTabList = p->pSrc; |
| 3708 | pWhere = p->pWhere; |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 3709 | pGroupBy = p->pGroupBy; |
| 3710 | pHaving = p->pHaving; |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 3711 | isAgg = p->isAgg; |
drh | 19a775c | 2000-06-05 18:54:46 +0000 | [diff] [blame] | 3712 | isDistinct = p->isDistinct; |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 3713 | pEList = p->pEList; |
| 3714 | if( pEList==0 ) goto select_end; |
drh | 9bb61fe | 2000-06-05 16:01:39 +0000 | [diff] [blame] | 3715 | |
| 3716 | /* |
| 3717 | ** Do not even attempt to generate any code if we have already seen |
| 3718 | ** errors before this routine starts. |
| 3719 | */ |
drh | 1d83f05 | 2002-02-17 00:30:36 +0000 | [diff] [blame] | 3720 | if( pParse->nErr>0 ) goto select_end; |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 3721 | |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 3722 | /* If writing to memory or generating a set |
| 3723 | ** only a single column may be output. |
drh | 19a775c | 2000-06-05 18:54:46 +0000 | [diff] [blame] | 3724 | */ |
danielk1977 | 93758c8 | 2005-01-21 08:13:14 +0000 | [diff] [blame] | 3725 | #ifndef SQLITE_OMIT_SUBQUERY |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 3726 | if( checkForMultiColumnSelectError(pParse, pDest, pEList->nExpr) ){ |
drh | 1d83f05 | 2002-02-17 00:30:36 +0000 | [diff] [blame] | 3727 | goto select_end; |
drh | 19a775c | 2000-06-05 18:54:46 +0000 | [diff] [blame] | 3728 | } |
danielk1977 | 93758c8 | 2005-01-21 08:13:14 +0000 | [diff] [blame] | 3729 | #endif |
drh | 19a775c | 2000-06-05 18:54:46 +0000 | [diff] [blame] | 3730 | |
drh | c926afb | 2002-06-20 03:38:26 +0000 | [diff] [blame] | 3731 | /* ORDER BY is ignored for some destinations. |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 3732 | */ |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 3733 | if( IgnorableOrderby(pDest) ){ |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3734 | pOrderBy = 0; |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 3735 | } |
| 3736 | |
drh | d820cb1 | 2002-02-18 03:21:45 +0000 | [diff] [blame] | 3737 | /* Begin generating code. |
| 3738 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 3739 | v = sqlite3GetVdbe(pParse); |
drh | d820cb1 | 2002-02-18 03:21:45 +0000 | [diff] [blame] | 3740 | if( v==0 ) goto select_end; |
| 3741 | |
| 3742 | /* Generate code for all sub-queries in the FROM clause |
| 3743 | */ |
drh | 51522cd | 2005-01-20 13:36:19 +0000 | [diff] [blame] | 3744 | #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) |
drh | ad3cab5 | 2002-05-24 02:04:32 +0000 | [diff] [blame] | 3745 | for(i=0; i<pTabList->nSrc; i++){ |
danielk1977 | 742f947 | 2004-06-16 12:02:43 +0000 | [diff] [blame] | 3746 | const char *zSavedAuthContext = 0; |
drh | c31c2eb | 2003-05-02 16:04:17 +0000 | [diff] [blame] | 3747 | int needRestoreContext; |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3748 | struct SrcList_item *pItem = &pTabList->a[i]; |
drh | 1013c93 | 2008-01-06 00:25:21 +0000 | [diff] [blame] | 3749 | SelectDest dest; |
drh | c31c2eb | 2003-05-02 16:04:17 +0000 | [diff] [blame] | 3750 | |
danielk1977 | 1787cca | 2006-02-10 07:07:14 +0000 | [diff] [blame] | 3751 | if( pItem->pSelect==0 || pItem->isPopulated ) continue; |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3752 | if( pItem->zName!=0 ){ |
drh | 5cf590c | 2003-04-24 01:45:04 +0000 | [diff] [blame] | 3753 | zSavedAuthContext = pParse->zAuthContext; |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3754 | pParse->zAuthContext = pItem->zName; |
drh | c31c2eb | 2003-05-02 16:04:17 +0000 | [diff] [blame] | 3755 | needRestoreContext = 1; |
| 3756 | }else{ |
| 3757 | needRestoreContext = 0; |
drh | 5cf590c | 2003-04-24 01:45:04 +0000 | [diff] [blame] | 3758 | } |
danielk1977 | fc97606 | 2007-05-10 10:46:56 +0000 | [diff] [blame] | 3759 | /* Increment Parse.nHeight by the height of the largest expression |
| 3760 | ** tree refered to by this, the parent select. The child select |
| 3761 | ** may contain expression trees of at most |
| 3762 | ** (SQLITE_MAX_EXPR_DEPTH-Parse.nHeight) height. This is a bit |
| 3763 | ** more conservative than necessary, but much easier than enforcing |
| 3764 | ** an exact limit. |
| 3765 | */ |
| 3766 | pParse->nHeight += sqlite3SelectExprHeight(p); |
drh | 1013c93 | 2008-01-06 00:25:21 +0000 | [diff] [blame] | 3767 | sqlite3SelectDestInit(&dest, SRT_EphemTab, pItem->iCursor); |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 3768 | sqlite3Select(pParse, pItem->pSelect, &dest, p, i, &isAgg, 0); |
drh | cfa063b | 2007-11-21 15:24:00 +0000 | [diff] [blame] | 3769 | if( db->mallocFailed ){ |
| 3770 | goto select_end; |
| 3771 | } |
danielk1977 | fc97606 | 2007-05-10 10:46:56 +0000 | [diff] [blame] | 3772 | pParse->nHeight -= sqlite3SelectExprHeight(p); |
drh | c31c2eb | 2003-05-02 16:04:17 +0000 | [diff] [blame] | 3773 | if( needRestoreContext ){ |
drh | 5cf590c | 2003-04-24 01:45:04 +0000 | [diff] [blame] | 3774 | pParse->zAuthContext = zSavedAuthContext; |
| 3775 | } |
drh | 1b2e032 | 2002-03-03 02:49:51 +0000 | [diff] [blame] | 3776 | pTabList = p->pSrc; |
| 3777 | pWhere = p->pWhere; |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 3778 | if( !IgnorableOrderby(pDest) ){ |
drh | acd4c69 | 2002-03-07 02:02:51 +0000 | [diff] [blame] | 3779 | pOrderBy = p->pOrderBy; |
| 3780 | } |
drh | 1b2e032 | 2002-03-03 02:49:51 +0000 | [diff] [blame] | 3781 | pGroupBy = p->pGroupBy; |
| 3782 | pHaving = p->pHaving; |
| 3783 | isDistinct = p->isDistinct; |
drh | d820cb1 | 2002-02-18 03:21:45 +0000 | [diff] [blame] | 3784 | } |
drh | 51522cd | 2005-01-20 13:36:19 +0000 | [diff] [blame] | 3785 | #endif |
drh | d820cb1 | 2002-02-18 03:21:45 +0000 | [diff] [blame] | 3786 | |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 3787 | /* Check to see if this is a subquery that can be "flattened" into its parent. |
| 3788 | ** If flattening is a possiblity, do so and return immediately. |
| 3789 | */ |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 3790 | #ifndef SQLITE_OMIT_VIEW |
drh | 1b2e032 | 2002-03-03 02:49:51 +0000 | [diff] [blame] | 3791 | if( pParent && pParentAgg && |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 3792 | flattenSubquery(db, pParent, parentTab, *pParentAgg, isAgg) ){ |
drh | 1b2e032 | 2002-03-03 02:49:51 +0000 | [diff] [blame] | 3793 | if( isAgg ) *pParentAgg = 1; |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 3794 | goto select_end; |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 3795 | } |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 3796 | #endif |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 3797 | |
danielk1977 | 0318d44 | 2007-11-12 15:40:41 +0000 | [diff] [blame] | 3798 | /* If possible, rewrite the query to use GROUP BY instead of DISTINCT. |
| 3799 | ** GROUP BY may use an index, DISTINCT never does. |
danielk1977 | 3c4809a | 2007-11-12 15:29:18 +0000 | [diff] [blame] | 3800 | */ |
| 3801 | if( p->isDistinct && !p->isAgg && !p->pGroupBy ){ |
| 3802 | p->pGroupBy = sqlite3ExprListDup(db, p->pEList); |
| 3803 | pGroupBy = p->pGroupBy; |
| 3804 | p->isDistinct = 0; |
| 3805 | isDistinct = 0; |
| 3806 | } |
| 3807 | |
drh | 8b4c40d | 2007-02-01 23:02:45 +0000 | [diff] [blame] | 3808 | /* If there is an ORDER BY clause, then this sorting |
| 3809 | ** index might end up being unused if the data can be |
drh | 9d2985c | 2005-09-08 01:58:42 +0000 | [diff] [blame] | 3810 | ** extracted in pre-sorted order. If that is the case, then the |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 3811 | ** OP_OpenEphemeral instruction will be changed to an OP_Noop once |
drh | 9d2985c | 2005-09-08 01:58:42 +0000 | [diff] [blame] | 3812 | ** we figure out that the sorting index is not needed. The addrSortIndex |
| 3813 | ** variable is used to facilitate that change. |
danielk1977 | 7cedc8d | 2004-06-10 10:50:08 +0000 | [diff] [blame] | 3814 | */ |
| 3815 | if( pOrderBy ){ |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 3816 | KeyInfo *pKeyInfo; |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 3817 | pKeyInfo = keyInfoFromExprList(pParse, pOrderBy); |
drh | 9d2985c | 2005-09-08 01:58:42 +0000 | [diff] [blame] | 3818 | pOrderBy->iECursor = pParse->nTab++; |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 3819 | p->addrOpenEphm[2] = addrSortIndex = |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 3820 | sqlite3VdbeAddOp4(v, OP_OpenEphemeral, |
| 3821 | pOrderBy->iECursor, pOrderBy->nExpr+2, 0, |
| 3822 | (char*)pKeyInfo, P4_KEYINFO_HANDOFF); |
drh | 9d2985c | 2005-09-08 01:58:42 +0000 | [diff] [blame] | 3823 | }else{ |
| 3824 | addrSortIndex = -1; |
danielk1977 | 7cedc8d | 2004-06-10 10:50:08 +0000 | [diff] [blame] | 3825 | } |
| 3826 | |
drh | 2d0794e | 2002-03-03 03:03:52 +0000 | [diff] [blame] | 3827 | /* If the output is destined for a temporary table, open that table. |
| 3828 | */ |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 3829 | if( pDest->eDest==SRT_EphemTab ){ |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 3830 | sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pDest->iParm, pEList->nExpr); |
drh | 2d0794e | 2002-03-03 03:03:52 +0000 | [diff] [blame] | 3831 | } |
| 3832 | |
drh | f42bacc | 2006-04-26 17:39:34 +0000 | [diff] [blame] | 3833 | /* Set the limiter. |
| 3834 | */ |
| 3835 | iEnd = sqlite3VdbeMakeLabel(v); |
| 3836 | computeLimitRegisters(pParse, p, iEnd); |
| 3837 | |
drh | dece1a8 | 2005-08-31 18:20:00 +0000 | [diff] [blame] | 3838 | /* Open a virtual index to use for the distinct set. |
drh | efb7251 | 2000-05-31 20:00:52 +0000 | [diff] [blame] | 3839 | */ |
drh | 19a775c | 2000-06-05 18:54:46 +0000 | [diff] [blame] | 3840 | if( isDistinct ){ |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 3841 | KeyInfo *pKeyInfo; |
danielk1977 | 3c4809a | 2007-11-12 15:29:18 +0000 | [diff] [blame] | 3842 | assert( isAgg || pGroupBy ); |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 3843 | distinct = pParse->nTab++; |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 3844 | pKeyInfo = keyInfoFromExprList(pParse, p->pEList); |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 3845 | sqlite3VdbeAddOp4(v, OP_OpenEphemeral, distinct, 0, 0, |
| 3846 | (char*)pKeyInfo, P4_KEYINFO_HANDOFF); |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 3847 | }else{ |
| 3848 | distinct = -1; |
drh | efb7251 | 2000-05-31 20:00:52 +0000 | [diff] [blame] | 3849 | } |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 3850 | |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3851 | /* Aggregate and non-aggregate queries are handled differently */ |
| 3852 | if( !isAgg && pGroupBy==0 ){ |
| 3853 | /* This case is for non-aggregate queries |
| 3854 | ** Begin the database scan |
| 3855 | */ |
danielk1977 | a9d1ccb | 2008-01-05 17:39:29 +0000 | [diff] [blame] | 3856 | pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, &pOrderBy, 0); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3857 | if( pWInfo==0 ) goto select_end; |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 3858 | |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 3859 | /* If sorting index that was created by a prior OP_OpenEphemeral |
| 3860 | ** instruction ended up not being needed, then change the OP_OpenEphemeral |
drh | 9d2985c | 2005-09-08 01:58:42 +0000 | [diff] [blame] | 3861 | ** into an OP_Noop. |
| 3862 | */ |
| 3863 | if( addrSortIndex>=0 && pOrderBy==0 ){ |
drh | f887540 | 2006-03-17 13:56:34 +0000 | [diff] [blame] | 3864 | sqlite3VdbeChangeToNoop(v, addrSortIndex, 1); |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 3865 | p->addrOpenEphm[2] = -1; |
drh | 9d2985c | 2005-09-08 01:58:42 +0000 | [diff] [blame] | 3866 | } |
| 3867 | |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3868 | /* Use the standard inner loop |
| 3869 | */ |
danielk1977 | 3c4809a | 2007-11-12 15:29:18 +0000 | [diff] [blame] | 3870 | assert(!isDistinct); |
drh | d2b3e23 | 2008-01-23 14:51:49 +0000 | [diff] [blame] | 3871 | selectInnerLoop(pParse, p, pEList, 0, 0, pOrderBy, -1, pDest, |
| 3872 | pWInfo->iContinue, pWInfo->iBreak, aff); |
drh | efb7251 | 2000-05-31 20:00:52 +0000 | [diff] [blame] | 3873 | |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3874 | /* End the database scan loop. |
| 3875 | */ |
| 3876 | sqlite3WhereEnd(pWInfo); |
| 3877 | }else{ |
| 3878 | /* This is the processing for aggregate queries */ |
| 3879 | NameContext sNC; /* Name context for processing aggregate information */ |
| 3880 | int iAMem; /* First Mem address for storing current GROUP BY */ |
| 3881 | int iBMem; /* First Mem address for previous GROUP BY */ |
| 3882 | int iUseFlag; /* Mem address holding flag indicating that at least |
| 3883 | ** one row of the input to the aggregator has been |
| 3884 | ** processed */ |
| 3885 | int iAbortFlag; /* Mem address which causes query abort if positive */ |
| 3886 | int groupBySort; /* Rows come from source in GROUP BY order */ |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 3887 | |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 3888 | |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3889 | /* The following variables hold addresses or labels for parts of the |
| 3890 | ** virtual machine program we are putting together */ |
| 3891 | int addrOutputRow; /* Start of subroutine that outputs a result row */ |
drh | 16ee60f | 2008-06-20 18:13:25 +0000 | [diff] [blame] | 3892 | int regOutputRow; /* Return address register for output subroutine */ |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3893 | int addrSetAbort; /* Set the abort flag and return */ |
| 3894 | int addrInitializeLoop; /* Start of code that initializes the input loop */ |
| 3895 | int addrTopOfLoop; /* Top of the input loop */ |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3896 | int addrEnd; /* End of all processing */ |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 3897 | int addrSortingIdx; /* The OP_OpenEphemeral for the sorting index */ |
drh | e313382 | 2005-09-20 13:11:59 +0000 | [diff] [blame] | 3898 | int addrReset; /* Subroutine for resetting the accumulator */ |
drh | 2eb9537 | 2008-06-06 15:04:36 +0000 | [diff] [blame] | 3899 | int regReset; /* Return address register for reset subroutine */ |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3900 | |
| 3901 | addrEnd = sqlite3VdbeMakeLabel(v); |
| 3902 | |
| 3903 | /* Convert TK_COLUMN nodes into TK_AGG_COLUMN and make entries in |
| 3904 | ** sAggInfo for all TK_AGG_FUNCTION nodes in expressions of the |
| 3905 | ** SELECT statement. |
| 3906 | */ |
| 3907 | memset(&sNC, 0, sizeof(sNC)); |
| 3908 | sNC.pParse = pParse; |
| 3909 | sNC.pSrcList = pTabList; |
| 3910 | sNC.pAggInfo = &sAggInfo; |
| 3911 | sAggInfo.nSortingColumn = pGroupBy ? pGroupBy->nExpr+1 : 0; |
drh | 9d2985c | 2005-09-08 01:58:42 +0000 | [diff] [blame] | 3912 | sAggInfo.pGroupBy = pGroupBy; |
drh | d2b3e23 | 2008-01-23 14:51:49 +0000 | [diff] [blame] | 3913 | sqlite3ExprAnalyzeAggList(&sNC, pEList); |
| 3914 | sqlite3ExprAnalyzeAggList(&sNC, pOrderBy); |
| 3915 | if( pHaving ){ |
| 3916 | sqlite3ExprAnalyzeAggregates(&sNC, pHaving); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3917 | } |
| 3918 | sAggInfo.nAccumulator = sAggInfo.nColumn; |
| 3919 | for(i=0; i<sAggInfo.nFunc; i++){ |
drh | d2b3e23 | 2008-01-23 14:51:49 +0000 | [diff] [blame] | 3920 | sqlite3ExprAnalyzeAggList(&sNC, sAggInfo.aFunc[i].pExpr->pList); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3921 | } |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 3922 | if( db->mallocFailed ) goto select_end; |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3923 | |
| 3924 | /* Processing for aggregates with GROUP BY is very different and |
danielk1977 | 3c4809a | 2007-11-12 15:29:18 +0000 | [diff] [blame] | 3925 | ** much more complex than aggregates without a GROUP BY. |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3926 | */ |
| 3927 | if( pGroupBy ){ |
| 3928 | KeyInfo *pKeyInfo; /* Keying information for the group by clause */ |
drh | 16ee60f | 2008-06-20 18:13:25 +0000 | [diff] [blame] | 3929 | int j1; |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3930 | |
| 3931 | /* Create labels that we will be needing |
| 3932 | */ |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3933 | addrInitializeLoop = sqlite3VdbeMakeLabel(v); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3934 | |
| 3935 | /* If there is a GROUP BY clause we might need a sorting index to |
| 3936 | ** implement it. Allocate that sorting index now. If it turns out |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 3937 | ** that we do not need it after all, the OpenEphemeral instruction |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3938 | ** will be converted into a Noop. |
| 3939 | */ |
| 3940 | sAggInfo.sortingIdx = pParse->nTab++; |
| 3941 | pKeyInfo = keyInfoFromExprList(pParse, pGroupBy); |
danielk1977 | cd3e8f7 | 2008-03-25 09:47:35 +0000 | [diff] [blame] | 3942 | addrSortingIdx = sqlite3VdbeAddOp4(v, OP_OpenEphemeral, |
| 3943 | sAggInfo.sortingIdx, sAggInfo.nSortingColumn, |
| 3944 | 0, (char*)pKeyInfo, P4_KEYINFO_HANDOFF); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3945 | |
| 3946 | /* Initialize memory locations used by GROUP BY aggregate processing |
| 3947 | */ |
drh | 0a07c10 | 2008-01-03 18:03:08 +0000 | [diff] [blame] | 3948 | iUseFlag = ++pParse->nMem; |
| 3949 | iAbortFlag = ++pParse->nMem; |
| 3950 | iAMem = pParse->nMem + 1; |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3951 | pParse->nMem += pGroupBy->nExpr; |
drh | 0a07c10 | 2008-01-03 18:03:08 +0000 | [diff] [blame] | 3952 | iBMem = pParse->nMem + 1; |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3953 | pParse->nMem += pGroupBy->nExpr; |
drh | 4c58312 | 2008-01-04 22:01:03 +0000 | [diff] [blame] | 3954 | sqlite3VdbeAddOp2(v, OP_Integer, 0, iAbortFlag); |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 3955 | VdbeComment((v, "clear abort flag")); |
drh | 4c58312 | 2008-01-04 22:01:03 +0000 | [diff] [blame] | 3956 | sqlite3VdbeAddOp2(v, OP_Integer, 0, iUseFlag); |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 3957 | VdbeComment((v, "indicate accumulator empty")); |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 3958 | sqlite3VdbeAddOp2(v, OP_Goto, 0, addrInitializeLoop); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3959 | |
| 3960 | /* Generate a subroutine that outputs a single row of the result |
| 3961 | ** set. This subroutine first looks at the iUseFlag. If iUseFlag |
| 3962 | ** is less than or equal to zero, the subroutine is a no-op. If |
| 3963 | ** the processing calls for the query to abort, this subroutine |
| 3964 | ** increments the iAbortFlag memory location before returning in |
| 3965 | ** order to signal the caller to abort. |
| 3966 | */ |
| 3967 | addrSetAbort = sqlite3VdbeCurrentAddr(v); |
drh | 4c58312 | 2008-01-04 22:01:03 +0000 | [diff] [blame] | 3968 | sqlite3VdbeAddOp2(v, OP_Integer, 1, iAbortFlag); |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 3969 | VdbeComment((v, "set abort flag")); |
drh | 2eb9537 | 2008-06-06 15:04:36 +0000 | [diff] [blame] | 3970 | regOutputRow = ++pParse->nMem; |
| 3971 | sqlite3VdbeAddOp1(v, OP_Return, regOutputRow); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3972 | addrOutputRow = sqlite3VdbeCurrentAddr(v); |
drh | 3c84ddf | 2008-01-09 02:15:38 +0000 | [diff] [blame] | 3973 | sqlite3VdbeAddOp2(v, OP_IfPos, iUseFlag, addrOutputRow+2); |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 3974 | VdbeComment((v, "Groupby result generator entry point")); |
drh | 2eb9537 | 2008-06-06 15:04:36 +0000 | [diff] [blame] | 3975 | sqlite3VdbeAddOp1(v, OP_Return, regOutputRow); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3976 | finalizeAggFunctions(pParse, &sAggInfo); |
| 3977 | if( pHaving ){ |
drh | 3557335 | 2008-01-08 23:54:25 +0000 | [diff] [blame] | 3978 | sqlite3ExprIfFalse(pParse, pHaving, addrOutputRow+1, SQLITE_JUMPIFNULL); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3979 | } |
drh | d2b3e23 | 2008-01-23 14:51:49 +0000 | [diff] [blame] | 3980 | selectInnerLoop(pParse, p, p->pEList, 0, 0, pOrderBy, |
| 3981 | distinct, pDest, |
| 3982 | addrOutputRow+1, addrSetAbort, aff); |
drh | 2eb9537 | 2008-06-06 15:04:36 +0000 | [diff] [blame] | 3983 | sqlite3VdbeAddOp1(v, OP_Return, regOutputRow); |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 3984 | VdbeComment((v, "end groupby result generator")); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3985 | |
drh | e313382 | 2005-09-20 13:11:59 +0000 | [diff] [blame] | 3986 | /* Generate a subroutine that will reset the group-by accumulator |
| 3987 | */ |
| 3988 | addrReset = sqlite3VdbeCurrentAddr(v); |
drh | 2eb9537 | 2008-06-06 15:04:36 +0000 | [diff] [blame] | 3989 | regReset = ++pParse->nMem; |
drh | e313382 | 2005-09-20 13:11:59 +0000 | [diff] [blame] | 3990 | resetAccumulator(pParse, &sAggInfo); |
drh | 2eb9537 | 2008-06-06 15:04:36 +0000 | [diff] [blame] | 3991 | sqlite3VdbeAddOp1(v, OP_Return, regReset); |
drh | e313382 | 2005-09-20 13:11:59 +0000 | [diff] [blame] | 3992 | |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 3993 | /* Begin a loop that will extract all source rows in GROUP BY order. |
| 3994 | ** This might involve two separate loops with an OP_Sort in between, or |
| 3995 | ** it might be a single loop that uses an index to extract information |
| 3996 | ** in the right order to begin with. |
| 3997 | */ |
| 3998 | sqlite3VdbeResolveLabel(v, addrInitializeLoop); |
drh | 2eb9537 | 2008-06-06 15:04:36 +0000 | [diff] [blame] | 3999 | sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset); |
danielk1977 | a9d1ccb | 2008-01-05 17:39:29 +0000 | [diff] [blame] | 4000 | pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, &pGroupBy, 0); |
drh | 5360ad3 | 2005-09-08 00:13:27 +0000 | [diff] [blame] | 4001 | if( pWInfo==0 ) goto select_end; |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 4002 | if( pGroupBy==0 ){ |
| 4003 | /* The optimizer is able to deliver rows in group by order so |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 4004 | ** we do not have to sort. The OP_OpenEphemeral table will be |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 4005 | ** cancelled later because we still need to use the pKeyInfo |
| 4006 | */ |
| 4007 | pGroupBy = p->pGroupBy; |
| 4008 | groupBySort = 0; |
| 4009 | }else{ |
| 4010 | /* Rows are coming out in undetermined order. We have to push |
| 4011 | ** each row into a sorting index, terminate the first loop, |
| 4012 | ** then loop over the sorting index in order to get the output |
| 4013 | ** in sorted order |
| 4014 | */ |
drh | 892d317 | 2008-01-10 03:46:36 +0000 | [diff] [blame] | 4015 | int regBase; |
| 4016 | int regRecord; |
| 4017 | int nCol; |
| 4018 | int nGroupBy; |
| 4019 | |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 4020 | groupBySort = 1; |
drh | 892d317 | 2008-01-10 03:46:36 +0000 | [diff] [blame] | 4021 | nGroupBy = pGroupBy->nExpr; |
| 4022 | nCol = nGroupBy + 1; |
| 4023 | j = nGroupBy+1; |
| 4024 | for(i=0; i<sAggInfo.nColumn; i++){ |
| 4025 | if( sAggInfo.aCol[i].iSorterColumn>=j ){ |
| 4026 | nCol++; |
| 4027 | j++; |
| 4028 | } |
| 4029 | } |
| 4030 | regBase = sqlite3GetTempRange(pParse, nCol); |
drh | 191b54c | 2008-04-15 12:14:21 +0000 | [diff] [blame] | 4031 | sqlite3ExprCodeExprList(pParse, pGroupBy, regBase, 0); |
drh | 892d317 | 2008-01-10 03:46:36 +0000 | [diff] [blame] | 4032 | sqlite3VdbeAddOp2(v, OP_Sequence, sAggInfo.sortingIdx,regBase+nGroupBy); |
| 4033 | j = nGroupBy+1; |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 4034 | for(i=0; i<sAggInfo.nColumn; i++){ |
| 4035 | struct AggInfo_col *pCol = &sAggInfo.aCol[i]; |
drh | 892d317 | 2008-01-10 03:46:36 +0000 | [diff] [blame] | 4036 | if( pCol->iSorterColumn>=j ){ |
drh | e55cbd7 | 2008-03-31 23:48:03 +0000 | [diff] [blame] | 4037 | int r1 = j + regBase; |
| 4038 | int r2 = sqlite3ExprCodeGetColumn(pParse, |
drh | da250ea | 2008-04-01 05:07:14 +0000 | [diff] [blame] | 4039 | pCol->pTab, pCol->iColumn, pCol->iTable, r1, 0); |
drh | e55cbd7 | 2008-03-31 23:48:03 +0000 | [diff] [blame] | 4040 | if( r1!=r2 ){ |
| 4041 | sqlite3VdbeAddOp2(v, OP_SCopy, r2, r1); |
| 4042 | } |
drh | 892d317 | 2008-01-10 03:46:36 +0000 | [diff] [blame] | 4043 | j++; |
| 4044 | } |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 4045 | } |
drh | 892d317 | 2008-01-10 03:46:36 +0000 | [diff] [blame] | 4046 | regRecord = sqlite3GetTempReg(pParse); |
drh | 1db639c | 2008-01-17 02:36:28 +0000 | [diff] [blame] | 4047 | sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord); |
drh | 892d317 | 2008-01-10 03:46:36 +0000 | [diff] [blame] | 4048 | sqlite3VdbeAddOp2(v, OP_IdxInsert, sAggInfo.sortingIdx, regRecord); |
| 4049 | sqlite3ReleaseTempReg(pParse, regRecord); |
| 4050 | sqlite3ReleaseTempRange(pParse, regBase, nCol); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 4051 | sqlite3WhereEnd(pWInfo); |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 4052 | sqlite3VdbeAddOp2(v, OP_Sort, sAggInfo.sortingIdx, addrEnd); |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 4053 | VdbeComment((v, "GROUP BY sort")); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 4054 | sAggInfo.useSortingIdx = 1; |
| 4055 | } |
| 4056 | |
| 4057 | /* Evaluate the current GROUP BY terms and store in b0, b1, b2... |
| 4058 | ** (b0 is memory location iBMem+0, b1 is iBMem+1, and so forth) |
| 4059 | ** Then compare the current GROUP BY terms against the GROUP BY terms |
| 4060 | ** from the previous row currently stored in a0, a1, a2... |
| 4061 | */ |
| 4062 | addrTopOfLoop = sqlite3VdbeCurrentAddr(v); |
| 4063 | for(j=0; j<pGroupBy->nExpr; j++){ |
| 4064 | if( groupBySort ){ |
drh | 2dcef11 | 2008-01-12 19:03:48 +0000 | [diff] [blame] | 4065 | sqlite3VdbeAddOp3(v, OP_Column, sAggInfo.sortingIdx, j, iBMem+j); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 4066 | }else{ |
| 4067 | sAggInfo.directMode = 1; |
drh | 2dcef11 | 2008-01-12 19:03:48 +0000 | [diff] [blame] | 4068 | sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr, iBMem+j); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 4069 | } |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 4070 | } |
drh | 16ee60f | 2008-06-20 18:13:25 +0000 | [diff] [blame] | 4071 | sqlite3VdbeAddOp4(v, OP_Compare, iAMem, iBMem, pGroupBy->nExpr, |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 4072 | (char*)pKeyInfo, P4_KEYINFO); |
drh | 16ee60f | 2008-06-20 18:13:25 +0000 | [diff] [blame] | 4073 | j1 = sqlite3VdbeCurrentAddr(v); |
| 4074 | sqlite3VdbeAddOp3(v, OP_Jump, j1+1, 0, j1+1); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 4075 | |
| 4076 | /* Generate code that runs whenever the GROUP BY changes. |
drh | e00ee6e | 2008-06-20 15:24:01 +0000 | [diff] [blame] | 4077 | ** Changes in the GROUP BY are detected by the previous code |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 4078 | ** block. If there were no changes, this block is skipped. |
| 4079 | ** |
| 4080 | ** This code copies current group by terms in b0,b1,b2,... |
| 4081 | ** over to a0,a1,a2. It then calls the output subroutine |
| 4082 | ** and resets the aggregate accumulator registers in preparation |
| 4083 | ** for the next GROUP BY batch. |
| 4084 | */ |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 4085 | sqlite3ExprCodeMove(pParse, iBMem, iAMem, pGroupBy->nExpr); |
drh | 2eb9537 | 2008-06-06 15:04:36 +0000 | [diff] [blame] | 4086 | sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow); |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 4087 | VdbeComment((v, "output one row")); |
drh | 3c84ddf | 2008-01-09 02:15:38 +0000 | [diff] [blame] | 4088 | sqlite3VdbeAddOp2(v, OP_IfPos, iAbortFlag, addrEnd); |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 4089 | VdbeComment((v, "check abort flag")); |
drh | 2eb9537 | 2008-06-06 15:04:36 +0000 | [diff] [blame] | 4090 | sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset); |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 4091 | VdbeComment((v, "reset accumulator")); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 4092 | |
| 4093 | /* Update the aggregate accumulators based on the content of |
| 4094 | ** the current row |
| 4095 | */ |
drh | 16ee60f | 2008-06-20 18:13:25 +0000 | [diff] [blame] | 4096 | sqlite3VdbeJumpHere(v, j1); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 4097 | updateAccumulator(pParse, &sAggInfo); |
drh | 4c58312 | 2008-01-04 22:01:03 +0000 | [diff] [blame] | 4098 | sqlite3VdbeAddOp2(v, OP_Integer, 1, iUseFlag); |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 4099 | VdbeComment((v, "indicate data in accumulator")); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 4100 | |
| 4101 | /* End of the loop |
| 4102 | */ |
| 4103 | if( groupBySort ){ |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 4104 | sqlite3VdbeAddOp2(v, OP_Next, sAggInfo.sortingIdx, addrTopOfLoop); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 4105 | }else{ |
| 4106 | sqlite3WhereEnd(pWInfo); |
drh | f887540 | 2006-03-17 13:56:34 +0000 | [diff] [blame] | 4107 | sqlite3VdbeChangeToNoop(v, addrSortingIdx, 1); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 4108 | } |
| 4109 | |
| 4110 | /* Output the final row of result |
| 4111 | */ |
drh | 2eb9537 | 2008-06-06 15:04:36 +0000 | [diff] [blame] | 4112 | sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow); |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 4113 | VdbeComment((v, "output final row")); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 4114 | |
| 4115 | } /* endif pGroupBy */ |
| 4116 | else { |
danielk1977 | a9d1ccb | 2008-01-05 17:39:29 +0000 | [diff] [blame] | 4117 | ExprList *pMinMax = 0; |
danielk1977 | dba0137 | 2008-01-05 18:44:29 +0000 | [diff] [blame] | 4118 | ExprList *pDel = 0; |
danielk1977 | a9d1ccb | 2008-01-05 17:39:29 +0000 | [diff] [blame] | 4119 | u8 flag; |
| 4120 | |
danielk1977 | 738bdcf | 2008-01-07 10:16:40 +0000 | [diff] [blame] | 4121 | /* Check if the query is of one of the following forms: |
| 4122 | ** |
| 4123 | ** SELECT min(x) FROM ... |
| 4124 | ** SELECT max(x) FROM ... |
| 4125 | ** |
| 4126 | ** If it is, then ask the code in where.c to attempt to sort results |
| 4127 | ** as if there was an "ORDER ON x" or "ORDER ON x DESC" clause. |
| 4128 | ** If where.c is able to produce results sorted in this order, then |
| 4129 | ** add vdbe code to break out of the processing loop after the |
| 4130 | ** first iteration (since the first iteration of the loop is |
| 4131 | ** guaranteed to operate on the row with the minimum or maximum |
| 4132 | ** value of x, the only row required). |
| 4133 | ** |
| 4134 | ** A special flag must be passed to sqlite3WhereBegin() to slightly |
| 4135 | ** modify behaviour as follows: |
| 4136 | ** |
| 4137 | ** + If the query is a "SELECT min(x)", then the loop coded by |
| 4138 | ** where.c should not iterate over any values with a NULL value |
| 4139 | ** for x. |
| 4140 | ** |
| 4141 | ** + The optimizer code in where.c (the thing that decides which |
| 4142 | ** index or indices to use) should place a different priority on |
| 4143 | ** satisfying the 'ORDER BY' clause than it does in other cases. |
| 4144 | ** Refer to code and comments in where.c for details. |
| 4145 | */ |
danielk1977 | a9d1ccb | 2008-01-05 17:39:29 +0000 | [diff] [blame] | 4146 | flag = minMaxQuery(pParse, p); |
| 4147 | if( flag ){ |
drh | 8cc7432 | 2008-01-15 02:22:24 +0000 | [diff] [blame] | 4148 | pDel = pMinMax = sqlite3ExprListDup(db, p->pEList->a[0].pExpr->pList); |
drh | 0e359b3 | 2008-01-13 19:02:11 +0000 | [diff] [blame] | 4149 | if( pMinMax && !db->mallocFailed ){ |
drh | 08c88eb | 2008-04-10 13:33:18 +0000 | [diff] [blame] | 4150 | pMinMax->a[0].sortOrder = ((flag==WHERE_ORDERBY_MIN)?0:1); |
danielk1977 | a9d1ccb | 2008-01-05 17:39:29 +0000 | [diff] [blame] | 4151 | pMinMax->a[0].pExpr->op = TK_COLUMN; |
| 4152 | } |
| 4153 | } |
| 4154 | |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 4155 | /* This case runs if the aggregate has no GROUP BY clause. The |
| 4156 | ** processing is much simpler since there is only a single row |
| 4157 | ** of output. |
| 4158 | */ |
| 4159 | resetAccumulator(pParse, &sAggInfo); |
danielk1977 | a9d1ccb | 2008-01-05 17:39:29 +0000 | [diff] [blame] | 4160 | pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, &pMinMax, flag); |
danielk1977 | dba0137 | 2008-01-05 18:44:29 +0000 | [diff] [blame] | 4161 | if( pWInfo==0 ){ |
drh | 1013c93 | 2008-01-06 00:25:21 +0000 | [diff] [blame] | 4162 | sqlite3ExprListDelete(pDel); |
danielk1977 | dba0137 | 2008-01-05 18:44:29 +0000 | [diff] [blame] | 4163 | goto select_end; |
| 4164 | } |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 4165 | updateAccumulator(pParse, &sAggInfo); |
danielk1977 | a9d1ccb | 2008-01-05 17:39:29 +0000 | [diff] [blame] | 4166 | if( !pMinMax && flag ){ |
| 4167 | sqlite3VdbeAddOp2(v, OP_Goto, 0, pWInfo->iBreak); |
drh | 16ee60f | 2008-06-20 18:13:25 +0000 | [diff] [blame] | 4168 | VdbeComment((v, "%s() by index",(flag==WHERE_ORDERBY_MIN?"min":"max"))); |
danielk1977 | a9d1ccb | 2008-01-05 17:39:29 +0000 | [diff] [blame] | 4169 | } |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 4170 | sqlite3WhereEnd(pWInfo); |
| 4171 | finalizeAggFunctions(pParse, &sAggInfo); |
| 4172 | pOrderBy = 0; |
drh | 5774b80 | 2005-09-07 22:48:16 +0000 | [diff] [blame] | 4173 | if( pHaving ){ |
drh | 3557335 | 2008-01-08 23:54:25 +0000 | [diff] [blame] | 4174 | sqlite3ExprIfFalse(pParse, pHaving, addrEnd, SQLITE_JUMPIFNULL); |
drh | 5774b80 | 2005-09-07 22:48:16 +0000 | [diff] [blame] | 4175 | } |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 4176 | selectInnerLoop(pParse, p, p->pEList, 0, 0, 0, -1, |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 4177 | pDest, addrEnd, addrEnd, aff); |
danielk1977 | a9d1ccb | 2008-01-05 17:39:29 +0000 | [diff] [blame] | 4178 | |
danielk1977 | dba0137 | 2008-01-05 18:44:29 +0000 | [diff] [blame] | 4179 | sqlite3ExprListDelete(pDel); |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 4180 | } |
| 4181 | sqlite3VdbeResolveLabel(v, addrEnd); |
| 4182 | |
| 4183 | } /* endif aggregate query */ |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 4184 | |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 4185 | /* If there is an ORDER BY clause, then we need to sort the results |
| 4186 | ** and send them to the callback one by one. |
| 4187 | */ |
| 4188 | if( pOrderBy ){ |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 4189 | generateSortTail(pParse, p, v, pEList->nExpr, pDest); |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 4190 | } |
drh | 6a53534 | 2001-10-19 16:44:56 +0000 | [diff] [blame] | 4191 | |
danielk1977 | 93758c8 | 2005-01-21 08:13:14 +0000 | [diff] [blame] | 4192 | #ifndef SQLITE_OMIT_SUBQUERY |
drh | f620b4e | 2004-02-09 14:37:50 +0000 | [diff] [blame] | 4193 | /* If this was a subquery, we have now converted the subquery into a |
danielk1977 | 1787cca | 2006-02-10 07:07:14 +0000 | [diff] [blame] | 4194 | ** temporary table. So set the SrcList_item.isPopulated flag to prevent |
| 4195 | ** this subquery from being evaluated again and to force the use of |
| 4196 | ** the temporary table. |
drh | f620b4e | 2004-02-09 14:37:50 +0000 | [diff] [blame] | 4197 | */ |
| 4198 | if( pParent ){ |
| 4199 | assert( pParent->pSrc->nSrc>parentTab ); |
| 4200 | assert( pParent->pSrc->a[parentTab].pSelect==p ); |
danielk1977 | 1787cca | 2006-02-10 07:07:14 +0000 | [diff] [blame] | 4201 | pParent->pSrc->a[parentTab].isPopulated = 1; |
drh | f620b4e | 2004-02-09 14:37:50 +0000 | [diff] [blame] | 4202 | } |
danielk1977 | 93758c8 | 2005-01-21 08:13:14 +0000 | [diff] [blame] | 4203 | #endif |
drh | f620b4e | 2004-02-09 14:37:50 +0000 | [diff] [blame] | 4204 | |
drh | ec7429a | 2005-10-06 16:53:14 +0000 | [diff] [blame] | 4205 | /* Jump here to skip this query |
| 4206 | */ |
| 4207 | sqlite3VdbeResolveLabel(v, iEnd); |
| 4208 | |
drh | 1d83f05 | 2002-02-17 00:30:36 +0000 | [diff] [blame] | 4209 | /* The SELECT was successfully coded. Set the return code to 0 |
| 4210 | ** to indicate no errors. |
| 4211 | */ |
| 4212 | rc = 0; |
| 4213 | |
| 4214 | /* Control jumps to here if an error is encountered above, or upon |
| 4215 | ** successful coding of the SELECT. |
| 4216 | */ |
| 4217 | select_end: |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 4218 | |
| 4219 | /* Identify column names if we will be using them in a callback. This |
| 4220 | ** step is skipped if the output is going to some other destination. |
| 4221 | */ |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 4222 | if( rc==SQLITE_OK && pDest->eDest==SRT_Callback ){ |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 4223 | generateColumnNames(pParse, pTabList, pEList); |
| 4224 | } |
| 4225 | |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 4226 | sqlite3_free(sAggInfo.aCol); |
| 4227 | sqlite3_free(sAggInfo.aFunc); |
drh | 1d83f05 | 2002-02-17 00:30:36 +0000 | [diff] [blame] | 4228 | return rc; |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 4229 | } |
drh | 485f003 | 2007-01-26 19:23:33 +0000 | [diff] [blame] | 4230 | |
drh | 77a2a5e | 2007-04-06 01:04:39 +0000 | [diff] [blame] | 4231 | #if defined(SQLITE_DEBUG) |
drh | 485f003 | 2007-01-26 19:23:33 +0000 | [diff] [blame] | 4232 | /* |
| 4233 | ******************************************************************************* |
| 4234 | ** The following code is used for testing and debugging only. The code |
| 4235 | ** that follows does not appear in normal builds. |
| 4236 | ** |
| 4237 | ** These routines are used to print out the content of all or part of a |
| 4238 | ** parse structures such as Select or Expr. Such printouts are useful |
| 4239 | ** for helping to understand what is happening inside the code generator |
| 4240 | ** during the execution of complex SELECT statements. |
| 4241 | ** |
| 4242 | ** These routine are not called anywhere from within the normal |
| 4243 | ** code base. Then are intended to be called from within the debugger |
| 4244 | ** or from temporary "printf" statements inserted for debugging. |
| 4245 | */ |
drh | dafc0ce | 2008-04-17 19:14:02 +0000 | [diff] [blame] | 4246 | void sqlite3PrintExpr(Expr *p){ |
drh | 485f003 | 2007-01-26 19:23:33 +0000 | [diff] [blame] | 4247 | if( p->token.z && p->token.n>0 ){ |
| 4248 | sqlite3DebugPrintf("(%.*s", p->token.n, p->token.z); |
| 4249 | }else{ |
| 4250 | sqlite3DebugPrintf("(%d", p->op); |
| 4251 | } |
| 4252 | if( p->pLeft ){ |
| 4253 | sqlite3DebugPrintf(" "); |
| 4254 | sqlite3PrintExpr(p->pLeft); |
| 4255 | } |
| 4256 | if( p->pRight ){ |
| 4257 | sqlite3DebugPrintf(" "); |
| 4258 | sqlite3PrintExpr(p->pRight); |
| 4259 | } |
| 4260 | sqlite3DebugPrintf(")"); |
| 4261 | } |
drh | dafc0ce | 2008-04-17 19:14:02 +0000 | [diff] [blame] | 4262 | void sqlite3PrintExprList(ExprList *pList){ |
drh | 485f003 | 2007-01-26 19:23:33 +0000 | [diff] [blame] | 4263 | int i; |
| 4264 | for(i=0; i<pList->nExpr; i++){ |
| 4265 | sqlite3PrintExpr(pList->a[i].pExpr); |
| 4266 | if( i<pList->nExpr-1 ){ |
| 4267 | sqlite3DebugPrintf(", "); |
| 4268 | } |
| 4269 | } |
| 4270 | } |
drh | dafc0ce | 2008-04-17 19:14:02 +0000 | [diff] [blame] | 4271 | void sqlite3PrintSelect(Select *p, int indent){ |
drh | 485f003 | 2007-01-26 19:23:33 +0000 | [diff] [blame] | 4272 | sqlite3DebugPrintf("%*sSELECT(%p) ", indent, "", p); |
| 4273 | sqlite3PrintExprList(p->pEList); |
| 4274 | sqlite3DebugPrintf("\n"); |
| 4275 | if( p->pSrc ){ |
| 4276 | char *zPrefix; |
| 4277 | int i; |
| 4278 | zPrefix = "FROM"; |
| 4279 | for(i=0; i<p->pSrc->nSrc; i++){ |
| 4280 | struct SrcList_item *pItem = &p->pSrc->a[i]; |
| 4281 | sqlite3DebugPrintf("%*s ", indent+6, zPrefix); |
| 4282 | zPrefix = ""; |
| 4283 | if( pItem->pSelect ){ |
| 4284 | sqlite3DebugPrintf("(\n"); |
| 4285 | sqlite3PrintSelect(pItem->pSelect, indent+10); |
| 4286 | sqlite3DebugPrintf("%*s)", indent+8, ""); |
| 4287 | }else if( pItem->zName ){ |
| 4288 | sqlite3DebugPrintf("%s", pItem->zName); |
| 4289 | } |
| 4290 | if( pItem->pTab ){ |
| 4291 | sqlite3DebugPrintf("(table: %s)", pItem->pTab->zName); |
| 4292 | } |
| 4293 | if( pItem->zAlias ){ |
| 4294 | sqlite3DebugPrintf(" AS %s", pItem->zAlias); |
| 4295 | } |
| 4296 | if( i<p->pSrc->nSrc-1 ){ |
| 4297 | sqlite3DebugPrintf(","); |
| 4298 | } |
| 4299 | sqlite3DebugPrintf("\n"); |
| 4300 | } |
| 4301 | } |
| 4302 | if( p->pWhere ){ |
| 4303 | sqlite3DebugPrintf("%*s WHERE ", indent, ""); |
| 4304 | sqlite3PrintExpr(p->pWhere); |
| 4305 | sqlite3DebugPrintf("\n"); |
| 4306 | } |
| 4307 | if( p->pGroupBy ){ |
| 4308 | sqlite3DebugPrintf("%*s GROUP BY ", indent, ""); |
| 4309 | sqlite3PrintExprList(p->pGroupBy); |
| 4310 | sqlite3DebugPrintf("\n"); |
| 4311 | } |
| 4312 | if( p->pHaving ){ |
| 4313 | sqlite3DebugPrintf("%*s HAVING ", indent, ""); |
| 4314 | sqlite3PrintExpr(p->pHaving); |
| 4315 | sqlite3DebugPrintf("\n"); |
| 4316 | } |
| 4317 | if( p->pOrderBy ){ |
| 4318 | sqlite3DebugPrintf("%*s ORDER BY ", indent, ""); |
| 4319 | sqlite3PrintExprList(p->pOrderBy); |
| 4320 | sqlite3DebugPrintf("\n"); |
| 4321 | } |
| 4322 | } |
| 4323 | /* End of the structure debug printing code |
| 4324 | *****************************************************************************/ |
| 4325 | #endif /* defined(SQLITE_TEST) || defined(SQLITE_DEBUG) */ |