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