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 | ************************************************************************* |
drh | 1ccde15 | 2000-06-17 13:12:39 +0000 | [diff] [blame] | 12 | ** This file contains routines used for analyzing expressions and |
drh | b19a2bc | 2001-09-16 00:13:26 +0000 | [diff] [blame] | 13 | ** for generating VDBE code that evaluates expressions in SQLite. |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 14 | ** |
drh | bf4133c | 2001-10-13 02:59:08 +0000 | [diff] [blame] | 15 | ** $Id: expr.c,v 1.31 2001/10/13 02:59:09 drh Exp $ |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 16 | */ |
| 17 | #include "sqliteInt.h" |
| 18 | |
| 19 | /* |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 20 | ** Walk an expression tree. Return 1 if the expression is constant |
| 21 | ** and 0 if it involves variables. |
| 22 | */ |
| 23 | static int isConstant(Expr *p){ |
| 24 | switch( p->op ){ |
| 25 | case TK_ID: |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 26 | case TK_COLUMN: |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 27 | case TK_DOT: |
| 28 | return 0; |
| 29 | default: { |
| 30 | if( p->pLeft && !isConstant(p->pLeft) ) return 0; |
| 31 | if( p->pRight && !isConstant(p->pRight) ) return 0; |
| 32 | if( p->pList ){ |
| 33 | int i; |
| 34 | for(i=0; i<p->pList->nExpr; i++){ |
| 35 | if( !isConstant(p->pList->a[i].pExpr) ) return 0; |
| 36 | } |
| 37 | } |
| 38 | break; |
| 39 | } |
| 40 | } |
| 41 | return 1; |
| 42 | } |
| 43 | |
| 44 | /* |
drh | 4794b98 | 2000-06-06 13:54:14 +0000 | [diff] [blame] | 45 | ** Walk the expression tree and process operators of the form: |
| 46 | ** |
| 47 | ** expr IN (SELECT ...) |
| 48 | ** |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 49 | ** These operators have to be processed before column names are |
drh | 4794b98 | 2000-06-06 13:54:14 +0000 | [diff] [blame] | 50 | ** resolved because each such operator increments pParse->nTab |
drh | 1ccde15 | 2000-06-17 13:12:39 +0000 | [diff] [blame] | 51 | ** to reserve cursor numbers for its own use. But pParse->nTab |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 52 | ** needs to be constant once we begin resolving column names. |
drh | 4794b98 | 2000-06-06 13:54:14 +0000 | [diff] [blame] | 53 | ** |
| 54 | ** Actually, the processing of IN-SELECT is only started by this |
| 55 | ** routine. This routine allocates a cursor number to the IN-SELECT |
| 56 | ** and then moves on. The code generation is done by |
| 57 | ** sqliteExprResolveIds() which must be called afterwards. |
| 58 | */ |
| 59 | void sqliteExprResolveInSelect(Parse *pParse, Expr *pExpr){ |
| 60 | if( pExpr==0 ) return; |
| 61 | if( pExpr->op==TK_IN && pExpr->pSelect!=0 ){ |
| 62 | pExpr->iTable = pParse->nTab++; |
| 63 | }else{ |
| 64 | if( pExpr->pLeft ) sqliteExprResolveInSelect(pParse, pExpr->pLeft); |
| 65 | if( pExpr->pRight ) sqliteExprResolveInSelect(pParse, pExpr->pRight); |
| 66 | if( pExpr->pList ){ |
| 67 | int i; |
| 68 | ExprList *pList = pExpr->pList; |
| 69 | for(i=0; i<pList->nExpr; i++){ |
| 70 | sqliteExprResolveInSelect(pParse, pList->a[i].pExpr); |
| 71 | } |
| 72 | } |
| 73 | } |
| 74 | } |
| 75 | |
| 76 | /* |
drh | c4a3c77 | 2001-04-04 11:48:57 +0000 | [diff] [blame] | 77 | ** Return TRUE if the given string is a row-id column name. |
| 78 | */ |
| 79 | static int sqliteIsRowid(const char *z){ |
| 80 | if( sqliteStrICmp(z, "_ROWID_")==0 ) return 1; |
| 81 | if( sqliteStrICmp(z, "ROWID")==0 ) return 1; |
| 82 | if( sqliteStrICmp(z, "OID")==0 ) return 1; |
| 83 | return 0; |
| 84 | } |
| 85 | |
| 86 | /* |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 87 | ** This routine walks an expression tree and resolves references to |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 88 | ** table columns. Nodes of the form ID.ID or ID resolve into an |
| 89 | ** index to the table in the table list and a column offset. The opcode |
| 90 | ** for such nodes is changed to TK_COLUMN. The iTable value is changed |
drh | 19a775c | 2000-06-05 18:54:46 +0000 | [diff] [blame] | 91 | ** to the index of the referenced table in pTabList plus the pParse->nTab |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 92 | ** value. The iColumn value is changed to the index of the column of the |
drh | 19a775c | 2000-06-05 18:54:46 +0000 | [diff] [blame] | 93 | ** referenced table. |
| 94 | ** |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 95 | ** We also check for instances of the IN operator. IN comes in two |
| 96 | ** forms: |
| 97 | ** |
| 98 | ** expr IN (exprlist) |
| 99 | ** and |
| 100 | ** expr IN (SELECT ...) |
| 101 | ** |
| 102 | ** The first form is handled by creating a set holding the list |
| 103 | ** of allowed values. The second form causes the SELECT to generate |
| 104 | ** a temporary table. |
| 105 | ** |
| 106 | ** This routine also looks for scalar SELECTs that are part of an expression. |
drh | 19a775c | 2000-06-05 18:54:46 +0000 | [diff] [blame] | 107 | ** If it finds any, it generates code to write the value of that select |
| 108 | ** into a memory cell. |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 109 | ** |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 110 | ** Unknown columns or tables provoke an error. The function returns |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 111 | ** the number of errors seen and leaves an error message on pParse->zErrMsg. |
| 112 | */ |
| 113 | int sqliteExprResolveIds(Parse *pParse, IdList *pTabList, Expr *pExpr){ |
drh | daffd0e | 2001-04-11 14:28:42 +0000 | [diff] [blame] | 114 | if( pExpr==0 || pTabList==0 ) return 0; |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 115 | switch( pExpr->op ){ |
| 116 | /* A lone identifier */ |
| 117 | case TK_ID: { |
drh | c4a3c77 | 2001-04-04 11:48:57 +0000 | [diff] [blame] | 118 | int cnt = 0; /* Number of matches */ |
| 119 | int i; /* Loop counter */ |
drh | 6e142f5 | 2000-06-08 13:36:40 +0000 | [diff] [blame] | 120 | char *z = sqliteStrNDup(pExpr->token.z, pExpr->token.n); |
drh | daffd0e | 2001-04-11 14:28:42 +0000 | [diff] [blame] | 121 | if( z==0 ) return 1; |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 122 | for(i=0; i<pTabList->nId; i++){ |
| 123 | int j; |
| 124 | Table *pTab = pTabList->a[i].pTab; |
| 125 | if( pTab==0 ) continue; |
| 126 | for(j=0; j<pTab->nCol; j++){ |
drh | 7020f65 | 2000-06-03 18:06:52 +0000 | [diff] [blame] | 127 | if( sqliteStrICmp(pTab->aCol[j].zName, z)==0 ){ |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 128 | cnt++; |
drh | 19a775c | 2000-06-05 18:54:46 +0000 | [diff] [blame] | 129 | pExpr->iTable = i + pParse->nTab; |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 130 | pExpr->iColumn = j; |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 131 | } |
| 132 | } |
| 133 | } |
drh | c4a3c77 | 2001-04-04 11:48:57 +0000 | [diff] [blame] | 134 | if( cnt==0 && sqliteIsRowid(z) ){ |
| 135 | pExpr->iColumn = -1; |
| 136 | pExpr->iTable = pParse->nTab; |
| 137 | cnt = 1 + (pTabList->nId>1); |
| 138 | } |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 139 | sqliteFree(z); |
| 140 | if( cnt==0 ){ |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 141 | sqliteSetNString(&pParse->zErrMsg, "no such column: ", -1, |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 142 | pExpr->token.z, pExpr->token.n, 0); |
| 143 | pParse->nErr++; |
| 144 | return 1; |
| 145 | }else if( cnt>1 ){ |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 146 | sqliteSetNString(&pParse->zErrMsg, "ambiguous column name: ", -1, |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 147 | pExpr->token.z, pExpr->token.n, 0); |
| 148 | pParse->nErr++; |
| 149 | return 1; |
| 150 | } |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 151 | pExpr->op = TK_COLUMN; |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 152 | break; |
| 153 | } |
| 154 | |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 155 | /* A table name and column name: ID.ID */ |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 156 | case TK_DOT: { |
drh | bed8690 | 2000-06-02 13:27:59 +0000 | [diff] [blame] | 157 | int cnt = 0; /* Number of matches */ |
drh | c4a3c77 | 2001-04-04 11:48:57 +0000 | [diff] [blame] | 158 | int cntTab = 0; /* Number of matching tables */ |
drh | bed8690 | 2000-06-02 13:27:59 +0000 | [diff] [blame] | 159 | int i; /* Loop counter */ |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 160 | Expr *pLeft, *pRight; /* Left and right subbranches of the expr */ |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 161 | char *zLeft, *zRight; /* Text of an identifier */ |
| 162 | |
| 163 | pLeft = pExpr->pLeft; |
| 164 | pRight = pExpr->pRight; |
| 165 | assert( pLeft && pLeft->op==TK_ID ); |
| 166 | assert( pRight && pRight->op==TK_ID ); |
drh | 6e142f5 | 2000-06-08 13:36:40 +0000 | [diff] [blame] | 167 | zLeft = sqliteStrNDup(pLeft->token.z, pLeft->token.n); |
| 168 | zRight = sqliteStrNDup(pRight->token.z, pRight->token.n); |
drh | daffd0e | 2001-04-11 14:28:42 +0000 | [diff] [blame] | 169 | if( zLeft==0 || zRight==0 ){ |
| 170 | sqliteFree(zLeft); |
| 171 | sqliteFree(zRight); |
| 172 | return 1; |
| 173 | } |
drh | 87c40e8 | 2001-07-23 14:33:02 +0000 | [diff] [blame] | 174 | sqliteDequote(zLeft); |
| 175 | sqliteDequote(zRight); |
drh | c4a3c77 | 2001-04-04 11:48:57 +0000 | [diff] [blame] | 176 | pExpr->iTable = -1; |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 177 | for(i=0; i<pTabList->nId; i++){ |
| 178 | int j; |
| 179 | char *zTab; |
| 180 | Table *pTab = pTabList->a[i].pTab; |
| 181 | if( pTab==0 ) continue; |
| 182 | if( pTabList->a[i].zAlias ){ |
| 183 | zTab = pTabList->a[i].zAlias; |
| 184 | }else{ |
| 185 | zTab = pTab->zName; |
| 186 | } |
| 187 | if( sqliteStrICmp(zTab, zLeft)!=0 ) continue; |
drh | c4a3c77 | 2001-04-04 11:48:57 +0000 | [diff] [blame] | 188 | if( 0==(cntTab++) ) pExpr->iTable = i + pParse->nTab; |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 189 | for(j=0; j<pTab->nCol; j++){ |
drh | 7020f65 | 2000-06-03 18:06:52 +0000 | [diff] [blame] | 190 | if( sqliteStrICmp(pTab->aCol[j].zName, zRight)==0 ){ |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 191 | cnt++; |
drh | 19a775c | 2000-06-05 18:54:46 +0000 | [diff] [blame] | 192 | pExpr->iTable = i + pParse->nTab; |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 193 | pExpr->iColumn = j; |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 194 | } |
| 195 | } |
| 196 | } |
drh | c4a3c77 | 2001-04-04 11:48:57 +0000 | [diff] [blame] | 197 | if( cnt==0 && cntTab==1 && sqliteIsRowid(zRight) ){ |
| 198 | cnt = 1; |
| 199 | pExpr->iColumn = -1; |
| 200 | } |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 201 | sqliteFree(zLeft); |
| 202 | sqliteFree(zRight); |
| 203 | if( cnt==0 ){ |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 204 | sqliteSetNString(&pParse->zErrMsg, "no such column: ", -1, |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 205 | pLeft->token.z, pLeft->token.n, ".", 1, |
| 206 | pRight->token.z, pRight->token.n, 0); |
| 207 | pParse->nErr++; |
| 208 | return 1; |
| 209 | }else if( cnt>1 ){ |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 210 | sqliteSetNString(&pParse->zErrMsg, "ambiguous column name: ", -1, |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 211 | pLeft->token.z, pLeft->token.n, ".", 1, |
| 212 | pRight->token.z, pRight->token.n, 0); |
| 213 | pParse->nErr++; |
| 214 | return 1; |
| 215 | } |
| 216 | sqliteExprDelete(pLeft); |
| 217 | pExpr->pLeft = 0; |
| 218 | sqliteExprDelete(pRight); |
| 219 | pExpr->pRight = 0; |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 220 | pExpr->op = TK_COLUMN; |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 221 | break; |
| 222 | } |
| 223 | |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 224 | case TK_IN: { |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 225 | Vdbe *v = sqliteGetVdbe(pParse); |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 226 | if( v==0 ) return 1; |
drh | cfab11b | 2000-06-06 03:31:22 +0000 | [diff] [blame] | 227 | if( sqliteExprResolveIds(pParse, pTabList, pExpr->pLeft) ){ |
| 228 | return 1; |
| 229 | } |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 230 | if( pExpr->pSelect ){ |
| 231 | /* Case 1: expr IN (SELECT ...) |
| 232 | ** |
| 233 | ** Generate code to write the results of the select into a temporary |
drh | 4794b98 | 2000-06-06 13:54:14 +0000 | [diff] [blame] | 234 | ** table. The cursor number of the temporary table has already |
| 235 | ** been put in iTable by sqliteExprResolveInSelect(). |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 236 | */ |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 237 | sqliteVdbeAddOp(v, OP_OpenTemp, pExpr->iTable, 0); |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 238 | if( sqliteSelect(pParse, pExpr->pSelect, SRT_Set, pExpr->iTable) ); |
| 239 | }else if( pExpr->pList ){ |
| 240 | /* Case 2: expr IN (exprlist) |
| 241 | ** |
| 242 | ** Create a set to put the exprlist values in. The Set id is stored |
| 243 | ** in iTable. |
| 244 | */ |
| 245 | int i, iSet; |
| 246 | for(i=0; i<pExpr->pList->nExpr; i++){ |
| 247 | Expr *pE2 = pExpr->pList->a[i].pExpr; |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 248 | if( !isConstant(pE2) ){ |
| 249 | sqliteSetString(&pParse->zErrMsg, |
| 250 | "right-hand side of IN operator must be constant", 0); |
| 251 | pParse->nErr++; |
| 252 | return 1; |
| 253 | } |
drh | 4794b98 | 2000-06-06 13:54:14 +0000 | [diff] [blame] | 254 | if( sqliteExprCheck(pParse, pE2, 0, 0) ){ |
| 255 | return 1; |
| 256 | } |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 257 | } |
| 258 | iSet = pExpr->iTable = pParse->nSet++; |
| 259 | for(i=0; i<pExpr->pList->nExpr; i++){ |
| 260 | Expr *pE2 = pExpr->pList->a[i].pExpr; |
| 261 | switch( pE2->op ){ |
| 262 | case TK_FLOAT: |
| 263 | case TK_INTEGER: |
| 264 | case TK_STRING: { |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 265 | int addr = sqliteVdbeAddOp(v, OP_SetInsert, iSet, 0); |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 266 | sqliteVdbeChangeP3(v, addr, pE2->token.z, pE2->token.n); |
| 267 | sqliteVdbeDequoteP3(v, addr); |
| 268 | break; |
| 269 | } |
| 270 | default: { |
| 271 | sqliteExprCode(pParse, pE2); |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 272 | sqliteVdbeAddOp(v, OP_SetInsert, iSet, 0); |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 273 | break; |
| 274 | } |
| 275 | } |
| 276 | } |
| 277 | } |
drh | cfab11b | 2000-06-06 03:31:22 +0000 | [diff] [blame] | 278 | break; |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 279 | } |
| 280 | |
drh | 19a775c | 2000-06-05 18:54:46 +0000 | [diff] [blame] | 281 | case TK_SELECT: { |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 282 | /* This has to be a scalar SELECT. Generate code to put the |
| 283 | ** value of this select in a memory cell and record the number |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 284 | ** of the memory cell in iColumn. |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 285 | */ |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 286 | pExpr->iColumn = pParse->nMem++; |
| 287 | if( sqliteSelect(pParse, pExpr->pSelect, SRT_Mem, pExpr->iColumn) ){ |
drh | 19a775c | 2000-06-05 18:54:46 +0000 | [diff] [blame] | 288 | return 1; |
| 289 | } |
| 290 | break; |
| 291 | } |
| 292 | |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 293 | /* For all else, just recursively walk the tree */ |
| 294 | default: { |
drh | 4794b98 | 2000-06-06 13:54:14 +0000 | [diff] [blame] | 295 | if( pExpr->pLeft |
| 296 | && sqliteExprResolveIds(pParse, pTabList, pExpr->pLeft) ){ |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 297 | return 1; |
| 298 | } |
| 299 | if( pExpr->pRight |
drh | 4794b98 | 2000-06-06 13:54:14 +0000 | [diff] [blame] | 300 | && sqliteExprResolveIds(pParse, pTabList, pExpr->pRight) ){ |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 301 | return 1; |
| 302 | } |
| 303 | if( pExpr->pList ){ |
| 304 | int i; |
| 305 | ExprList *pList = pExpr->pList; |
| 306 | for(i=0; i<pList->nExpr; i++){ |
| 307 | if( sqliteExprResolveIds(pParse, pTabList, pList->a[i].pExpr) ){ |
| 308 | return 1; |
| 309 | } |
| 310 | } |
| 311 | } |
| 312 | } |
| 313 | } |
| 314 | return 0; |
| 315 | } |
| 316 | |
| 317 | #if 0 /* NOT USED */ |
| 318 | /* |
| 319 | ** Compare a token against a string. Return TRUE if they match. |
| 320 | */ |
| 321 | static int sqliteTokenCmp(Token *pToken, const char *zStr){ |
| 322 | int n = strlen(zStr); |
| 323 | if( n!=pToken->n ) return 0; |
| 324 | return sqliteStrNICmp(pToken->z, zStr, n)==0; |
| 325 | } |
| 326 | #endif |
| 327 | |
| 328 | /* |
| 329 | ** Convert a function name into its integer identifier. Return the |
| 330 | ** identifier. Return FN_Unknown if the function name is unknown. |
| 331 | */ |
| 332 | int sqliteFuncId(Token *pToken){ |
| 333 | static const struct { |
| 334 | char *zName; |
| 335 | int len; |
| 336 | int id; |
| 337 | } aFunc[] = { |
drh | bf4133c | 2001-10-13 02:59:08 +0000 | [diff] [blame] | 338 | { "count", 5, FN_Count }, |
| 339 | { "min", 3, FN_Min }, |
| 340 | { "max", 3, FN_Max }, |
| 341 | { "sum", 3, FN_Sum }, |
| 342 | { "avg", 3, FN_Avg }, |
| 343 | { "fcnt", 4, FN_Fcnt }, /* Used for testing only */ |
| 344 | { "length", 6, FN_Length }, |
| 345 | { "substr", 6, FN_Substr }, |
| 346 | { "abs", 3, FN_Abs }, |
| 347 | { "round", 5, FN_Round }, |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 348 | }; |
| 349 | int i; |
| 350 | for(i=0; i<ArraySize(aFunc); i++){ |
| 351 | if( aFunc[i].len==pToken->n |
| 352 | && sqliteStrNICmp(pToken->z, aFunc[i].zName, aFunc[i].len)==0 ){ |
| 353 | return aFunc[i].id; |
| 354 | } |
| 355 | } |
| 356 | return FN_Unknown; |
| 357 | } |
| 358 | |
| 359 | /* |
| 360 | ** Error check the functions in an expression. Make sure all |
| 361 | ** function names are recognized and all functions have the correct |
| 362 | ** number of arguments. Leave an error message in pParse->zErrMsg |
| 363 | ** if anything is amiss. Return the number of errors. |
| 364 | ** |
| 365 | ** if pIsAgg is not null and this expression is an aggregate function |
| 366 | ** (like count(*) or max(value)) then write a 1 into *pIsAgg. |
| 367 | */ |
| 368 | int sqliteExprCheck(Parse *pParse, Expr *pExpr, int allowAgg, int *pIsAgg){ |
| 369 | int nErr = 0; |
| 370 | if( pExpr==0 ) return 0; |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 371 | switch( pExpr->op ){ |
| 372 | case TK_FUNCTION: { |
| 373 | int id = sqliteFuncId(&pExpr->token); |
| 374 | int n = pExpr->pList ? pExpr->pList->nExpr : 0; |
| 375 | int no_such_func = 0; |
| 376 | int too_many_args = 0; |
| 377 | int too_few_args = 0; |
| 378 | int is_agg = 0; |
| 379 | int i; |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 380 | pExpr->iColumn = id; |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 381 | switch( id ){ |
| 382 | case FN_Unknown: { |
| 383 | no_such_func = 1; |
| 384 | break; |
| 385 | } |
| 386 | case FN_Count: { |
| 387 | no_such_func = !allowAgg; |
| 388 | too_many_args = n>1; |
| 389 | is_agg = 1; |
| 390 | break; |
| 391 | } |
| 392 | case FN_Max: |
| 393 | case FN_Min: { |
| 394 | too_few_args = allowAgg ? n<1 : n<2; |
| 395 | is_agg = n==1; |
| 396 | break; |
| 397 | } |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 398 | case FN_Avg: |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 399 | case FN_Sum: { |
| 400 | no_such_func = !allowAgg; |
| 401 | too_many_args = n>1; |
| 402 | too_few_args = n<1; |
| 403 | is_agg = 1; |
| 404 | break; |
| 405 | } |
drh | bf4133c | 2001-10-13 02:59:08 +0000 | [diff] [blame] | 406 | case FN_Abs: |
drh | 6ec2733 | 2000-08-28 15:51:43 +0000 | [diff] [blame] | 407 | case FN_Length: { |
| 408 | too_few_args = n<1; |
| 409 | too_many_args = n>1; |
| 410 | break; |
| 411 | } |
drh | bf4133c | 2001-10-13 02:59:08 +0000 | [diff] [blame] | 412 | case FN_Round: { |
| 413 | too_few_args = n<1; |
| 414 | too_many_args = n>2; |
| 415 | break; |
| 416 | } |
drh | 6ec2733 | 2000-08-28 15:51:43 +0000 | [diff] [blame] | 417 | case FN_Substr: { |
| 418 | too_few_args = n<3; |
| 419 | too_many_args = n>3; |
| 420 | break; |
| 421 | } |
drh | bf4133c | 2001-10-13 02:59:08 +0000 | [diff] [blame] | 422 | /* The "fcnt(*)" function always returns the number of OP_MoveTo |
drh | 0bdaf62 | 2000-06-11 23:50:13 +0000 | [diff] [blame] | 423 | ** operations that have occurred so far while processing the |
| 424 | ** SQL statement. This information can be used by test procedures |
| 425 | ** to verify that indices are being used properly to minimize |
| 426 | ** searching. All arguments to fcnt() are ignored. fcnt() has |
| 427 | ** no use (other than testing) that we are aware of. |
| 428 | */ |
| 429 | case FN_Fcnt: { |
| 430 | n = 0; |
| 431 | break; |
| 432 | } |
drh | 6ec2733 | 2000-08-28 15:51:43 +0000 | [diff] [blame] | 433 | |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 434 | default: break; |
| 435 | } |
| 436 | if( no_such_func ){ |
| 437 | sqliteSetNString(&pParse->zErrMsg, "no such function: ", -1, |
| 438 | pExpr->token.z, pExpr->token.n, 0); |
| 439 | pParse->nErr++; |
| 440 | nErr++; |
| 441 | }else if( too_many_args ){ |
| 442 | sqliteSetNString(&pParse->zErrMsg, "too many arguments to function ",-1, |
| 443 | pExpr->token.z, pExpr->token.n, "()", 2, 0); |
| 444 | pParse->nErr++; |
| 445 | nErr++; |
| 446 | }else if( too_few_args ){ |
| 447 | sqliteSetNString(&pParse->zErrMsg, "too few arguments to function ",-1, |
| 448 | pExpr->token.z, pExpr->token.n, "()", 2, 0); |
| 449 | pParse->nErr++; |
| 450 | nErr++; |
| 451 | } |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 452 | if( is_agg ) pExpr->op = TK_AGG_FUNCTION; |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 453 | if( is_agg && pIsAgg ) *pIsAgg = 1; |
| 454 | for(i=0; nErr==0 && i<n; i++){ |
drh | 4cfa793 | 2000-06-08 15:10:46 +0000 | [diff] [blame] | 455 | nErr = sqliteExprCheck(pParse, pExpr->pList->a[i].pExpr, |
| 456 | allowAgg && !is_agg, pIsAgg); |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 457 | } |
| 458 | } |
| 459 | default: { |
| 460 | if( pExpr->pLeft ){ |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 461 | nErr = sqliteExprCheck(pParse, pExpr->pLeft, allowAgg, pIsAgg); |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 462 | } |
| 463 | if( nErr==0 && pExpr->pRight ){ |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 464 | nErr = sqliteExprCheck(pParse, pExpr->pRight, allowAgg, pIsAgg); |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 465 | } |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 466 | if( nErr==0 && pExpr->pList ){ |
| 467 | int n = pExpr->pList->nExpr; |
| 468 | int i; |
| 469 | for(i=0; nErr==0 && i<n; i++){ |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 470 | Expr *pE2 = pExpr->pList->a[i].pExpr; |
| 471 | nErr = sqliteExprCheck(pParse, pE2, allowAgg, pIsAgg); |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 472 | } |
| 473 | } |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 474 | break; |
| 475 | } |
| 476 | } |
| 477 | return nErr; |
| 478 | } |
| 479 | |
| 480 | /* |
| 481 | ** Generate code into the current Vdbe to evaluate the given |
drh | 1ccde15 | 2000-06-17 13:12:39 +0000 | [diff] [blame] | 482 | ** expression and leave the result on the top of stack. |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 483 | */ |
| 484 | void sqliteExprCode(Parse *pParse, Expr *pExpr){ |
| 485 | Vdbe *v = pParse->pVdbe; |
| 486 | int op; |
drh | daffd0e | 2001-04-11 14:28:42 +0000 | [diff] [blame] | 487 | if( v==0 || pExpr==0 ) return; |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 488 | switch( pExpr->op ){ |
| 489 | case TK_PLUS: op = OP_Add; break; |
| 490 | case TK_MINUS: op = OP_Subtract; break; |
| 491 | case TK_STAR: op = OP_Multiply; break; |
| 492 | case TK_SLASH: op = OP_Divide; break; |
| 493 | case TK_AND: op = OP_And; break; |
| 494 | case TK_OR: op = OP_Or; break; |
| 495 | case TK_LT: op = OP_Lt; break; |
| 496 | case TK_LE: op = OP_Le; break; |
| 497 | case TK_GT: op = OP_Gt; break; |
| 498 | case TK_GE: op = OP_Ge; break; |
| 499 | case TK_NE: op = OP_Ne; break; |
| 500 | case TK_EQ: op = OP_Eq; break; |
| 501 | case TK_LIKE: op = OP_Like; break; |
| 502 | case TK_GLOB: op = OP_Glob; break; |
| 503 | case TK_ISNULL: op = OP_IsNull; break; |
| 504 | case TK_NOTNULL: op = OP_NotNull; break; |
| 505 | case TK_NOT: op = OP_Not; break; |
| 506 | case TK_UMINUS: op = OP_Negative; break; |
drh | bf4133c | 2001-10-13 02:59:08 +0000 | [diff] [blame] | 507 | case TK_BITAND: op = OP_BitAnd; break; |
| 508 | case TK_BITOR: op = OP_BitOr; break; |
| 509 | case TK_BITNOT: op = OP_BitNot; break; |
| 510 | case TK_LSHIFT: op = OP_ShiftLeft; break; |
| 511 | case TK_RSHIFT: op = OP_ShiftRight; break; |
| 512 | case TK_REM: op = OP_Remainder; break; |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 513 | default: break; |
| 514 | } |
| 515 | switch( pExpr->op ){ |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 516 | case TK_COLUMN: { |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 517 | if( pParse->useAgg ){ |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 518 | sqliteVdbeAddOp(v, OP_AggGet, 0, pExpr->iAgg); |
drh | c4a3c77 | 2001-04-04 11:48:57 +0000 | [diff] [blame] | 519 | }else if( pExpr->iColumn>=0 ){ |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 520 | sqliteVdbeAddOp(v, OP_Column, pExpr->iTable, pExpr->iColumn); |
drh | c4a3c77 | 2001-04-04 11:48:57 +0000 | [diff] [blame] | 521 | }else{ |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 522 | sqliteVdbeAddOp(v, OP_Recno, pExpr->iTable, 0); |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 523 | } |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 524 | break; |
| 525 | } |
| 526 | case TK_INTEGER: { |
| 527 | int i = atoi(pExpr->token.z); |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 528 | sqliteVdbeAddOp(v, OP_Integer, i, 0); |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 529 | break; |
| 530 | } |
| 531 | case TK_FLOAT: { |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 532 | int addr = sqliteVdbeAddOp(v, OP_String, 0, 0); |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 533 | sqliteVdbeChangeP3(v, addr, pExpr->token.z, pExpr->token.n); |
| 534 | break; |
| 535 | } |
| 536 | case TK_STRING: { |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 537 | int addr = sqliteVdbeAddOp(v, OP_String, 0, 0); |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 538 | sqliteVdbeChangeP3(v, addr, pExpr->token.z, pExpr->token.n); |
| 539 | sqliteVdbeDequoteP3(v, addr); |
| 540 | break; |
| 541 | } |
| 542 | case TK_NULL: { |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 543 | sqliteVdbeAddOp(v, OP_String, 0, 0); |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 544 | break; |
| 545 | } |
| 546 | case TK_AND: |
| 547 | case TK_OR: |
| 548 | case TK_PLUS: |
| 549 | case TK_STAR: |
| 550 | case TK_MINUS: |
drh | bf4133c | 2001-10-13 02:59:08 +0000 | [diff] [blame] | 551 | case TK_REM: |
| 552 | case TK_BITAND: |
| 553 | case TK_BITOR: |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 554 | case TK_SLASH: { |
| 555 | sqliteExprCode(pParse, pExpr->pLeft); |
| 556 | sqliteExprCode(pParse, pExpr->pRight); |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 557 | sqliteVdbeAddOp(v, op, 0, 0); |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 558 | break; |
| 559 | } |
drh | bf4133c | 2001-10-13 02:59:08 +0000 | [diff] [blame] | 560 | case TK_LSHIFT: |
| 561 | case TK_RSHIFT: { |
| 562 | sqliteExprCode(pParse, pExpr->pRight); |
| 563 | sqliteExprCode(pParse, pExpr->pLeft); |
| 564 | sqliteVdbeAddOp(v, op, 0, 0); |
| 565 | break; |
| 566 | } |
drh | 0040077 | 2000-06-16 20:51:26 +0000 | [diff] [blame] | 567 | case TK_CONCAT: { |
| 568 | sqliteExprCode(pParse, pExpr->pLeft); |
| 569 | sqliteExprCode(pParse, pExpr->pRight); |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 570 | sqliteVdbeAddOp(v, OP_Concat, 2, 0); |
drh | 0040077 | 2000-06-16 20:51:26 +0000 | [diff] [blame] | 571 | break; |
| 572 | } |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 573 | case TK_LT: |
| 574 | case TK_LE: |
| 575 | case TK_GT: |
| 576 | case TK_GE: |
| 577 | case TK_NE: |
| 578 | case TK_EQ: |
| 579 | case TK_LIKE: |
| 580 | case TK_GLOB: { |
| 581 | int dest; |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 582 | sqliteVdbeAddOp(v, OP_Integer, 1, 0); |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 583 | sqliteExprCode(pParse, pExpr->pLeft); |
| 584 | sqliteExprCode(pParse, pExpr->pRight); |
| 585 | dest = sqliteVdbeCurrentAddr(v) + 2; |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 586 | sqliteVdbeAddOp(v, op, 0, dest); |
| 587 | sqliteVdbeAddOp(v, OP_AddImm, -1, 0); |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 588 | break; |
| 589 | } |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 590 | case TK_UMINUS: { |
drh | 6e142f5 | 2000-06-08 13:36:40 +0000 | [diff] [blame] | 591 | assert( pExpr->pLeft ); |
| 592 | if( pExpr->pLeft->op==TK_INTEGER ){ |
| 593 | int i = atoi(pExpr->pLeft->token.z); |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 594 | sqliteVdbeAddOp(v, OP_Integer, -i, 0); |
drh | 6e142f5 | 2000-06-08 13:36:40 +0000 | [diff] [blame] | 595 | break; |
| 596 | }else if( pExpr->pLeft->op==TK_FLOAT ){ |
| 597 | Token *p = &pExpr->pLeft->token; |
| 598 | char *z = sqliteMalloc( p->n + 2 ); |
| 599 | sprintf(z, "-%.*s", p->n, p->z); |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 600 | sqliteVdbeAddOp(v, OP_String, 0, 0); |
| 601 | sqliteVdbeChangeP3(v, -1, z, p->n+1); |
drh | 6e142f5 | 2000-06-08 13:36:40 +0000 | [diff] [blame] | 602 | sqliteFree(z); |
| 603 | break; |
| 604 | } |
drh | 1ccde15 | 2000-06-17 13:12:39 +0000 | [diff] [blame] | 605 | /* Fall through into TK_NOT */ |
drh | 6e142f5 | 2000-06-08 13:36:40 +0000 | [diff] [blame] | 606 | } |
drh | bf4133c | 2001-10-13 02:59:08 +0000 | [diff] [blame] | 607 | case TK_BITNOT: |
drh | 6e142f5 | 2000-06-08 13:36:40 +0000 | [diff] [blame] | 608 | case TK_NOT: { |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 609 | sqliteExprCode(pParse, pExpr->pLeft); |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 610 | sqliteVdbeAddOp(v, op, 0, 0); |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 611 | break; |
| 612 | } |
| 613 | case TK_ISNULL: |
| 614 | case TK_NOTNULL: { |
| 615 | int dest; |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 616 | sqliteVdbeAddOp(v, OP_Integer, 1, 0); |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 617 | sqliteExprCode(pParse, pExpr->pLeft); |
| 618 | dest = sqliteVdbeCurrentAddr(v) + 2; |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 619 | sqliteVdbeAddOp(v, op, 0, dest); |
| 620 | sqliteVdbeAddOp(v, OP_AddImm, -1, 0); |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 621 | break; |
| 622 | } |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 623 | case TK_AGG_FUNCTION: { |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 624 | sqliteVdbeAddOp(v, OP_AggGet, 0, pExpr->iAgg); |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 625 | if( pExpr->iColumn==FN_Avg ){ |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 626 | assert( pParse->iAggCount>=0 && pParse->iAggCount<pParse->nAgg ); |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 627 | sqliteVdbeAddOp(v, OP_AggGet, 0, pParse->iAggCount); |
| 628 | sqliteVdbeAddOp(v, OP_Divide, 0, 0); |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 629 | } |
| 630 | break; |
| 631 | } |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 632 | case TK_FUNCTION: { |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 633 | int id = pExpr->iColumn; |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 634 | int op; |
| 635 | int i; |
| 636 | ExprList *pList = pExpr->pList; |
drh | 6ec2733 | 2000-08-28 15:51:43 +0000 | [diff] [blame] | 637 | switch( id ){ |
| 638 | case FN_Fcnt: { |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 639 | sqliteVdbeAddOp(v, OP_Fcnt, 0, 0); |
drh | 6ec2733 | 2000-08-28 15:51:43 +0000 | [diff] [blame] | 640 | break; |
| 641 | } |
| 642 | case FN_Min: |
| 643 | case FN_Max: { |
| 644 | op = id==FN_Min ? OP_Min : OP_Max; |
| 645 | for(i=0; i<pList->nExpr; i++){ |
| 646 | sqliteExprCode(pParse, pList->a[i].pExpr); |
| 647 | if( i>0 ){ |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 648 | sqliteVdbeAddOp(v, op, 0, 0); |
drh | 6ec2733 | 2000-08-28 15:51:43 +0000 | [diff] [blame] | 649 | } |
| 650 | } |
| 651 | break; |
| 652 | } |
drh | bf4133c | 2001-10-13 02:59:08 +0000 | [diff] [blame] | 653 | case FN_Abs: { |
| 654 | sqliteExprCode(pParse, pList->a[0].pExpr); |
| 655 | sqliteVdbeAddOp(v, OP_AbsValue, 0, 0); |
| 656 | break; |
| 657 | } |
| 658 | case FN_Round: { |
| 659 | if( pList->nExpr==2 ){ |
| 660 | sqliteExprCode(pParse, pList->a[1].pExpr); |
| 661 | }else{ |
| 662 | sqliteVdbeAddOp(v, OP_Integer, 0, 0); |
| 663 | } |
| 664 | sqliteExprCode(pParse, pList->a[0].pExpr); |
| 665 | sqliteVdbeAddOp(v, OP_Precision, 0, 0); |
| 666 | break; |
| 667 | } |
drh | 6ec2733 | 2000-08-28 15:51:43 +0000 | [diff] [blame] | 668 | case FN_Length: { |
| 669 | sqliteExprCode(pParse, pList->a[0].pExpr); |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 670 | sqliteVdbeAddOp(v, OP_Strlen, 0, 0); |
drh | 6ec2733 | 2000-08-28 15:51:43 +0000 | [diff] [blame] | 671 | break; |
| 672 | } |
| 673 | case FN_Substr: { |
| 674 | for(i=0; i<pList->nExpr; i++){ |
| 675 | sqliteExprCode(pParse, pList->a[i].pExpr); |
| 676 | } |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 677 | sqliteVdbeAddOp(v, OP_Substr, 0, 0); |
drh | 6ec2733 | 2000-08-28 15:51:43 +0000 | [diff] [blame] | 678 | break; |
| 679 | } |
| 680 | default: { |
| 681 | /* Can't happen! */ |
| 682 | break; |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 683 | } |
| 684 | } |
| 685 | break; |
| 686 | } |
drh | 19a775c | 2000-06-05 18:54:46 +0000 | [diff] [blame] | 687 | case TK_SELECT: { |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 688 | sqliteVdbeAddOp(v, OP_MemLoad, pExpr->iColumn, 0); |
drh | 19a775c | 2000-06-05 18:54:46 +0000 | [diff] [blame] | 689 | break; |
| 690 | } |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 691 | case TK_IN: { |
| 692 | int addr; |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 693 | sqliteVdbeAddOp(v, OP_Integer, 1, 0); |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 694 | sqliteExprCode(pParse, pExpr->pLeft); |
| 695 | addr = sqliteVdbeCurrentAddr(v); |
| 696 | if( pExpr->pSelect ){ |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 697 | sqliteVdbeAddOp(v, OP_Found, pExpr->iTable, addr+2); |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 698 | }else{ |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 699 | sqliteVdbeAddOp(v, OP_SetFound, pExpr->iTable, addr+2); |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 700 | } |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 701 | sqliteVdbeAddOp(v, OP_AddImm, -1, 0); |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 702 | break; |
| 703 | } |
| 704 | case TK_BETWEEN: { |
| 705 | int lbl = sqliteVdbeMakeLabel(v); |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 706 | sqliteVdbeAddOp(v, OP_Integer, 0, 0); |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 707 | sqliteExprIfFalse(pParse, pExpr, lbl); |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 708 | sqliteVdbeAddOp(v, OP_AddImm, 1, 0); |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 709 | sqliteVdbeResolveLabel(v, lbl); |
| 710 | break; |
| 711 | } |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 712 | } |
| 713 | return; |
| 714 | } |
| 715 | |
| 716 | /* |
| 717 | ** Generate code for a boolean expression such that a jump is made |
| 718 | ** to the label "dest" if the expression is true but execution |
| 719 | ** continues straight thru if the expression is false. |
| 720 | */ |
| 721 | void sqliteExprIfTrue(Parse *pParse, Expr *pExpr, int dest){ |
| 722 | Vdbe *v = pParse->pVdbe; |
| 723 | int op = 0; |
drh | daffd0e | 2001-04-11 14:28:42 +0000 | [diff] [blame] | 724 | if( v==0 || pExpr==0 ) return; |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 725 | switch( pExpr->op ){ |
| 726 | case TK_LT: op = OP_Lt; break; |
| 727 | case TK_LE: op = OP_Le; break; |
| 728 | case TK_GT: op = OP_Gt; break; |
| 729 | case TK_GE: op = OP_Ge; break; |
| 730 | case TK_NE: op = OP_Ne; break; |
| 731 | case TK_EQ: op = OP_Eq; break; |
| 732 | case TK_LIKE: op = OP_Like; break; |
| 733 | case TK_GLOB: op = OP_Glob; break; |
| 734 | case TK_ISNULL: op = OP_IsNull; break; |
| 735 | case TK_NOTNULL: op = OP_NotNull; break; |
| 736 | default: break; |
| 737 | } |
| 738 | switch( pExpr->op ){ |
| 739 | case TK_AND: { |
| 740 | int d2 = sqliteVdbeMakeLabel(v); |
| 741 | sqliteExprIfFalse(pParse, pExpr->pLeft, d2); |
| 742 | sqliteExprIfTrue(pParse, pExpr->pRight, dest); |
| 743 | sqliteVdbeResolveLabel(v, d2); |
| 744 | break; |
| 745 | } |
| 746 | case TK_OR: { |
| 747 | sqliteExprIfTrue(pParse, pExpr->pLeft, dest); |
| 748 | sqliteExprIfTrue(pParse, pExpr->pRight, dest); |
| 749 | break; |
| 750 | } |
| 751 | case TK_NOT: { |
| 752 | sqliteExprIfFalse(pParse, pExpr->pLeft, dest); |
| 753 | break; |
| 754 | } |
| 755 | case TK_LT: |
| 756 | case TK_LE: |
| 757 | case TK_GT: |
| 758 | case TK_GE: |
| 759 | case TK_NE: |
| 760 | case TK_EQ: |
| 761 | case TK_LIKE: |
| 762 | case TK_GLOB: { |
| 763 | sqliteExprCode(pParse, pExpr->pLeft); |
| 764 | sqliteExprCode(pParse, pExpr->pRight); |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 765 | sqliteVdbeAddOp(v, op, 0, dest); |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 766 | break; |
| 767 | } |
| 768 | case TK_ISNULL: |
| 769 | case TK_NOTNULL: { |
| 770 | sqliteExprCode(pParse, pExpr->pLeft); |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 771 | sqliteVdbeAddOp(v, op, 0, dest); |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 772 | break; |
| 773 | } |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 774 | case TK_IN: { |
drh | cfab11b | 2000-06-06 03:31:22 +0000 | [diff] [blame] | 775 | sqliteExprCode(pParse, pExpr->pLeft); |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 776 | if( pExpr->pSelect ){ |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 777 | sqliteVdbeAddOp(v, OP_Found, pExpr->iTable, dest); |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 778 | }else{ |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 779 | sqliteVdbeAddOp(v, OP_SetFound, pExpr->iTable, dest); |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 780 | } |
| 781 | break; |
| 782 | } |
| 783 | case TK_BETWEEN: { |
| 784 | int lbl = sqliteVdbeMakeLabel(v); |
| 785 | sqliteExprCode(pParse, pExpr->pLeft); |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 786 | sqliteVdbeAddOp(v, OP_Dup, 0, 0); |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 787 | sqliteExprCode(pParse, pExpr->pList->a[0].pExpr); |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 788 | sqliteVdbeAddOp(v, OP_Lt, 0, lbl); |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 789 | sqliteExprCode(pParse, pExpr->pList->a[1].pExpr); |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 790 | sqliteVdbeAddOp(v, OP_Le, 0, dest); |
| 791 | sqliteVdbeAddOp(v, OP_Integer, 0, 0); |
| 792 | sqliteVdbeResolveLabel(v, lbl); |
| 793 | sqliteVdbeAddOp(v, OP_Pop, 1, 0); |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 794 | break; |
| 795 | } |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 796 | default: { |
| 797 | sqliteExprCode(pParse, pExpr); |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 798 | sqliteVdbeAddOp(v, OP_If, 0, dest); |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 799 | break; |
| 800 | } |
| 801 | } |
| 802 | } |
| 803 | |
| 804 | /* |
drh | 66b89c8 | 2000-11-28 20:47:17 +0000 | [diff] [blame] | 805 | ** Generate code for a boolean expression such that a jump is made |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 806 | ** to the label "dest" if the expression is false but execution |
| 807 | ** continues straight thru if the expression is true. |
| 808 | */ |
| 809 | void sqliteExprIfFalse(Parse *pParse, Expr *pExpr, int dest){ |
| 810 | Vdbe *v = pParse->pVdbe; |
| 811 | int op = 0; |
drh | daffd0e | 2001-04-11 14:28:42 +0000 | [diff] [blame] | 812 | if( v==0 || pExpr==0 ) return; |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 813 | switch( pExpr->op ){ |
| 814 | case TK_LT: op = OP_Ge; break; |
| 815 | case TK_LE: op = OP_Gt; break; |
| 816 | case TK_GT: op = OP_Le; break; |
| 817 | case TK_GE: op = OP_Lt; break; |
| 818 | case TK_NE: op = OP_Eq; break; |
| 819 | case TK_EQ: op = OP_Ne; break; |
| 820 | case TK_LIKE: op = OP_Like; break; |
| 821 | case TK_GLOB: op = OP_Glob; break; |
| 822 | case TK_ISNULL: op = OP_NotNull; break; |
| 823 | case TK_NOTNULL: op = OP_IsNull; break; |
| 824 | default: break; |
| 825 | } |
| 826 | switch( pExpr->op ){ |
| 827 | case TK_AND: { |
| 828 | sqliteExprIfFalse(pParse, pExpr->pLeft, dest); |
| 829 | sqliteExprIfFalse(pParse, pExpr->pRight, dest); |
| 830 | break; |
| 831 | } |
| 832 | case TK_OR: { |
| 833 | int d2 = sqliteVdbeMakeLabel(v); |
| 834 | sqliteExprIfTrue(pParse, pExpr->pLeft, d2); |
| 835 | sqliteExprIfFalse(pParse, pExpr->pRight, dest); |
| 836 | sqliteVdbeResolveLabel(v, d2); |
| 837 | break; |
| 838 | } |
| 839 | case TK_NOT: { |
| 840 | sqliteExprIfTrue(pParse, pExpr->pLeft, dest); |
| 841 | break; |
| 842 | } |
| 843 | case TK_LT: |
| 844 | case TK_LE: |
| 845 | case TK_GT: |
| 846 | case TK_GE: |
| 847 | case TK_NE: |
| 848 | case TK_EQ: { |
| 849 | sqliteExprCode(pParse, pExpr->pLeft); |
| 850 | sqliteExprCode(pParse, pExpr->pRight); |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 851 | sqliteVdbeAddOp(v, op, 0, dest); |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 852 | break; |
| 853 | } |
| 854 | case TK_LIKE: |
| 855 | case TK_GLOB: { |
| 856 | sqliteExprCode(pParse, pExpr->pLeft); |
| 857 | sqliteExprCode(pParse, pExpr->pRight); |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 858 | sqliteVdbeAddOp(v, op, 1, dest); |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 859 | break; |
| 860 | } |
| 861 | case TK_ISNULL: |
| 862 | case TK_NOTNULL: { |
| 863 | sqliteExprCode(pParse, pExpr->pLeft); |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 864 | sqliteVdbeAddOp(v, op, 0, dest); |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 865 | break; |
| 866 | } |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 867 | case TK_IN: { |
drh | cfab11b | 2000-06-06 03:31:22 +0000 | [diff] [blame] | 868 | sqliteExprCode(pParse, pExpr->pLeft); |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 869 | if( pExpr->pSelect ){ |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 870 | sqliteVdbeAddOp(v, OP_NotFound, pExpr->iTable, dest); |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 871 | }else{ |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 872 | sqliteVdbeAddOp(v, OP_SetNotFound, pExpr->iTable, dest); |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 873 | } |
| 874 | break; |
| 875 | } |
| 876 | case TK_BETWEEN: { |
| 877 | int addr; |
| 878 | sqliteExprCode(pParse, pExpr->pLeft); |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 879 | sqliteVdbeAddOp(v, OP_Dup, 0, 0); |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 880 | sqliteExprCode(pParse, pExpr->pList->a[0].pExpr); |
| 881 | addr = sqliteVdbeCurrentAddr(v); |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 882 | sqliteVdbeAddOp(v, OP_Ge, 0, addr+3); |
| 883 | sqliteVdbeAddOp(v, OP_Pop, 1, 0); |
| 884 | sqliteVdbeAddOp(v, OP_Goto, 0, dest); |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 885 | sqliteExprCode(pParse, pExpr->pList->a[1].pExpr); |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 886 | sqliteVdbeAddOp(v, OP_Gt, 0, dest); |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 887 | break; |
| 888 | } |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 889 | default: { |
| 890 | sqliteExprCode(pParse, pExpr); |
drh | 99fcd71 | 2001-10-13 01:06:47 +0000 | [diff] [blame] | 891 | sqliteVdbeAddOp(v, OP_Not, 0, 0); |
| 892 | sqliteVdbeAddOp(v, OP_If, 0, dest); |
drh | cce7d17 | 2000-05-31 15:34:51 +0000 | [diff] [blame] | 893 | break; |
| 894 | } |
| 895 | } |
| 896 | } |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 897 | |
| 898 | /* |
| 899 | ** Do a deep comparison of two expression trees. Return TRUE (non-zero) |
| 900 | ** if they are identical and return FALSE if they differ in any way. |
| 901 | */ |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 902 | int sqliteExprCompare(Expr *pA, Expr *pB){ |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 903 | int i; |
| 904 | if( pA==0 ){ |
| 905 | return pB==0; |
| 906 | }else if( pB==0 ){ |
| 907 | return 0; |
| 908 | } |
| 909 | if( pA->op!=pB->op ) return 0; |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 910 | if( !sqliteExprCompare(pA->pLeft, pB->pLeft) ) return 0; |
| 911 | if( !sqliteExprCompare(pA->pRight, pB->pRight) ) return 0; |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 912 | if( pA->pList ){ |
| 913 | if( pB->pList==0 ) return 0; |
| 914 | if( pA->pList->nExpr!=pB->pList->nExpr ) return 0; |
| 915 | for(i=0; i<pA->pList->nExpr; i++){ |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 916 | if( !sqliteExprCompare(pA->pList->a[i].pExpr, pB->pList->a[i].pExpr) ){ |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 917 | return 0; |
| 918 | } |
| 919 | } |
| 920 | }else if( pB->pList ){ |
| 921 | return 0; |
| 922 | } |
| 923 | if( pA->pSelect || pB->pSelect ) return 0; |
| 924 | if( pA->token.z ){ |
| 925 | if( pB->token.z==0 ) return 0; |
| 926 | if( pB->token.n!=pA->token.n ) return 0; |
| 927 | if( sqliteStrNICmp(pA->token.z, pB->token.z, pA->token.n)!=0 ) return 0; |
| 928 | } |
| 929 | return 1; |
| 930 | } |
| 931 | |
| 932 | /* |
| 933 | ** Add a new element to the pParse->aAgg[] array and return its index. |
| 934 | */ |
| 935 | static int appendAggInfo(Parse *pParse){ |
| 936 | if( (pParse->nAgg & 0x7)==0 ){ |
| 937 | int amt = pParse->nAgg + 8; |
| 938 | pParse->aAgg = sqliteRealloc(pParse->aAgg, amt*sizeof(pParse->aAgg[0])); |
| 939 | if( pParse->aAgg==0 ){ |
drh | daffd0e | 2001-04-11 14:28:42 +0000 | [diff] [blame] | 940 | pParse->nAgg = 0; |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 941 | return -1; |
| 942 | } |
| 943 | } |
| 944 | memset(&pParse->aAgg[pParse->nAgg], 0, sizeof(pParse->aAgg[0])); |
| 945 | return pParse->nAgg++; |
| 946 | } |
| 947 | |
| 948 | /* |
| 949 | ** Analyze the given expression looking for aggregate functions and |
| 950 | ** for variables that need to be added to the pParse->aAgg[] array. |
| 951 | ** Make additional entries to the pParse->aAgg[] array as necessary. |
| 952 | ** |
| 953 | ** This routine should only be called after the expression has been |
| 954 | ** analyzed by sqliteExprResolveIds() and sqliteExprCheck(). |
| 955 | ** |
| 956 | ** If errors are seen, leave an error message in zErrMsg and return |
| 957 | ** the number of errors. |
| 958 | */ |
| 959 | int sqliteExprAnalyzeAggregates(Parse *pParse, Expr *pExpr){ |
| 960 | int i; |
| 961 | AggExpr *aAgg; |
| 962 | int nErr = 0; |
| 963 | |
| 964 | if( pExpr==0 ) return 0; |
| 965 | switch( pExpr->op ){ |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 966 | case TK_COLUMN: { |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 967 | aAgg = pParse->aAgg; |
| 968 | for(i=0; i<pParse->nAgg; i++){ |
| 969 | if( aAgg[i].isAgg ) continue; |
| 970 | if( aAgg[i].pExpr->iTable==pExpr->iTable |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 971 | && aAgg[i].pExpr->iColumn==pExpr->iColumn ){ |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 972 | break; |
| 973 | } |
| 974 | } |
| 975 | if( i>=pParse->nAgg ){ |
| 976 | i = appendAggInfo(pParse); |
| 977 | if( i<0 ) return 1; |
| 978 | pParse->aAgg[i].isAgg = 0; |
| 979 | pParse->aAgg[i].pExpr = pExpr; |
| 980 | } |
drh | aaf8872 | 2000-06-08 11:25:00 +0000 | [diff] [blame] | 981 | pExpr->iAgg = i; |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 982 | break; |
| 983 | } |
| 984 | case TK_AGG_FUNCTION: { |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 985 | if( pExpr->iColumn==FN_Count || pExpr->iColumn==FN_Avg ){ |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 986 | if( pParse->iAggCount>=0 ){ |
| 987 | i = pParse->iAggCount; |
| 988 | }else{ |
| 989 | i = appendAggInfo(pParse); |
| 990 | if( i<0 ) return 1; |
| 991 | pParse->aAgg[i].isAgg = 1; |
| 992 | pParse->aAgg[i].pExpr = 0; |
| 993 | pParse->iAggCount = i; |
| 994 | } |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 995 | if( pExpr->iColumn==FN_Count ){ |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 996 | pExpr->iAgg = i; |
| 997 | break; |
| 998 | } |
| 999 | } |
| 1000 | aAgg = pParse->aAgg; |
| 1001 | for(i=0; i<pParse->nAgg; i++){ |
| 1002 | if( !aAgg[i].isAgg ) continue; |
drh | d8bc708 | 2000-06-07 23:51:50 +0000 | [diff] [blame] | 1003 | if( sqliteExprCompare(aAgg[i].pExpr, pExpr) ){ |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 1004 | break; |
| 1005 | } |
| 1006 | } |
| 1007 | if( i>=pParse->nAgg ){ |
| 1008 | i = appendAggInfo(pParse); |
| 1009 | if( i<0 ) return 1; |
| 1010 | pParse->aAgg[i].isAgg = 1; |
| 1011 | pParse->aAgg[i].pExpr = pExpr; |
| 1012 | } |
| 1013 | pExpr->iAgg = i; |
| 1014 | break; |
| 1015 | } |
| 1016 | default: { |
| 1017 | if( pExpr->pLeft ){ |
| 1018 | nErr = sqliteExprAnalyzeAggregates(pParse, pExpr->pLeft); |
| 1019 | } |
| 1020 | if( nErr==0 && pExpr->pRight ){ |
| 1021 | nErr = sqliteExprAnalyzeAggregates(pParse, pExpr->pRight); |
| 1022 | } |
| 1023 | if( nErr==0 && pExpr->pList ){ |
| 1024 | int n = pExpr->pList->nExpr; |
| 1025 | int i; |
| 1026 | for(i=0; nErr==0 && i<n; i++){ |
| 1027 | nErr = sqliteExprAnalyzeAggregates(pParse, pExpr->pList->a[i].pExpr); |
| 1028 | } |
| 1029 | } |
| 1030 | break; |
| 1031 | } |
| 1032 | } |
| 1033 | return nErr; |
| 1034 | } |