1 | /* |
2 | ** 2001 September 15 |
3 | ** |
4 | ** The author disclaims copyright to this source code. In place of |
5 | ** a legal notice, here is a blessing: |
6 | ** |
7 | ** May you do good and not evil. |
8 | ** May you find forgiveness for yourself and forgive others. |
9 | ** May you share freely, never taking more than you give. |
10 | ** |
11 | ************************************************************************* |
12 | ** This file contains routines used for analyzing expressions and |
13 | ** for generating VDBE code that evaluates expressions in SQLite. |
14 | */ |
15 | #include "sqliteInt.h" |
16 | |
17 | /* Forward declarations */ |
18 | static void exprCodeBetween(Parse*,Expr*,int,void(*)(Parse*,Expr*,int,int),int); |
19 | static int exprCodeVector(Parse *pParse, Expr *p, int *piToFree); |
20 | |
21 | /* |
22 | ** Return the affinity character for a single column of a table. |
23 | */ |
24 | char sqlite3TableColumnAffinity(const Table *pTab, int iCol){ |
25 | if( iCol<0 || NEVER(iCol>=pTab->nCol) ) return SQLITE_AFF_INTEGER; |
26 | return pTab->aCol[iCol].affinity; |
27 | } |
28 | |
29 | /* |
30 | ** Return the 'affinity' of the expression pExpr if any. |
31 | ** |
32 | ** If pExpr is a column, a reference to a column via an 'AS' alias, |
33 | ** or a sub-select with a column as the return value, then the |
34 | ** affinity of that column is returned. Otherwise, 0x00 is returned, |
35 | ** indicating no affinity for the expression. |
36 | ** |
37 | ** i.e. the WHERE clause expressions in the following statements all |
38 | ** have an affinity: |
39 | ** |
40 | ** CREATE TABLE t1(a); |
41 | ** SELECT * FROM t1 WHERE a; |
42 | ** SELECT a AS b FROM t1 WHERE b; |
43 | ** SELECT * FROM t1 WHERE (select a from t1); |
44 | */ |
45 | char sqlite3ExprAffinity(const Expr *pExpr){ |
46 | int op; |
47 | while( ExprHasProperty(pExpr, EP_Skip|EP_IfNullRow) ){ |
48 | assert( pExpr->op==TK_COLLATE |
49 | || pExpr->op==TK_IF_NULL_ROW |
50 | || (pExpr->op==TK_REGISTER && pExpr->op2==TK_IF_NULL_ROW) ); |
51 | pExpr = pExpr->pLeft; |
52 | assert( pExpr!=0 ); |
53 | } |
54 | op = pExpr->op; |
55 | if( op==TK_REGISTER ) op = pExpr->op2; |
56 | if( op==TK_COLUMN || op==TK_AGG_COLUMN ){ |
57 | assert( ExprUseYTab(pExpr) ); |
58 | assert( pExpr->y.pTab!=0 ); |
59 | return sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn); |
60 | } |
61 | if( op==TK_SELECT ){ |
62 | assert( ExprUseXSelect(pExpr) ); |
63 | assert( pExpr->x.pSelect!=0 ); |
64 | assert( pExpr->x.pSelect->pEList!=0 ); |
65 | assert( pExpr->x.pSelect->pEList->a[0].pExpr!=0 ); |
66 | return sqlite3ExprAffinity(pExpr->x.pSelect->pEList->a[0].pExpr); |
67 | } |
68 | #ifndef SQLITE_OMIT_CAST |
69 | if( op==TK_CAST ){ |
70 | assert( !ExprHasProperty(pExpr, EP_IntValue) ); |
71 | return sqlite3AffinityType(pExpr->u.zToken, 0); |
72 | } |
73 | #endif |
74 | if( op==TK_SELECT_COLUMN ){ |
75 | assert( pExpr->pLeft!=0 && ExprUseXSelect(pExpr->pLeft) ); |
76 | assert( pExpr->iColumn < pExpr->iTable ); |
77 | assert( pExpr->iTable==pExpr->pLeft->x.pSelect->pEList->nExpr ); |
78 | return sqlite3ExprAffinity( |
79 | pExpr->pLeft->x.pSelect->pEList->a[pExpr->iColumn].pExpr |
80 | ); |
81 | } |
82 | if( op==TK_VECTOR ){ |
83 | assert( ExprUseXList(pExpr) ); |
84 | return sqlite3ExprAffinity(pExpr->x.pList->a[0].pExpr); |
85 | } |
86 | return pExpr->affExpr; |
87 | } |
88 | |
89 | /* |
90 | ** Set the collating sequence for expression pExpr to be the collating |
91 | ** sequence named by pToken. Return a pointer to a new Expr node that |
92 | ** implements the COLLATE operator. |
93 | ** |
94 | ** If a memory allocation error occurs, that fact is recorded in pParse->db |
95 | ** and the pExpr parameter is returned unchanged. |
96 | */ |
97 | Expr *sqlite3ExprAddCollateToken( |
98 | const Parse *pParse, /* Parsing context */ |
99 | Expr *pExpr, /* Add the "COLLATE" clause to this expression */ |
100 | const Token *pCollName, /* Name of collating sequence */ |
101 | int dequote /* True to dequote pCollName */ |
102 | ){ |
103 | if( pCollName->n>0 ){ |
104 | Expr *pNew = sqlite3ExprAlloc(pParse->db, TK_COLLATE, pCollName, dequote); |
105 | if( pNew ){ |
106 | pNew->pLeft = pExpr; |
107 | pNew->flags |= EP_Collate|EP_Skip; |
108 | pExpr = pNew; |
109 | } |
110 | } |
111 | return pExpr; |
112 | } |
113 | Expr *sqlite3ExprAddCollateString( |
114 | const Parse *pParse, /* Parsing context */ |
115 | Expr *pExpr, /* Add the "COLLATE" clause to this expression */ |
116 | const char *zC /* The collating sequence name */ |
117 | ){ |
118 | Token s; |
119 | assert( zC!=0 ); |
120 | sqlite3TokenInit(&s, (char*)zC); |
121 | return sqlite3ExprAddCollateToken(pParse, pExpr, &s, 0); |
122 | } |
123 | |
124 | /* |
125 | ** Skip over any TK_COLLATE operators. |
126 | */ |
127 | Expr *sqlite3ExprSkipCollate(Expr *pExpr){ |
128 | while( pExpr && ExprHasProperty(pExpr, EP_Skip) ){ |
129 | assert( pExpr->op==TK_COLLATE ); |
130 | pExpr = pExpr->pLeft; |
131 | } |
132 | return pExpr; |
133 | } |
134 | |
135 | /* |
136 | ** Skip over any TK_COLLATE operators and/or any unlikely() |
137 | ** or likelihood() or likely() functions at the root of an |
138 | ** expression. |
139 | */ |
140 | Expr *sqlite3ExprSkipCollateAndLikely(Expr *pExpr){ |
141 | while( pExpr && ExprHasProperty(pExpr, EP_Skip|EP_Unlikely) ){ |
142 | if( ExprHasProperty(pExpr, EP_Unlikely) ){ |
143 | assert( ExprUseXList(pExpr) ); |
144 | assert( pExpr->x.pList->nExpr>0 ); |
145 | assert( pExpr->op==TK_FUNCTION ); |
146 | pExpr = pExpr->x.pList->a[0].pExpr; |
147 | }else{ |
148 | assert( pExpr->op==TK_COLLATE ); |
149 | pExpr = pExpr->pLeft; |
150 | } |
151 | } |
152 | return pExpr; |
153 | } |
154 | |
155 | /* |
156 | ** Return the collation sequence for the expression pExpr. If |
157 | ** there is no defined collating sequence, return NULL. |
158 | ** |
159 | ** See also: sqlite3ExprNNCollSeq() |
160 | ** |
161 | ** The sqlite3ExprNNCollSeq() works the same exact that it returns the |
162 | ** default collation if pExpr has no defined collation. |
163 | ** |
164 | ** The collating sequence might be determined by a COLLATE operator |
165 | ** or by the presence of a column with a defined collating sequence. |
166 | ** COLLATE operators take first precedence. Left operands take |
167 | ** precedence over right operands. |
168 | */ |
169 | CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr){ |
170 | sqlite3 *db = pParse->db; |
171 | CollSeq *pColl = 0; |
172 | const Expr *p = pExpr; |
173 | while( p ){ |
174 | int op = p->op; |
175 | if( op==TK_REGISTER ) op = p->op2; |
176 | if( op==TK_AGG_COLUMN || op==TK_COLUMN || op==TK_TRIGGER ){ |
177 | int j; |
178 | assert( ExprUseYTab(p) ); |
179 | assert( p->y.pTab!=0 ); |
180 | if( (j = p->iColumn)>=0 ){ |
181 | const char *zColl = sqlite3ColumnColl(&p->y.pTab->aCol[j]); |
182 | pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0); |
183 | } |
184 | break; |
185 | } |
186 | if( op==TK_CAST || op==TK_UPLUS ){ |
187 | p = p->pLeft; |
188 | continue; |
189 | } |
190 | if( op==TK_VECTOR ){ |
191 | assert( ExprUseXList(p) ); |
192 | p = p->x.pList->a[0].pExpr; |
193 | continue; |
194 | } |
195 | if( op==TK_COLLATE ){ |
196 | assert( !ExprHasProperty(p, EP_IntValue) ); |
197 | pColl = sqlite3GetCollSeq(pParse, ENC(db), 0, p->u.zToken); |
198 | break; |
199 | } |
200 | if( p->flags & EP_Collate ){ |
201 | if( p->pLeft && (p->pLeft->flags & EP_Collate)!=0 ){ |
202 | p = p->pLeft; |
203 | }else{ |
204 | Expr *pNext = p->pRight; |
205 | /* The Expr.x union is never used at the same time as Expr.pRight */ |
206 | assert( ExprUseXList(p) ); |
207 | assert( p->x.pList==0 || p->pRight==0 ); |
208 | if( p->x.pList!=0 && !db->mallocFailed ){ |
209 | int i; |
210 | for(i=0; ALWAYS(i<p->x.pList->nExpr); i++){ |
211 | if( ExprHasProperty(p->x.pList->a[i].pExpr, EP_Collate) ){ |
212 | pNext = p->x.pList->a[i].pExpr; |
213 | break; |
214 | } |
215 | } |
216 | } |
217 | p = pNext; |
218 | } |
219 | }else{ |
220 | break; |
221 | } |
222 | } |
223 | if( sqlite3CheckCollSeq(pParse, pColl) ){ |
224 | pColl = 0; |
225 | } |
226 | return pColl; |
227 | } |
228 | |
229 | /* |
230 | ** Return the collation sequence for the expression pExpr. If |
231 | ** there is no defined collating sequence, return a pointer to the |
232 | ** defautl collation sequence. |
233 | ** |
234 | ** See also: sqlite3ExprCollSeq() |
235 | ** |
236 | ** The sqlite3ExprCollSeq() routine works the same except that it |
237 | ** returns NULL if there is no defined collation. |
238 | */ |
239 | CollSeq *sqlite3ExprNNCollSeq(Parse *pParse, const Expr *pExpr){ |
240 | CollSeq *p = sqlite3ExprCollSeq(pParse, pExpr); |
241 | if( p==0 ) p = pParse->db->pDfltColl; |
242 | assert( p!=0 ); |
243 | return p; |
244 | } |
245 | |
246 | /* |
247 | ** Return TRUE if the two expressions have equivalent collating sequences. |
248 | */ |
249 | int sqlite3ExprCollSeqMatch(Parse *pParse, const Expr *pE1, const Expr *pE2){ |
250 | CollSeq *pColl1 = sqlite3ExprNNCollSeq(pParse, pE1); |
251 | CollSeq *pColl2 = sqlite3ExprNNCollSeq(pParse, pE2); |
252 | return sqlite3StrICmp(pColl1->zName, pColl2->zName)==0; |
253 | } |
254 | |
255 | /* |
256 | ** pExpr is an operand of a comparison operator. aff2 is the |
257 | ** type affinity of the other operand. This routine returns the |
258 | ** type affinity that should be used for the comparison operator. |
259 | */ |
260 | char sqlite3CompareAffinity(const Expr *pExpr, char aff2){ |
261 | char aff1 = sqlite3ExprAffinity(pExpr); |
262 | if( aff1>SQLITE_AFF_NONE && aff2>SQLITE_AFF_NONE ){ |
263 | /* Both sides of the comparison are columns. If one has numeric |
264 | ** affinity, use that. Otherwise use no affinity. |
265 | */ |
266 | if( sqlite3IsNumericAffinity(aff1) || sqlite3IsNumericAffinity(aff2) ){ |
267 | return SQLITE_AFF_NUMERIC; |
268 | }else{ |
269 | return SQLITE_AFF_BLOB; |
270 | } |
271 | }else{ |
272 | /* One side is a column, the other is not. Use the columns affinity. */ |
273 | assert( aff1<=SQLITE_AFF_NONE || aff2<=SQLITE_AFF_NONE ); |
274 | return (aff1<=SQLITE_AFF_NONE ? aff2 : aff1) | SQLITE_AFF_NONE; |
275 | } |
276 | } |
277 | |
278 | /* |
279 | ** pExpr is a comparison operator. Return the type affinity that should |
280 | ** be applied to both operands prior to doing the comparison. |
281 | */ |
282 | static char comparisonAffinity(const Expr *pExpr){ |
283 | char aff; |
284 | assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT || |
285 | pExpr->op==TK_GT || pExpr->op==TK_GE || pExpr->op==TK_LE || |
286 | pExpr->op==TK_NE || pExpr->op==TK_IS || pExpr->op==TK_ISNOT ); |
287 | assert( pExpr->pLeft ); |
288 | aff = sqlite3ExprAffinity(pExpr->pLeft); |
289 | if( pExpr->pRight ){ |
290 | aff = sqlite3CompareAffinity(pExpr->pRight, aff); |
291 | }else if( ExprUseXSelect(pExpr) ){ |
292 | aff = sqlite3CompareAffinity(pExpr->x.pSelect->pEList->a[0].pExpr, aff); |
293 | }else if( aff==0 ){ |
294 | aff = SQLITE_AFF_BLOB; |
295 | } |
296 | return aff; |
297 | } |
298 | |
299 | /* |
300 | ** pExpr is a comparison expression, eg. '=', '<', IN(...) etc. |
301 | ** idx_affinity is the affinity of an indexed column. Return true |
302 | ** if the index with affinity idx_affinity may be used to implement |
303 | ** the comparison in pExpr. |
304 | */ |
305 | int sqlite3IndexAffinityOk(const Expr *pExpr, char idx_affinity){ |
306 | char aff = comparisonAffinity(pExpr); |
307 | if( aff<SQLITE_AFF_TEXT ){ |
308 | return 1; |
309 | } |
310 | if( aff==SQLITE_AFF_TEXT ){ |
311 | return idx_affinity==SQLITE_AFF_TEXT; |
312 | } |
313 | return sqlite3IsNumericAffinity(idx_affinity); |
314 | } |
315 | |
316 | /* |
317 | ** Return the P5 value that should be used for a binary comparison |
318 | ** opcode (OP_Eq, OP_Ge etc.) used to compare pExpr1 and pExpr2. |
319 | */ |
320 | static u8 binaryCompareP5( |
321 | const Expr *pExpr1, /* Left operand */ |
322 | const Expr *pExpr2, /* Right operand */ |
323 | int jumpIfNull /* Extra flags added to P5 */ |
324 | ){ |
325 | u8 aff = (char)sqlite3ExprAffinity(pExpr2); |
326 | aff = (u8)sqlite3CompareAffinity(pExpr1, aff) | (u8)jumpIfNull; |
327 | return aff; |
328 | } |
329 | |
330 | /* |
331 | ** Return a pointer to the collation sequence that should be used by |
332 | ** a binary comparison operator comparing pLeft and pRight. |
333 | ** |
334 | ** If the left hand expression has a collating sequence type, then it is |
335 | ** used. Otherwise the collation sequence for the right hand expression |
336 | ** is used, or the default (BINARY) if neither expression has a collating |
337 | ** type. |
338 | ** |
339 | ** Argument pRight (but not pLeft) may be a null pointer. In this case, |
340 | ** it is not considered. |
341 | */ |
342 | CollSeq *sqlite3BinaryCompareCollSeq( |
343 | Parse *pParse, |
344 | const Expr *pLeft, |
345 | const Expr *pRight |
346 | ){ |
347 | CollSeq *pColl; |
348 | assert( pLeft ); |
349 | if( pLeft->flags & EP_Collate ){ |
350 | pColl = sqlite3ExprCollSeq(pParse, pLeft); |
351 | }else if( pRight && (pRight->flags & EP_Collate)!=0 ){ |
352 | pColl = sqlite3ExprCollSeq(pParse, pRight); |
353 | }else{ |
354 | pColl = sqlite3ExprCollSeq(pParse, pLeft); |
355 | if( !pColl ){ |
356 | pColl = sqlite3ExprCollSeq(pParse, pRight); |
357 | } |
358 | } |
359 | return pColl; |
360 | } |
361 | |
362 | /* Expresssion p is a comparison operator. Return a collation sequence |
363 | ** appropriate for the comparison operator. |
364 | ** |
365 | ** This is normally just a wrapper around sqlite3BinaryCompareCollSeq(). |
366 | ** However, if the OP_Commuted flag is set, then the order of the operands |
367 | ** is reversed in the sqlite3BinaryCompareCollSeq() call so that the |
368 | ** correct collating sequence is found. |
369 | */ |
370 | CollSeq *sqlite3ExprCompareCollSeq(Parse *pParse, const Expr *p){ |
371 | if( ExprHasProperty(p, EP_Commuted) ){ |
372 | return sqlite3BinaryCompareCollSeq(pParse, p->pRight, p->pLeft); |
373 | }else{ |
374 | return sqlite3BinaryCompareCollSeq(pParse, p->pLeft, p->pRight); |
375 | } |
376 | } |
377 | |
378 | /* |
379 | ** Generate code for a comparison operator. |
380 | */ |
381 | static int codeCompare( |
382 | Parse *pParse, /* The parsing (and code generating) context */ |
383 | Expr *pLeft, /* The left operand */ |
384 | Expr *pRight, /* The right operand */ |
385 | int opcode, /* The comparison opcode */ |
386 | int in1, int in2, /* Register holding operands */ |
387 | int dest, /* Jump here if true. */ |
388 | int jumpIfNull, /* If true, jump if either operand is NULL */ |
389 | int isCommuted /* The comparison has been commuted */ |
390 | ){ |
391 | int p5; |
392 | int addr; |
393 | CollSeq *p4; |
394 | |
395 | if( pParse->nErr ) return 0; |
396 | if( isCommuted ){ |
397 | p4 = sqlite3BinaryCompareCollSeq(pParse, pRight, pLeft); |
398 | }else{ |
399 | p4 = sqlite3BinaryCompareCollSeq(pParse, pLeft, pRight); |
400 | } |
401 | p5 = binaryCompareP5(pLeft, pRight, jumpIfNull); |
402 | addr = sqlite3VdbeAddOp4(pParse->pVdbe, opcode, in2, dest, in1, |
403 | (void*)p4, P4_COLLSEQ); |
404 | sqlite3VdbeChangeP5(pParse->pVdbe, (u8)p5); |
405 | return addr; |
406 | } |
407 | |
408 | /* |
409 | ** Return true if expression pExpr is a vector, or false otherwise. |
410 | ** |
411 | ** A vector is defined as any expression that results in two or more |
412 | ** columns of result. Every TK_VECTOR node is an vector because the |
413 | ** parser will not generate a TK_VECTOR with fewer than two entries. |
414 | ** But a TK_SELECT might be either a vector or a scalar. It is only |
415 | ** considered a vector if it has two or more result columns. |
416 | */ |
417 | int sqlite3ExprIsVector(const Expr *pExpr){ |
418 | return sqlite3ExprVectorSize(pExpr)>1; |
419 | } |
420 | |
421 | /* |
422 | ** If the expression passed as the only argument is of type TK_VECTOR |
423 | ** return the number of expressions in the vector. Or, if the expression |
424 | ** is a sub-select, return the number of columns in the sub-select. For |
425 | ** any other type of expression, return 1. |
426 | */ |
427 | int sqlite3ExprVectorSize(const Expr *pExpr){ |
428 | u8 op = pExpr->op; |
429 | if( op==TK_REGISTER ) op = pExpr->op2; |
430 | if( op==TK_VECTOR ){ |
431 | assert( ExprUseXList(pExpr) ); |
432 | return pExpr->x.pList->nExpr; |
433 | }else if( op==TK_SELECT ){ |
434 | assert( ExprUseXSelect(pExpr) ); |
435 | return pExpr->x.pSelect->pEList->nExpr; |
436 | }else{ |
437 | return 1; |
438 | } |
439 | } |
440 | |
441 | /* |
442 | ** Return a pointer to a subexpression of pVector that is the i-th |
443 | ** column of the vector (numbered starting with 0). The caller must |
444 | ** ensure that i is within range. |
445 | ** |
446 | ** If pVector is really a scalar (and "scalar" here includes subqueries |
447 | ** that return a single column!) then return pVector unmodified. |
448 | ** |
449 | ** pVector retains ownership of the returned subexpression. |
450 | ** |
451 | ** If the vector is a (SELECT ...) then the expression returned is |
452 | ** just the expression for the i-th term of the result set, and may |
453 | ** not be ready for evaluation because the table cursor has not yet |
454 | ** been positioned. |
455 | */ |
456 | Expr *sqlite3VectorFieldSubexpr(Expr *pVector, int i){ |
457 | assert( i<sqlite3ExprVectorSize(pVector) || pVector->op==TK_ERROR ); |
458 | if( sqlite3ExprIsVector(pVector) ){ |
459 | assert( pVector->op2==0 || pVector->op==TK_REGISTER ); |
460 | if( pVector->op==TK_SELECT || pVector->op2==TK_SELECT ){ |
461 | assert( ExprUseXSelect(pVector) ); |
462 | return pVector->x.pSelect->pEList->a[i].pExpr; |
463 | }else{ |
464 | assert( ExprUseXList(pVector) ); |
465 | return pVector->x.pList->a[i].pExpr; |
466 | } |
467 | } |
468 | return pVector; |
469 | } |
470 | |
471 | /* |
472 | ** Compute and return a new Expr object which when passed to |
473 | ** sqlite3ExprCode() will generate all necessary code to compute |
474 | ** the iField-th column of the vector expression pVector. |
475 | ** |
476 | ** It is ok for pVector to be a scalar (as long as iField==0). |
477 | ** In that case, this routine works like sqlite3ExprDup(). |
478 | ** |
479 | ** The caller owns the returned Expr object and is responsible for |
480 | ** ensuring that the returned value eventually gets freed. |
481 | ** |
482 | ** The caller retains ownership of pVector. If pVector is a TK_SELECT, |
483 | ** then the returned object will reference pVector and so pVector must remain |
484 | ** valid for the life of the returned object. If pVector is a TK_VECTOR |
485 | ** or a scalar expression, then it can be deleted as soon as this routine |
486 | ** returns. |
487 | ** |
488 | ** A trick to cause a TK_SELECT pVector to be deleted together with |
489 | ** the returned Expr object is to attach the pVector to the pRight field |
490 | ** of the returned TK_SELECT_COLUMN Expr object. |
491 | */ |
492 | Expr *sqlite3ExprForVectorField( |
493 | Parse *pParse, /* Parsing context */ |
494 | Expr *pVector, /* The vector. List of expressions or a sub-SELECT */ |
495 | int iField, /* Which column of the vector to return */ |
496 | int nField /* Total number of columns in the vector */ |
497 | ){ |
498 | Expr *pRet; |
499 | if( pVector->op==TK_SELECT ){ |
500 | assert( ExprUseXSelect(pVector) ); |
501 | /* The TK_SELECT_COLUMN Expr node: |
502 | ** |
503 | ** pLeft: pVector containing TK_SELECT. Not deleted. |
504 | ** pRight: not used. But recursively deleted. |
505 | ** iColumn: Index of a column in pVector |
506 | ** iTable: 0 or the number of columns on the LHS of an assignment |
507 | ** pLeft->iTable: First in an array of register holding result, or 0 |
508 | ** if the result is not yet computed. |
509 | ** |
510 | ** sqlite3ExprDelete() specifically skips the recursive delete of |
511 | ** pLeft on TK_SELECT_COLUMN nodes. But pRight is followed, so pVector |
512 | ** can be attached to pRight to cause this node to take ownership of |
513 | ** pVector. Typically there will be multiple TK_SELECT_COLUMN nodes |
514 | ** with the same pLeft pointer to the pVector, but only one of them |
515 | ** will own the pVector. |
516 | */ |
517 | pRet = sqlite3PExpr(pParse, TK_SELECT_COLUMN, 0, 0); |
518 | if( pRet ){ |
519 | pRet->iTable = nField; |
520 | pRet->iColumn = iField; |
521 | pRet->pLeft = pVector; |
522 | } |
523 | }else{ |
524 | if( pVector->op==TK_VECTOR ){ |
525 | Expr **ppVector; |
526 | assert( ExprUseXList(pVector) ); |
527 | ppVector = &pVector->x.pList->a[iField].pExpr; |
528 | pVector = *ppVector; |
529 | if( IN_RENAME_OBJECT ){ |
530 | /* This must be a vector UPDATE inside a trigger */ |
531 | *ppVector = 0; |
532 | return pVector; |
533 | } |
534 | } |
535 | pRet = sqlite3ExprDup(pParse->db, pVector, 0); |
536 | } |
537 | return pRet; |
538 | } |
539 | |
540 | /* |
541 | ** If expression pExpr is of type TK_SELECT, generate code to evaluate |
542 | ** it. Return the register in which the result is stored (or, if the |
543 | ** sub-select returns more than one column, the first in an array |
544 | ** of registers in which the result is stored). |
545 | ** |
546 | ** If pExpr is not a TK_SELECT expression, return 0. |
547 | */ |
548 | static int exprCodeSubselect(Parse *pParse, Expr *pExpr){ |
549 | int reg = 0; |
550 | #ifndef SQLITE_OMIT_SUBQUERY |
551 | if( pExpr->op==TK_SELECT ){ |
552 | reg = sqlite3CodeSubselect(pParse, pExpr); |
553 | } |
554 | #endif |
555 | return reg; |
556 | } |
557 | |
558 | /* |
559 | ** Argument pVector points to a vector expression - either a TK_VECTOR |
560 | ** or TK_SELECT that returns more than one column. This function returns |
561 | ** the register number of a register that contains the value of |
562 | ** element iField of the vector. |
563 | ** |
564 | ** If pVector is a TK_SELECT expression, then code for it must have |
565 | ** already been generated using the exprCodeSubselect() routine. In this |
566 | ** case parameter regSelect should be the first in an array of registers |
567 | ** containing the results of the sub-select. |
568 | ** |
569 | ** If pVector is of type TK_VECTOR, then code for the requested field |
570 | ** is generated. In this case (*pRegFree) may be set to the number of |
571 | ** a temporary register to be freed by the caller before returning. |
572 | ** |
573 | ** Before returning, output parameter (*ppExpr) is set to point to the |
574 | ** Expr object corresponding to element iElem of the vector. |
575 | */ |
576 | static int exprVectorRegister( |
577 | Parse *pParse, /* Parse context */ |
578 | Expr *pVector, /* Vector to extract element from */ |
579 | int iField, /* Field to extract from pVector */ |
580 | int regSelect, /* First in array of registers */ |
581 | Expr **ppExpr, /* OUT: Expression element */ |
582 | int *pRegFree /* OUT: Temp register to free */ |
583 | ){ |
584 | u8 op = pVector->op; |
585 | assert( op==TK_VECTOR || op==TK_REGISTER || op==TK_SELECT || op==TK_ERROR ); |
586 | if( op==TK_REGISTER ){ |
587 | *ppExpr = sqlite3VectorFieldSubexpr(pVector, iField); |
588 | return pVector->iTable+iField; |
589 | } |
590 | if( op==TK_SELECT ){ |
591 | assert( ExprUseXSelect(pVector) ); |
592 | *ppExpr = pVector->x.pSelect->pEList->a[iField].pExpr; |
593 | return regSelect+iField; |
594 | } |
595 | if( op==TK_VECTOR ){ |
596 | assert( ExprUseXList(pVector) ); |
597 | *ppExpr = pVector->x.pList->a[iField].pExpr; |
598 | return sqlite3ExprCodeTemp(pParse, *ppExpr, pRegFree); |
599 | } |
600 | return 0; |
601 | } |
602 | |
603 | /* |
604 | ** Expression pExpr is a comparison between two vector values. Compute |
605 | ** the result of the comparison (1, 0, or NULL) and write that |
606 | ** result into register dest. |
607 | ** |
608 | ** The caller must satisfy the following preconditions: |
609 | ** |
610 | ** if pExpr->op==TK_IS: op==TK_EQ and p5==SQLITE_NULLEQ |
611 | ** if pExpr->op==TK_ISNOT: op==TK_NE and p5==SQLITE_NULLEQ |
612 | ** otherwise: op==pExpr->op and p5==0 |
613 | */ |
614 | static void codeVectorCompare( |
615 | Parse *pParse, /* Code generator context */ |
616 | Expr *pExpr, /* The comparison operation */ |
617 | int dest, /* Write results into this register */ |
618 | u8 op, /* Comparison operator */ |
619 | u8 p5 /* SQLITE_NULLEQ or zero */ |
620 | ){ |
621 | Vdbe *v = pParse->pVdbe; |
622 | Expr *pLeft = pExpr->pLeft; |
623 | Expr *pRight = pExpr->pRight; |
624 | int nLeft = sqlite3ExprVectorSize(pLeft); |
625 | int i; |
626 | int regLeft = 0; |
627 | int regRight = 0; |
628 | u8 opx = op; |
629 | int addrCmp = 0; |
630 | int addrDone = sqlite3VdbeMakeLabel(pParse); |
631 | int isCommuted = ExprHasProperty(pExpr,EP_Commuted); |
632 | |
633 | assert( !ExprHasVVAProperty(pExpr,EP_Immutable) ); |
634 | if( pParse->nErr ) return; |
635 | if( nLeft!=sqlite3ExprVectorSize(pRight) ){ |
636 | sqlite3ErrorMsg(pParse, "row value misused" ); |
637 | return; |
638 | } |
639 | assert( pExpr->op==TK_EQ || pExpr->op==TK_NE |
640 | || pExpr->op==TK_IS || pExpr->op==TK_ISNOT |
641 | || pExpr->op==TK_LT || pExpr->op==TK_GT |
642 | || pExpr->op==TK_LE || pExpr->op==TK_GE |
643 | ); |
644 | assert( pExpr->op==op || (pExpr->op==TK_IS && op==TK_EQ) |
645 | || (pExpr->op==TK_ISNOT && op==TK_NE) ); |
646 | assert( p5==0 || pExpr->op!=op ); |
647 | assert( p5==SQLITE_NULLEQ || pExpr->op==op ); |
648 | |
649 | if( op==TK_LE ) opx = TK_LT; |
650 | if( op==TK_GE ) opx = TK_GT; |
651 | if( op==TK_NE ) opx = TK_EQ; |
652 | |
653 | regLeft = exprCodeSubselect(pParse, pLeft); |
654 | regRight = exprCodeSubselect(pParse, pRight); |
655 | |
656 | sqlite3VdbeAddOp2(v, OP_Integer, 1, dest); |
657 | for(i=0; 1 /*Loop exits by "break"*/; i++){ |
658 | int regFree1 = 0, regFree2 = 0; |
659 | Expr *pL = 0, *pR = 0; |
660 | int r1, r2; |
661 | assert( i>=0 && i<nLeft ); |
662 | if( addrCmp ) sqlite3VdbeJumpHere(v, addrCmp); |
663 | r1 = exprVectorRegister(pParse, pLeft, i, regLeft, &pL, ®Free1); |
664 | r2 = exprVectorRegister(pParse, pRight, i, regRight, &pR, ®Free2); |
665 | addrCmp = sqlite3VdbeCurrentAddr(v); |
666 | codeCompare(pParse, pL, pR, opx, r1, r2, addrDone, p5, isCommuted); |
667 | testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt); |
668 | testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le); |
669 | testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt); |
670 | testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge); |
671 | testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq); |
672 | testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne); |
673 | sqlite3ReleaseTempReg(pParse, regFree1); |
674 | sqlite3ReleaseTempReg(pParse, regFree2); |
675 | if( (opx==TK_LT || opx==TK_GT) && i<nLeft-1 ){ |
676 | addrCmp = sqlite3VdbeAddOp0(v, OP_ElseEq); |
677 | testcase(opx==TK_LT); VdbeCoverageIf(v,opx==TK_LT); |
678 | testcase(opx==TK_GT); VdbeCoverageIf(v,opx==TK_GT); |
679 | } |
680 | if( p5==SQLITE_NULLEQ ){ |
681 | sqlite3VdbeAddOp2(v, OP_Integer, 0, dest); |
682 | }else{ |
683 | sqlite3VdbeAddOp3(v, OP_ZeroOrNull, r1, dest, r2); |
684 | } |
685 | if( i==nLeft-1 ){ |
686 | break; |
687 | } |
688 | if( opx==TK_EQ ){ |
689 | sqlite3VdbeAddOp2(v, OP_NotNull, dest, addrDone); VdbeCoverage(v); |
690 | }else{ |
691 | assert( op==TK_LT || op==TK_GT || op==TK_LE || op==TK_GE ); |
692 | sqlite3VdbeAddOp2(v, OP_Goto, 0, addrDone); |
693 | if( i==nLeft-2 ) opx = op; |
694 | } |
695 | } |
696 | sqlite3VdbeJumpHere(v, addrCmp); |
697 | sqlite3VdbeResolveLabel(v, addrDone); |
698 | if( op==TK_NE ){ |
699 | sqlite3VdbeAddOp2(v, OP_Not, dest, dest); |
700 | } |
701 | } |
702 | |
703 | #if SQLITE_MAX_EXPR_DEPTH>0 |
704 | /* |
705 | ** Check that argument nHeight is less than or equal to the maximum |
706 | ** expression depth allowed. If it is not, leave an error message in |
707 | ** pParse. |
708 | */ |
709 | int sqlite3ExprCheckHeight(Parse *pParse, int nHeight){ |
710 | int rc = SQLITE_OK; |
711 | int mxHeight = pParse->db->aLimit[SQLITE_LIMIT_EXPR_DEPTH]; |
712 | if( nHeight>mxHeight ){ |
713 | sqlite3ErrorMsg(pParse, |
714 | "Expression tree is too large (maximum depth %d)" , mxHeight |
715 | ); |
716 | rc = SQLITE_ERROR; |
717 | } |
718 | return rc; |
719 | } |
720 | |
721 | /* The following three functions, heightOfExpr(), heightOfExprList() |
722 | ** and heightOfSelect(), are used to determine the maximum height |
723 | ** of any expression tree referenced by the structure passed as the |
724 | ** first argument. |
725 | ** |
726 | ** If this maximum height is greater than the current value pointed |
727 | ** to by pnHeight, the second parameter, then set *pnHeight to that |
728 | ** value. |
729 | */ |
730 | static void heightOfExpr(const Expr *p, int *pnHeight){ |
731 | if( p ){ |
732 | if( p->nHeight>*pnHeight ){ |
733 | *pnHeight = p->nHeight; |
734 | } |
735 | } |
736 | } |
737 | static void heightOfExprList(const ExprList *p, int *pnHeight){ |
738 | if( p ){ |
739 | int i; |
740 | for(i=0; i<p->nExpr; i++){ |
741 | heightOfExpr(p->a[i].pExpr, pnHeight); |
742 | } |
743 | } |
744 | } |
745 | static void heightOfSelect(const Select *pSelect, int *pnHeight){ |
746 | const Select *p; |
747 | for(p=pSelect; p; p=p->pPrior){ |
748 | heightOfExpr(p->pWhere, pnHeight); |
749 | heightOfExpr(p->pHaving, pnHeight); |
750 | heightOfExpr(p->pLimit, pnHeight); |
751 | heightOfExprList(p->pEList, pnHeight); |
752 | heightOfExprList(p->pGroupBy, pnHeight); |
753 | heightOfExprList(p->pOrderBy, pnHeight); |
754 | } |
755 | } |
756 | |
757 | /* |
758 | ** Set the Expr.nHeight variable in the structure passed as an |
759 | ** argument. An expression with no children, Expr.pList or |
760 | ** Expr.pSelect member has a height of 1. Any other expression |
761 | ** has a height equal to the maximum height of any other |
762 | ** referenced Expr plus one. |
763 | ** |
764 | ** Also propagate EP_Propagate flags up from Expr.x.pList to Expr.flags, |
765 | ** if appropriate. |
766 | */ |
767 | static void exprSetHeight(Expr *p){ |
768 | int nHeight = p->pLeft ? p->pLeft->nHeight : 0; |
769 | if( NEVER(p->pRight) && p->pRight->nHeight>nHeight ){ |
770 | nHeight = p->pRight->nHeight; |
771 | } |
772 | if( ExprUseXSelect(p) ){ |
773 | heightOfSelect(p->x.pSelect, &nHeight); |
774 | }else if( p->x.pList ){ |
775 | heightOfExprList(p->x.pList, &nHeight); |
776 | p->flags |= EP_Propagate & sqlite3ExprListFlags(p->x.pList); |
777 | } |
778 | p->nHeight = nHeight + 1; |
779 | } |
780 | |
781 | /* |
782 | ** Set the Expr.nHeight variable using the exprSetHeight() function. If |
783 | ** the height is greater than the maximum allowed expression depth, |
784 | ** leave an error in pParse. |
785 | ** |
786 | ** Also propagate all EP_Propagate flags from the Expr.x.pList into |
787 | ** Expr.flags. |
788 | */ |
789 | void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p){ |
790 | if( pParse->nErr ) return; |
791 | exprSetHeight(p); |
792 | sqlite3ExprCheckHeight(pParse, p->nHeight); |
793 | } |
794 | |
795 | /* |
796 | ** Return the maximum height of any expression tree referenced |
797 | ** by the select statement passed as an argument. |
798 | */ |
799 | int sqlite3SelectExprHeight(const Select *p){ |
800 | int nHeight = 0; |
801 | heightOfSelect(p, &nHeight); |
802 | return nHeight; |
803 | } |
804 | #else /* ABOVE: Height enforcement enabled. BELOW: Height enforcement off */ |
805 | /* |
806 | ** Propagate all EP_Propagate flags from the Expr.x.pList into |
807 | ** Expr.flags. |
808 | */ |
809 | void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p){ |
810 | if( pParse->nErr ) return; |
811 | if( p && ExprUseXList(p) && p->x.pList ){ |
812 | p->flags |= EP_Propagate & sqlite3ExprListFlags(p->x.pList); |
813 | } |
814 | } |
815 | #define exprSetHeight(y) |
816 | #endif /* SQLITE_MAX_EXPR_DEPTH>0 */ |
817 | |
818 | /* |
819 | ** This routine is the core allocator for Expr nodes. |
820 | ** |
821 | ** Construct a new expression node and return a pointer to it. Memory |
822 | ** for this node and for the pToken argument is a single allocation |
823 | ** obtained from sqlite3DbMalloc(). The calling function |
824 | ** is responsible for making sure the node eventually gets freed. |
825 | ** |
826 | ** If dequote is true, then the token (if it exists) is dequoted. |
827 | ** If dequote is false, no dequoting is performed. The deQuote |
828 | ** parameter is ignored if pToken is NULL or if the token does not |
829 | ** appear to be quoted. If the quotes were of the form "..." (double-quotes) |
830 | ** then the EP_DblQuoted flag is set on the expression node. |
831 | ** |
832 | ** Special case: If op==TK_INTEGER and pToken points to a string that |
833 | ** can be translated into a 32-bit integer, then the token is not |
834 | ** stored in u.zToken. Instead, the integer values is written |
835 | ** into u.iValue and the EP_IntValue flag is set. No extra storage |
836 | ** is allocated to hold the integer text and the dequote flag is ignored. |
837 | */ |
838 | Expr *sqlite3ExprAlloc( |
839 | sqlite3 *db, /* Handle for sqlite3DbMallocRawNN() */ |
840 | int op, /* Expression opcode */ |
841 | const Token *pToken, /* Token argument. Might be NULL */ |
842 | int dequote /* True to dequote */ |
843 | ){ |
844 | Expr *pNew; |
845 | int = 0; |
846 | int iValue = 0; |
847 | |
848 | assert( db!=0 ); |
849 | if( pToken ){ |
850 | if( op!=TK_INTEGER || pToken->z==0 |
851 | || sqlite3GetInt32(pToken->z, &iValue)==0 ){ |
852 | nExtra = pToken->n+1; |
853 | assert( iValue>=0 ); |
854 | } |
855 | } |
856 | pNew = sqlite3DbMallocRawNN(db, sizeof(Expr)+nExtra); |
857 | if( pNew ){ |
858 | memset(pNew, 0, sizeof(Expr)); |
859 | pNew->op = (u8)op; |
860 | pNew->iAgg = -1; |
861 | if( pToken ){ |
862 | if( nExtra==0 ){ |
863 | pNew->flags |= EP_IntValue|EP_Leaf|(iValue?EP_IsTrue:EP_IsFalse); |
864 | pNew->u.iValue = iValue; |
865 | }else{ |
866 | pNew->u.zToken = (char*)&pNew[1]; |
867 | assert( pToken->z!=0 || pToken->n==0 ); |
868 | if( pToken->n ) memcpy(pNew->u.zToken, pToken->z, pToken->n); |
869 | pNew->u.zToken[pToken->n] = 0; |
870 | if( dequote && sqlite3Isquote(pNew->u.zToken[0]) ){ |
871 | sqlite3DequoteExpr(pNew); |
872 | } |
873 | } |
874 | } |
875 | #if SQLITE_MAX_EXPR_DEPTH>0 |
876 | pNew->nHeight = 1; |
877 | #endif |
878 | } |
879 | return pNew; |
880 | } |
881 | |
882 | /* |
883 | ** Allocate a new expression node from a zero-terminated token that has |
884 | ** already been dequoted. |
885 | */ |
886 | Expr *sqlite3Expr( |
887 | sqlite3 *db, /* Handle for sqlite3DbMallocZero() (may be null) */ |
888 | int op, /* Expression opcode */ |
889 | const char *zToken /* Token argument. Might be NULL */ |
890 | ){ |
891 | Token x; |
892 | x.z = zToken; |
893 | x.n = sqlite3Strlen30(zToken); |
894 | return sqlite3ExprAlloc(db, op, &x, 0); |
895 | } |
896 | |
897 | /* |
898 | ** Attach subtrees pLeft and pRight to the Expr node pRoot. |
899 | ** |
900 | ** If pRoot==NULL that means that a memory allocation error has occurred. |
901 | ** In that case, delete the subtrees pLeft and pRight. |
902 | */ |
903 | void sqlite3ExprAttachSubtrees( |
904 | sqlite3 *db, |
905 | Expr *pRoot, |
906 | Expr *pLeft, |
907 | Expr *pRight |
908 | ){ |
909 | if( pRoot==0 ){ |
910 | assert( db->mallocFailed ); |
911 | sqlite3ExprDelete(db, pLeft); |
912 | sqlite3ExprDelete(db, pRight); |
913 | }else{ |
914 | assert( ExprUseXList(pRoot) ); |
915 | assert( pRoot->x.pSelect==0 ); |
916 | if( pRight ){ |
917 | pRoot->pRight = pRight; |
918 | pRoot->flags |= EP_Propagate & pRight->flags; |
919 | #if SQLITE_MAX_EXPR_DEPTH>0 |
920 | pRoot->nHeight = pRight->nHeight+1; |
921 | }else{ |
922 | pRoot->nHeight = 1; |
923 | #endif |
924 | } |
925 | if( pLeft ){ |
926 | pRoot->pLeft = pLeft; |
927 | pRoot->flags |= EP_Propagate & pLeft->flags; |
928 | #if SQLITE_MAX_EXPR_DEPTH>0 |
929 | if( pLeft->nHeight>=pRoot->nHeight ){ |
930 | pRoot->nHeight = pLeft->nHeight+1; |
931 | } |
932 | #endif |
933 | } |
934 | } |
935 | } |
936 | |
937 | /* |
938 | ** Allocate an Expr node which joins as many as two subtrees. |
939 | ** |
940 | ** One or both of the subtrees can be NULL. Return a pointer to the new |
941 | ** Expr node. Or, if an OOM error occurs, set pParse->db->mallocFailed, |
942 | ** free the subtrees and return NULL. |
943 | */ |
944 | Expr *sqlite3PExpr( |
945 | Parse *pParse, /* Parsing context */ |
946 | int op, /* Expression opcode */ |
947 | Expr *pLeft, /* Left operand */ |
948 | Expr *pRight /* Right operand */ |
949 | ){ |
950 | Expr *p; |
951 | p = sqlite3DbMallocRawNN(pParse->db, sizeof(Expr)); |
952 | if( p ){ |
953 | memset(p, 0, sizeof(Expr)); |
954 | p->op = op & 0xff; |
955 | p->iAgg = -1; |
956 | sqlite3ExprAttachSubtrees(pParse->db, p, pLeft, pRight); |
957 | sqlite3ExprCheckHeight(pParse, p->nHeight); |
958 | }else{ |
959 | sqlite3ExprDelete(pParse->db, pLeft); |
960 | sqlite3ExprDelete(pParse->db, pRight); |
961 | } |
962 | return p; |
963 | } |
964 | |
965 | /* |
966 | ** Add pSelect to the Expr.x.pSelect field. Or, if pExpr is NULL (due |
967 | ** do a memory allocation failure) then delete the pSelect object. |
968 | */ |
969 | void sqlite3PExprAddSelect(Parse *pParse, Expr *pExpr, Select *pSelect){ |
970 | if( pExpr ){ |
971 | pExpr->x.pSelect = pSelect; |
972 | ExprSetProperty(pExpr, EP_xIsSelect|EP_Subquery); |
973 | sqlite3ExprSetHeightAndFlags(pParse, pExpr); |
974 | }else{ |
975 | assert( pParse->db->mallocFailed ); |
976 | sqlite3SelectDelete(pParse->db, pSelect); |
977 | } |
978 | } |
979 | |
980 | /* |
981 | ** Expression list pEList is a list of vector values. This function |
982 | ** converts the contents of pEList to a VALUES(...) Select statement |
983 | ** returning 1 row for each element of the list. For example, the |
984 | ** expression list: |
985 | ** |
986 | ** ( (1,2), (3,4) (5,6) ) |
987 | ** |
988 | ** is translated to the equivalent of: |
989 | ** |
990 | ** VALUES(1,2), (3,4), (5,6) |
991 | ** |
992 | ** Each of the vector values in pEList must contain exactly nElem terms. |
993 | ** If a list element that is not a vector or does not contain nElem terms, |
994 | ** an error message is left in pParse. |
995 | ** |
996 | ** This is used as part of processing IN(...) expressions with a list |
997 | ** of vectors on the RHS. e.g. "... IN ((1,2), (3,4), (5,6))". |
998 | */ |
999 | Select *sqlite3ExprListToValues(Parse *pParse, int nElem, ExprList *pEList){ |
1000 | int ii; |
1001 | Select *pRet = 0; |
1002 | assert( nElem>1 ); |
1003 | for(ii=0; ii<pEList->nExpr; ii++){ |
1004 | Select *pSel; |
1005 | Expr *pExpr = pEList->a[ii].pExpr; |
1006 | int nExprElem; |
1007 | if( pExpr->op==TK_VECTOR ){ |
1008 | assert( ExprUseXList(pExpr) ); |
1009 | nExprElem = pExpr->x.pList->nExpr; |
1010 | }else{ |
1011 | nExprElem = 1; |
1012 | } |
1013 | if( nExprElem!=nElem ){ |
1014 | sqlite3ErrorMsg(pParse, "IN(...) element has %d term%s - expected %d" , |
1015 | nExprElem, nExprElem>1?"s" :"" , nElem |
1016 | ); |
1017 | break; |
1018 | } |
1019 | assert( ExprUseXList(pExpr) ); |
1020 | pSel = sqlite3SelectNew(pParse, pExpr->x.pList, 0, 0, 0, 0, 0, SF_Values,0); |
1021 | pExpr->x.pList = 0; |
1022 | if( pSel ){ |
1023 | if( pRet ){ |
1024 | pSel->op = TK_ALL; |
1025 | pSel->pPrior = pRet; |
1026 | } |
1027 | pRet = pSel; |
1028 | } |
1029 | } |
1030 | |
1031 | if( pRet && pRet->pPrior ){ |
1032 | pRet->selFlags |= SF_MultiValue; |
1033 | } |
1034 | sqlite3ExprListDelete(pParse->db, pEList); |
1035 | return pRet; |
1036 | } |
1037 | |
1038 | /* |
1039 | ** Join two expressions using an AND operator. If either expression is |
1040 | ** NULL, then just return the other expression. |
1041 | ** |
1042 | ** If one side or the other of the AND is known to be false, then instead |
1043 | ** of returning an AND expression, just return a constant expression with |
1044 | ** a value of false. |
1045 | */ |
1046 | Expr *sqlite3ExprAnd(Parse *pParse, Expr *pLeft, Expr *pRight){ |
1047 | sqlite3 *db = pParse->db; |
1048 | if( pLeft==0 ){ |
1049 | return pRight; |
1050 | }else if( pRight==0 ){ |
1051 | return pLeft; |
1052 | }else if( (ExprAlwaysFalse(pLeft) || ExprAlwaysFalse(pRight)) |
1053 | && !IN_RENAME_OBJECT |
1054 | ){ |
1055 | sqlite3ExprDeferredDelete(pParse, pLeft); |
1056 | sqlite3ExprDeferredDelete(pParse, pRight); |
1057 | return sqlite3Expr(db, TK_INTEGER, "0" ); |
1058 | }else{ |
1059 | return sqlite3PExpr(pParse, TK_AND, pLeft, pRight); |
1060 | } |
1061 | } |
1062 | |
1063 | /* |
1064 | ** Construct a new expression node for a function with multiple |
1065 | ** arguments. |
1066 | */ |
1067 | Expr *sqlite3ExprFunction( |
1068 | Parse *pParse, /* Parsing context */ |
1069 | ExprList *pList, /* Argument list */ |
1070 | const Token *pToken, /* Name of the function */ |
1071 | int eDistinct /* SF_Distinct or SF_ALL or 0 */ |
1072 | ){ |
1073 | Expr *pNew; |
1074 | sqlite3 *db = pParse->db; |
1075 | assert( pToken ); |
1076 | pNew = sqlite3ExprAlloc(db, TK_FUNCTION, pToken, 1); |
1077 | if( pNew==0 ){ |
1078 | sqlite3ExprListDelete(db, pList); /* Avoid memory leak when malloc fails */ |
1079 | return 0; |
1080 | } |
1081 | assert( !ExprHasProperty(pNew, EP_InnerON|EP_OuterON) ); |
1082 | pNew->w.iOfst = (int)(pToken->z - pParse->zTail); |
1083 | if( pList |
1084 | && pList->nExpr > pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG] |
1085 | && !pParse->nested |
1086 | ){ |
1087 | sqlite3ErrorMsg(pParse, "too many arguments on function %T" , pToken); |
1088 | } |
1089 | pNew->x.pList = pList; |
1090 | ExprSetProperty(pNew, EP_HasFunc); |
1091 | assert( ExprUseXList(pNew) ); |
1092 | sqlite3ExprSetHeightAndFlags(pParse, pNew); |
1093 | if( eDistinct==SF_Distinct ) ExprSetProperty(pNew, EP_Distinct); |
1094 | return pNew; |
1095 | } |
1096 | |
1097 | /* |
1098 | ** Check to see if a function is usable according to current access |
1099 | ** rules: |
1100 | ** |
1101 | ** SQLITE_FUNC_DIRECT - Only usable from top-level SQL |
1102 | ** |
1103 | ** SQLITE_FUNC_UNSAFE - Usable if TRUSTED_SCHEMA or from |
1104 | ** top-level SQL |
1105 | ** |
1106 | ** If the function is not usable, create an error. |
1107 | */ |
1108 | void sqlite3ExprFunctionUsable( |
1109 | Parse *pParse, /* Parsing and code generating context */ |
1110 | const Expr *pExpr, /* The function invocation */ |
1111 | const FuncDef *pDef /* The function being invoked */ |
1112 | ){ |
1113 | assert( !IN_RENAME_OBJECT ); |
1114 | assert( (pDef->funcFlags & (SQLITE_FUNC_DIRECT|SQLITE_FUNC_UNSAFE))!=0 ); |
1115 | if( ExprHasProperty(pExpr, EP_FromDDL) ){ |
1116 | if( (pDef->funcFlags & SQLITE_FUNC_DIRECT)!=0 |
1117 | || (pParse->db->flags & SQLITE_TrustedSchema)==0 |
1118 | ){ |
1119 | /* Functions prohibited in triggers and views if: |
1120 | ** (1) tagged with SQLITE_DIRECTONLY |
1121 | ** (2) not tagged with SQLITE_INNOCUOUS (which means it |
1122 | ** is tagged with SQLITE_FUNC_UNSAFE) and |
1123 | ** SQLITE_DBCONFIG_TRUSTED_SCHEMA is off (meaning |
1124 | ** that the schema is possibly tainted). |
1125 | */ |
1126 | sqlite3ErrorMsg(pParse, "unsafe use of %#T()" , pExpr); |
1127 | } |
1128 | } |
1129 | } |
1130 | |
1131 | /* |
1132 | ** Assign a variable number to an expression that encodes a wildcard |
1133 | ** in the original SQL statement. |
1134 | ** |
1135 | ** Wildcards consisting of a single "?" are assigned the next sequential |
1136 | ** variable number. |
1137 | ** |
1138 | ** Wildcards of the form "?nnn" are assigned the number "nnn". We make |
1139 | ** sure "nnn" is not too big to avoid a denial of service attack when |
1140 | ** the SQL statement comes from an external source. |
1141 | ** |
1142 | ** Wildcards of the form ":aaa", "@aaa", or "$aaa" are assigned the same number |
1143 | ** as the previous instance of the same wildcard. Or if this is the first |
1144 | ** instance of the wildcard, the next sequential variable number is |
1145 | ** assigned. |
1146 | */ |
1147 | void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr, u32 n){ |
1148 | sqlite3 *db = pParse->db; |
1149 | const char *z; |
1150 | ynVar x; |
1151 | |
1152 | if( pExpr==0 ) return; |
1153 | assert( !ExprHasProperty(pExpr, EP_IntValue|EP_Reduced|EP_TokenOnly) ); |
1154 | z = pExpr->u.zToken; |
1155 | assert( z!=0 ); |
1156 | assert( z[0]!=0 ); |
1157 | assert( n==(u32)sqlite3Strlen30(z) ); |
1158 | if( z[1]==0 ){ |
1159 | /* Wildcard of the form "?". Assign the next variable number */ |
1160 | assert( z[0]=='?' ); |
1161 | x = (ynVar)(++pParse->nVar); |
1162 | }else{ |
1163 | int doAdd = 0; |
1164 | if( z[0]=='?' ){ |
1165 | /* Wildcard of the form "?nnn". Convert "nnn" to an integer and |
1166 | ** use it as the variable number */ |
1167 | i64 i; |
1168 | int bOk; |
1169 | if( n==2 ){ /*OPTIMIZATION-IF-TRUE*/ |
1170 | i = z[1]-'0'; /* The common case of ?N for a single digit N */ |
1171 | bOk = 1; |
1172 | }else{ |
1173 | bOk = 0==sqlite3Atoi64(&z[1], &i, n-1, SQLITE_UTF8); |
1174 | } |
1175 | testcase( i==0 ); |
1176 | testcase( i==1 ); |
1177 | testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]-1 ); |
1178 | testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ); |
1179 | if( bOk==0 || i<1 || i>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){ |
1180 | sqlite3ErrorMsg(pParse, "variable number must be between ?1 and ?%d" , |
1181 | db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]); |
1182 | sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr); |
1183 | return; |
1184 | } |
1185 | x = (ynVar)i; |
1186 | if( x>pParse->nVar ){ |
1187 | pParse->nVar = (int)x; |
1188 | doAdd = 1; |
1189 | }else if( sqlite3VListNumToName(pParse->pVList, x)==0 ){ |
1190 | doAdd = 1; |
1191 | } |
1192 | }else{ |
1193 | /* Wildcards like ":aaa", "$aaa" or "@aaa". Reuse the same variable |
1194 | ** number as the prior appearance of the same name, or if the name |
1195 | ** has never appeared before, reuse the same variable number |
1196 | */ |
1197 | x = (ynVar)sqlite3VListNameToNum(pParse->pVList, z, n); |
1198 | if( x==0 ){ |
1199 | x = (ynVar)(++pParse->nVar); |
1200 | doAdd = 1; |
1201 | } |
1202 | } |
1203 | if( doAdd ){ |
1204 | pParse->pVList = sqlite3VListAdd(db, pParse->pVList, z, n, x); |
1205 | } |
1206 | } |
1207 | pExpr->iColumn = x; |
1208 | if( x>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){ |
1209 | sqlite3ErrorMsg(pParse, "too many SQL variables" ); |
1210 | sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr); |
1211 | } |
1212 | } |
1213 | |
1214 | /* |
1215 | ** Recursively delete an expression tree. |
1216 | */ |
1217 | static SQLITE_NOINLINE void sqlite3ExprDeleteNN(sqlite3 *db, Expr *p){ |
1218 | assert( p!=0 ); |
1219 | assert( db!=0 ); |
1220 | assert( !ExprUseUValue(p) || p->u.iValue>=0 ); |
1221 | assert( !ExprUseYWin(p) || !ExprUseYSub(p) ); |
1222 | assert( !ExprUseYWin(p) || p->y.pWin!=0 || db->mallocFailed ); |
1223 | assert( p->op!=TK_FUNCTION || !ExprUseYSub(p) ); |
1224 | #ifdef SQLITE_DEBUG |
1225 | if( ExprHasProperty(p, EP_Leaf) && !ExprHasProperty(p, EP_TokenOnly) ){ |
1226 | assert( p->pLeft==0 ); |
1227 | assert( p->pRight==0 ); |
1228 | assert( !ExprUseXSelect(p) || p->x.pSelect==0 ); |
1229 | assert( !ExprUseXList(p) || p->x.pList==0 ); |
1230 | } |
1231 | #endif |
1232 | if( !ExprHasProperty(p, (EP_TokenOnly|EP_Leaf)) ){ |
1233 | /* The Expr.x union is never used at the same time as Expr.pRight */ |
1234 | assert( (ExprUseXList(p) && p->x.pList==0) || p->pRight==0 ); |
1235 | if( p->pLeft && p->op!=TK_SELECT_COLUMN ) sqlite3ExprDeleteNN(db, p->pLeft); |
1236 | if( p->pRight ){ |
1237 | assert( !ExprHasProperty(p, EP_WinFunc) ); |
1238 | sqlite3ExprDeleteNN(db, p->pRight); |
1239 | }else if( ExprUseXSelect(p) ){ |
1240 | assert( !ExprHasProperty(p, EP_WinFunc) ); |
1241 | sqlite3SelectDelete(db, p->x.pSelect); |
1242 | }else{ |
1243 | sqlite3ExprListDelete(db, p->x.pList); |
1244 | #ifndef SQLITE_OMIT_WINDOWFUNC |
1245 | if( ExprHasProperty(p, EP_WinFunc) ){ |
1246 | sqlite3WindowDelete(db, p->y.pWin); |
1247 | } |
1248 | #endif |
1249 | } |
1250 | } |
1251 | if( !ExprHasProperty(p, EP_Static) ){ |
1252 | sqlite3DbNNFreeNN(db, p); |
1253 | } |
1254 | } |
1255 | void sqlite3ExprDelete(sqlite3 *db, Expr *p){ |
1256 | if( p ) sqlite3ExprDeleteNN(db, p); |
1257 | } |
1258 | |
1259 | /* |
1260 | ** Clear both elements of an OnOrUsing object |
1261 | */ |
1262 | void sqlite3ClearOnOrUsing(sqlite3 *db, OnOrUsing *p){ |
1263 | if( p==0 ){ |
1264 | /* Nothing to clear */ |
1265 | }else if( p->pOn ){ |
1266 | sqlite3ExprDeleteNN(db, p->pOn); |
1267 | }else if( p->pUsing ){ |
1268 | sqlite3IdListDelete(db, p->pUsing); |
1269 | } |
1270 | } |
1271 | |
1272 | /* |
1273 | ** Arrange to cause pExpr to be deleted when the pParse is deleted. |
1274 | ** This is similar to sqlite3ExprDelete() except that the delete is |
1275 | ** deferred untilthe pParse is deleted. |
1276 | ** |
1277 | ** The pExpr might be deleted immediately on an OOM error. |
1278 | ** |
1279 | ** The deferred delete is (currently) implemented by adding the |
1280 | ** pExpr to the pParse->pConstExpr list with a register number of 0. |
1281 | */ |
1282 | void sqlite3ExprDeferredDelete(Parse *pParse, Expr *pExpr){ |
1283 | sqlite3ParserAddCleanup(pParse, |
1284 | (void(*)(sqlite3*,void*))sqlite3ExprDelete, |
1285 | pExpr); |
1286 | } |
1287 | |
1288 | /* Invoke sqlite3RenameExprUnmap() and sqlite3ExprDelete() on the |
1289 | ** expression. |
1290 | */ |
1291 | void sqlite3ExprUnmapAndDelete(Parse *pParse, Expr *p){ |
1292 | if( p ){ |
1293 | if( IN_RENAME_OBJECT ){ |
1294 | sqlite3RenameExprUnmap(pParse, p); |
1295 | } |
1296 | sqlite3ExprDeleteNN(pParse->db, p); |
1297 | } |
1298 | } |
1299 | |
1300 | /* |
1301 | ** Return the number of bytes allocated for the expression structure |
1302 | ** passed as the first argument. This is always one of EXPR_FULLSIZE, |
1303 | ** EXPR_REDUCEDSIZE or EXPR_TOKENONLYSIZE. |
1304 | */ |
1305 | static int exprStructSize(const Expr *p){ |
1306 | if( ExprHasProperty(p, EP_TokenOnly) ) return EXPR_TOKENONLYSIZE; |
1307 | if( ExprHasProperty(p, EP_Reduced) ) return EXPR_REDUCEDSIZE; |
1308 | return EXPR_FULLSIZE; |
1309 | } |
1310 | |
1311 | /* |
1312 | ** The dupedExpr*Size() routines each return the number of bytes required |
1313 | ** to store a copy of an expression or expression tree. They differ in |
1314 | ** how much of the tree is measured. |
1315 | ** |
1316 | ** dupedExprStructSize() Size of only the Expr structure |
1317 | ** dupedExprNodeSize() Size of Expr + space for token |
1318 | ** dupedExprSize() Expr + token + subtree components |
1319 | ** |
1320 | *************************************************************************** |
1321 | ** |
1322 | ** The dupedExprStructSize() function returns two values OR-ed together: |
1323 | ** (1) the space required for a copy of the Expr structure only and |
1324 | ** (2) the EP_xxx flags that indicate what the structure size should be. |
1325 | ** The return values is always one of: |
1326 | ** |
1327 | ** EXPR_FULLSIZE |
1328 | ** EXPR_REDUCEDSIZE | EP_Reduced |
1329 | ** EXPR_TOKENONLYSIZE | EP_TokenOnly |
1330 | ** |
1331 | ** The size of the structure can be found by masking the return value |
1332 | ** of this routine with 0xfff. The flags can be found by masking the |
1333 | ** return value with EP_Reduced|EP_TokenOnly. |
1334 | ** |
1335 | ** Note that with flags==EXPRDUP_REDUCE, this routines works on full-size |
1336 | ** (unreduced) Expr objects as they or originally constructed by the parser. |
1337 | ** During expression analysis, extra information is computed and moved into |
1338 | ** later parts of the Expr object and that extra information might get chopped |
1339 | ** off if the expression is reduced. Note also that it does not work to |
1340 | ** make an EXPRDUP_REDUCE copy of a reduced expression. It is only legal |
1341 | ** to reduce a pristine expression tree from the parser. The implementation |
1342 | ** of dupedExprStructSize() contain multiple assert() statements that attempt |
1343 | ** to enforce this constraint. |
1344 | */ |
1345 | static int dupedExprStructSize(const Expr *p, int flags){ |
1346 | int nSize; |
1347 | assert( flags==EXPRDUP_REDUCE || flags==0 ); /* Only one flag value allowed */ |
1348 | assert( EXPR_FULLSIZE<=0xfff ); |
1349 | assert( (0xfff & (EP_Reduced|EP_TokenOnly))==0 ); |
1350 | if( 0==flags || p->op==TK_SELECT_COLUMN |
1351 | #ifndef SQLITE_OMIT_WINDOWFUNC |
1352 | || ExprHasProperty(p, EP_WinFunc) |
1353 | #endif |
1354 | ){ |
1355 | nSize = EXPR_FULLSIZE; |
1356 | }else{ |
1357 | assert( !ExprHasProperty(p, EP_TokenOnly|EP_Reduced) ); |
1358 | assert( !ExprHasProperty(p, EP_OuterON) ); |
1359 | assert( !ExprHasVVAProperty(p, EP_NoReduce) ); |
1360 | if( p->pLeft || p->x.pList ){ |
1361 | nSize = EXPR_REDUCEDSIZE | EP_Reduced; |
1362 | }else{ |
1363 | assert( p->pRight==0 ); |
1364 | nSize = EXPR_TOKENONLYSIZE | EP_TokenOnly; |
1365 | } |
1366 | } |
1367 | return nSize; |
1368 | } |
1369 | |
1370 | /* |
1371 | ** This function returns the space in bytes required to store the copy |
1372 | ** of the Expr structure and a copy of the Expr.u.zToken string (if that |
1373 | ** string is defined.) |
1374 | */ |
1375 | static int dupedExprNodeSize(const Expr *p, int flags){ |
1376 | int nByte = dupedExprStructSize(p, flags) & 0xfff; |
1377 | if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){ |
1378 | nByte += sqlite3Strlen30NN(p->u.zToken)+1; |
1379 | } |
1380 | return ROUND8(nByte); |
1381 | } |
1382 | |
1383 | /* |
1384 | ** Return the number of bytes required to create a duplicate of the |
1385 | ** expression passed as the first argument. The second argument is a |
1386 | ** mask containing EXPRDUP_XXX flags. |
1387 | ** |
1388 | ** The value returned includes space to create a copy of the Expr struct |
1389 | ** itself and the buffer referred to by Expr.u.zToken, if any. |
1390 | ** |
1391 | ** If the EXPRDUP_REDUCE flag is set, then the return value includes |
1392 | ** space to duplicate all Expr nodes in the tree formed by Expr.pLeft |
1393 | ** and Expr.pRight variables (but not for any structures pointed to or |
1394 | ** descended from the Expr.x.pList or Expr.x.pSelect variables). |
1395 | */ |
1396 | static int dupedExprSize(const Expr *p, int flags){ |
1397 | int nByte = 0; |
1398 | if( p ){ |
1399 | nByte = dupedExprNodeSize(p, flags); |
1400 | if( flags&EXPRDUP_REDUCE ){ |
1401 | nByte += dupedExprSize(p->pLeft, flags) + dupedExprSize(p->pRight, flags); |
1402 | } |
1403 | } |
1404 | return nByte; |
1405 | } |
1406 | |
1407 | /* |
1408 | ** This function is similar to sqlite3ExprDup(), except that if pzBuffer |
1409 | ** is not NULL then *pzBuffer is assumed to point to a buffer large enough |
1410 | ** to store the copy of expression p, the copies of p->u.zToken |
1411 | ** (if applicable), and the copies of the p->pLeft and p->pRight expressions, |
1412 | ** if any. Before returning, *pzBuffer is set to the first byte past the |
1413 | ** portion of the buffer copied into by this function. |
1414 | */ |
1415 | static Expr *exprDup(sqlite3 *db, const Expr *p, int dupFlags, u8 **pzBuffer){ |
1416 | Expr *pNew; /* Value to return */ |
1417 | u8 *zAlloc; /* Memory space from which to build Expr object */ |
1418 | u32 staticFlag; /* EP_Static if space not obtained from malloc */ |
1419 | |
1420 | assert( db!=0 ); |
1421 | assert( p ); |
1422 | assert( dupFlags==0 || dupFlags==EXPRDUP_REDUCE ); |
1423 | assert( pzBuffer==0 || dupFlags==EXPRDUP_REDUCE ); |
1424 | |
1425 | /* Figure out where to write the new Expr structure. */ |
1426 | if( pzBuffer ){ |
1427 | zAlloc = *pzBuffer; |
1428 | staticFlag = EP_Static; |
1429 | assert( zAlloc!=0 ); |
1430 | }else{ |
1431 | zAlloc = sqlite3DbMallocRawNN(db, dupedExprSize(p, dupFlags)); |
1432 | staticFlag = 0; |
1433 | } |
1434 | pNew = (Expr *)zAlloc; |
1435 | |
1436 | if( pNew ){ |
1437 | /* Set nNewSize to the size allocated for the structure pointed to |
1438 | ** by pNew. This is either EXPR_FULLSIZE, EXPR_REDUCEDSIZE or |
1439 | ** EXPR_TOKENONLYSIZE. nToken is set to the number of bytes consumed |
1440 | ** by the copy of the p->u.zToken string (if any). |
1441 | */ |
1442 | const unsigned nStructSize = dupedExprStructSize(p, dupFlags); |
1443 | const int nNewSize = nStructSize & 0xfff; |
1444 | int nToken; |
1445 | if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){ |
1446 | nToken = sqlite3Strlen30(p->u.zToken) + 1; |
1447 | }else{ |
1448 | nToken = 0; |
1449 | } |
1450 | if( dupFlags ){ |
1451 | assert( ExprHasProperty(p, EP_Reduced)==0 ); |
1452 | memcpy(zAlloc, p, nNewSize); |
1453 | }else{ |
1454 | u32 nSize = (u32)exprStructSize(p); |
1455 | memcpy(zAlloc, p, nSize); |
1456 | if( nSize<EXPR_FULLSIZE ){ |
1457 | memset(&zAlloc[nSize], 0, EXPR_FULLSIZE-nSize); |
1458 | } |
1459 | } |
1460 | |
1461 | /* Set the EP_Reduced, EP_TokenOnly, and EP_Static flags appropriately. */ |
1462 | pNew->flags &= ~(EP_Reduced|EP_TokenOnly|EP_Static); |
1463 | pNew->flags |= nStructSize & (EP_Reduced|EP_TokenOnly); |
1464 | pNew->flags |= staticFlag; |
1465 | ExprClearVVAProperties(pNew); |
1466 | if( dupFlags ){ |
1467 | ExprSetVVAProperty(pNew, EP_Immutable); |
1468 | } |
1469 | |
1470 | /* Copy the p->u.zToken string, if any. */ |
1471 | if( nToken ){ |
1472 | char *zToken = pNew->u.zToken = (char*)&zAlloc[nNewSize]; |
1473 | memcpy(zToken, p->u.zToken, nToken); |
1474 | } |
1475 | |
1476 | if( 0==((p->flags|pNew->flags) & (EP_TokenOnly|EP_Leaf)) ){ |
1477 | /* Fill in the pNew->x.pSelect or pNew->x.pList member. */ |
1478 | if( ExprUseXSelect(p) ){ |
1479 | pNew->x.pSelect = sqlite3SelectDup(db, p->x.pSelect, dupFlags); |
1480 | }else{ |
1481 | pNew->x.pList = sqlite3ExprListDup(db, p->x.pList, dupFlags); |
1482 | } |
1483 | } |
1484 | |
1485 | /* Fill in pNew->pLeft and pNew->pRight. */ |
1486 | if( ExprHasProperty(pNew, EP_Reduced|EP_TokenOnly|EP_WinFunc) ){ |
1487 | zAlloc += dupedExprNodeSize(p, dupFlags); |
1488 | if( !ExprHasProperty(pNew, EP_TokenOnly|EP_Leaf) ){ |
1489 | pNew->pLeft = p->pLeft ? |
1490 | exprDup(db, p->pLeft, EXPRDUP_REDUCE, &zAlloc) : 0; |
1491 | pNew->pRight = p->pRight ? |
1492 | exprDup(db, p->pRight, EXPRDUP_REDUCE, &zAlloc) : 0; |
1493 | } |
1494 | #ifndef SQLITE_OMIT_WINDOWFUNC |
1495 | if( ExprHasProperty(p, EP_WinFunc) ){ |
1496 | pNew->y.pWin = sqlite3WindowDup(db, pNew, p->y.pWin); |
1497 | assert( ExprHasProperty(pNew, EP_WinFunc) ); |
1498 | } |
1499 | #endif /* SQLITE_OMIT_WINDOWFUNC */ |
1500 | if( pzBuffer ){ |
1501 | *pzBuffer = zAlloc; |
1502 | } |
1503 | }else{ |
1504 | if( !ExprHasProperty(p, EP_TokenOnly|EP_Leaf) ){ |
1505 | if( pNew->op==TK_SELECT_COLUMN ){ |
1506 | pNew->pLeft = p->pLeft; |
1507 | assert( p->pRight==0 || p->pRight==p->pLeft |
1508 | || ExprHasProperty(p->pLeft, EP_Subquery) ); |
1509 | }else{ |
1510 | pNew->pLeft = sqlite3ExprDup(db, p->pLeft, 0); |
1511 | } |
1512 | pNew->pRight = sqlite3ExprDup(db, p->pRight, 0); |
1513 | } |
1514 | } |
1515 | } |
1516 | return pNew; |
1517 | } |
1518 | |
1519 | /* |
1520 | ** Create and return a deep copy of the object passed as the second |
1521 | ** argument. If an OOM condition is encountered, NULL is returned |
1522 | ** and the db->mallocFailed flag set. |
1523 | */ |
1524 | #ifndef SQLITE_OMIT_CTE |
1525 | With *sqlite3WithDup(sqlite3 *db, With *p){ |
1526 | With *pRet = 0; |
1527 | if( p ){ |
1528 | sqlite3_int64 nByte = sizeof(*p) + sizeof(p->a[0]) * (p->nCte-1); |
1529 | pRet = sqlite3DbMallocZero(db, nByte); |
1530 | if( pRet ){ |
1531 | int i; |
1532 | pRet->nCte = p->nCte; |
1533 | for(i=0; i<p->nCte; i++){ |
1534 | pRet->a[i].pSelect = sqlite3SelectDup(db, p->a[i].pSelect, 0); |
1535 | pRet->a[i].pCols = sqlite3ExprListDup(db, p->a[i].pCols, 0); |
1536 | pRet->a[i].zName = sqlite3DbStrDup(db, p->a[i].zName); |
1537 | pRet->a[i].eM10d = p->a[i].eM10d; |
1538 | } |
1539 | } |
1540 | } |
1541 | return pRet; |
1542 | } |
1543 | #else |
1544 | # define sqlite3WithDup(x,y) 0 |
1545 | #endif |
1546 | |
1547 | #ifndef SQLITE_OMIT_WINDOWFUNC |
1548 | /* |
1549 | ** The gatherSelectWindows() procedure and its helper routine |
1550 | ** gatherSelectWindowsCallback() are used to scan all the expressions |
1551 | ** an a newly duplicated SELECT statement and gather all of the Window |
1552 | ** objects found there, assembling them onto the linked list at Select->pWin. |
1553 | */ |
1554 | static int gatherSelectWindowsCallback(Walker *pWalker, Expr *pExpr){ |
1555 | if( pExpr->op==TK_FUNCTION && ExprHasProperty(pExpr, EP_WinFunc) ){ |
1556 | Select *pSelect = pWalker->u.pSelect; |
1557 | Window *pWin = pExpr->y.pWin; |
1558 | assert( pWin ); |
1559 | assert( IsWindowFunc(pExpr) ); |
1560 | assert( pWin->ppThis==0 ); |
1561 | sqlite3WindowLink(pSelect, pWin); |
1562 | } |
1563 | return WRC_Continue; |
1564 | } |
1565 | static int gatherSelectWindowsSelectCallback(Walker *pWalker, Select *p){ |
1566 | return p==pWalker->u.pSelect ? WRC_Continue : WRC_Prune; |
1567 | } |
1568 | static void gatherSelectWindows(Select *p){ |
1569 | Walker w; |
1570 | w.xExprCallback = gatherSelectWindowsCallback; |
1571 | w.xSelectCallback = gatherSelectWindowsSelectCallback; |
1572 | w.xSelectCallback2 = 0; |
1573 | w.pParse = 0; |
1574 | w.u.pSelect = p; |
1575 | sqlite3WalkSelect(&w, p); |
1576 | } |
1577 | #endif |
1578 | |
1579 | |
1580 | /* |
1581 | ** The following group of routines make deep copies of expressions, |
1582 | ** expression lists, ID lists, and select statements. The copies can |
1583 | ** be deleted (by being passed to their respective ...Delete() routines) |
1584 | ** without effecting the originals. |
1585 | ** |
1586 | ** The expression list, ID, and source lists return by sqlite3ExprListDup(), |
1587 | ** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded |
1588 | ** by subsequent calls to sqlite*ListAppend() routines. |
1589 | ** |
1590 | ** Any tables that the SrcList might point to are not duplicated. |
1591 | ** |
1592 | ** The flags parameter contains a combination of the EXPRDUP_XXX flags. |
1593 | ** If the EXPRDUP_REDUCE flag is set, then the structure returned is a |
1594 | ** truncated version of the usual Expr structure that will be stored as |
1595 | ** part of the in-memory representation of the database schema. |
1596 | */ |
1597 | Expr *sqlite3ExprDup(sqlite3 *db, const Expr *p, int flags){ |
1598 | assert( flags==0 || flags==EXPRDUP_REDUCE ); |
1599 | return p ? exprDup(db, p, flags, 0) : 0; |
1600 | } |
1601 | ExprList *sqlite3ExprListDup(sqlite3 *db, const ExprList *p, int flags){ |
1602 | ExprList *pNew; |
1603 | struct ExprList_item *pItem; |
1604 | const struct ExprList_item *pOldItem; |
1605 | int i; |
1606 | Expr *pPriorSelectColOld = 0; |
1607 | Expr *pPriorSelectColNew = 0; |
1608 | assert( db!=0 ); |
1609 | if( p==0 ) return 0; |
1610 | pNew = sqlite3DbMallocRawNN(db, sqlite3DbMallocSize(db, p)); |
1611 | if( pNew==0 ) return 0; |
1612 | pNew->nExpr = p->nExpr; |
1613 | pNew->nAlloc = p->nAlloc; |
1614 | pItem = pNew->a; |
1615 | pOldItem = p->a; |
1616 | for(i=0; i<p->nExpr; i++, pItem++, pOldItem++){ |
1617 | Expr *pOldExpr = pOldItem->pExpr; |
1618 | Expr *pNewExpr; |
1619 | pItem->pExpr = sqlite3ExprDup(db, pOldExpr, flags); |
1620 | if( pOldExpr |
1621 | && pOldExpr->op==TK_SELECT_COLUMN |
1622 | && (pNewExpr = pItem->pExpr)!=0 |
1623 | ){ |
1624 | if( pNewExpr->pRight ){ |
1625 | pPriorSelectColOld = pOldExpr->pRight; |
1626 | pPriorSelectColNew = pNewExpr->pRight; |
1627 | pNewExpr->pLeft = pNewExpr->pRight; |
1628 | }else{ |
1629 | if( pOldExpr->pLeft!=pPriorSelectColOld ){ |
1630 | pPriorSelectColOld = pOldExpr->pLeft; |
1631 | pPriorSelectColNew = sqlite3ExprDup(db, pPriorSelectColOld, flags); |
1632 | pNewExpr->pRight = pPriorSelectColNew; |
1633 | } |
1634 | pNewExpr->pLeft = pPriorSelectColNew; |
1635 | } |
1636 | } |
1637 | pItem->zEName = sqlite3DbStrDup(db, pOldItem->zEName); |
1638 | pItem->fg = pOldItem->fg; |
1639 | pItem->fg.done = 0; |
1640 | pItem->u = pOldItem->u; |
1641 | } |
1642 | return pNew; |
1643 | } |
1644 | |
1645 | /* |
1646 | ** If cursors, triggers, views and subqueries are all omitted from |
1647 | ** the build, then none of the following routines, except for |
1648 | ** sqlite3SelectDup(), can be called. sqlite3SelectDup() is sometimes |
1649 | ** called with a NULL argument. |
1650 | */ |
1651 | #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) \ |
1652 | || !defined(SQLITE_OMIT_SUBQUERY) |
1653 | SrcList *sqlite3SrcListDup(sqlite3 *db, const SrcList *p, int flags){ |
1654 | SrcList *pNew; |
1655 | int i; |
1656 | int nByte; |
1657 | assert( db!=0 ); |
1658 | if( p==0 ) return 0; |
1659 | nByte = sizeof(*p) + (p->nSrc>0 ? sizeof(p->a[0]) * (p->nSrc-1) : 0); |
1660 | pNew = sqlite3DbMallocRawNN(db, nByte ); |
1661 | if( pNew==0 ) return 0; |
1662 | pNew->nSrc = pNew->nAlloc = p->nSrc; |
1663 | for(i=0; i<p->nSrc; i++){ |
1664 | SrcItem *pNewItem = &pNew->a[i]; |
1665 | const SrcItem *pOldItem = &p->a[i]; |
1666 | Table *pTab; |
1667 | pNewItem->pSchema = pOldItem->pSchema; |
1668 | pNewItem->zDatabase = sqlite3DbStrDup(db, pOldItem->zDatabase); |
1669 | pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName); |
1670 | pNewItem->zAlias = sqlite3DbStrDup(db, pOldItem->zAlias); |
1671 | pNewItem->fg = pOldItem->fg; |
1672 | pNewItem->iCursor = pOldItem->iCursor; |
1673 | pNewItem->addrFillSub = pOldItem->addrFillSub; |
1674 | pNewItem->regReturn = pOldItem->regReturn; |
1675 | if( pNewItem->fg.isIndexedBy ){ |
1676 | pNewItem->u1.zIndexedBy = sqlite3DbStrDup(db, pOldItem->u1.zIndexedBy); |
1677 | } |
1678 | pNewItem->u2 = pOldItem->u2; |
1679 | if( pNewItem->fg.isCte ){ |
1680 | pNewItem->u2.pCteUse->nUse++; |
1681 | } |
1682 | if( pNewItem->fg.isTabFunc ){ |
1683 | pNewItem->u1.pFuncArg = |
1684 | sqlite3ExprListDup(db, pOldItem->u1.pFuncArg, flags); |
1685 | } |
1686 | pTab = pNewItem->pTab = pOldItem->pTab; |
1687 | if( pTab ){ |
1688 | pTab->nTabRef++; |
1689 | } |
1690 | pNewItem->pSelect = sqlite3SelectDup(db, pOldItem->pSelect, flags); |
1691 | if( pOldItem->fg.isUsing ){ |
1692 | assert( pNewItem->fg.isUsing ); |
1693 | pNewItem->u3.pUsing = sqlite3IdListDup(db, pOldItem->u3.pUsing); |
1694 | }else{ |
1695 | pNewItem->u3.pOn = sqlite3ExprDup(db, pOldItem->u3.pOn, flags); |
1696 | } |
1697 | pNewItem->colUsed = pOldItem->colUsed; |
1698 | } |
1699 | return pNew; |
1700 | } |
1701 | IdList *sqlite3IdListDup(sqlite3 *db, const IdList *p){ |
1702 | IdList *pNew; |
1703 | int i; |
1704 | assert( db!=0 ); |
1705 | if( p==0 ) return 0; |
1706 | assert( p->eU4!=EU4_EXPR ); |
1707 | pNew = sqlite3DbMallocRawNN(db, sizeof(*pNew)+(p->nId-1)*sizeof(p->a[0]) ); |
1708 | if( pNew==0 ) return 0; |
1709 | pNew->nId = p->nId; |
1710 | pNew->eU4 = p->eU4; |
1711 | for(i=0; i<p->nId; i++){ |
1712 | struct IdList_item *pNewItem = &pNew->a[i]; |
1713 | const struct IdList_item *pOldItem = &p->a[i]; |
1714 | pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName); |
1715 | pNewItem->u4 = pOldItem->u4; |
1716 | } |
1717 | return pNew; |
1718 | } |
1719 | Select *sqlite3SelectDup(sqlite3 *db, const Select *pDup, int flags){ |
1720 | Select *pRet = 0; |
1721 | Select *pNext = 0; |
1722 | Select **pp = &pRet; |
1723 | const Select *p; |
1724 | |
1725 | assert( db!=0 ); |
1726 | for(p=pDup; p; p=p->pPrior){ |
1727 | Select *pNew = sqlite3DbMallocRawNN(db, sizeof(*p) ); |
1728 | if( pNew==0 ) break; |
1729 | pNew->pEList = sqlite3ExprListDup(db, p->pEList, flags); |
1730 | pNew->pSrc = sqlite3SrcListDup(db, p->pSrc, flags); |
1731 | pNew->pWhere = sqlite3ExprDup(db, p->pWhere, flags); |
1732 | pNew->pGroupBy = sqlite3ExprListDup(db, p->pGroupBy, flags); |
1733 | pNew->pHaving = sqlite3ExprDup(db, p->pHaving, flags); |
1734 | pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, flags); |
1735 | pNew->op = p->op; |
1736 | pNew->pNext = pNext; |
1737 | pNew->pPrior = 0; |
1738 | pNew->pLimit = sqlite3ExprDup(db, p->pLimit, flags); |
1739 | pNew->iLimit = 0; |
1740 | pNew->iOffset = 0; |
1741 | pNew->selFlags = p->selFlags & ~SF_UsesEphemeral; |
1742 | pNew->addrOpenEphm[0] = -1; |
1743 | pNew->addrOpenEphm[1] = -1; |
1744 | pNew->nSelectRow = p->nSelectRow; |
1745 | pNew->pWith = sqlite3WithDup(db, p->pWith); |
1746 | #ifndef SQLITE_OMIT_WINDOWFUNC |
1747 | pNew->pWin = 0; |
1748 | pNew->pWinDefn = sqlite3WindowListDup(db, p->pWinDefn); |
1749 | if( p->pWin && db->mallocFailed==0 ) gatherSelectWindows(pNew); |
1750 | #endif |
1751 | pNew->selId = p->selId; |
1752 | if( db->mallocFailed ){ |
1753 | /* Any prior OOM might have left the Select object incomplete. |
1754 | ** Delete the whole thing rather than allow an incomplete Select |
1755 | ** to be used by the code generator. */ |
1756 | pNew->pNext = 0; |
1757 | sqlite3SelectDelete(db, pNew); |
1758 | break; |
1759 | } |
1760 | *pp = pNew; |
1761 | pp = &pNew->pPrior; |
1762 | pNext = pNew; |
1763 | } |
1764 | |
1765 | return pRet; |
1766 | } |
1767 | #else |
1768 | Select *sqlite3SelectDup(sqlite3 *db, const Select *p, int flags){ |
1769 | assert( p==0 ); |
1770 | return 0; |
1771 | } |
1772 | #endif |
1773 | |
1774 | |
1775 | /* |
1776 | ** Add a new element to the end of an expression list. If pList is |
1777 | ** initially NULL, then create a new expression list. |
1778 | ** |
1779 | ** The pList argument must be either NULL or a pointer to an ExprList |
1780 | ** obtained from a prior call to sqlite3ExprListAppend(). This routine |
1781 | ** may not be used with an ExprList obtained from sqlite3ExprListDup(). |
1782 | ** Reason: This routine assumes that the number of slots in pList->a[] |
1783 | ** is a power of two. That is true for sqlite3ExprListAppend() returns |
1784 | ** but is not necessarily true from the return value of sqlite3ExprListDup(). |
1785 | ** |
1786 | ** If a memory allocation error occurs, the entire list is freed and |
1787 | ** NULL is returned. If non-NULL is returned, then it is guaranteed |
1788 | ** that the new entry was successfully appended. |
1789 | */ |
1790 | static const struct ExprList_item zeroItem = {0}; |
1791 | SQLITE_NOINLINE ExprList *sqlite3ExprListAppendNew( |
1792 | sqlite3 *db, /* Database handle. Used for memory allocation */ |
1793 | Expr *pExpr /* Expression to be appended. Might be NULL */ |
1794 | ){ |
1795 | struct ExprList_item *pItem; |
1796 | ExprList *pList; |
1797 | |
1798 | pList = sqlite3DbMallocRawNN(db, sizeof(ExprList)+sizeof(pList->a[0])*4 ); |
1799 | if( pList==0 ){ |
1800 | sqlite3ExprDelete(db, pExpr); |
1801 | return 0; |
1802 | } |
1803 | pList->nAlloc = 4; |
1804 | pList->nExpr = 1; |
1805 | pItem = &pList->a[0]; |
1806 | *pItem = zeroItem; |
1807 | pItem->pExpr = pExpr; |
1808 | return pList; |
1809 | } |
1810 | SQLITE_NOINLINE ExprList *sqlite3ExprListAppendGrow( |
1811 | sqlite3 *db, /* Database handle. Used for memory allocation */ |
1812 | ExprList *pList, /* List to which to append. Might be NULL */ |
1813 | Expr *pExpr /* Expression to be appended. Might be NULL */ |
1814 | ){ |
1815 | struct ExprList_item *pItem; |
1816 | ExprList *pNew; |
1817 | pList->nAlloc *= 2; |
1818 | pNew = sqlite3DbRealloc(db, pList, |
1819 | sizeof(*pList)+(pList->nAlloc-1)*sizeof(pList->a[0])); |
1820 | if( pNew==0 ){ |
1821 | sqlite3ExprListDelete(db, pList); |
1822 | sqlite3ExprDelete(db, pExpr); |
1823 | return 0; |
1824 | }else{ |
1825 | pList = pNew; |
1826 | } |
1827 | pItem = &pList->a[pList->nExpr++]; |
1828 | *pItem = zeroItem; |
1829 | pItem->pExpr = pExpr; |
1830 | return pList; |
1831 | } |
1832 | ExprList *sqlite3ExprListAppend( |
1833 | Parse *pParse, /* Parsing context */ |
1834 | ExprList *pList, /* List to which to append. Might be NULL */ |
1835 | Expr *pExpr /* Expression to be appended. Might be NULL */ |
1836 | ){ |
1837 | struct ExprList_item *pItem; |
1838 | if( pList==0 ){ |
1839 | return sqlite3ExprListAppendNew(pParse->db,pExpr); |
1840 | } |
1841 | if( pList->nAlloc<pList->nExpr+1 ){ |
1842 | return sqlite3ExprListAppendGrow(pParse->db,pList,pExpr); |
1843 | } |
1844 | pItem = &pList->a[pList->nExpr++]; |
1845 | *pItem = zeroItem; |
1846 | pItem->pExpr = pExpr; |
1847 | return pList; |
1848 | } |
1849 | |
1850 | /* |
1851 | ** pColumns and pExpr form a vector assignment which is part of the SET |
1852 | ** clause of an UPDATE statement. Like this: |
1853 | ** |
1854 | ** (a,b,c) = (expr1,expr2,expr3) |
1855 | ** Or: (a,b,c) = (SELECT x,y,z FROM ....) |
1856 | ** |
1857 | ** For each term of the vector assignment, append new entries to the |
1858 | ** expression list pList. In the case of a subquery on the RHS, append |
1859 | ** TK_SELECT_COLUMN expressions. |
1860 | */ |
1861 | ExprList *sqlite3ExprListAppendVector( |
1862 | Parse *pParse, /* Parsing context */ |
1863 | ExprList *pList, /* List to which to append. Might be NULL */ |
1864 | IdList *pColumns, /* List of names of LHS of the assignment */ |
1865 | Expr *pExpr /* Vector expression to be appended. Might be NULL */ |
1866 | ){ |
1867 | sqlite3 *db = pParse->db; |
1868 | int n; |
1869 | int i; |
1870 | int iFirst = pList ? pList->nExpr : 0; |
1871 | /* pColumns can only be NULL due to an OOM but an OOM will cause an |
1872 | ** exit prior to this routine being invoked */ |
1873 | if( NEVER(pColumns==0) ) goto vector_append_error; |
1874 | if( pExpr==0 ) goto vector_append_error; |
1875 | |
1876 | /* If the RHS is a vector, then we can immediately check to see that |
1877 | ** the size of the RHS and LHS match. But if the RHS is a SELECT, |
1878 | ** wildcards ("*") in the result set of the SELECT must be expanded before |
1879 | ** we can do the size check, so defer the size check until code generation. |
1880 | */ |
1881 | if( pExpr->op!=TK_SELECT && pColumns->nId!=(n=sqlite3ExprVectorSize(pExpr)) ){ |
1882 | sqlite3ErrorMsg(pParse, "%d columns assigned %d values" , |
1883 | pColumns->nId, n); |
1884 | goto vector_append_error; |
1885 | } |
1886 | |
1887 | for(i=0; i<pColumns->nId; i++){ |
1888 | Expr *pSubExpr = sqlite3ExprForVectorField(pParse, pExpr, i, pColumns->nId); |
1889 | assert( pSubExpr!=0 || db->mallocFailed ); |
1890 | if( pSubExpr==0 ) continue; |
1891 | pList = sqlite3ExprListAppend(pParse, pList, pSubExpr); |
1892 | if( pList ){ |
1893 | assert( pList->nExpr==iFirst+i+1 ); |
1894 | pList->a[pList->nExpr-1].zEName = pColumns->a[i].zName; |
1895 | pColumns->a[i].zName = 0; |
1896 | } |
1897 | } |
1898 | |
1899 | if( !db->mallocFailed && pExpr->op==TK_SELECT && ALWAYS(pList!=0) ){ |
1900 | Expr *pFirst = pList->a[iFirst].pExpr; |
1901 | assert( pFirst!=0 ); |
1902 | assert( pFirst->op==TK_SELECT_COLUMN ); |
1903 | |
1904 | /* Store the SELECT statement in pRight so it will be deleted when |
1905 | ** sqlite3ExprListDelete() is called */ |
1906 | pFirst->pRight = pExpr; |
1907 | pExpr = 0; |
1908 | |
1909 | /* Remember the size of the LHS in iTable so that we can check that |
1910 | ** the RHS and LHS sizes match during code generation. */ |
1911 | pFirst->iTable = pColumns->nId; |
1912 | } |
1913 | |
1914 | vector_append_error: |
1915 | sqlite3ExprUnmapAndDelete(pParse, pExpr); |
1916 | sqlite3IdListDelete(db, pColumns); |
1917 | return pList; |
1918 | } |
1919 | |
1920 | /* |
1921 | ** Set the sort order for the last element on the given ExprList. |
1922 | */ |
1923 | void sqlite3ExprListSetSortOrder(ExprList *p, int iSortOrder, int eNulls){ |
1924 | struct ExprList_item *pItem; |
1925 | if( p==0 ) return; |
1926 | assert( p->nExpr>0 ); |
1927 | |
1928 | assert( SQLITE_SO_UNDEFINED<0 && SQLITE_SO_ASC==0 && SQLITE_SO_DESC>0 ); |
1929 | assert( iSortOrder==SQLITE_SO_UNDEFINED |
1930 | || iSortOrder==SQLITE_SO_ASC |
1931 | || iSortOrder==SQLITE_SO_DESC |
1932 | ); |
1933 | assert( eNulls==SQLITE_SO_UNDEFINED |
1934 | || eNulls==SQLITE_SO_ASC |
1935 | || eNulls==SQLITE_SO_DESC |
1936 | ); |
1937 | |
1938 | pItem = &p->a[p->nExpr-1]; |
1939 | assert( pItem->fg.bNulls==0 ); |
1940 | if( iSortOrder==SQLITE_SO_UNDEFINED ){ |
1941 | iSortOrder = SQLITE_SO_ASC; |
1942 | } |
1943 | pItem->fg.sortFlags = (u8)iSortOrder; |
1944 | |
1945 | if( eNulls!=SQLITE_SO_UNDEFINED ){ |
1946 | pItem->fg.bNulls = 1; |
1947 | if( iSortOrder!=eNulls ){ |
1948 | pItem->fg.sortFlags |= KEYINFO_ORDER_BIGNULL; |
1949 | } |
1950 | } |
1951 | } |
1952 | |
1953 | /* |
1954 | ** Set the ExprList.a[].zEName element of the most recently added item |
1955 | ** on the expression list. |
1956 | ** |
1957 | ** pList might be NULL following an OOM error. But pName should never be |
1958 | ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag |
1959 | ** is set. |
1960 | */ |
1961 | void sqlite3ExprListSetName( |
1962 | Parse *pParse, /* Parsing context */ |
1963 | ExprList *pList, /* List to which to add the span. */ |
1964 | const Token *pName, /* Name to be added */ |
1965 | int dequote /* True to cause the name to be dequoted */ |
1966 | ){ |
1967 | assert( pList!=0 || pParse->db->mallocFailed!=0 ); |
1968 | assert( pParse->eParseMode!=PARSE_MODE_UNMAP || dequote==0 ); |
1969 | if( pList ){ |
1970 | struct ExprList_item *pItem; |
1971 | assert( pList->nExpr>0 ); |
1972 | pItem = &pList->a[pList->nExpr-1]; |
1973 | assert( pItem->zEName==0 ); |
1974 | assert( pItem->fg.eEName==ENAME_NAME ); |
1975 | pItem->zEName = sqlite3DbStrNDup(pParse->db, pName->z, pName->n); |
1976 | if( dequote ){ |
1977 | /* If dequote==0, then pName->z does not point to part of a DDL |
1978 | ** statement handled by the parser. And so no token need be added |
1979 | ** to the token-map. */ |
1980 | sqlite3Dequote(pItem->zEName); |
1981 | if( IN_RENAME_OBJECT ){ |
1982 | sqlite3RenameTokenMap(pParse, (const void*)pItem->zEName, pName); |
1983 | } |
1984 | } |
1985 | } |
1986 | } |
1987 | |
1988 | /* |
1989 | ** Set the ExprList.a[].zSpan element of the most recently added item |
1990 | ** on the expression list. |
1991 | ** |
1992 | ** pList might be NULL following an OOM error. But pSpan should never be |
1993 | ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag |
1994 | ** is set. |
1995 | */ |
1996 | void sqlite3ExprListSetSpan( |
1997 | Parse *pParse, /* Parsing context */ |
1998 | ExprList *pList, /* List to which to add the span. */ |
1999 | const char *zStart, /* Start of the span */ |
2000 | const char *zEnd /* End of the span */ |
2001 | ){ |
2002 | sqlite3 *db = pParse->db; |
2003 | assert( pList!=0 || db->mallocFailed!=0 ); |
2004 | if( pList ){ |
2005 | struct ExprList_item *pItem = &pList->a[pList->nExpr-1]; |
2006 | assert( pList->nExpr>0 ); |
2007 | if( pItem->zEName==0 ){ |
2008 | pItem->zEName = sqlite3DbSpanDup(db, zStart, zEnd); |
2009 | pItem->fg.eEName = ENAME_SPAN; |
2010 | } |
2011 | } |
2012 | } |
2013 | |
2014 | /* |
2015 | ** If the expression list pEList contains more than iLimit elements, |
2016 | ** leave an error message in pParse. |
2017 | */ |
2018 | void sqlite3ExprListCheckLength( |
2019 | Parse *pParse, |
2020 | ExprList *pEList, |
2021 | const char *zObject |
2022 | ){ |
2023 | int mx = pParse->db->aLimit[SQLITE_LIMIT_COLUMN]; |
2024 | testcase( pEList && pEList->nExpr==mx ); |
2025 | testcase( pEList && pEList->nExpr==mx+1 ); |
2026 | if( pEList && pEList->nExpr>mx ){ |
2027 | sqlite3ErrorMsg(pParse, "too many columns in %s" , zObject); |
2028 | } |
2029 | } |
2030 | |
2031 | /* |
2032 | ** Delete an entire expression list. |
2033 | */ |
2034 | static SQLITE_NOINLINE void exprListDeleteNN(sqlite3 *db, ExprList *pList){ |
2035 | int i = pList->nExpr; |
2036 | struct ExprList_item *pItem = pList->a; |
2037 | assert( pList->nExpr>0 ); |
2038 | assert( db!=0 ); |
2039 | do{ |
2040 | sqlite3ExprDelete(db, pItem->pExpr); |
2041 | if( pItem->zEName ) sqlite3DbNNFreeNN(db, pItem->zEName); |
2042 | pItem++; |
2043 | }while( --i>0 ); |
2044 | sqlite3DbNNFreeNN(db, pList); |
2045 | } |
2046 | void sqlite3ExprListDelete(sqlite3 *db, ExprList *pList){ |
2047 | if( pList ) exprListDeleteNN(db, pList); |
2048 | } |
2049 | |
2050 | /* |
2051 | ** Return the bitwise-OR of all Expr.flags fields in the given |
2052 | ** ExprList. |
2053 | */ |
2054 | u32 sqlite3ExprListFlags(const ExprList *pList){ |
2055 | int i; |
2056 | u32 m = 0; |
2057 | assert( pList!=0 ); |
2058 | for(i=0; i<pList->nExpr; i++){ |
2059 | Expr *pExpr = pList->a[i].pExpr; |
2060 | assert( pExpr!=0 ); |
2061 | m |= pExpr->flags; |
2062 | } |
2063 | return m; |
2064 | } |
2065 | |
2066 | /* |
2067 | ** This is a SELECT-node callback for the expression walker that |
2068 | ** always "fails". By "fail" in this case, we mean set |
2069 | ** pWalker->eCode to zero and abort. |
2070 | ** |
2071 | ** This callback is used by multiple expression walkers. |
2072 | */ |
2073 | int sqlite3SelectWalkFail(Walker *pWalker, Select *NotUsed){ |
2074 | UNUSED_PARAMETER(NotUsed); |
2075 | pWalker->eCode = 0; |
2076 | return WRC_Abort; |
2077 | } |
2078 | |
2079 | /* |
2080 | ** Check the input string to see if it is "true" or "false" (in any case). |
2081 | ** |
2082 | ** If the string is.... Return |
2083 | ** "true" EP_IsTrue |
2084 | ** "false" EP_IsFalse |
2085 | ** anything else 0 |
2086 | */ |
2087 | u32 sqlite3IsTrueOrFalse(const char *zIn){ |
2088 | if( sqlite3StrICmp(zIn, "true" )==0 ) return EP_IsTrue; |
2089 | if( sqlite3StrICmp(zIn, "false" )==0 ) return EP_IsFalse; |
2090 | return 0; |
2091 | } |
2092 | |
2093 | |
2094 | /* |
2095 | ** If the input expression is an ID with the name "true" or "false" |
2096 | ** then convert it into an TK_TRUEFALSE term. Return non-zero if |
2097 | ** the conversion happened, and zero if the expression is unaltered. |
2098 | */ |
2099 | int sqlite3ExprIdToTrueFalse(Expr *pExpr){ |
2100 | u32 v; |
2101 | assert( pExpr->op==TK_ID || pExpr->op==TK_STRING ); |
2102 | if( !ExprHasProperty(pExpr, EP_Quoted|EP_IntValue) |
2103 | && (v = sqlite3IsTrueOrFalse(pExpr->u.zToken))!=0 |
2104 | ){ |
2105 | pExpr->op = TK_TRUEFALSE; |
2106 | ExprSetProperty(pExpr, v); |
2107 | return 1; |
2108 | } |
2109 | return 0; |
2110 | } |
2111 | |
2112 | /* |
2113 | ** The argument must be a TK_TRUEFALSE Expr node. Return 1 if it is TRUE |
2114 | ** and 0 if it is FALSE. |
2115 | */ |
2116 | int sqlite3ExprTruthValue(const Expr *pExpr){ |
2117 | pExpr = sqlite3ExprSkipCollate((Expr*)pExpr); |
2118 | assert( pExpr->op==TK_TRUEFALSE ); |
2119 | assert( !ExprHasProperty(pExpr, EP_IntValue) ); |
2120 | assert( sqlite3StrICmp(pExpr->u.zToken,"true" )==0 |
2121 | || sqlite3StrICmp(pExpr->u.zToken,"false" )==0 ); |
2122 | return pExpr->u.zToken[4]==0; |
2123 | } |
2124 | |
2125 | /* |
2126 | ** If pExpr is an AND or OR expression, try to simplify it by eliminating |
2127 | ** terms that are always true or false. Return the simplified expression. |
2128 | ** Or return the original expression if no simplification is possible. |
2129 | ** |
2130 | ** Examples: |
2131 | ** |
2132 | ** (x<10) AND true => (x<10) |
2133 | ** (x<10) AND false => false |
2134 | ** (x<10) AND (y=22 OR false) => (x<10) AND (y=22) |
2135 | ** (x<10) AND (y=22 OR true) => (x<10) |
2136 | ** (y=22) OR true => true |
2137 | */ |
2138 | Expr *sqlite3ExprSimplifiedAndOr(Expr *pExpr){ |
2139 | assert( pExpr!=0 ); |
2140 | if( pExpr->op==TK_AND || pExpr->op==TK_OR ){ |
2141 | Expr *pRight = sqlite3ExprSimplifiedAndOr(pExpr->pRight); |
2142 | Expr *pLeft = sqlite3ExprSimplifiedAndOr(pExpr->pLeft); |
2143 | if( ExprAlwaysTrue(pLeft) || ExprAlwaysFalse(pRight) ){ |
2144 | pExpr = pExpr->op==TK_AND ? pRight : pLeft; |
2145 | }else if( ExprAlwaysTrue(pRight) || ExprAlwaysFalse(pLeft) ){ |
2146 | pExpr = pExpr->op==TK_AND ? pLeft : pRight; |
2147 | } |
2148 | } |
2149 | return pExpr; |
2150 | } |
2151 | |
2152 | |
2153 | /* |
2154 | ** These routines are Walker callbacks used to check expressions to |
2155 | ** see if they are "constant" for some definition of constant. The |
2156 | ** Walker.eCode value determines the type of "constant" we are looking |
2157 | ** for. |
2158 | ** |
2159 | ** These callback routines are used to implement the following: |
2160 | ** |
2161 | ** sqlite3ExprIsConstant() pWalker->eCode==1 |
2162 | ** sqlite3ExprIsConstantNotJoin() pWalker->eCode==2 |
2163 | ** sqlite3ExprIsTableConstant() pWalker->eCode==3 |
2164 | ** sqlite3ExprIsConstantOrFunction() pWalker->eCode==4 or 5 |
2165 | ** |
2166 | ** In all cases, the callbacks set Walker.eCode=0 and abort if the expression |
2167 | ** is found to not be a constant. |
2168 | ** |
2169 | ** The sqlite3ExprIsConstantOrFunction() is used for evaluating DEFAULT |
2170 | ** expressions in a CREATE TABLE statement. The Walker.eCode value is 5 |
2171 | ** when parsing an existing schema out of the sqlite_schema table and 4 |
2172 | ** when processing a new CREATE TABLE statement. A bound parameter raises |
2173 | ** an error for new statements, but is silently converted |
2174 | ** to NULL for existing schemas. This allows sqlite_schema tables that |
2175 | ** contain a bound parameter because they were generated by older versions |
2176 | ** of SQLite to be parsed by newer versions of SQLite without raising a |
2177 | ** malformed schema error. |
2178 | */ |
2179 | static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){ |
2180 | |
2181 | /* If pWalker->eCode is 2 then any term of the expression that comes from |
2182 | ** the ON or USING clauses of an outer join disqualifies the expression |
2183 | ** from being considered constant. */ |
2184 | if( pWalker->eCode==2 && ExprHasProperty(pExpr, EP_OuterON) ){ |
2185 | pWalker->eCode = 0; |
2186 | return WRC_Abort; |
2187 | } |
2188 | |
2189 | switch( pExpr->op ){ |
2190 | /* Consider functions to be constant if all their arguments are constant |
2191 | ** and either pWalker->eCode==4 or 5 or the function has the |
2192 | ** SQLITE_FUNC_CONST flag. */ |
2193 | case TK_FUNCTION: |
2194 | if( (pWalker->eCode>=4 || ExprHasProperty(pExpr,EP_ConstFunc)) |
2195 | && !ExprHasProperty(pExpr, EP_WinFunc) |
2196 | ){ |
2197 | if( pWalker->eCode==5 ) ExprSetProperty(pExpr, EP_FromDDL); |
2198 | return WRC_Continue; |
2199 | }else{ |
2200 | pWalker->eCode = 0; |
2201 | return WRC_Abort; |
2202 | } |
2203 | case TK_ID: |
2204 | /* Convert "true" or "false" in a DEFAULT clause into the |
2205 | ** appropriate TK_TRUEFALSE operator */ |
2206 | if( sqlite3ExprIdToTrueFalse(pExpr) ){ |
2207 | return WRC_Prune; |
2208 | } |
2209 | /* no break */ deliberate_fall_through |
2210 | case TK_COLUMN: |
2211 | case TK_AGG_FUNCTION: |
2212 | case TK_AGG_COLUMN: |
2213 | testcase( pExpr->op==TK_ID ); |
2214 | testcase( pExpr->op==TK_COLUMN ); |
2215 | testcase( pExpr->op==TK_AGG_FUNCTION ); |
2216 | testcase( pExpr->op==TK_AGG_COLUMN ); |
2217 | if( ExprHasProperty(pExpr, EP_FixedCol) && pWalker->eCode!=2 ){ |
2218 | return WRC_Continue; |
2219 | } |
2220 | if( pWalker->eCode==3 && pExpr->iTable==pWalker->u.iCur ){ |
2221 | return WRC_Continue; |
2222 | } |
2223 | /* no break */ deliberate_fall_through |
2224 | case TK_IF_NULL_ROW: |
2225 | case TK_REGISTER: |
2226 | case TK_DOT: |
2227 | testcase( pExpr->op==TK_REGISTER ); |
2228 | testcase( pExpr->op==TK_IF_NULL_ROW ); |
2229 | testcase( pExpr->op==TK_DOT ); |
2230 | pWalker->eCode = 0; |
2231 | return WRC_Abort; |
2232 | case TK_VARIABLE: |
2233 | if( pWalker->eCode==5 ){ |
2234 | /* Silently convert bound parameters that appear inside of CREATE |
2235 | ** statements into a NULL when parsing the CREATE statement text out |
2236 | ** of the sqlite_schema table */ |
2237 | pExpr->op = TK_NULL; |
2238 | }else if( pWalker->eCode==4 ){ |
2239 | /* A bound parameter in a CREATE statement that originates from |
2240 | ** sqlite3_prepare() causes an error */ |
2241 | pWalker->eCode = 0; |
2242 | return WRC_Abort; |
2243 | } |
2244 | /* no break */ deliberate_fall_through |
2245 | default: |
2246 | testcase( pExpr->op==TK_SELECT ); /* sqlite3SelectWalkFail() disallows */ |
2247 | testcase( pExpr->op==TK_EXISTS ); /* sqlite3SelectWalkFail() disallows */ |
2248 | return WRC_Continue; |
2249 | } |
2250 | } |
2251 | static int exprIsConst(Expr *p, int initFlag, int iCur){ |
2252 | Walker w; |
2253 | w.eCode = initFlag; |
2254 | w.xExprCallback = exprNodeIsConstant; |
2255 | w.xSelectCallback = sqlite3SelectWalkFail; |
2256 | #ifdef SQLITE_DEBUG |
2257 | w.xSelectCallback2 = sqlite3SelectWalkAssert2; |
2258 | #endif |
2259 | w.u.iCur = iCur; |
2260 | sqlite3WalkExpr(&w, p); |
2261 | return w.eCode; |
2262 | } |
2263 | |
2264 | /* |
2265 | ** Walk an expression tree. Return non-zero if the expression is constant |
2266 | ** and 0 if it involves variables or function calls. |
2267 | ** |
2268 | ** For the purposes of this function, a double-quoted string (ex: "abc") |
2269 | ** is considered a variable but a single-quoted string (ex: 'abc') is |
2270 | ** a constant. |
2271 | */ |
2272 | int sqlite3ExprIsConstant(Expr *p){ |
2273 | return exprIsConst(p, 1, 0); |
2274 | } |
2275 | |
2276 | /* |
2277 | ** Walk an expression tree. Return non-zero if |
2278 | ** |
2279 | ** (1) the expression is constant, and |
2280 | ** (2) the expression does originate in the ON or USING clause |
2281 | ** of a LEFT JOIN, and |
2282 | ** (3) the expression does not contain any EP_FixedCol TK_COLUMN |
2283 | ** operands created by the constant propagation optimization. |
2284 | ** |
2285 | ** When this routine returns true, it indicates that the expression |
2286 | ** can be added to the pParse->pConstExpr list and evaluated once when |
2287 | ** the prepared statement starts up. See sqlite3ExprCodeRunJustOnce(). |
2288 | */ |
2289 | int sqlite3ExprIsConstantNotJoin(Expr *p){ |
2290 | return exprIsConst(p, 2, 0); |
2291 | } |
2292 | |
2293 | /* |
2294 | ** Walk an expression tree. Return non-zero if the expression is constant |
2295 | ** for any single row of the table with cursor iCur. In other words, the |
2296 | ** expression must not refer to any non-deterministic function nor any |
2297 | ** table other than iCur. |
2298 | */ |
2299 | int sqlite3ExprIsTableConstant(Expr *p, int iCur){ |
2300 | return exprIsConst(p, 3, iCur); |
2301 | } |
2302 | |
2303 | /* |
2304 | ** Check pExpr to see if it is an invariant constraint on data source pSrc. |
2305 | ** This is an optimization. False negatives will perhaps cause slower |
2306 | ** queries, but false positives will yield incorrect answers. So when in |
2307 | ** doubt, return 0. |
2308 | ** |
2309 | ** To be an invariant constraint, the following must be true: |
2310 | ** |
2311 | ** (1) pExpr cannot refer to any table other than pSrc->iCursor. |
2312 | ** |
2313 | ** (2) pExpr cannot use subqueries or non-deterministic functions. |
2314 | ** |
2315 | ** (3) pSrc cannot be part of the left operand for a RIGHT JOIN. |
2316 | ** (Is there some way to relax this constraint?) |
2317 | ** |
2318 | ** (4) If pSrc is the right operand of a LEFT JOIN, then... |
2319 | ** (4a) pExpr must come from an ON clause.. |
2320 | (4b) and specifically the ON clause associated with the LEFT JOIN. |
2321 | ** |
2322 | ** (5) If pSrc is not the right operand of a LEFT JOIN or the left |
2323 | ** operand of a RIGHT JOIN, then pExpr must be from the WHERE |
2324 | ** clause, not an ON clause. |
2325 | */ |
2326 | int sqlite3ExprIsTableConstraint(Expr *pExpr, const SrcItem *pSrc){ |
2327 | if( pSrc->fg.jointype & JT_LTORJ ){ |
2328 | return 0; /* rule (3) */ |
2329 | } |
2330 | if( pSrc->fg.jointype & JT_LEFT ){ |
2331 | if( !ExprHasProperty(pExpr, EP_OuterON) ) return 0; /* rule (4a) */ |
2332 | if( pExpr->w.iJoin!=pSrc->iCursor ) return 0; /* rule (4b) */ |
2333 | }else{ |
2334 | if( ExprHasProperty(pExpr, EP_OuterON) ) return 0; /* rule (5) */ |
2335 | } |
2336 | return sqlite3ExprIsTableConstant(pExpr, pSrc->iCursor); /* rules (1), (2) */ |
2337 | } |
2338 | |
2339 | |
2340 | /* |
2341 | ** sqlite3WalkExpr() callback used by sqlite3ExprIsConstantOrGroupBy(). |
2342 | */ |
2343 | static int exprNodeIsConstantOrGroupBy(Walker *pWalker, Expr *pExpr){ |
2344 | ExprList *pGroupBy = pWalker->u.pGroupBy; |
2345 | int i; |
2346 | |
2347 | /* Check if pExpr is identical to any GROUP BY term. If so, consider |
2348 | ** it constant. */ |
2349 | for(i=0; i<pGroupBy->nExpr; i++){ |
2350 | Expr *p = pGroupBy->a[i].pExpr; |
2351 | if( sqlite3ExprCompare(0, pExpr, p, -1)<2 ){ |
2352 | CollSeq *pColl = sqlite3ExprNNCollSeq(pWalker->pParse, p); |
2353 | if( sqlite3IsBinary(pColl) ){ |
2354 | return WRC_Prune; |
2355 | } |
2356 | } |
2357 | } |
2358 | |
2359 | /* Check if pExpr is a sub-select. If so, consider it variable. */ |
2360 | if( ExprUseXSelect(pExpr) ){ |
2361 | pWalker->eCode = 0; |
2362 | return WRC_Abort; |
2363 | } |
2364 | |
2365 | return exprNodeIsConstant(pWalker, pExpr); |
2366 | } |
2367 | |
2368 | /* |
2369 | ** Walk the expression tree passed as the first argument. Return non-zero |
2370 | ** if the expression consists entirely of constants or copies of terms |
2371 | ** in pGroupBy that sort with the BINARY collation sequence. |
2372 | ** |
2373 | ** This routine is used to determine if a term of the HAVING clause can |
2374 | ** be promoted into the WHERE clause. In order for such a promotion to work, |
2375 | ** the value of the HAVING clause term must be the same for all members of |
2376 | ** a "group". The requirement that the GROUP BY term must be BINARY |
2377 | ** assumes that no other collating sequence will have a finer-grained |
2378 | ** grouping than binary. In other words (A=B COLLATE binary) implies |
2379 | ** A=B in every other collating sequence. The requirement that the |
2380 | ** GROUP BY be BINARY is stricter than necessary. It would also work |
2381 | ** to promote HAVING clauses that use the same alternative collating |
2382 | ** sequence as the GROUP BY term, but that is much harder to check, |
2383 | ** alternative collating sequences are uncommon, and this is only an |
2384 | ** optimization, so we take the easy way out and simply require the |
2385 | ** GROUP BY to use the BINARY collating sequence. |
2386 | */ |
2387 | int sqlite3ExprIsConstantOrGroupBy(Parse *pParse, Expr *p, ExprList *pGroupBy){ |
2388 | Walker w; |
2389 | w.eCode = 1; |
2390 | w.xExprCallback = exprNodeIsConstantOrGroupBy; |
2391 | w.xSelectCallback = 0; |
2392 | w.u.pGroupBy = pGroupBy; |
2393 | w.pParse = pParse; |
2394 | sqlite3WalkExpr(&w, p); |
2395 | return w.eCode; |
2396 | } |
2397 | |
2398 | /* |
2399 | ** Walk an expression tree for the DEFAULT field of a column definition |
2400 | ** in a CREATE TABLE statement. Return non-zero if the expression is |
2401 | ** acceptable for use as a DEFAULT. That is to say, return non-zero if |
2402 | ** the expression is constant or a function call with constant arguments. |
2403 | ** Return and 0 if there are any variables. |
2404 | ** |
2405 | ** isInit is true when parsing from sqlite_schema. isInit is false when |
2406 | ** processing a new CREATE TABLE statement. When isInit is true, parameters |
2407 | ** (such as ? or $abc) in the expression are converted into NULL. When |
2408 | ** isInit is false, parameters raise an error. Parameters should not be |
2409 | ** allowed in a CREATE TABLE statement, but some legacy versions of SQLite |
2410 | ** allowed it, so we need to support it when reading sqlite_schema for |
2411 | ** backwards compatibility. |
2412 | ** |
2413 | ** If isInit is true, set EP_FromDDL on every TK_FUNCTION node. |
2414 | ** |
2415 | ** For the purposes of this function, a double-quoted string (ex: "abc") |
2416 | ** is considered a variable but a single-quoted string (ex: 'abc') is |
2417 | ** a constant. |
2418 | */ |
2419 | int sqlite3ExprIsConstantOrFunction(Expr *p, u8 isInit){ |
2420 | assert( isInit==0 || isInit==1 ); |
2421 | return exprIsConst(p, 4+isInit, 0); |
2422 | } |
2423 | |
2424 | #ifdef SQLITE_ENABLE_CURSOR_HINTS |
2425 | /* |
2426 | ** Walk an expression tree. Return 1 if the expression contains a |
2427 | ** subquery of some kind. Return 0 if there are no subqueries. |
2428 | */ |
2429 | int sqlite3ExprContainsSubquery(Expr *p){ |
2430 | Walker w; |
2431 | w.eCode = 1; |
2432 | w.xExprCallback = sqlite3ExprWalkNoop; |
2433 | w.xSelectCallback = sqlite3SelectWalkFail; |
2434 | #ifdef SQLITE_DEBUG |
2435 | w.xSelectCallback2 = sqlite3SelectWalkAssert2; |
2436 | #endif |
2437 | sqlite3WalkExpr(&w, p); |
2438 | return w.eCode==0; |
2439 | } |
2440 | #endif |
2441 | |
2442 | /* |
2443 | ** If the expression p codes a constant integer that is small enough |
2444 | ** to fit in a 32-bit integer, return 1 and put the value of the integer |
2445 | ** in *pValue. If the expression is not an integer or if it is too big |
2446 | ** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged. |
2447 | */ |
2448 | int sqlite3ExprIsInteger(const Expr *p, int *pValue){ |
2449 | int rc = 0; |
2450 | if( NEVER(p==0) ) return 0; /* Used to only happen following on OOM */ |
2451 | |
2452 | /* If an expression is an integer literal that fits in a signed 32-bit |
2453 | ** integer, then the EP_IntValue flag will have already been set */ |
2454 | assert( p->op!=TK_INTEGER || (p->flags & EP_IntValue)!=0 |
2455 | || sqlite3GetInt32(p->u.zToken, &rc)==0 ); |
2456 | |
2457 | if( p->flags & EP_IntValue ){ |
2458 | *pValue = p->u.iValue; |
2459 | return 1; |
2460 | } |
2461 | switch( p->op ){ |
2462 | case TK_UPLUS: { |
2463 | rc = sqlite3ExprIsInteger(p->pLeft, pValue); |
2464 | break; |
2465 | } |
2466 | case TK_UMINUS: { |
2467 | int v = 0; |
2468 | if( sqlite3ExprIsInteger(p->pLeft, &v) ){ |
2469 | assert( ((unsigned int)v)!=0x80000000 ); |
2470 | *pValue = -v; |
2471 | rc = 1; |
2472 | } |
2473 | break; |
2474 | } |
2475 | default: break; |
2476 | } |
2477 | return rc; |
2478 | } |
2479 | |
2480 | /* |
2481 | ** Return FALSE if there is no chance that the expression can be NULL. |
2482 | ** |
2483 | ** If the expression might be NULL or if the expression is too complex |
2484 | ** to tell return TRUE. |
2485 | ** |
2486 | ** This routine is used as an optimization, to skip OP_IsNull opcodes |
2487 | ** when we know that a value cannot be NULL. Hence, a false positive |
2488 | ** (returning TRUE when in fact the expression can never be NULL) might |
2489 | ** be a small performance hit but is otherwise harmless. On the other |
2490 | ** hand, a false negative (returning FALSE when the result could be NULL) |
2491 | ** will likely result in an incorrect answer. So when in doubt, return |
2492 | ** TRUE. |
2493 | */ |
2494 | int sqlite3ExprCanBeNull(const Expr *p){ |
2495 | u8 op; |
2496 | assert( p!=0 ); |
2497 | while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ |
2498 | p = p->pLeft; |
2499 | assert( p!=0 ); |
2500 | } |
2501 | op = p->op; |
2502 | if( op==TK_REGISTER ) op = p->op2; |
2503 | switch( op ){ |
2504 | case TK_INTEGER: |
2505 | case TK_STRING: |
2506 | case TK_FLOAT: |
2507 | case TK_BLOB: |
2508 | return 0; |
2509 | case TK_COLUMN: |
2510 | assert( ExprUseYTab(p) ); |
2511 | return ExprHasProperty(p, EP_CanBeNull) || |
2512 | p->y.pTab==0 || /* Reference to column of index on expression */ |
2513 | (p->iColumn>=0 |
2514 | && p->y.pTab->aCol!=0 /* Possible due to prior error */ |
2515 | && p->y.pTab->aCol[p->iColumn].notNull==0); |
2516 | default: |
2517 | return 1; |
2518 | } |
2519 | } |
2520 | |
2521 | /* |
2522 | ** Return TRUE if the given expression is a constant which would be |
2523 | ** unchanged by OP_Affinity with the affinity given in the second |
2524 | ** argument. |
2525 | ** |
2526 | ** This routine is used to determine if the OP_Affinity operation |
2527 | ** can be omitted. When in doubt return FALSE. A false negative |
2528 | ** is harmless. A false positive, however, can result in the wrong |
2529 | ** answer. |
2530 | */ |
2531 | int sqlite3ExprNeedsNoAffinityChange(const Expr *p, char aff){ |
2532 | u8 op; |
2533 | int unaryMinus = 0; |
2534 | if( aff==SQLITE_AFF_BLOB ) return 1; |
2535 | while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ |
2536 | if( p->op==TK_UMINUS ) unaryMinus = 1; |
2537 | p = p->pLeft; |
2538 | } |
2539 | op = p->op; |
2540 | if( op==TK_REGISTER ) op = p->op2; |
2541 | switch( op ){ |
2542 | case TK_INTEGER: { |
2543 | return aff>=SQLITE_AFF_NUMERIC; |
2544 | } |
2545 | case TK_FLOAT: { |
2546 | return aff>=SQLITE_AFF_NUMERIC; |
2547 | } |
2548 | case TK_STRING: { |
2549 | return !unaryMinus && aff==SQLITE_AFF_TEXT; |
2550 | } |
2551 | case TK_BLOB: { |
2552 | return !unaryMinus; |
2553 | } |
2554 | case TK_COLUMN: { |
2555 | assert( p->iTable>=0 ); /* p cannot be part of a CHECK constraint */ |
2556 | return aff>=SQLITE_AFF_NUMERIC && p->iColumn<0; |
2557 | } |
2558 | default: { |
2559 | return 0; |
2560 | } |
2561 | } |
2562 | } |
2563 | |
2564 | /* |
2565 | ** Return TRUE if the given string is a row-id column name. |
2566 | */ |
2567 | int sqlite3IsRowid(const char *z){ |
2568 | if( sqlite3StrICmp(z, "_ROWID_" )==0 ) return 1; |
2569 | if( sqlite3StrICmp(z, "ROWID" )==0 ) return 1; |
2570 | if( sqlite3StrICmp(z, "OID" )==0 ) return 1; |
2571 | return 0; |
2572 | } |
2573 | |
2574 | /* |
2575 | ** pX is the RHS of an IN operator. If pX is a SELECT statement |
2576 | ** that can be simplified to a direct table access, then return |
2577 | ** a pointer to the SELECT statement. If pX is not a SELECT statement, |
2578 | ** or if the SELECT statement needs to be manifested into a transient |
2579 | ** table, then return NULL. |
2580 | */ |
2581 | #ifndef SQLITE_OMIT_SUBQUERY |
2582 | static Select *isCandidateForInOpt(const Expr *pX){ |
2583 | Select *p; |
2584 | SrcList *pSrc; |
2585 | ExprList *pEList; |
2586 | Table *pTab; |
2587 | int i; |
2588 | if( !ExprUseXSelect(pX) ) return 0; /* Not a subquery */ |
2589 | if( ExprHasProperty(pX, EP_VarSelect) ) return 0; /* Correlated subq */ |
2590 | p = pX->x.pSelect; |
2591 | if( p->pPrior ) return 0; /* Not a compound SELECT */ |
2592 | if( p->selFlags & (SF_Distinct|SF_Aggregate) ){ |
2593 | testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct ); |
2594 | testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate ); |
2595 | return 0; /* No DISTINCT keyword and no aggregate functions */ |
2596 | } |
2597 | assert( p->pGroupBy==0 ); /* Has no GROUP BY clause */ |
2598 | if( p->pLimit ) return 0; /* Has no LIMIT clause */ |
2599 | if( p->pWhere ) return 0; /* Has no WHERE clause */ |
2600 | pSrc = p->pSrc; |
2601 | assert( pSrc!=0 ); |
2602 | if( pSrc->nSrc!=1 ) return 0; /* Single term in FROM clause */ |
2603 | if( pSrc->a[0].pSelect ) return 0; /* FROM is not a subquery or view */ |
2604 | pTab = pSrc->a[0].pTab; |
2605 | assert( pTab!=0 ); |
2606 | assert( !IsView(pTab) ); /* FROM clause is not a view */ |
2607 | if( IsVirtual(pTab) ) return 0; /* FROM clause not a virtual table */ |
2608 | pEList = p->pEList; |
2609 | assert( pEList!=0 ); |
2610 | /* All SELECT results must be columns. */ |
2611 | for(i=0; i<pEList->nExpr; i++){ |
2612 | Expr *pRes = pEList->a[i].pExpr; |
2613 | if( pRes->op!=TK_COLUMN ) return 0; |
2614 | assert( pRes->iTable==pSrc->a[0].iCursor ); /* Not a correlated subquery */ |
2615 | } |
2616 | return p; |
2617 | } |
2618 | #endif /* SQLITE_OMIT_SUBQUERY */ |
2619 | |
2620 | #ifndef SQLITE_OMIT_SUBQUERY |
2621 | /* |
2622 | ** Generate code that checks the left-most column of index table iCur to see if |
2623 | ** it contains any NULL entries. Cause the register at regHasNull to be set |
2624 | ** to a non-NULL value if iCur contains no NULLs. Cause register regHasNull |
2625 | ** to be set to NULL if iCur contains one or more NULL values. |
2626 | */ |
2627 | static void sqlite3SetHasNullFlag(Vdbe *v, int iCur, int regHasNull){ |
2628 | int addr1; |
2629 | sqlite3VdbeAddOp2(v, OP_Integer, 0, regHasNull); |
2630 | addr1 = sqlite3VdbeAddOp1(v, OP_Rewind, iCur); VdbeCoverage(v); |
2631 | sqlite3VdbeAddOp3(v, OP_Column, iCur, 0, regHasNull); |
2632 | sqlite3VdbeChangeP5(v, OPFLAG_TYPEOFARG); |
2633 | VdbeComment((v, "first_entry_in(%d)" , iCur)); |
2634 | sqlite3VdbeJumpHere(v, addr1); |
2635 | } |
2636 | #endif |
2637 | |
2638 | |
2639 | #ifndef SQLITE_OMIT_SUBQUERY |
2640 | /* |
2641 | ** The argument is an IN operator with a list (not a subquery) on the |
2642 | ** right-hand side. Return TRUE if that list is constant. |
2643 | */ |
2644 | static int sqlite3InRhsIsConstant(Expr *pIn){ |
2645 | Expr *pLHS; |
2646 | int res; |
2647 | assert( !ExprHasProperty(pIn, EP_xIsSelect) ); |
2648 | pLHS = pIn->pLeft; |
2649 | pIn->pLeft = 0; |
2650 | res = sqlite3ExprIsConstant(pIn); |
2651 | pIn->pLeft = pLHS; |
2652 | return res; |
2653 | } |
2654 | #endif |
2655 | |
2656 | /* |
2657 | ** This function is used by the implementation of the IN (...) operator. |
2658 | ** The pX parameter is the expression on the RHS of the IN operator, which |
2659 | ** might be either a list of expressions or a subquery. |
2660 | ** |
2661 | ** The job of this routine is to find or create a b-tree object that can |
2662 | ** be used either to test for membership in the RHS set or to iterate through |
2663 | ** all members of the RHS set, skipping duplicates. |
2664 | ** |
2665 | ** A cursor is opened on the b-tree object that is the RHS of the IN operator |
2666 | ** and the *piTab parameter is set to the index of that cursor. |
2667 | ** |
2668 | ** The returned value of this function indicates the b-tree type, as follows: |
2669 | ** |
2670 | ** IN_INDEX_ROWID - The cursor was opened on a database table. |
2671 | ** IN_INDEX_INDEX_ASC - The cursor was opened on an ascending index. |
2672 | ** IN_INDEX_INDEX_DESC - The cursor was opened on a descending index. |
2673 | ** IN_INDEX_EPH - The cursor was opened on a specially created and |
2674 | ** populated epheremal table. |
2675 | ** IN_INDEX_NOOP - No cursor was allocated. The IN operator must be |
2676 | ** implemented as a sequence of comparisons. |
2677 | ** |
2678 | ** An existing b-tree might be used if the RHS expression pX is a simple |
2679 | ** subquery such as: |
2680 | ** |
2681 | ** SELECT <column1>, <column2>... FROM <table> |
2682 | ** |
2683 | ** If the RHS of the IN operator is a list or a more complex subquery, then |
2684 | ** an ephemeral table might need to be generated from the RHS and then |
2685 | ** pX->iTable made to point to the ephemeral table instead of an |
2686 | ** existing table. In this case, the creation and initialization of the |
2687 | ** ephmeral table might be put inside of a subroutine, the EP_Subrtn flag |
2688 | ** will be set on pX and the pX->y.sub fields will be set to show where |
2689 | ** the subroutine is coded. |
2690 | ** |
2691 | ** The inFlags parameter must contain, at a minimum, one of the bits |
2692 | ** IN_INDEX_MEMBERSHIP or IN_INDEX_LOOP but not both. If inFlags contains |
2693 | ** IN_INDEX_MEMBERSHIP, then the generated table will be used for a fast |
2694 | ** membership test. When the IN_INDEX_LOOP bit is set, the IN index will |
2695 | ** be used to loop over all values of the RHS of the IN operator. |
2696 | ** |
2697 | ** When IN_INDEX_LOOP is used (and the b-tree will be used to iterate |
2698 | ** through the set members) then the b-tree must not contain duplicates. |
2699 | ** An epheremal table will be created unless the selected columns are guaranteed |
2700 | ** to be unique - either because it is an INTEGER PRIMARY KEY or due to |
2701 | ** a UNIQUE constraint or index. |
2702 | ** |
2703 | ** When IN_INDEX_MEMBERSHIP is used (and the b-tree will be used |
2704 | ** for fast set membership tests) then an epheremal table must |
2705 | ** be used unless <columns> is a single INTEGER PRIMARY KEY column or an |
2706 | ** index can be found with the specified <columns> as its left-most. |
2707 | ** |
2708 | ** If the IN_INDEX_NOOP_OK and IN_INDEX_MEMBERSHIP are both set and |
2709 | ** if the RHS of the IN operator is a list (not a subquery) then this |
2710 | ** routine might decide that creating an ephemeral b-tree for membership |
2711 | ** testing is too expensive and return IN_INDEX_NOOP. In that case, the |
2712 | ** calling routine should implement the IN operator using a sequence |
2713 | ** of Eq or Ne comparison operations. |
2714 | ** |
2715 | ** When the b-tree is being used for membership tests, the calling function |
2716 | ** might need to know whether or not the RHS side of the IN operator |
2717 | ** contains a NULL. If prRhsHasNull is not a NULL pointer and |
2718 | ** if there is any chance that the (...) might contain a NULL value at |
2719 | ** runtime, then a register is allocated and the register number written |
2720 | ** to *prRhsHasNull. If there is no chance that the (...) contains a |
2721 | ** NULL value, then *prRhsHasNull is left unchanged. |
2722 | ** |
2723 | ** If a register is allocated and its location stored in *prRhsHasNull, then |
2724 | ** the value in that register will be NULL if the b-tree contains one or more |
2725 | ** NULL values, and it will be some non-NULL value if the b-tree contains no |
2726 | ** NULL values. |
2727 | ** |
2728 | ** If the aiMap parameter is not NULL, it must point to an array containing |
2729 | ** one element for each column returned by the SELECT statement on the RHS |
2730 | ** of the IN(...) operator. The i'th entry of the array is populated with the |
2731 | ** offset of the index column that matches the i'th column returned by the |
2732 | ** SELECT. For example, if the expression and selected index are: |
2733 | ** |
2734 | ** (?,?,?) IN (SELECT a, b, c FROM t1) |
2735 | ** CREATE INDEX i1 ON t1(b, c, a); |
2736 | ** |
2737 | ** then aiMap[] is populated with {2, 0, 1}. |
2738 | */ |
2739 | #ifndef SQLITE_OMIT_SUBQUERY |
2740 | int sqlite3FindInIndex( |
2741 | Parse *pParse, /* Parsing context */ |
2742 | Expr *pX, /* The IN expression */ |
2743 | u32 inFlags, /* IN_INDEX_LOOP, _MEMBERSHIP, and/or _NOOP_OK */ |
2744 | int *prRhsHasNull, /* Register holding NULL status. See notes */ |
2745 | int *aiMap, /* Mapping from Index fields to RHS fields */ |
2746 | int *piTab /* OUT: index to use */ |
2747 | ){ |
2748 | Select *p; /* SELECT to the right of IN operator */ |
2749 | int eType = 0; /* Type of RHS table. IN_INDEX_* */ |
2750 | int iTab; /* Cursor of the RHS table */ |
2751 | int mustBeUnique; /* True if RHS must be unique */ |
2752 | Vdbe *v = sqlite3GetVdbe(pParse); /* Virtual machine being coded */ |
2753 | |
2754 | assert( pX->op==TK_IN ); |
2755 | mustBeUnique = (inFlags & IN_INDEX_LOOP)!=0; |
2756 | iTab = pParse->nTab++; |
2757 | |
2758 | /* If the RHS of this IN(...) operator is a SELECT, and if it matters |
2759 | ** whether or not the SELECT result contains NULL values, check whether |
2760 | ** or not NULL is actually possible (it may not be, for example, due |
2761 | ** to NOT NULL constraints in the schema). If no NULL values are possible, |
2762 | ** set prRhsHasNull to 0 before continuing. */ |
2763 | if( prRhsHasNull && ExprUseXSelect(pX) ){ |
2764 | int i; |
2765 | ExprList *pEList = pX->x.pSelect->pEList; |
2766 | for(i=0; i<pEList->nExpr; i++){ |
2767 | if( sqlite3ExprCanBeNull(pEList->a[i].pExpr) ) break; |
2768 | } |
2769 | if( i==pEList->nExpr ){ |
2770 | prRhsHasNull = 0; |
2771 | } |
2772 | } |
2773 | |
2774 | /* Check to see if an existing table or index can be used to |
2775 | ** satisfy the query. This is preferable to generating a new |
2776 | ** ephemeral table. */ |
2777 | if( pParse->nErr==0 && (p = isCandidateForInOpt(pX))!=0 ){ |
2778 | sqlite3 *db = pParse->db; /* Database connection */ |
2779 | Table *pTab; /* Table <table>. */ |
2780 | int iDb; /* Database idx for pTab */ |
2781 | ExprList *pEList = p->pEList; |
2782 | int nExpr = pEList->nExpr; |
2783 | |
2784 | assert( p->pEList!=0 ); /* Because of isCandidateForInOpt(p) */ |
2785 | assert( p->pEList->a[0].pExpr!=0 ); /* Because of isCandidateForInOpt(p) */ |
2786 | assert( p->pSrc!=0 ); /* Because of isCandidateForInOpt(p) */ |
2787 | pTab = p->pSrc->a[0].pTab; |
2788 | |
2789 | /* Code an OP_Transaction and OP_TableLock for <table>. */ |
2790 | iDb = sqlite3SchemaToIndex(db, pTab->pSchema); |
2791 | assert( iDb>=0 && iDb<SQLITE_MAX_DB ); |
2792 | sqlite3CodeVerifySchema(pParse, iDb); |
2793 | sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName); |
2794 | |
2795 | assert(v); /* sqlite3GetVdbe() has always been previously called */ |
2796 | if( nExpr==1 && pEList->a[0].pExpr->iColumn<0 ){ |
2797 | /* The "x IN (SELECT rowid FROM table)" case */ |
2798 | int iAddr = sqlite3VdbeAddOp0(v, OP_Once); |
2799 | VdbeCoverage(v); |
2800 | |
2801 | sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead); |
2802 | eType = IN_INDEX_ROWID; |
2803 | ExplainQueryPlan((pParse, 0, |
2804 | "USING ROWID SEARCH ON TABLE %s FOR IN-OPERATOR" ,pTab->zName)); |
2805 | sqlite3VdbeJumpHere(v, iAddr); |
2806 | }else{ |
2807 | Index *pIdx; /* Iterator variable */ |
2808 | int affinity_ok = 1; |
2809 | int i; |
2810 | |
2811 | /* Check that the affinity that will be used to perform each |
2812 | ** comparison is the same as the affinity of each column in table |
2813 | ** on the RHS of the IN operator. If it not, it is not possible to |
2814 | ** use any index of the RHS table. */ |
2815 | for(i=0; i<nExpr && affinity_ok; i++){ |
2816 | Expr *pLhs = sqlite3VectorFieldSubexpr(pX->pLeft, i); |
2817 | int iCol = pEList->a[i].pExpr->iColumn; |
2818 | char idxaff = sqlite3TableColumnAffinity(pTab,iCol); /* RHS table */ |
2819 | char cmpaff = sqlite3CompareAffinity(pLhs, idxaff); |
2820 | testcase( cmpaff==SQLITE_AFF_BLOB ); |
2821 | testcase( cmpaff==SQLITE_AFF_TEXT ); |
2822 | switch( cmpaff ){ |
2823 | case SQLITE_AFF_BLOB: |
2824 | break; |
2825 | case SQLITE_AFF_TEXT: |
2826 | /* sqlite3CompareAffinity() only returns TEXT if one side or the |
2827 | ** other has no affinity and the other side is TEXT. Hence, |
2828 | ** the only way for cmpaff to be TEXT is for idxaff to be TEXT |
2829 | ** and for the term on the LHS of the IN to have no affinity. */ |
2830 | assert( idxaff==SQLITE_AFF_TEXT ); |
2831 | break; |
2832 | default: |
2833 | affinity_ok = sqlite3IsNumericAffinity(idxaff); |
2834 | } |
2835 | } |
2836 | |
2837 | if( affinity_ok ){ |
2838 | /* Search for an existing index that will work for this IN operator */ |
2839 | for(pIdx=pTab->pIndex; pIdx && eType==0; pIdx=pIdx->pNext){ |
2840 | Bitmask colUsed; /* Columns of the index used */ |
2841 | Bitmask mCol; /* Mask for the current column */ |
2842 | if( pIdx->nColumn<nExpr ) continue; |
2843 | if( pIdx->pPartIdxWhere!=0 ) continue; |
2844 | /* Maximum nColumn is BMS-2, not BMS-1, so that we can compute |
2845 | ** BITMASK(nExpr) without overflowing */ |
2846 | testcase( pIdx->nColumn==BMS-2 ); |
2847 | testcase( pIdx->nColumn==BMS-1 ); |
2848 | if( pIdx->nColumn>=BMS-1 ) continue; |
2849 | if( mustBeUnique ){ |
2850 | if( pIdx->nKeyCol>nExpr |
2851 | ||(pIdx->nColumn>nExpr && !IsUniqueIndex(pIdx)) |
2852 | ){ |
2853 | continue; /* This index is not unique over the IN RHS columns */ |
2854 | } |
2855 | } |
2856 | |
2857 | colUsed = 0; /* Columns of index used so far */ |
2858 | for(i=0; i<nExpr; i++){ |
2859 | Expr *pLhs = sqlite3VectorFieldSubexpr(pX->pLeft, i); |
2860 | Expr *pRhs = pEList->a[i].pExpr; |
2861 | CollSeq *pReq = sqlite3BinaryCompareCollSeq(pParse, pLhs, pRhs); |
2862 | int j; |
2863 | |
2864 | assert( pReq!=0 || pRhs->iColumn==XN_ROWID || pParse->nErr ); |
2865 | for(j=0; j<nExpr; j++){ |
2866 | if( pIdx->aiColumn[j]!=pRhs->iColumn ) continue; |
2867 | assert( pIdx->azColl[j] ); |
2868 | if( pReq!=0 && sqlite3StrICmp(pReq->zName, pIdx->azColl[j])!=0 ){ |
2869 | continue; |
2870 | } |
2871 | break; |
2872 | } |
2873 | if( j==nExpr ) break; |
2874 | mCol = MASKBIT(j); |
2875 | if( mCol & colUsed ) break; /* Each column used only once */ |
2876 | colUsed |= mCol; |
2877 | if( aiMap ) aiMap[i] = j; |
2878 | } |
2879 | |
2880 | assert( i==nExpr || colUsed!=(MASKBIT(nExpr)-1) ); |
2881 | if( colUsed==(MASKBIT(nExpr)-1) ){ |
2882 | /* If we reach this point, that means the index pIdx is usable */ |
2883 | int iAddr = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); |
2884 | ExplainQueryPlan((pParse, 0, |
2885 | "USING INDEX %s FOR IN-OPERATOR" ,pIdx->zName)); |
2886 | sqlite3VdbeAddOp3(v, OP_OpenRead, iTab, pIdx->tnum, iDb); |
2887 | sqlite3VdbeSetP4KeyInfo(pParse, pIdx); |
2888 | VdbeComment((v, "%s" , pIdx->zName)); |
2889 | assert( IN_INDEX_INDEX_DESC == IN_INDEX_INDEX_ASC+1 ); |
2890 | eType = IN_INDEX_INDEX_ASC + pIdx->aSortOrder[0]; |
2891 | |
2892 | if( prRhsHasNull ){ |
2893 | #ifdef SQLITE_ENABLE_COLUMN_USED_MASK |
2894 | i64 mask = (1<<nExpr)-1; |
2895 | sqlite3VdbeAddOp4Dup8(v, OP_ColumnsUsed, |
2896 | iTab, 0, 0, (u8*)&mask, P4_INT64); |
2897 | #endif |
2898 | *prRhsHasNull = ++pParse->nMem; |
2899 | if( nExpr==1 ){ |
2900 | sqlite3SetHasNullFlag(v, iTab, *prRhsHasNull); |
2901 | } |
2902 | } |
2903 | sqlite3VdbeJumpHere(v, iAddr); |
2904 | } |
2905 | } /* End loop over indexes */ |
2906 | } /* End if( affinity_ok ) */ |
2907 | } /* End if not an rowid index */ |
2908 | } /* End attempt to optimize using an index */ |
2909 | |
2910 | /* If no preexisting index is available for the IN clause |
2911 | ** and IN_INDEX_NOOP is an allowed reply |
2912 | ** and the RHS of the IN operator is a list, not a subquery |
2913 | ** and the RHS is not constant or has two or fewer terms, |
2914 | ** then it is not worth creating an ephemeral table to evaluate |
2915 | ** the IN operator so return IN_INDEX_NOOP. |
2916 | */ |
2917 | if( eType==0 |
2918 | && (inFlags & IN_INDEX_NOOP_OK) |
2919 | && ExprUseXList(pX) |
2920 | && (!sqlite3InRhsIsConstant(pX) || pX->x.pList->nExpr<=2) |
2921 | ){ |
2922 | pParse->nTab--; /* Back out the allocation of the unused cursor */ |
2923 | iTab = -1; /* Cursor is not allocated */ |
2924 | eType = IN_INDEX_NOOP; |
2925 | } |
2926 | |
2927 | if( eType==0 ){ |
2928 | /* Could not find an existing table or index to use as the RHS b-tree. |
2929 | ** We will have to generate an ephemeral table to do the job. |
2930 | */ |
2931 | u32 savedNQueryLoop = pParse->nQueryLoop; |
2932 | int rMayHaveNull = 0; |
2933 | eType = IN_INDEX_EPH; |
2934 | if( inFlags & IN_INDEX_LOOP ){ |
2935 | pParse->nQueryLoop = 0; |
2936 | }else if( prRhsHasNull ){ |
2937 | *prRhsHasNull = rMayHaveNull = ++pParse->nMem; |
2938 | } |
2939 | assert( pX->op==TK_IN ); |
2940 | sqlite3CodeRhsOfIN(pParse, pX, iTab); |
2941 | if( rMayHaveNull ){ |
2942 | sqlite3SetHasNullFlag(v, iTab, rMayHaveNull); |
2943 | } |
2944 | pParse->nQueryLoop = savedNQueryLoop; |
2945 | } |
2946 | |
2947 | if( aiMap && eType!=IN_INDEX_INDEX_ASC && eType!=IN_INDEX_INDEX_DESC ){ |
2948 | int i, n; |
2949 | n = sqlite3ExprVectorSize(pX->pLeft); |
2950 | for(i=0; i<n; i++) aiMap[i] = i; |
2951 | } |
2952 | *piTab = iTab; |
2953 | return eType; |
2954 | } |
2955 | #endif |
2956 | |
2957 | #ifndef SQLITE_OMIT_SUBQUERY |
2958 | /* |
2959 | ** Argument pExpr is an (?, ?...) IN(...) expression. This |
2960 | ** function allocates and returns a nul-terminated string containing |
2961 | ** the affinities to be used for each column of the comparison. |
2962 | ** |
2963 | ** It is the responsibility of the caller to ensure that the returned |
2964 | ** string is eventually freed using sqlite3DbFree(). |
2965 | */ |
2966 | static char *exprINAffinity(Parse *pParse, const Expr *pExpr){ |
2967 | Expr *pLeft = pExpr->pLeft; |
2968 | int nVal = sqlite3ExprVectorSize(pLeft); |
2969 | Select *pSelect = ExprUseXSelect(pExpr) ? pExpr->x.pSelect : 0; |
2970 | char *zRet; |
2971 | |
2972 | assert( pExpr->op==TK_IN ); |
2973 | zRet = sqlite3DbMallocRaw(pParse->db, nVal+1); |
2974 | if( zRet ){ |
2975 | int i; |
2976 | for(i=0; i<nVal; i++){ |
2977 | Expr *pA = sqlite3VectorFieldSubexpr(pLeft, i); |
2978 | char a = sqlite3ExprAffinity(pA); |
2979 | if( pSelect ){ |
2980 | zRet[i] = sqlite3CompareAffinity(pSelect->pEList->a[i].pExpr, a); |
2981 | }else{ |
2982 | zRet[i] = a; |
2983 | } |
2984 | } |
2985 | zRet[nVal] = '\0'; |
2986 | } |
2987 | return zRet; |
2988 | } |
2989 | #endif |
2990 | |
2991 | #ifndef SQLITE_OMIT_SUBQUERY |
2992 | /* |
2993 | ** Load the Parse object passed as the first argument with an error |
2994 | ** message of the form: |
2995 | ** |
2996 | ** "sub-select returns N columns - expected M" |
2997 | */ |
2998 | void sqlite3SubselectError(Parse *pParse, int nActual, int nExpect){ |
2999 | if( pParse->nErr==0 ){ |
3000 | const char *zFmt = "sub-select returns %d columns - expected %d" ; |
3001 | sqlite3ErrorMsg(pParse, zFmt, nActual, nExpect); |
3002 | } |
3003 | } |
3004 | #endif |
3005 | |
3006 | /* |
3007 | ** Expression pExpr is a vector that has been used in a context where |
3008 | ** it is not permitted. If pExpr is a sub-select vector, this routine |
3009 | ** loads the Parse object with a message of the form: |
3010 | ** |
3011 | ** "sub-select returns N columns - expected 1" |
3012 | ** |
3013 | ** Or, if it is a regular scalar vector: |
3014 | ** |
3015 | ** "row value misused" |
3016 | */ |
3017 | void sqlite3VectorErrorMsg(Parse *pParse, Expr *pExpr){ |
3018 | #ifndef SQLITE_OMIT_SUBQUERY |
3019 | if( ExprUseXSelect(pExpr) ){ |
3020 | sqlite3SubselectError(pParse, pExpr->x.pSelect->pEList->nExpr, 1); |
3021 | }else |
3022 | #endif |
3023 | { |
3024 | sqlite3ErrorMsg(pParse, "row value misused" ); |
3025 | } |
3026 | } |
3027 | |
3028 | #ifndef SQLITE_OMIT_SUBQUERY |
3029 | /* |
3030 | ** Generate code that will construct an ephemeral table containing all terms |
3031 | ** in the RHS of an IN operator. The IN operator can be in either of two |
3032 | ** forms: |
3033 | ** |
3034 | ** x IN (4,5,11) -- IN operator with list on right-hand side |
3035 | ** x IN (SELECT a FROM b) -- IN operator with subquery on the right |
3036 | ** |
3037 | ** The pExpr parameter is the IN operator. The cursor number for the |
3038 | ** constructed ephermeral table is returned. The first time the ephemeral |
3039 | ** table is computed, the cursor number is also stored in pExpr->iTable, |
3040 | ** however the cursor number returned might not be the same, as it might |
3041 | ** have been duplicated using OP_OpenDup. |
3042 | ** |
3043 | ** If the LHS expression ("x" in the examples) is a column value, or |
3044 | ** the SELECT statement returns a column value, then the affinity of that |
3045 | ** column is used to build the index keys. If both 'x' and the |
3046 | ** SELECT... statement are columns, then numeric affinity is used |
3047 | ** if either column has NUMERIC or INTEGER affinity. If neither |
3048 | ** 'x' nor the SELECT... statement are columns, then numeric affinity |
3049 | ** is used. |
3050 | */ |
3051 | void sqlite3CodeRhsOfIN( |
3052 | Parse *pParse, /* Parsing context */ |
3053 | Expr *pExpr, /* The IN operator */ |
3054 | int iTab /* Use this cursor number */ |
3055 | ){ |
3056 | int addrOnce = 0; /* Address of the OP_Once instruction at top */ |
3057 | int addr; /* Address of OP_OpenEphemeral instruction */ |
3058 | Expr *pLeft; /* the LHS of the IN operator */ |
3059 | KeyInfo *pKeyInfo = 0; /* Key information */ |
3060 | int nVal; /* Size of vector pLeft */ |
3061 | Vdbe *v; /* The prepared statement under construction */ |
3062 | |
3063 | v = pParse->pVdbe; |
3064 | assert( v!=0 ); |
3065 | |
3066 | /* The evaluation of the IN must be repeated every time it |
3067 | ** is encountered if any of the following is true: |
3068 | ** |
3069 | ** * The right-hand side is a correlated subquery |
3070 | ** * The right-hand side is an expression list containing variables |
3071 | ** * We are inside a trigger |
3072 | ** |
3073 | ** If all of the above are false, then we can compute the RHS just once |
3074 | ** and reuse it many names. |
3075 | */ |
3076 | if( !ExprHasProperty(pExpr, EP_VarSelect) && pParse->iSelfTab==0 ){ |
3077 | /* Reuse of the RHS is allowed */ |
3078 | /* If this routine has already been coded, but the previous code |
3079 | ** might not have been invoked yet, so invoke it now as a subroutine. |
3080 | */ |
3081 | if( ExprHasProperty(pExpr, EP_Subrtn) ){ |
3082 | addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); |
3083 | if( ExprUseXSelect(pExpr) ){ |
3084 | ExplainQueryPlan((pParse, 0, "REUSE LIST SUBQUERY %d" , |
3085 | pExpr->x.pSelect->selId)); |
3086 | } |
3087 | assert( ExprUseYSub(pExpr) ); |
3088 | sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn, |
3089 | pExpr->y.sub.iAddr); |
3090 | assert( iTab!=pExpr->iTable ); |
3091 | sqlite3VdbeAddOp2(v, OP_OpenDup, iTab, pExpr->iTable); |
3092 | sqlite3VdbeJumpHere(v, addrOnce); |
3093 | return; |
3094 | } |
3095 | |
3096 | /* Begin coding the subroutine */ |
3097 | assert( !ExprUseYWin(pExpr) ); |
3098 | ExprSetProperty(pExpr, EP_Subrtn); |
3099 | assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) ); |
3100 | pExpr->y.sub.regReturn = ++pParse->nMem; |
3101 | pExpr->y.sub.iAddr = |
3102 | sqlite3VdbeAddOp2(v, OP_BeginSubrtn, 0, pExpr->y.sub.regReturn) + 1; |
3103 | |
3104 | addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); |
3105 | } |
3106 | |
3107 | /* Check to see if this is a vector IN operator */ |
3108 | pLeft = pExpr->pLeft; |
3109 | nVal = sqlite3ExprVectorSize(pLeft); |
3110 | |
3111 | /* Construct the ephemeral table that will contain the content of |
3112 | ** RHS of the IN operator. |
3113 | */ |
3114 | pExpr->iTable = iTab; |
3115 | addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, nVal); |
3116 | #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS |
3117 | if( ExprUseXSelect(pExpr) ){ |
3118 | VdbeComment((v, "Result of SELECT %u" , pExpr->x.pSelect->selId)); |
3119 | }else{ |
3120 | VdbeComment((v, "RHS of IN operator" )); |
3121 | } |
3122 | #endif |
3123 | pKeyInfo = sqlite3KeyInfoAlloc(pParse->db, nVal, 1); |
3124 | |
3125 | if( ExprUseXSelect(pExpr) ){ |
3126 | /* Case 1: expr IN (SELECT ...) |
3127 | ** |
3128 | ** Generate code to write the results of the select into the temporary |
3129 | ** table allocated and opened above. |
3130 | */ |
3131 | Select *pSelect = pExpr->x.pSelect; |
3132 | ExprList *pEList = pSelect->pEList; |
3133 | |
3134 | ExplainQueryPlan((pParse, 1, "%sLIST SUBQUERY %d" , |
3135 | addrOnce?"" :"CORRELATED " , pSelect->selId |
3136 | )); |
3137 | /* If the LHS and RHS of the IN operator do not match, that |
3138 | ** error will have been caught long before we reach this point. */ |
3139 | if( ALWAYS(pEList->nExpr==nVal) ){ |
3140 | Select *pCopy; |
3141 | SelectDest dest; |
3142 | int i; |
3143 | int rc; |
3144 | sqlite3SelectDestInit(&dest, SRT_Set, iTab); |
3145 | dest.zAffSdst = exprINAffinity(pParse, pExpr); |
3146 | pSelect->iLimit = 0; |
3147 | testcase( pSelect->selFlags & SF_Distinct ); |
3148 | testcase( pKeyInfo==0 ); /* Caused by OOM in sqlite3KeyInfoAlloc() */ |
3149 | pCopy = sqlite3SelectDup(pParse->db, pSelect, 0); |
3150 | rc = pParse->db->mallocFailed ? 1 :sqlite3Select(pParse, pCopy, &dest); |
3151 | sqlite3SelectDelete(pParse->db, pCopy); |
3152 | sqlite3DbFree(pParse->db, dest.zAffSdst); |
3153 | if( rc ){ |
3154 | sqlite3KeyInfoUnref(pKeyInfo); |
3155 | return; |
3156 | } |
3157 | assert( pKeyInfo!=0 ); /* OOM will cause exit after sqlite3Select() */ |
3158 | assert( pEList!=0 ); |
3159 | assert( pEList->nExpr>0 ); |
3160 | assert( sqlite3KeyInfoIsWriteable(pKeyInfo) ); |
3161 | for(i=0; i<nVal; i++){ |
3162 | Expr *p = sqlite3VectorFieldSubexpr(pLeft, i); |
3163 | pKeyInfo->aColl[i] = sqlite3BinaryCompareCollSeq( |
3164 | pParse, p, pEList->a[i].pExpr |
3165 | ); |
3166 | } |
3167 | } |
3168 | }else if( ALWAYS(pExpr->x.pList!=0) ){ |
3169 | /* Case 2: expr IN (exprlist) |
3170 | ** |
3171 | ** For each expression, build an index key from the evaluation and |
3172 | ** store it in the temporary table. If <expr> is a column, then use |
3173 | ** that columns affinity when building index keys. If <expr> is not |
3174 | ** a column, use numeric affinity. |
3175 | */ |
3176 | char affinity; /* Affinity of the LHS of the IN */ |
3177 | int i; |
3178 | ExprList *pList = pExpr->x.pList; |
3179 | struct ExprList_item *pItem; |
3180 | int r1, r2; |
3181 | affinity = sqlite3ExprAffinity(pLeft); |
3182 | if( affinity<=SQLITE_AFF_NONE ){ |
3183 | affinity = SQLITE_AFF_BLOB; |
3184 | }else if( affinity==SQLITE_AFF_REAL ){ |
3185 | affinity = SQLITE_AFF_NUMERIC; |
3186 | } |
3187 | if( pKeyInfo ){ |
3188 | assert( sqlite3KeyInfoIsWriteable(pKeyInfo) ); |
3189 | pKeyInfo->aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft); |
3190 | } |
3191 | |
3192 | /* Loop through each expression in <exprlist>. */ |
3193 | r1 = sqlite3GetTempReg(pParse); |
3194 | r2 = sqlite3GetTempReg(pParse); |
3195 | for(i=pList->nExpr, pItem=pList->a; i>0; i--, pItem++){ |
3196 | Expr *pE2 = pItem->pExpr; |
3197 | |
3198 | /* If the expression is not constant then we will need to |
3199 | ** disable the test that was generated above that makes sure |
3200 | ** this code only executes once. Because for a non-constant |
3201 | ** expression we need to rerun this code each time. |
3202 | */ |
3203 | if( addrOnce && !sqlite3ExprIsConstant(pE2) ){ |
3204 | sqlite3VdbeChangeToNoop(v, addrOnce-1); |
3205 | sqlite3VdbeChangeToNoop(v, addrOnce); |
3206 | ExprClearProperty(pExpr, EP_Subrtn); |
3207 | addrOnce = 0; |
3208 | } |
3209 | |
3210 | /* Evaluate the expression and insert it into the temp table */ |
3211 | sqlite3ExprCode(pParse, pE2, r1); |
3212 | sqlite3VdbeAddOp4(v, OP_MakeRecord, r1, 1, r2, &affinity, 1); |
3213 | sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iTab, r2, r1, 1); |
3214 | } |
3215 | sqlite3ReleaseTempReg(pParse, r1); |
3216 | sqlite3ReleaseTempReg(pParse, r2); |
3217 | } |
3218 | if( pKeyInfo ){ |
3219 | sqlite3VdbeChangeP4(v, addr, (void *)pKeyInfo, P4_KEYINFO); |
3220 | } |
3221 | if( addrOnce ){ |
3222 | sqlite3VdbeAddOp1(v, OP_NullRow, iTab); |
3223 | sqlite3VdbeJumpHere(v, addrOnce); |
3224 | /* Subroutine return */ |
3225 | assert( ExprUseYSub(pExpr) ); |
3226 | assert( sqlite3VdbeGetOp(v,pExpr->y.sub.iAddr-1)->opcode==OP_BeginSubrtn |
3227 | || pParse->nErr ); |
3228 | sqlite3VdbeAddOp3(v, OP_Return, pExpr->y.sub.regReturn, |
3229 | pExpr->y.sub.iAddr, 1); |
3230 | VdbeCoverage(v); |
3231 | sqlite3ClearTempRegCache(pParse); |
3232 | } |
3233 | } |
3234 | #endif /* SQLITE_OMIT_SUBQUERY */ |
3235 | |
3236 | /* |
3237 | ** Generate code for scalar subqueries used as a subquery expression |
3238 | ** or EXISTS operator: |
3239 | ** |
3240 | ** (SELECT a FROM b) -- subquery |
3241 | ** EXISTS (SELECT a FROM b) -- EXISTS subquery |
3242 | ** |
3243 | ** The pExpr parameter is the SELECT or EXISTS operator to be coded. |
3244 | ** |
3245 | ** Return the register that holds the result. For a multi-column SELECT, |
3246 | ** the result is stored in a contiguous array of registers and the |
3247 | ** return value is the register of the left-most result column. |
3248 | ** Return 0 if an error occurs. |
3249 | */ |
3250 | #ifndef SQLITE_OMIT_SUBQUERY |
3251 | int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){ |
3252 | int addrOnce = 0; /* Address of OP_Once at top of subroutine */ |
3253 | int rReg = 0; /* Register storing resulting */ |
3254 | Select *pSel; /* SELECT statement to encode */ |
3255 | SelectDest dest; /* How to deal with SELECT result */ |
3256 | int nReg; /* Registers to allocate */ |
3257 | Expr *pLimit; /* New limit expression */ |
3258 | |
3259 | Vdbe *v = pParse->pVdbe; |
3260 | assert( v!=0 ); |
3261 | if( pParse->nErr ) return 0; |
3262 | testcase( pExpr->op==TK_EXISTS ); |
3263 | testcase( pExpr->op==TK_SELECT ); |
3264 | assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT ); |
3265 | assert( ExprUseXSelect(pExpr) ); |
3266 | pSel = pExpr->x.pSelect; |
3267 | |
3268 | /* If this routine has already been coded, then invoke it as a |
3269 | ** subroutine. */ |
3270 | if( ExprHasProperty(pExpr, EP_Subrtn) ){ |
3271 | ExplainQueryPlan((pParse, 0, "REUSE SUBQUERY %d" , pSel->selId)); |
3272 | assert( ExprUseYSub(pExpr) ); |
3273 | sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn, |
3274 | pExpr->y.sub.iAddr); |
3275 | return pExpr->iTable; |
3276 | } |
3277 | |
3278 | /* Begin coding the subroutine */ |
3279 | assert( !ExprUseYWin(pExpr) ); |
3280 | assert( !ExprHasProperty(pExpr, EP_Reduced|EP_TokenOnly) ); |
3281 | ExprSetProperty(pExpr, EP_Subrtn); |
3282 | pExpr->y.sub.regReturn = ++pParse->nMem; |
3283 | pExpr->y.sub.iAddr = |
3284 | sqlite3VdbeAddOp2(v, OP_BeginSubrtn, 0, pExpr->y.sub.regReturn) + 1; |
3285 | |
3286 | /* The evaluation of the EXISTS/SELECT must be repeated every time it |
3287 | ** is encountered if any of the following is true: |
3288 | ** |
3289 | ** * The right-hand side is a correlated subquery |
3290 | ** * The right-hand side is an expression list containing variables |
3291 | ** * We are inside a trigger |
3292 | ** |
3293 | ** If all of the above are false, then we can run this code just once |
3294 | ** save the results, and reuse the same result on subsequent invocations. |
3295 | */ |
3296 | if( !ExprHasProperty(pExpr, EP_VarSelect) ){ |
3297 | addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); |
3298 | } |
3299 | |
3300 | /* For a SELECT, generate code to put the values for all columns of |
3301 | ** the first row into an array of registers and return the index of |
3302 | ** the first register. |
3303 | ** |
3304 | ** If this is an EXISTS, write an integer 0 (not exists) or 1 (exists) |
3305 | ** into a register and return that register number. |
3306 | ** |
3307 | ** In both cases, the query is augmented with "LIMIT 1". Any |
3308 | ** preexisting limit is discarded in place of the new LIMIT 1. |
3309 | */ |
3310 | ExplainQueryPlan((pParse, 1, "%sSCALAR SUBQUERY %d" , |
3311 | addrOnce?"" :"CORRELATED " , pSel->selId)); |
3312 | nReg = pExpr->op==TK_SELECT ? pSel->pEList->nExpr : 1; |
3313 | sqlite3SelectDestInit(&dest, 0, pParse->nMem+1); |
3314 | pParse->nMem += nReg; |
3315 | if( pExpr->op==TK_SELECT ){ |
3316 | dest.eDest = SRT_Mem; |
3317 | dest.iSdst = dest.iSDParm; |
3318 | dest.nSdst = nReg; |
3319 | sqlite3VdbeAddOp3(v, OP_Null, 0, dest.iSDParm, dest.iSDParm+nReg-1); |
3320 | VdbeComment((v, "Init subquery result" )); |
3321 | }else{ |
3322 | dest.eDest = SRT_Exists; |
3323 | sqlite3VdbeAddOp2(v, OP_Integer, 0, dest.iSDParm); |
3324 | VdbeComment((v, "Init EXISTS result" )); |
3325 | } |
3326 | if( pSel->pLimit ){ |
3327 | /* The subquery already has a limit. If the pre-existing limit is X |
3328 | ** then make the new limit X<>0 so that the new limit is either 1 or 0 */ |
3329 | sqlite3 *db = pParse->db; |
3330 | pLimit = sqlite3Expr(db, TK_INTEGER, "0" ); |
3331 | if( pLimit ){ |
3332 | pLimit->affExpr = SQLITE_AFF_NUMERIC; |
3333 | pLimit = sqlite3PExpr(pParse, TK_NE, |
3334 | sqlite3ExprDup(db, pSel->pLimit->pLeft, 0), pLimit); |
3335 | } |
3336 | sqlite3ExprDeferredDelete(pParse, pSel->pLimit->pLeft); |
3337 | pSel->pLimit->pLeft = pLimit; |
3338 | }else{ |
3339 | /* If there is no pre-existing limit add a limit of 1 */ |
3340 | pLimit = sqlite3Expr(pParse->db, TK_INTEGER, "1" ); |
3341 | pSel->pLimit = sqlite3PExpr(pParse, TK_LIMIT, pLimit, 0); |
3342 | } |
3343 | pSel->iLimit = 0; |
3344 | if( sqlite3Select(pParse, pSel, &dest) ){ |
3345 | pExpr->op2 = pExpr->op; |
3346 | pExpr->op = TK_ERROR; |
3347 | return 0; |
3348 | } |
3349 | pExpr->iTable = rReg = dest.iSDParm; |
3350 | ExprSetVVAProperty(pExpr, EP_NoReduce); |
3351 | if( addrOnce ){ |
3352 | sqlite3VdbeJumpHere(v, addrOnce); |
3353 | } |
3354 | |
3355 | /* Subroutine return */ |
3356 | assert( ExprUseYSub(pExpr) ); |
3357 | assert( sqlite3VdbeGetOp(v,pExpr->y.sub.iAddr-1)->opcode==OP_BeginSubrtn |
3358 | || pParse->nErr ); |
3359 | sqlite3VdbeAddOp3(v, OP_Return, pExpr->y.sub.regReturn, |
3360 | pExpr->y.sub.iAddr, 1); |
3361 | VdbeCoverage(v); |
3362 | sqlite3ClearTempRegCache(pParse); |
3363 | return rReg; |
3364 | } |
3365 | #endif /* SQLITE_OMIT_SUBQUERY */ |
3366 | |
3367 | #ifndef SQLITE_OMIT_SUBQUERY |
3368 | /* |
3369 | ** Expr pIn is an IN(...) expression. This function checks that the |
3370 | ** sub-select on the RHS of the IN() operator has the same number of |
3371 | ** columns as the vector on the LHS. Or, if the RHS of the IN() is not |
3372 | ** a sub-query, that the LHS is a vector of size 1. |
3373 | */ |
3374 | int sqlite3ExprCheckIN(Parse *pParse, Expr *pIn){ |
3375 | int nVector = sqlite3ExprVectorSize(pIn->pLeft); |
3376 | if( ExprUseXSelect(pIn) && !pParse->db->mallocFailed ){ |
3377 | if( nVector!=pIn->x.pSelect->pEList->nExpr ){ |
3378 | sqlite3SubselectError(pParse, pIn->x.pSelect->pEList->nExpr, nVector); |
3379 | return 1; |
3380 | } |
3381 | }else if( nVector!=1 ){ |
3382 | sqlite3VectorErrorMsg(pParse, pIn->pLeft); |
3383 | return 1; |
3384 | } |
3385 | return 0; |
3386 | } |
3387 | #endif |
3388 | |
3389 | #ifndef SQLITE_OMIT_SUBQUERY |
3390 | /* |
3391 | ** Generate code for an IN expression. |
3392 | ** |
3393 | ** x IN (SELECT ...) |
3394 | ** x IN (value, value, ...) |
3395 | ** |
3396 | ** The left-hand side (LHS) is a scalar or vector expression. The |
3397 | ** right-hand side (RHS) is an array of zero or more scalar values, or a |
3398 | ** subquery. If the RHS is a subquery, the number of result columns must |
3399 | ** match the number of columns in the vector on the LHS. If the RHS is |
3400 | ** a list of values, the LHS must be a scalar. |
3401 | ** |
3402 | ** The IN operator is true if the LHS value is contained within the RHS. |
3403 | ** The result is false if the LHS is definitely not in the RHS. The |
3404 | ** result is NULL if the presence of the LHS in the RHS cannot be |
3405 | ** determined due to NULLs. |
3406 | ** |
3407 | ** This routine generates code that jumps to destIfFalse if the LHS is not |
3408 | ** contained within the RHS. If due to NULLs we cannot determine if the LHS |
3409 | ** is contained in the RHS then jump to destIfNull. If the LHS is contained |
3410 | ** within the RHS then fall through. |
3411 | ** |
3412 | ** See the separate in-operator.md documentation file in the canonical |
3413 | ** SQLite source tree for additional information. |
3414 | */ |
3415 | static void sqlite3ExprCodeIN( |
3416 | Parse *pParse, /* Parsing and code generating context */ |
3417 | Expr *pExpr, /* The IN expression */ |
3418 | int destIfFalse, /* Jump here if LHS is not contained in the RHS */ |
3419 | int destIfNull /* Jump here if the results are unknown due to NULLs */ |
3420 | ){ |
3421 | int rRhsHasNull = 0; /* Register that is true if RHS contains NULL values */ |
3422 | int eType; /* Type of the RHS */ |
3423 | int rLhs; /* Register(s) holding the LHS values */ |
3424 | int rLhsOrig; /* LHS values prior to reordering by aiMap[] */ |
3425 | Vdbe *v; /* Statement under construction */ |
3426 | int *aiMap = 0; /* Map from vector field to index column */ |
3427 | char *zAff = 0; /* Affinity string for comparisons */ |
3428 | int nVector; /* Size of vectors for this IN operator */ |
3429 | int iDummy; /* Dummy parameter to exprCodeVector() */ |
3430 | Expr *pLeft; /* The LHS of the IN operator */ |
3431 | int i; /* loop counter */ |
3432 | int destStep2; /* Where to jump when NULLs seen in step 2 */ |
3433 | int destStep6 = 0; /* Start of code for Step 6 */ |
3434 | int addrTruthOp; /* Address of opcode that determines the IN is true */ |
3435 | int destNotNull; /* Jump here if a comparison is not true in step 6 */ |
3436 | int addrTop; /* Top of the step-6 loop */ |
3437 | int iTab = 0; /* Index to use */ |
3438 | u8 okConstFactor = pParse->okConstFactor; |
3439 | |
3440 | assert( !ExprHasVVAProperty(pExpr,EP_Immutable) ); |
3441 | pLeft = pExpr->pLeft; |
3442 | if( sqlite3ExprCheckIN(pParse, pExpr) ) return; |
3443 | zAff = exprINAffinity(pParse, pExpr); |
3444 | nVector = sqlite3ExprVectorSize(pExpr->pLeft); |
3445 | aiMap = (int*)sqlite3DbMallocZero( |
3446 | pParse->db, nVector*(sizeof(int) + sizeof(char)) + 1 |
3447 | ); |
3448 | if( pParse->db->mallocFailed ) goto sqlite3ExprCodeIN_oom_error; |
3449 | |
3450 | /* Attempt to compute the RHS. After this step, if anything other than |
3451 | ** IN_INDEX_NOOP is returned, the table opened with cursor iTab |
3452 | ** contains the values that make up the RHS. If IN_INDEX_NOOP is returned, |
3453 | ** the RHS has not yet been coded. */ |
3454 | v = pParse->pVdbe; |
3455 | assert( v!=0 ); /* OOM detected prior to this routine */ |
3456 | VdbeNoopComment((v, "begin IN expr" )); |
3457 | eType = sqlite3FindInIndex(pParse, pExpr, |
3458 | IN_INDEX_MEMBERSHIP | IN_INDEX_NOOP_OK, |
3459 | destIfFalse==destIfNull ? 0 : &rRhsHasNull, |
3460 | aiMap, &iTab); |
3461 | |
3462 | assert( pParse->nErr || nVector==1 || eType==IN_INDEX_EPH |
3463 | || eType==IN_INDEX_INDEX_ASC || eType==IN_INDEX_INDEX_DESC |
3464 | ); |
3465 | #ifdef SQLITE_DEBUG |
3466 | /* Confirm that aiMap[] contains nVector integer values between 0 and |
3467 | ** nVector-1. */ |
3468 | for(i=0; i<nVector; i++){ |
3469 | int j, cnt; |
3470 | for(cnt=j=0; j<nVector; j++) if( aiMap[j]==i ) cnt++; |
3471 | assert( cnt==1 ); |
3472 | } |
3473 | #endif |
3474 | |
3475 | /* Code the LHS, the <expr> from "<expr> IN (...)". If the LHS is a |
3476 | ** vector, then it is stored in an array of nVector registers starting |
3477 | ** at r1. |
3478 | ** |
3479 | ** sqlite3FindInIndex() might have reordered the fields of the LHS vector |
3480 | ** so that the fields are in the same order as an existing index. The |
3481 | ** aiMap[] array contains a mapping from the original LHS field order to |
3482 | ** the field order that matches the RHS index. |
3483 | ** |
3484 | ** Avoid factoring the LHS of the IN(...) expression out of the loop, |
3485 | ** even if it is constant, as OP_Affinity may be used on the register |
3486 | ** by code generated below. */ |
3487 | assert( pParse->okConstFactor==okConstFactor ); |
3488 | pParse->okConstFactor = 0; |
3489 | rLhsOrig = exprCodeVector(pParse, pLeft, &iDummy); |
3490 | pParse->okConstFactor = okConstFactor; |
3491 | for(i=0; i<nVector && aiMap[i]==i; i++){} /* Are LHS fields reordered? */ |
3492 | if( i==nVector ){ |
3493 | /* LHS fields are not reordered */ |
3494 | rLhs = rLhsOrig; |
3495 | }else{ |
3496 | /* Need to reorder the LHS fields according to aiMap */ |
3497 | rLhs = sqlite3GetTempRange(pParse, nVector); |
3498 | for(i=0; i<nVector; i++){ |
3499 | sqlite3VdbeAddOp3(v, OP_Copy, rLhsOrig+i, rLhs+aiMap[i], 0); |
3500 | } |
3501 | } |
3502 | |
3503 | /* If sqlite3FindInIndex() did not find or create an index that is |
3504 | ** suitable for evaluating the IN operator, then evaluate using a |
3505 | ** sequence of comparisons. |
3506 | ** |
3507 | ** This is step (1) in the in-operator.md optimized algorithm. |
3508 | */ |
3509 | if( eType==IN_INDEX_NOOP ){ |
3510 | ExprList *pList; |
3511 | CollSeq *pColl; |
3512 | int labelOk = sqlite3VdbeMakeLabel(pParse); |
3513 | int r2, regToFree; |
3514 | int regCkNull = 0; |
3515 | int ii; |
3516 | assert( ExprUseXList(pExpr) ); |
3517 | pList = pExpr->x.pList; |
3518 | pColl = sqlite3ExprCollSeq(pParse, pExpr->pLeft); |
3519 | if( destIfNull!=destIfFalse ){ |
3520 | regCkNull = sqlite3GetTempReg(pParse); |
3521 | sqlite3VdbeAddOp3(v, OP_BitAnd, rLhs, rLhs, regCkNull); |
3522 | } |
3523 | for(ii=0; ii<pList->nExpr; ii++){ |
3524 | r2 = sqlite3ExprCodeTemp(pParse, pList->a[ii].pExpr, ®ToFree); |
3525 | if( regCkNull && sqlite3ExprCanBeNull(pList->a[ii].pExpr) ){ |
3526 | sqlite3VdbeAddOp3(v, OP_BitAnd, regCkNull, r2, regCkNull); |
3527 | } |
3528 | sqlite3ReleaseTempReg(pParse, regToFree); |
3529 | if( ii<pList->nExpr-1 || destIfNull!=destIfFalse ){ |
3530 | int op = rLhs!=r2 ? OP_Eq : OP_NotNull; |
3531 | sqlite3VdbeAddOp4(v, op, rLhs, labelOk, r2, |
3532 | (void*)pColl, P4_COLLSEQ); |
3533 | VdbeCoverageIf(v, ii<pList->nExpr-1 && op==OP_Eq); |
3534 | VdbeCoverageIf(v, ii==pList->nExpr-1 && op==OP_Eq); |
3535 | VdbeCoverageIf(v, ii<pList->nExpr-1 && op==OP_NotNull); |
3536 | VdbeCoverageIf(v, ii==pList->nExpr-1 && op==OP_NotNull); |
3537 | sqlite3VdbeChangeP5(v, zAff[0]); |
3538 | }else{ |
3539 | int op = rLhs!=r2 ? OP_Ne : OP_IsNull; |
3540 | assert( destIfNull==destIfFalse ); |
3541 | sqlite3VdbeAddOp4(v, op, rLhs, destIfFalse, r2, |
3542 | (void*)pColl, P4_COLLSEQ); |
3543 | VdbeCoverageIf(v, op==OP_Ne); |
3544 | VdbeCoverageIf(v, op==OP_IsNull); |
3545 | sqlite3VdbeChangeP5(v, zAff[0] | SQLITE_JUMPIFNULL); |
3546 | } |
3547 | } |
3548 | if( regCkNull ){ |
3549 | sqlite3VdbeAddOp2(v, OP_IsNull, regCkNull, destIfNull); VdbeCoverage(v); |
3550 | sqlite3VdbeGoto(v, destIfFalse); |
3551 | } |
3552 | sqlite3VdbeResolveLabel(v, labelOk); |
3553 | sqlite3ReleaseTempReg(pParse, regCkNull); |
3554 | goto sqlite3ExprCodeIN_finished; |
3555 | } |
3556 | |
3557 | /* Step 2: Check to see if the LHS contains any NULL columns. If the |
3558 | ** LHS does contain NULLs then the result must be either FALSE or NULL. |
3559 | ** We will then skip the binary search of the RHS. |
3560 | */ |
3561 | if( destIfNull==destIfFalse ){ |
3562 | destStep2 = destIfFalse; |
3563 | }else{ |
3564 | destStep2 = destStep6 = sqlite3VdbeMakeLabel(pParse); |
3565 | } |
3566 | for(i=0; i<nVector; i++){ |
3567 | Expr *p = sqlite3VectorFieldSubexpr(pExpr->pLeft, i); |
3568 | if( pParse->nErr ) goto sqlite3ExprCodeIN_oom_error; |
3569 | if( sqlite3ExprCanBeNull(p) ){ |
3570 | sqlite3VdbeAddOp2(v, OP_IsNull, rLhs+i, destStep2); |
3571 | VdbeCoverage(v); |
3572 | } |
3573 | } |
3574 | |
3575 | /* Step 3. The LHS is now known to be non-NULL. Do the binary search |
3576 | ** of the RHS using the LHS as a probe. If found, the result is |
3577 | ** true. |
3578 | */ |
3579 | if( eType==IN_INDEX_ROWID ){ |
3580 | /* In this case, the RHS is the ROWID of table b-tree and so we also |
3581 | ** know that the RHS is non-NULL. Hence, we combine steps 3 and 4 |
3582 | ** into a single opcode. */ |
3583 | sqlite3VdbeAddOp3(v, OP_SeekRowid, iTab, destIfFalse, rLhs); |
3584 | VdbeCoverage(v); |
3585 | addrTruthOp = sqlite3VdbeAddOp0(v, OP_Goto); /* Return True */ |
3586 | }else{ |
3587 | sqlite3VdbeAddOp4(v, OP_Affinity, rLhs, nVector, 0, zAff, nVector); |
3588 | if( destIfFalse==destIfNull ){ |
3589 | /* Combine Step 3 and Step 5 into a single opcode */ |
3590 | sqlite3VdbeAddOp4Int(v, OP_NotFound, iTab, destIfFalse, |
3591 | rLhs, nVector); VdbeCoverage(v); |
3592 | goto sqlite3ExprCodeIN_finished; |
3593 | } |
3594 | /* Ordinary Step 3, for the case where FALSE and NULL are distinct */ |
3595 | addrTruthOp = sqlite3VdbeAddOp4Int(v, OP_Found, iTab, 0, |
3596 | rLhs, nVector); VdbeCoverage(v); |
3597 | } |
3598 | |
3599 | /* Step 4. If the RHS is known to be non-NULL and we did not find |
3600 | ** an match on the search above, then the result must be FALSE. |
3601 | */ |
3602 | if( rRhsHasNull && nVector==1 ){ |
3603 | sqlite3VdbeAddOp2(v, OP_NotNull, rRhsHasNull, destIfFalse); |
3604 | VdbeCoverage(v); |
3605 | } |
3606 | |
3607 | /* Step 5. If we do not care about the difference between NULL and |
3608 | ** FALSE, then just return false. |
3609 | */ |
3610 | if( destIfFalse==destIfNull ) sqlite3VdbeGoto(v, destIfFalse); |
3611 | |
3612 | /* Step 6: Loop through rows of the RHS. Compare each row to the LHS. |
3613 | ** If any comparison is NULL, then the result is NULL. If all |
3614 | ** comparisons are FALSE then the final result is FALSE. |
3615 | ** |
3616 | ** For a scalar LHS, it is sufficient to check just the first row |
3617 | ** of the RHS. |
3618 | */ |
3619 | if( destStep6 ) sqlite3VdbeResolveLabel(v, destStep6); |
3620 | addrTop = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, destIfFalse); |
3621 | VdbeCoverage(v); |
3622 | if( nVector>1 ){ |
3623 | destNotNull = sqlite3VdbeMakeLabel(pParse); |
3624 | }else{ |
3625 | /* For nVector==1, combine steps 6 and 7 by immediately returning |
3626 | ** FALSE if the first comparison is not NULL */ |
3627 | destNotNull = destIfFalse; |
3628 | } |
3629 | for(i=0; i<nVector; i++){ |
3630 | Expr *p; |
3631 | CollSeq *pColl; |
3632 | int r3 = sqlite3GetTempReg(pParse); |
3633 | p = sqlite3VectorFieldSubexpr(pLeft, i); |
3634 | pColl = sqlite3ExprCollSeq(pParse, p); |
3635 | sqlite3VdbeAddOp3(v, OP_Column, iTab, i, r3); |
3636 | sqlite3VdbeAddOp4(v, OP_Ne, rLhs+i, destNotNull, r3, |
3637 | (void*)pColl, P4_COLLSEQ); |
3638 | VdbeCoverage(v); |
3639 | sqlite3ReleaseTempReg(pParse, r3); |
3640 | } |
3641 | sqlite3VdbeAddOp2(v, OP_Goto, 0, destIfNull); |
3642 | if( nVector>1 ){ |
3643 | sqlite3VdbeResolveLabel(v, destNotNull); |
3644 | sqlite3VdbeAddOp2(v, OP_Next, iTab, addrTop+1); |
3645 | VdbeCoverage(v); |
3646 | |
3647 | /* Step 7: If we reach this point, we know that the result must |
3648 | ** be false. */ |
3649 | sqlite3VdbeAddOp2(v, OP_Goto, 0, destIfFalse); |
3650 | } |
3651 | |
3652 | /* Jumps here in order to return true. */ |
3653 | sqlite3VdbeJumpHere(v, addrTruthOp); |
3654 | |
3655 | sqlite3ExprCodeIN_finished: |
3656 | if( rLhs!=rLhsOrig ) sqlite3ReleaseTempReg(pParse, rLhs); |
3657 | VdbeComment((v, "end IN expr" )); |
3658 | sqlite3ExprCodeIN_oom_error: |
3659 | sqlite3DbFree(pParse->db, aiMap); |
3660 | sqlite3DbFree(pParse->db, zAff); |
3661 | } |
3662 | #endif /* SQLITE_OMIT_SUBQUERY */ |
3663 | |
3664 | #ifndef SQLITE_OMIT_FLOATING_POINT |
3665 | /* |
3666 | ** Generate an instruction that will put the floating point |
3667 | ** value described by z[0..n-1] into register iMem. |
3668 | ** |
3669 | ** The z[] string will probably not be zero-terminated. But the |
3670 | ** z[n] character is guaranteed to be something that does not look |
3671 | ** like the continuation of the number. |
3672 | */ |
3673 | static void codeReal(Vdbe *v, const char *z, int negateFlag, int iMem){ |
3674 | if( ALWAYS(z!=0) ){ |
3675 | double value; |
3676 | sqlite3AtoF(z, &value, sqlite3Strlen30(z), SQLITE_UTF8); |
3677 | assert( !sqlite3IsNaN(value) ); /* The new AtoF never returns NaN */ |
3678 | if( negateFlag ) value = -value; |
3679 | sqlite3VdbeAddOp4Dup8(v, OP_Real, 0, iMem, 0, (u8*)&value, P4_REAL); |
3680 | } |
3681 | } |
3682 | #endif |
3683 | |
3684 | |
3685 | /* |
3686 | ** Generate an instruction that will put the integer describe by |
3687 | ** text z[0..n-1] into register iMem. |
3688 | ** |
3689 | ** Expr.u.zToken is always UTF8 and zero-terminated. |
3690 | */ |
3691 | static void codeInteger(Parse *pParse, Expr *pExpr, int negFlag, int iMem){ |
3692 | Vdbe *v = pParse->pVdbe; |
3693 | if( pExpr->flags & EP_IntValue ){ |
3694 | int i = pExpr->u.iValue; |
3695 | assert( i>=0 ); |
3696 | if( negFlag ) i = -i; |
3697 | sqlite3VdbeAddOp2(v, OP_Integer, i, iMem); |
3698 | }else{ |
3699 | int c; |
3700 | i64 value; |
3701 | const char *z = pExpr->u.zToken; |
3702 | assert( z!=0 ); |
3703 | c = sqlite3DecOrHexToI64(z, &value); |
3704 | if( (c==3 && !negFlag) || (c==2) || (negFlag && value==SMALLEST_INT64)){ |
3705 | #ifdef SQLITE_OMIT_FLOATING_POINT |
3706 | sqlite3ErrorMsg(pParse, "oversized integer: %s%#T" , negFlag?"-" :"" ,pExpr); |
3707 | #else |
3708 | #ifndef SQLITE_OMIT_HEX_INTEGER |
3709 | if( sqlite3_strnicmp(z,"0x" ,2)==0 ){ |
3710 | sqlite3ErrorMsg(pParse, "hex literal too big: %s%#T" , |
3711 | negFlag?"-" :"" ,pExpr); |
3712 | }else |
3713 | #endif |
3714 | { |
3715 | codeReal(v, z, negFlag, iMem); |
3716 | } |
3717 | #endif |
3718 | }else{ |
3719 | if( negFlag ){ value = c==3 ? SMALLEST_INT64 : -value; } |
3720 | sqlite3VdbeAddOp4Dup8(v, OP_Int64, 0, iMem, 0, (u8*)&value, P4_INT64); |
3721 | } |
3722 | } |
3723 | } |
3724 | |
3725 | |
3726 | /* Generate code that will load into register regOut a value that is |
3727 | ** appropriate for the iIdxCol-th column of index pIdx. |
3728 | */ |
3729 | void sqlite3ExprCodeLoadIndexColumn( |
3730 | Parse *pParse, /* The parsing context */ |
3731 | Index *pIdx, /* The index whose column is to be loaded */ |
3732 | int iTabCur, /* Cursor pointing to a table row */ |
3733 | int iIdxCol, /* The column of the index to be loaded */ |
3734 | int regOut /* Store the index column value in this register */ |
3735 | ){ |
3736 | i16 iTabCol = pIdx->aiColumn[iIdxCol]; |
3737 | if( iTabCol==XN_EXPR ){ |
3738 | assert( pIdx->aColExpr ); |
3739 | assert( pIdx->aColExpr->nExpr>iIdxCol ); |
3740 | pParse->iSelfTab = iTabCur + 1; |
3741 | sqlite3ExprCodeCopy(pParse, pIdx->aColExpr->a[iIdxCol].pExpr, regOut); |
3742 | pParse->iSelfTab = 0; |
3743 | }else{ |
3744 | sqlite3ExprCodeGetColumnOfTable(pParse->pVdbe, pIdx->pTable, iTabCur, |
3745 | iTabCol, regOut); |
3746 | } |
3747 | } |
3748 | |
3749 | #ifndef SQLITE_OMIT_GENERATED_COLUMNS |
3750 | /* |
3751 | ** Generate code that will compute the value of generated column pCol |
3752 | ** and store the result in register regOut |
3753 | */ |
3754 | void sqlite3ExprCodeGeneratedColumn( |
3755 | Parse *pParse, /* Parsing context */ |
3756 | Table *pTab, /* Table containing the generated column */ |
3757 | Column *pCol, /* The generated column */ |
3758 | int regOut /* Put the result in this register */ |
3759 | ){ |
3760 | int iAddr; |
3761 | Vdbe *v = pParse->pVdbe; |
3762 | assert( v!=0 ); |
3763 | assert( pParse->iSelfTab!=0 ); |
3764 | if( pParse->iSelfTab>0 ){ |
3765 | iAddr = sqlite3VdbeAddOp3(v, OP_IfNullRow, pParse->iSelfTab-1, 0, regOut); |
3766 | }else{ |
3767 | iAddr = 0; |
3768 | } |
3769 | sqlite3ExprCodeCopy(pParse, sqlite3ColumnExpr(pTab,pCol), regOut); |
3770 | if( pCol->affinity>=SQLITE_AFF_TEXT ){ |
3771 | sqlite3VdbeAddOp4(v, OP_Affinity, regOut, 1, 0, &pCol->affinity, 1); |
3772 | } |
3773 | if( iAddr ) sqlite3VdbeJumpHere(v, iAddr); |
3774 | } |
3775 | #endif /* SQLITE_OMIT_GENERATED_COLUMNS */ |
3776 | |
3777 | /* |
3778 | ** Generate code to extract the value of the iCol-th column of a table. |
3779 | */ |
3780 | void sqlite3ExprCodeGetColumnOfTable( |
3781 | Vdbe *v, /* Parsing context */ |
3782 | Table *pTab, /* The table containing the value */ |
3783 | int iTabCur, /* The table cursor. Or the PK cursor for WITHOUT ROWID */ |
3784 | int iCol, /* Index of the column to extract */ |
3785 | int regOut /* Extract the value into this register */ |
3786 | ){ |
3787 | Column *pCol; |
3788 | assert( v!=0 ); |
3789 | assert( pTab!=0 ); |
3790 | if( iCol<0 || iCol==pTab->iPKey ){ |
3791 | sqlite3VdbeAddOp2(v, OP_Rowid, iTabCur, regOut); |
3792 | VdbeComment((v, "%s.rowid" , pTab->zName)); |
3793 | }else{ |
3794 | int op; |
3795 | int x; |
3796 | if( IsVirtual(pTab) ){ |
3797 | op = OP_VColumn; |
3798 | x = iCol; |
3799 | #ifndef SQLITE_OMIT_GENERATED_COLUMNS |
3800 | }else if( (pCol = &pTab->aCol[iCol])->colFlags & COLFLAG_VIRTUAL ){ |
3801 | Parse *pParse = sqlite3VdbeParser(v); |
3802 | if( pCol->colFlags & COLFLAG_BUSY ){ |
3803 | sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"" , |
3804 | pCol->zCnName); |
3805 | }else{ |
3806 | int savedSelfTab = pParse->iSelfTab; |
3807 | pCol->colFlags |= COLFLAG_BUSY; |
3808 | pParse->iSelfTab = iTabCur+1; |
3809 | sqlite3ExprCodeGeneratedColumn(pParse, pTab, pCol, regOut); |
3810 | pParse->iSelfTab = savedSelfTab; |
3811 | pCol->colFlags &= ~COLFLAG_BUSY; |
3812 | } |
3813 | return; |
3814 | #endif |
3815 | }else if( !HasRowid(pTab) ){ |
3816 | testcase( iCol!=sqlite3TableColumnToStorage(pTab, iCol) ); |
3817 | x = sqlite3TableColumnToIndex(sqlite3PrimaryKeyIndex(pTab), iCol); |
3818 | op = OP_Column; |
3819 | }else{ |
3820 | x = sqlite3TableColumnToStorage(pTab,iCol); |
3821 | testcase( x!=iCol ); |
3822 | op = OP_Column; |
3823 | } |
3824 | sqlite3VdbeAddOp3(v, op, iTabCur, x, regOut); |
3825 | sqlite3ColumnDefault(v, pTab, iCol, regOut); |
3826 | } |
3827 | } |
3828 | |
3829 | /* |
3830 | ** Generate code that will extract the iColumn-th column from |
3831 | ** table pTab and store the column value in register iReg. |
3832 | ** |
3833 | ** There must be an open cursor to pTab in iTable when this routine |
3834 | ** is called. If iColumn<0 then code is generated that extracts the rowid. |
3835 | */ |
3836 | int sqlite3ExprCodeGetColumn( |
3837 | Parse *pParse, /* Parsing and code generating context */ |
3838 | Table *pTab, /* Description of the table we are reading from */ |
3839 | int iColumn, /* Index of the table column */ |
3840 | int iTable, /* The cursor pointing to the table */ |
3841 | int iReg, /* Store results here */ |
3842 | u8 p5 /* P5 value for OP_Column + FLAGS */ |
3843 | ){ |
3844 | assert( pParse->pVdbe!=0 ); |
3845 | sqlite3ExprCodeGetColumnOfTable(pParse->pVdbe, pTab, iTable, iColumn, iReg); |
3846 | if( p5 ){ |
3847 | VdbeOp *pOp = sqlite3VdbeGetLastOp(pParse->pVdbe); |
3848 | if( pOp->opcode==OP_Column ) pOp->p5 = p5; |
3849 | } |
3850 | return iReg; |
3851 | } |
3852 | |
3853 | /* |
3854 | ** Generate code to move content from registers iFrom...iFrom+nReg-1 |
3855 | ** over to iTo..iTo+nReg-1. |
3856 | */ |
3857 | void sqlite3ExprCodeMove(Parse *pParse, int iFrom, int iTo, int nReg){ |
3858 | sqlite3VdbeAddOp3(pParse->pVdbe, OP_Move, iFrom, iTo, nReg); |
3859 | } |
3860 | |
3861 | /* |
3862 | ** Convert a scalar expression node to a TK_REGISTER referencing |
3863 | ** register iReg. The caller must ensure that iReg already contains |
3864 | ** the correct value for the expression. |
3865 | */ |
3866 | static void exprToRegister(Expr *pExpr, int iReg){ |
3867 | Expr *p = sqlite3ExprSkipCollateAndLikely(pExpr); |
3868 | if( NEVER(p==0) ) return; |
3869 | p->op2 = p->op; |
3870 | p->op = TK_REGISTER; |
3871 | p->iTable = iReg; |
3872 | ExprClearProperty(p, EP_Skip); |
3873 | } |
3874 | |
3875 | /* |
3876 | ** Evaluate an expression (either a vector or a scalar expression) and store |
3877 | ** the result in continguous temporary registers. Return the index of |
3878 | ** the first register used to store the result. |
3879 | ** |
3880 | ** If the returned result register is a temporary scalar, then also write |
3881 | ** that register number into *piFreeable. If the returned result register |
3882 | ** is not a temporary or if the expression is a vector set *piFreeable |
3883 | ** to 0. |
3884 | */ |
3885 | static int exprCodeVector(Parse *pParse, Expr *p, int *piFreeable){ |
3886 | int iResult; |
3887 | int nResult = sqlite3ExprVectorSize(p); |
3888 | if( nResult==1 ){ |
3889 | iResult = sqlite3ExprCodeTemp(pParse, p, piFreeable); |
3890 | }else{ |
3891 | *piFreeable = 0; |
3892 | if( p->op==TK_SELECT ){ |
3893 | #if SQLITE_OMIT_SUBQUERY |
3894 | iResult = 0; |
3895 | #else |
3896 | iResult = sqlite3CodeSubselect(pParse, p); |
3897 | #endif |
3898 | }else{ |
3899 | int i; |
3900 | iResult = pParse->nMem+1; |
3901 | pParse->nMem += nResult; |
3902 | assert( ExprUseXList(p) ); |
3903 | for(i=0; i<nResult; i++){ |
3904 | sqlite3ExprCodeFactorable(pParse, p->x.pList->a[i].pExpr, i+iResult); |
3905 | } |
3906 | } |
3907 | } |
3908 | return iResult; |
3909 | } |
3910 | |
3911 | /* |
3912 | ** If the last opcode is a OP_Copy, then set the do-not-merge flag (p5) |
3913 | ** so that a subsequent copy will not be merged into this one. |
3914 | */ |
3915 | static void setDoNotMergeFlagOnCopy(Vdbe *v){ |
3916 | if( sqlite3VdbeGetLastOp(v)->opcode==OP_Copy ){ |
3917 | sqlite3VdbeChangeP5(v, 1); /* Tag trailing OP_Copy as not mergable */ |
3918 | } |
3919 | } |
3920 | |
3921 | /* |
3922 | ** Generate code to implement special SQL functions that are implemented |
3923 | ** in-line rather than by using the usual callbacks. |
3924 | */ |
3925 | static int exprCodeInlineFunction( |
3926 | Parse *pParse, /* Parsing context */ |
3927 | ExprList *pFarg, /* List of function arguments */ |
3928 | int iFuncId, /* Function ID. One of the INTFUNC_... values */ |
3929 | int target /* Store function result in this register */ |
3930 | ){ |
3931 | int nFarg; |
3932 | Vdbe *v = pParse->pVdbe; |
3933 | assert( v!=0 ); |
3934 | assert( pFarg!=0 ); |
3935 | nFarg = pFarg->nExpr; |
3936 | assert( nFarg>0 ); /* All in-line functions have at least one argument */ |
3937 | switch( iFuncId ){ |
3938 | case INLINEFUNC_coalesce: { |
3939 | /* Attempt a direct implementation of the built-in COALESCE() and |
3940 | ** IFNULL() functions. This avoids unnecessary evaluation of |
3941 | ** arguments past the first non-NULL argument. |
3942 | */ |
3943 | int endCoalesce = sqlite3VdbeMakeLabel(pParse); |
3944 | int i; |
3945 | assert( nFarg>=2 ); |
3946 | sqlite3ExprCode(pParse, pFarg->a[0].pExpr, target); |
3947 | for(i=1; i<nFarg; i++){ |
3948 | sqlite3VdbeAddOp2(v, OP_NotNull, target, endCoalesce); |
3949 | VdbeCoverage(v); |
3950 | sqlite3ExprCode(pParse, pFarg->a[i].pExpr, target); |
3951 | } |
3952 | setDoNotMergeFlagOnCopy(v); |
3953 | sqlite3VdbeResolveLabel(v, endCoalesce); |
3954 | break; |
3955 | } |
3956 | case INLINEFUNC_iif: { |
3957 | Expr caseExpr; |
3958 | memset(&caseExpr, 0, sizeof(caseExpr)); |
3959 | caseExpr.op = TK_CASE; |
3960 | caseExpr.x.pList = pFarg; |
3961 | return sqlite3ExprCodeTarget(pParse, &caseExpr, target); |
3962 | } |
3963 | #ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC |
3964 | case INLINEFUNC_sqlite_offset: { |
3965 | Expr *pArg = pFarg->a[0].pExpr; |
3966 | if( pArg->op==TK_COLUMN && pArg->iTable>=0 ){ |
3967 | sqlite3VdbeAddOp3(v, OP_Offset, pArg->iTable, pArg->iColumn, target); |
3968 | }else{ |
3969 | sqlite3VdbeAddOp2(v, OP_Null, 0, target); |
3970 | } |
3971 | break; |
3972 | } |
3973 | #endif |
3974 | default: { |
3975 | /* The UNLIKELY() function is a no-op. The result is the value |
3976 | ** of the first argument. |
3977 | */ |
3978 | assert( nFarg==1 || nFarg==2 ); |
3979 | target = sqlite3ExprCodeTarget(pParse, pFarg->a[0].pExpr, target); |
3980 | break; |
3981 | } |
3982 | |
3983 | /*********************************************************************** |
3984 | ** Test-only SQL functions that are only usable if enabled |
3985 | ** via SQLITE_TESTCTRL_INTERNAL_FUNCTIONS |
3986 | */ |
3987 | #if !defined(SQLITE_UNTESTABLE) |
3988 | case INLINEFUNC_expr_compare: { |
3989 | /* Compare two expressions using sqlite3ExprCompare() */ |
3990 | assert( nFarg==2 ); |
3991 | sqlite3VdbeAddOp2(v, OP_Integer, |
3992 | sqlite3ExprCompare(0,pFarg->a[0].pExpr, pFarg->a[1].pExpr,-1), |
3993 | target); |
3994 | break; |
3995 | } |
3996 | |
3997 | case INLINEFUNC_expr_implies_expr: { |
3998 | /* Compare two expressions using sqlite3ExprImpliesExpr() */ |
3999 | assert( nFarg==2 ); |
4000 | sqlite3VdbeAddOp2(v, OP_Integer, |
4001 | sqlite3ExprImpliesExpr(pParse,pFarg->a[0].pExpr, pFarg->a[1].pExpr,-1), |
4002 | target); |
4003 | break; |
4004 | } |
4005 | |
4006 | case INLINEFUNC_implies_nonnull_row: { |
4007 | /* REsult of sqlite3ExprImpliesNonNullRow() */ |
4008 | Expr *pA1; |
4009 | assert( nFarg==2 ); |
4010 | pA1 = pFarg->a[1].pExpr; |
4011 | if( pA1->op==TK_COLUMN ){ |
4012 | sqlite3VdbeAddOp2(v, OP_Integer, |
4013 | sqlite3ExprImpliesNonNullRow(pFarg->a[0].pExpr,pA1->iTable), |
4014 | target); |
4015 | }else{ |
4016 | sqlite3VdbeAddOp2(v, OP_Null, 0, target); |
4017 | } |
4018 | break; |
4019 | } |
4020 | |
4021 | case INLINEFUNC_affinity: { |
4022 | /* The AFFINITY() function evaluates to a string that describes |
4023 | ** the type affinity of the argument. This is used for testing of |
4024 | ** the SQLite type logic. |
4025 | */ |
4026 | const char *azAff[] = { "blob" , "text" , "numeric" , "integer" , "real" }; |
4027 | char aff; |
4028 | assert( nFarg==1 ); |
4029 | aff = sqlite3ExprAffinity(pFarg->a[0].pExpr); |
4030 | sqlite3VdbeLoadString(v, target, |
4031 | (aff<=SQLITE_AFF_NONE) ? "none" : azAff[aff-SQLITE_AFF_BLOB]); |
4032 | break; |
4033 | } |
4034 | #endif /* !defined(SQLITE_UNTESTABLE) */ |
4035 | } |
4036 | return target; |
4037 | } |
4038 | |
4039 | /* |
4040 | ** Check to see if pExpr is one of the indexed expressions on pParse->pIdxExpr. |
4041 | ** If it is, then resolve the expression by reading from the index and |
4042 | ** return the register into which the value has been read. If pExpr is |
4043 | ** not an indexed expression, then return negative. |
4044 | */ |
4045 | static SQLITE_NOINLINE int sqlite3IndexedExprLookup( |
4046 | Parse *pParse, /* The parsing context */ |
4047 | Expr *pExpr, /* The expression to potentially bypass */ |
4048 | int target /* Where to store the result of the expression */ |
4049 | ){ |
4050 | IndexedExpr *p; |
4051 | Vdbe *v; |
4052 | for(p=pParse->pIdxExpr; p; p=p->pIENext){ |
4053 | int iDataCur = p->iDataCur; |
4054 | if( iDataCur<0 ) continue; |
4055 | if( pParse->iSelfTab ){ |
4056 | if( p->iDataCur!=pParse->iSelfTab-1 ) continue; |
4057 | iDataCur = -1; |
4058 | } |
4059 | if( sqlite3ExprCompare(0, pExpr, p->pExpr, iDataCur)!=0 ) continue; |
4060 | v = pParse->pVdbe; |
4061 | assert( v!=0 ); |
4062 | if( p->bMaybeNullRow ){ |
4063 | /* If the index is on a NULL row due to an outer join, then we |
4064 | ** cannot extract the value from the index. The value must be |
4065 | ** computed using the original expression. */ |
4066 | int addr = sqlite3VdbeCurrentAddr(v); |
4067 | sqlite3VdbeAddOp3(v, OP_IfNullRow, p->iIdxCur, addr+3, target); |
4068 | VdbeCoverage(v); |
4069 | sqlite3VdbeAddOp3(v, OP_Column, p->iIdxCur, p->iIdxCol, target); |
4070 | VdbeComment((v, "%s expr-column %d" , p->zIdxName, p->iIdxCol)); |
4071 | sqlite3VdbeGoto(v, 0); |
4072 | p = pParse->pIdxExpr; |
4073 | pParse->pIdxExpr = 0; |
4074 | sqlite3ExprCode(pParse, pExpr, target); |
4075 | pParse->pIdxExpr = p; |
4076 | sqlite3VdbeJumpHere(v, addr+2); |
4077 | }else{ |
4078 | sqlite3VdbeAddOp3(v, OP_Column, p->iIdxCur, p->iIdxCol, target); |
4079 | VdbeComment((v, "%s expr-column %d" , p->zIdxName, p->iIdxCol)); |
4080 | } |
4081 | return target; |
4082 | } |
4083 | return -1; /* Not found */ |
4084 | } |
4085 | |
4086 | |
4087 | /* |
4088 | ** Generate code into the current Vdbe to evaluate the given |
4089 | ** expression. Attempt to store the results in register "target". |
4090 | ** Return the register where results are stored. |
4091 | ** |
4092 | ** With this routine, there is no guarantee that results will |
4093 | ** be stored in target. The result might be stored in some other |
4094 | ** register if it is convenient to do so. The calling function |
4095 | ** must check the return code and move the results to the desired |
4096 | ** register. |
4097 | */ |
4098 | int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){ |
4099 | Vdbe *v = pParse->pVdbe; /* The VM under construction */ |
4100 | int op; /* The opcode being coded */ |
4101 | int inReg = target; /* Results stored in register inReg */ |
4102 | int regFree1 = 0; /* If non-zero free this temporary register */ |
4103 | int regFree2 = 0; /* If non-zero free this temporary register */ |
4104 | int r1, r2; /* Various register numbers */ |
4105 | Expr tempX; /* Temporary expression node */ |
4106 | int p5 = 0; |
4107 | |
4108 | assert( target>0 && target<=pParse->nMem ); |
4109 | assert( v!=0 ); |
4110 | |
4111 | expr_code_doover: |
4112 | if( pExpr==0 ){ |
4113 | op = TK_NULL; |
4114 | }else if( pParse->pIdxExpr!=0 |
4115 | && !ExprHasProperty(pExpr, EP_Leaf) |
4116 | && (r1 = sqlite3IndexedExprLookup(pParse, pExpr, target))>=0 |
4117 | ){ |
4118 | return r1; |
4119 | }else{ |
4120 | assert( !ExprHasVVAProperty(pExpr,EP_Immutable) ); |
4121 | op = pExpr->op; |
4122 | } |
4123 | switch( op ){ |
4124 | case TK_AGG_COLUMN: { |
4125 | AggInfo *pAggInfo = pExpr->pAggInfo; |
4126 | struct AggInfo_col *pCol; |
4127 | assert( pAggInfo!=0 ); |
4128 | assert( pExpr->iAgg>=0 && pExpr->iAgg<pAggInfo->nColumn ); |
4129 | pCol = &pAggInfo->aCol[pExpr->iAgg]; |
4130 | if( !pAggInfo->directMode ){ |
4131 | assert( pCol->iMem>0 ); |
4132 | return pCol->iMem; |
4133 | }else if( pAggInfo->useSortingIdx ){ |
4134 | Table *pTab = pCol->pTab; |
4135 | sqlite3VdbeAddOp3(v, OP_Column, pAggInfo->sortingIdxPTab, |
4136 | pCol->iSorterColumn, target); |
4137 | if( pCol->iColumn<0 ){ |
4138 | VdbeComment((v,"%s.rowid" ,pTab->zName)); |
4139 | }else if( ALWAYS(pTab!=0) ){ |
4140 | VdbeComment((v,"%s.%s" , |
4141 | pTab->zName, pTab->aCol[pCol->iColumn].zCnName)); |
4142 | if( pTab->aCol[pCol->iColumn].affinity==SQLITE_AFF_REAL ){ |
4143 | sqlite3VdbeAddOp1(v, OP_RealAffinity, target); |
4144 | } |
4145 | } |
4146 | return target; |
4147 | } |
4148 | /* Otherwise, fall thru into the TK_COLUMN case */ |
4149 | /* no break */ deliberate_fall_through |
4150 | } |
4151 | case TK_COLUMN: { |
4152 | int iTab = pExpr->iTable; |
4153 | int iReg; |
4154 | if( ExprHasProperty(pExpr, EP_FixedCol) ){ |
4155 | /* This COLUMN expression is really a constant due to WHERE clause |
4156 | ** constraints, and that constant is coded by the pExpr->pLeft |
4157 | ** expresssion. However, make sure the constant has the correct |
4158 | ** datatype by applying the Affinity of the table column to the |
4159 | ** constant. |
4160 | */ |
4161 | int aff; |
4162 | iReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft,target); |
4163 | assert( ExprUseYTab(pExpr) ); |
4164 | assert( pExpr->y.pTab!=0 ); |
4165 | aff = sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn); |
4166 | if( aff>SQLITE_AFF_BLOB ){ |
4167 | static const char zAff[] = "B\000C\000D\000E" ; |
4168 | assert( SQLITE_AFF_BLOB=='A' ); |
4169 | assert( SQLITE_AFF_TEXT=='B' ); |
4170 | sqlite3VdbeAddOp4(v, OP_Affinity, iReg, 1, 0, |
4171 | &zAff[(aff-'B')*2], P4_STATIC); |
4172 | } |
4173 | return iReg; |
4174 | } |
4175 | if( iTab<0 ){ |
4176 | if( pParse->iSelfTab<0 ){ |
4177 | /* Other columns in the same row for CHECK constraints or |
4178 | ** generated columns or for inserting into partial index. |
4179 | ** The row is unpacked into registers beginning at |
4180 | ** 0-(pParse->iSelfTab). The rowid (if any) is in a register |
4181 | ** immediately prior to the first column. |
4182 | */ |
4183 | Column *pCol; |
4184 | Table *pTab; |
4185 | int iSrc; |
4186 | int iCol = pExpr->iColumn; |
4187 | assert( ExprUseYTab(pExpr) ); |
4188 | pTab = pExpr->y.pTab; |
4189 | assert( pTab!=0 ); |
4190 | assert( iCol>=XN_ROWID ); |
4191 | assert( iCol<pTab->nCol ); |
4192 | if( iCol<0 ){ |
4193 | return -1-pParse->iSelfTab; |
4194 | } |
4195 | pCol = pTab->aCol + iCol; |
4196 | testcase( iCol!=sqlite3TableColumnToStorage(pTab,iCol) ); |
4197 | iSrc = sqlite3TableColumnToStorage(pTab, iCol) - pParse->iSelfTab; |
4198 | #ifndef SQLITE_OMIT_GENERATED_COLUMNS |
4199 | if( pCol->colFlags & COLFLAG_GENERATED ){ |
4200 | if( pCol->colFlags & COLFLAG_BUSY ){ |
4201 | sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"" , |
4202 | pCol->zCnName); |
4203 | return 0; |
4204 | } |
4205 | pCol->colFlags |= COLFLAG_BUSY; |
4206 | if( pCol->colFlags & COLFLAG_NOTAVAIL ){ |
4207 | sqlite3ExprCodeGeneratedColumn(pParse, pTab, pCol, iSrc); |
4208 | } |
4209 | pCol->colFlags &= ~(COLFLAG_BUSY|COLFLAG_NOTAVAIL); |
4210 | return iSrc; |
4211 | }else |
4212 | #endif /* SQLITE_OMIT_GENERATED_COLUMNS */ |
4213 | if( pCol->affinity==SQLITE_AFF_REAL ){ |
4214 | sqlite3VdbeAddOp2(v, OP_SCopy, iSrc, target); |
4215 | sqlite3VdbeAddOp1(v, OP_RealAffinity, target); |
4216 | return target; |
4217 | }else{ |
4218 | return iSrc; |
4219 | } |
4220 | }else{ |
4221 | /* Coding an expression that is part of an index where column names |
4222 | ** in the index refer to the table to which the index belongs */ |
4223 | iTab = pParse->iSelfTab - 1; |
4224 | } |
4225 | } |
4226 | assert( ExprUseYTab(pExpr) ); |
4227 | assert( pExpr->y.pTab!=0 ); |
4228 | iReg = sqlite3ExprCodeGetColumn(pParse, pExpr->y.pTab, |
4229 | pExpr->iColumn, iTab, target, |
4230 | pExpr->op2); |
4231 | return iReg; |
4232 | } |
4233 | case TK_INTEGER: { |
4234 | codeInteger(pParse, pExpr, 0, target); |
4235 | return target; |
4236 | } |
4237 | case TK_TRUEFALSE: { |
4238 | sqlite3VdbeAddOp2(v, OP_Integer, sqlite3ExprTruthValue(pExpr), target); |
4239 | return target; |
4240 | } |
4241 | #ifndef SQLITE_OMIT_FLOATING_POINT |
4242 | case TK_FLOAT: { |
4243 | assert( !ExprHasProperty(pExpr, EP_IntValue) ); |
4244 | codeReal(v, pExpr->u.zToken, 0, target); |
4245 | return target; |
4246 | } |
4247 | #endif |
4248 | case TK_STRING: { |
4249 | assert( !ExprHasProperty(pExpr, EP_IntValue) ); |
4250 | sqlite3VdbeLoadString(v, target, pExpr->u.zToken); |
4251 | return target; |
4252 | } |
4253 | default: { |
4254 | /* Make NULL the default case so that if a bug causes an illegal |
4255 | ** Expr node to be passed into this function, it will be handled |
4256 | ** sanely and not crash. But keep the assert() to bring the problem |
4257 | ** to the attention of the developers. */ |
4258 | assert( op==TK_NULL || op==TK_ERROR || pParse->db->mallocFailed ); |
4259 | sqlite3VdbeAddOp2(v, OP_Null, 0, target); |
4260 | return target; |
4261 | } |
4262 | #ifndef SQLITE_OMIT_BLOB_LITERAL |
4263 | case TK_BLOB: { |
4264 | int n; |
4265 | const char *z; |
4266 | char *zBlob; |
4267 | assert( !ExprHasProperty(pExpr, EP_IntValue) ); |
4268 | assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' ); |
4269 | assert( pExpr->u.zToken[1]=='\'' ); |
4270 | z = &pExpr->u.zToken[2]; |
4271 | n = sqlite3Strlen30(z) - 1; |
4272 | assert( z[n]=='\'' ); |
4273 | zBlob = sqlite3HexToBlob(sqlite3VdbeDb(v), z, n); |
4274 | sqlite3VdbeAddOp4(v, OP_Blob, n/2, target, 0, zBlob, P4_DYNAMIC); |
4275 | return target; |
4276 | } |
4277 | #endif |
4278 | case TK_VARIABLE: { |
4279 | assert( !ExprHasProperty(pExpr, EP_IntValue) ); |
4280 | assert( pExpr->u.zToken!=0 ); |
4281 | assert( pExpr->u.zToken[0]!=0 ); |
4282 | sqlite3VdbeAddOp2(v, OP_Variable, pExpr->iColumn, target); |
4283 | if( pExpr->u.zToken[1]!=0 ){ |
4284 | const char *z = sqlite3VListNumToName(pParse->pVList, pExpr->iColumn); |
4285 | assert( pExpr->u.zToken[0]=='?' || (z && !strcmp(pExpr->u.zToken, z)) ); |
4286 | pParse->pVList[0] = 0; /* Indicate VList may no longer be enlarged */ |
4287 | sqlite3VdbeAppendP4(v, (char*)z, P4_STATIC); |
4288 | } |
4289 | return target; |
4290 | } |
4291 | case TK_REGISTER: { |
4292 | return pExpr->iTable; |
4293 | } |
4294 | #ifndef SQLITE_OMIT_CAST |
4295 | case TK_CAST: { |
4296 | /* Expressions of the form: CAST(pLeft AS token) */ |
4297 | inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target); |
4298 | if( inReg!=target ){ |
4299 | sqlite3VdbeAddOp2(v, OP_SCopy, inReg, target); |
4300 | inReg = target; |
4301 | } |
4302 | assert( !ExprHasProperty(pExpr, EP_IntValue) ); |
4303 | sqlite3VdbeAddOp2(v, OP_Cast, target, |
4304 | sqlite3AffinityType(pExpr->u.zToken, 0)); |
4305 | return inReg; |
4306 | } |
4307 | #endif /* SQLITE_OMIT_CAST */ |
4308 | case TK_IS: |
4309 | case TK_ISNOT: |
4310 | op = (op==TK_IS) ? TK_EQ : TK_NE; |
4311 | p5 = SQLITE_NULLEQ; |
4312 | /* fall-through */ |
4313 | case TK_LT: |
4314 | case TK_LE: |
4315 | case TK_GT: |
4316 | case TK_GE: |
4317 | case TK_NE: |
4318 | case TK_EQ: { |
4319 | Expr *pLeft = pExpr->pLeft; |
4320 | if( sqlite3ExprIsVector(pLeft) ){ |
4321 | codeVectorCompare(pParse, pExpr, target, op, p5); |
4322 | }else{ |
4323 | r1 = sqlite3ExprCodeTemp(pParse, pLeft, ®Free1); |
4324 | r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2); |
4325 | sqlite3VdbeAddOp2(v, OP_Integer, 1, inReg); |
4326 | codeCompare(pParse, pLeft, pExpr->pRight, op, r1, r2, |
4327 | sqlite3VdbeCurrentAddr(v)+2, p5, |
4328 | ExprHasProperty(pExpr,EP_Commuted)); |
4329 | assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt); |
4330 | assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le); |
4331 | assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt); |
4332 | assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge); |
4333 | assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq); |
4334 | assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne); |
4335 | if( p5==SQLITE_NULLEQ ){ |
4336 | sqlite3VdbeAddOp2(v, OP_Integer, 0, inReg); |
4337 | }else{ |
4338 | sqlite3VdbeAddOp3(v, OP_ZeroOrNull, r1, inReg, r2); |
4339 | } |
4340 | testcase( regFree1==0 ); |
4341 | testcase( regFree2==0 ); |
4342 | } |
4343 | break; |
4344 | } |
4345 | case TK_AND: |
4346 | case TK_OR: |
4347 | case TK_PLUS: |
4348 | case TK_STAR: |
4349 | case TK_MINUS: |
4350 | case TK_REM: |
4351 | case TK_BITAND: |
4352 | case TK_BITOR: |
4353 | case TK_SLASH: |
4354 | case TK_LSHIFT: |
4355 | case TK_RSHIFT: |
4356 | case TK_CONCAT: { |
4357 | assert( TK_AND==OP_And ); testcase( op==TK_AND ); |
4358 | assert( TK_OR==OP_Or ); testcase( op==TK_OR ); |
4359 | assert( TK_PLUS==OP_Add ); testcase( op==TK_PLUS ); |
4360 | assert( TK_MINUS==OP_Subtract ); testcase( op==TK_MINUS ); |
4361 | assert( TK_REM==OP_Remainder ); testcase( op==TK_REM ); |
4362 | assert( TK_BITAND==OP_BitAnd ); testcase( op==TK_BITAND ); |
4363 | assert( TK_BITOR==OP_BitOr ); testcase( op==TK_BITOR ); |
4364 | assert( TK_SLASH==OP_Divide ); testcase( op==TK_SLASH ); |
4365 | assert( TK_LSHIFT==OP_ShiftLeft ); testcase( op==TK_LSHIFT ); |
4366 | assert( TK_RSHIFT==OP_ShiftRight ); testcase( op==TK_RSHIFT ); |
4367 | assert( TK_CONCAT==OP_Concat ); testcase( op==TK_CONCAT ); |
4368 | r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); |
4369 | r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2); |
4370 | sqlite3VdbeAddOp3(v, op, r2, r1, target); |
4371 | testcase( regFree1==0 ); |
4372 | testcase( regFree2==0 ); |
4373 | break; |
4374 | } |
4375 | case TK_UMINUS: { |
4376 | Expr *pLeft = pExpr->pLeft; |
4377 | assert( pLeft ); |
4378 | if( pLeft->op==TK_INTEGER ){ |
4379 | codeInteger(pParse, pLeft, 1, target); |
4380 | return target; |
4381 | #ifndef SQLITE_OMIT_FLOATING_POINT |
4382 | }else if( pLeft->op==TK_FLOAT ){ |
4383 | assert( !ExprHasProperty(pExpr, EP_IntValue) ); |
4384 | codeReal(v, pLeft->u.zToken, 1, target); |
4385 | return target; |
4386 | #endif |
4387 | }else{ |
4388 | tempX.op = TK_INTEGER; |
4389 | tempX.flags = EP_IntValue|EP_TokenOnly; |
4390 | tempX.u.iValue = 0; |
4391 | ExprClearVVAProperties(&tempX); |
4392 | r1 = sqlite3ExprCodeTemp(pParse, &tempX, ®Free1); |
4393 | r2 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free2); |
4394 | sqlite3VdbeAddOp3(v, OP_Subtract, r2, r1, target); |
4395 | testcase( regFree2==0 ); |
4396 | } |
4397 | break; |
4398 | } |
4399 | case TK_BITNOT: |
4400 | case TK_NOT: { |
4401 | assert( TK_BITNOT==OP_BitNot ); testcase( op==TK_BITNOT ); |
4402 | assert( TK_NOT==OP_Not ); testcase( op==TK_NOT ); |
4403 | r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); |
4404 | testcase( regFree1==0 ); |
4405 | sqlite3VdbeAddOp2(v, op, r1, inReg); |
4406 | break; |
4407 | } |
4408 | case TK_TRUTH: { |
4409 | int isTrue; /* IS TRUE or IS NOT TRUE */ |
4410 | int bNormal; /* IS TRUE or IS FALSE */ |
4411 | r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); |
4412 | testcase( regFree1==0 ); |
4413 | isTrue = sqlite3ExprTruthValue(pExpr->pRight); |
4414 | bNormal = pExpr->op2==TK_IS; |
4415 | testcase( isTrue && bNormal); |
4416 | testcase( !isTrue && bNormal); |
4417 | sqlite3VdbeAddOp4Int(v, OP_IsTrue, r1, inReg, !isTrue, isTrue ^ bNormal); |
4418 | break; |
4419 | } |
4420 | case TK_ISNULL: |
4421 | case TK_NOTNULL: { |
4422 | int addr; |
4423 | assert( TK_ISNULL==OP_IsNull ); testcase( op==TK_ISNULL ); |
4424 | assert( TK_NOTNULL==OP_NotNull ); testcase( op==TK_NOTNULL ); |
4425 | sqlite3VdbeAddOp2(v, OP_Integer, 1, target); |
4426 | r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); |
4427 | testcase( regFree1==0 ); |
4428 | addr = sqlite3VdbeAddOp1(v, op, r1); |
4429 | VdbeCoverageIf(v, op==TK_ISNULL); |
4430 | VdbeCoverageIf(v, op==TK_NOTNULL); |
4431 | sqlite3VdbeAddOp2(v, OP_Integer, 0, target); |
4432 | sqlite3VdbeJumpHere(v, addr); |
4433 | break; |
4434 | } |
4435 | case TK_AGG_FUNCTION: { |
4436 | AggInfo *pInfo = pExpr->pAggInfo; |
4437 | if( pInfo==0 |
4438 | || NEVER(pExpr->iAgg<0) |
4439 | || NEVER(pExpr->iAgg>=pInfo->nFunc) |
4440 | ){ |
4441 | assert( !ExprHasProperty(pExpr, EP_IntValue) ); |
4442 | sqlite3ErrorMsg(pParse, "misuse of aggregate: %#T()" , pExpr); |
4443 | }else{ |
4444 | return pInfo->aFunc[pExpr->iAgg].iMem; |
4445 | } |
4446 | break; |
4447 | } |
4448 | case TK_FUNCTION: { |
4449 | ExprList *pFarg; /* List of function arguments */ |
4450 | int nFarg; /* Number of function arguments */ |
4451 | FuncDef *pDef; /* The function definition object */ |
4452 | const char *zId; /* The function name */ |
4453 | u32 constMask = 0; /* Mask of function arguments that are constant */ |
4454 | int i; /* Loop counter */ |
4455 | sqlite3 *db = pParse->db; /* The database connection */ |
4456 | u8 enc = ENC(db); /* The text encoding used by this database */ |
4457 | CollSeq *pColl = 0; /* A collating sequence */ |
4458 | |
4459 | #ifndef SQLITE_OMIT_WINDOWFUNC |
4460 | if( ExprHasProperty(pExpr, EP_WinFunc) ){ |
4461 | return pExpr->y.pWin->regResult; |
4462 | } |
4463 | #endif |
4464 | |
4465 | if( ConstFactorOk(pParse) && sqlite3ExprIsConstantNotJoin(pExpr) ){ |
4466 | /* SQL functions can be expensive. So try to avoid running them |
4467 | ** multiple times if we know they always give the same result */ |
4468 | return sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1); |
4469 | } |
4470 | assert( !ExprHasProperty(pExpr, EP_TokenOnly) ); |
4471 | assert( ExprUseXList(pExpr) ); |
4472 | pFarg = pExpr->x.pList; |
4473 | nFarg = pFarg ? pFarg->nExpr : 0; |
4474 | assert( !ExprHasProperty(pExpr, EP_IntValue) ); |
4475 | zId = pExpr->u.zToken; |
4476 | pDef = sqlite3FindFunction(db, zId, nFarg, enc, 0); |
4477 | #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION |
4478 | if( pDef==0 && pParse->explain ){ |
4479 | pDef = sqlite3FindFunction(db, "unknown" , nFarg, enc, 0); |
4480 | } |
4481 | #endif |
4482 | if( pDef==0 || pDef->xFinalize!=0 ){ |
4483 | sqlite3ErrorMsg(pParse, "unknown function: %#T()" , pExpr); |
4484 | break; |
4485 | } |
4486 | if( pDef->funcFlags & SQLITE_FUNC_INLINE ){ |
4487 | assert( (pDef->funcFlags & SQLITE_FUNC_UNSAFE)==0 ); |
4488 | assert( (pDef->funcFlags & SQLITE_FUNC_DIRECT)==0 ); |
4489 | return exprCodeInlineFunction(pParse, pFarg, |
4490 | SQLITE_PTR_TO_INT(pDef->pUserData), target); |
4491 | }else if( pDef->funcFlags & (SQLITE_FUNC_DIRECT|SQLITE_FUNC_UNSAFE) ){ |
4492 | sqlite3ExprFunctionUsable(pParse, pExpr, pDef); |
4493 | } |
4494 | |
4495 | for(i=0; i<nFarg; i++){ |
4496 | if( i<32 && sqlite3ExprIsConstant(pFarg->a[i].pExpr) ){ |
4497 | testcase( i==31 ); |
4498 | constMask |= MASKBIT32(i); |
4499 | } |
4500 | if( (pDef->funcFlags & SQLITE_FUNC_NEEDCOLL)!=0 && !pColl ){ |
4501 | pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr); |
4502 | } |
4503 | } |
4504 | if( pFarg ){ |
4505 | if( constMask ){ |
4506 | r1 = pParse->nMem+1; |
4507 | pParse->nMem += nFarg; |
4508 | }else{ |
4509 | r1 = sqlite3GetTempRange(pParse, nFarg); |
4510 | } |
4511 | |
4512 | /* For length() and typeof() functions with a column argument, |
4513 | ** set the P5 parameter to the OP_Column opcode to OPFLAG_LENGTHARG |
4514 | ** or OPFLAG_TYPEOFARG respectively, to avoid unnecessary data |
4515 | ** loading. |
4516 | */ |
4517 | if( (pDef->funcFlags & (SQLITE_FUNC_LENGTH|SQLITE_FUNC_TYPEOF))!=0 ){ |
4518 | u8 exprOp; |
4519 | assert( nFarg==1 ); |
4520 | assert( pFarg->a[0].pExpr!=0 ); |
4521 | exprOp = pFarg->a[0].pExpr->op; |
4522 | if( exprOp==TK_COLUMN || exprOp==TK_AGG_COLUMN ){ |
4523 | assert( SQLITE_FUNC_LENGTH==OPFLAG_LENGTHARG ); |
4524 | assert( SQLITE_FUNC_TYPEOF==OPFLAG_TYPEOFARG ); |
4525 | testcase( pDef->funcFlags & OPFLAG_LENGTHARG ); |
4526 | pFarg->a[0].pExpr->op2 = |
4527 | pDef->funcFlags & (OPFLAG_LENGTHARG|OPFLAG_TYPEOFARG); |
4528 | } |
4529 | } |
4530 | |
4531 | sqlite3ExprCodeExprList(pParse, pFarg, r1, 0, |
4532 | SQLITE_ECEL_DUP|SQLITE_ECEL_FACTOR); |
4533 | }else{ |
4534 | r1 = 0; |
4535 | } |
4536 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
4537 | /* Possibly overload the function if the first argument is |
4538 | ** a virtual table column. |
4539 | ** |
4540 | ** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the |
4541 | ** second argument, not the first, as the argument to test to |
4542 | ** see if it is a column in a virtual table. This is done because |
4543 | ** the left operand of infix functions (the operand we want to |
4544 | ** control overloading) ends up as the second argument to the |
4545 | ** function. The expression "A glob B" is equivalent to |
4546 | ** "glob(B,A). We want to use the A in "A glob B" to test |
4547 | ** for function overloading. But we use the B term in "glob(B,A)". |
4548 | */ |
4549 | if( nFarg>=2 && ExprHasProperty(pExpr, EP_InfixFunc) ){ |
4550 | pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[1].pExpr); |
4551 | }else if( nFarg>0 ){ |
4552 | pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[0].pExpr); |
4553 | } |
4554 | #endif |
4555 | if( pDef->funcFlags & SQLITE_FUNC_NEEDCOLL ){ |
4556 | if( !pColl ) pColl = db->pDfltColl; |
4557 | sqlite3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ); |
4558 | } |
4559 | sqlite3VdbeAddFunctionCall(pParse, constMask, r1, target, nFarg, |
4560 | pDef, pExpr->op2); |
4561 | if( nFarg ){ |
4562 | if( constMask==0 ){ |
4563 | sqlite3ReleaseTempRange(pParse, r1, nFarg); |
4564 | }else{ |
4565 | sqlite3VdbeReleaseRegisters(pParse, r1, nFarg, constMask, 1); |
4566 | } |
4567 | } |
4568 | return target; |
4569 | } |
4570 | #ifndef SQLITE_OMIT_SUBQUERY |
4571 | case TK_EXISTS: |
4572 | case TK_SELECT: { |
4573 | int nCol; |
4574 | testcase( op==TK_EXISTS ); |
4575 | testcase( op==TK_SELECT ); |
4576 | if( pParse->db->mallocFailed ){ |
4577 | return 0; |
4578 | }else if( op==TK_SELECT |
4579 | && ALWAYS( ExprUseXSelect(pExpr) ) |
4580 | && (nCol = pExpr->x.pSelect->pEList->nExpr)!=1 |
4581 | ){ |
4582 | sqlite3SubselectError(pParse, nCol, 1); |
4583 | }else{ |
4584 | return sqlite3CodeSubselect(pParse, pExpr); |
4585 | } |
4586 | break; |
4587 | } |
4588 | case TK_SELECT_COLUMN: { |
4589 | int n; |
4590 | Expr *pLeft = pExpr->pLeft; |
4591 | if( pLeft->iTable==0 || pParse->withinRJSubrtn > pLeft->op2 ){ |
4592 | pLeft->iTable = sqlite3CodeSubselect(pParse, pLeft); |
4593 | pLeft->op2 = pParse->withinRJSubrtn; |
4594 | } |
4595 | assert( pLeft->op==TK_SELECT || pLeft->op==TK_ERROR ); |
4596 | n = sqlite3ExprVectorSize(pLeft); |
4597 | if( pExpr->iTable!=n ){ |
4598 | sqlite3ErrorMsg(pParse, "%d columns assigned %d values" , |
4599 | pExpr->iTable, n); |
4600 | } |
4601 | return pLeft->iTable + pExpr->iColumn; |
4602 | } |
4603 | case TK_IN: { |
4604 | int destIfFalse = sqlite3VdbeMakeLabel(pParse); |
4605 | int destIfNull = sqlite3VdbeMakeLabel(pParse); |
4606 | sqlite3VdbeAddOp2(v, OP_Null, 0, target); |
4607 | sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull); |
4608 | sqlite3VdbeAddOp2(v, OP_Integer, 1, target); |
4609 | sqlite3VdbeResolveLabel(v, destIfFalse); |
4610 | sqlite3VdbeAddOp2(v, OP_AddImm, target, 0); |
4611 | sqlite3VdbeResolveLabel(v, destIfNull); |
4612 | return target; |
4613 | } |
4614 | #endif /* SQLITE_OMIT_SUBQUERY */ |
4615 | |
4616 | |
4617 | /* |
4618 | ** x BETWEEN y AND z |
4619 | ** |
4620 | ** This is equivalent to |
4621 | ** |
4622 | ** x>=y AND x<=z |
4623 | ** |
4624 | ** X is stored in pExpr->pLeft. |
4625 | ** Y is stored in pExpr->pList->a[0].pExpr. |
4626 | ** Z is stored in pExpr->pList->a[1].pExpr. |
4627 | */ |
4628 | case TK_BETWEEN: { |
4629 | exprCodeBetween(pParse, pExpr, target, 0, 0); |
4630 | return target; |
4631 | } |
4632 | case TK_COLLATE: { |
4633 | if( !ExprHasProperty(pExpr, EP_Collate) |
4634 | && ALWAYS(pExpr->pLeft) |
4635 | && pExpr->pLeft->op==TK_FUNCTION |
4636 | ){ |
4637 | inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target); |
4638 | if( inReg!=target ){ |
4639 | sqlite3VdbeAddOp2(v, OP_SCopy, inReg, target); |
4640 | inReg = target; |
4641 | } |
4642 | sqlite3VdbeAddOp1(v, OP_ClrSubtype, inReg); |
4643 | return inReg; |
4644 | }else{ |
4645 | pExpr = pExpr->pLeft; |
4646 | goto expr_code_doover; /* 2018-04-28: Prevent deep recursion. */ |
4647 | } |
4648 | } |
4649 | case TK_SPAN: |
4650 | case TK_UPLUS: { |
4651 | pExpr = pExpr->pLeft; |
4652 | goto expr_code_doover; /* 2018-04-28: Prevent deep recursion. OSSFuzz. */ |
4653 | } |
4654 | |
4655 | case TK_TRIGGER: { |
4656 | /* If the opcode is TK_TRIGGER, then the expression is a reference |
4657 | ** to a column in the new.* or old.* pseudo-tables available to |
4658 | ** trigger programs. In this case Expr.iTable is set to 1 for the |
4659 | ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn |
4660 | ** is set to the column of the pseudo-table to read, or to -1 to |
4661 | ** read the rowid field. |
4662 | ** |
4663 | ** The expression is implemented using an OP_Param opcode. The p1 |
4664 | ** parameter is set to 0 for an old.rowid reference, or to (i+1) |
4665 | ** to reference another column of the old.* pseudo-table, where |
4666 | ** i is the index of the column. For a new.rowid reference, p1 is |
4667 | ** set to (n+1), where n is the number of columns in each pseudo-table. |
4668 | ** For a reference to any other column in the new.* pseudo-table, p1 |
4669 | ** is set to (n+2+i), where n and i are as defined previously. For |
4670 | ** example, if the table on which triggers are being fired is |
4671 | ** declared as: |
4672 | ** |
4673 | ** CREATE TABLE t1(a, b); |
4674 | ** |
4675 | ** Then p1 is interpreted as follows: |
4676 | ** |
4677 | ** p1==0 -> old.rowid p1==3 -> new.rowid |
4678 | ** p1==1 -> old.a p1==4 -> new.a |
4679 | ** p1==2 -> old.b p1==5 -> new.b |
4680 | */ |
4681 | Table *pTab; |
4682 | int iCol; |
4683 | int p1; |
4684 | |
4685 | assert( ExprUseYTab(pExpr) ); |
4686 | pTab = pExpr->y.pTab; |
4687 | iCol = pExpr->iColumn; |
4688 | p1 = pExpr->iTable * (pTab->nCol+1) + 1 |
4689 | + sqlite3TableColumnToStorage(pTab, iCol); |
4690 | |
4691 | assert( pExpr->iTable==0 || pExpr->iTable==1 ); |
4692 | assert( iCol>=-1 && iCol<pTab->nCol ); |
4693 | assert( pTab->iPKey<0 || iCol!=pTab->iPKey ); |
4694 | assert( p1>=0 && p1<(pTab->nCol*2+2) ); |
4695 | |
4696 | sqlite3VdbeAddOp2(v, OP_Param, p1, target); |
4697 | VdbeComment((v, "r[%d]=%s.%s" , target, |
4698 | (pExpr->iTable ? "new" : "old" ), |
4699 | (pExpr->iColumn<0 ? "rowid" : pExpr->y.pTab->aCol[iCol].zCnName) |
4700 | )); |
4701 | |
4702 | #ifndef SQLITE_OMIT_FLOATING_POINT |
4703 | /* If the column has REAL affinity, it may currently be stored as an |
4704 | ** integer. Use OP_RealAffinity to make sure it is really real. |
4705 | ** |
4706 | ** EVIDENCE-OF: R-60985-57662 SQLite will convert the value back to |
4707 | ** floating point when extracting it from the record. */ |
4708 | if( iCol>=0 && pTab->aCol[iCol].affinity==SQLITE_AFF_REAL ){ |
4709 | sqlite3VdbeAddOp1(v, OP_RealAffinity, target); |
4710 | } |
4711 | #endif |
4712 | break; |
4713 | } |
4714 | |
4715 | case TK_VECTOR: { |
4716 | sqlite3ErrorMsg(pParse, "row value misused" ); |
4717 | break; |
4718 | } |
4719 | |
4720 | /* TK_IF_NULL_ROW Expr nodes are inserted ahead of expressions |
4721 | ** that derive from the right-hand table of a LEFT JOIN. The |
4722 | ** Expr.iTable value is the table number for the right-hand table. |
4723 | ** The expression is only evaluated if that table is not currently |
4724 | ** on a LEFT JOIN NULL row. |
4725 | */ |
4726 | case TK_IF_NULL_ROW: { |
4727 | int addrINR; |
4728 | u8 okConstFactor = pParse->okConstFactor; |
4729 | AggInfo *pAggInfo = pExpr->pAggInfo; |
4730 | if( pAggInfo ){ |
4731 | assert( pExpr->iAgg>=0 && pExpr->iAgg<pAggInfo->nColumn ); |
4732 | if( !pAggInfo->directMode ){ |
4733 | inReg = pAggInfo->aCol[pExpr->iAgg].iMem; |
4734 | break; |
4735 | } |
4736 | if( pExpr->pAggInfo->useSortingIdx ){ |
4737 | sqlite3VdbeAddOp3(v, OP_Column, pAggInfo->sortingIdxPTab, |
4738 | pAggInfo->aCol[pExpr->iAgg].iSorterColumn, |
4739 | target); |
4740 | inReg = target; |
4741 | break; |
4742 | } |
4743 | } |
4744 | addrINR = sqlite3VdbeAddOp1(v, OP_IfNullRow, pExpr->iTable); |
4745 | /* Temporarily disable factoring of constant expressions, since |
4746 | ** even though expressions may appear to be constant, they are not |
4747 | ** really constant because they originate from the right-hand side |
4748 | ** of a LEFT JOIN. */ |
4749 | pParse->okConstFactor = 0; |
4750 | inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target); |
4751 | pParse->okConstFactor = okConstFactor; |
4752 | sqlite3VdbeJumpHere(v, addrINR); |
4753 | sqlite3VdbeChangeP3(v, addrINR, inReg); |
4754 | break; |
4755 | } |
4756 | |
4757 | /* |
4758 | ** Form A: |
4759 | ** CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END |
4760 | ** |
4761 | ** Form B: |
4762 | ** CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END |
4763 | ** |
4764 | ** Form A is can be transformed into the equivalent form B as follows: |
4765 | ** CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ... |
4766 | ** WHEN x=eN THEN rN ELSE y END |
4767 | ** |
4768 | ** X (if it exists) is in pExpr->pLeft. |
4769 | ** Y is in the last element of pExpr->x.pList if pExpr->x.pList->nExpr is |
4770 | ** odd. The Y is also optional. If the number of elements in x.pList |
4771 | ** is even, then Y is omitted and the "otherwise" result is NULL. |
4772 | ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1]. |
4773 | ** |
4774 | ** The result of the expression is the Ri for the first matching Ei, |
4775 | ** or if there is no matching Ei, the ELSE term Y, or if there is |
4776 | ** no ELSE term, NULL. |
4777 | */ |
4778 | case TK_CASE: { |
4779 | int endLabel; /* GOTO label for end of CASE stmt */ |
4780 | int nextCase; /* GOTO label for next WHEN clause */ |
4781 | int nExpr; /* 2x number of WHEN terms */ |
4782 | int i; /* Loop counter */ |
4783 | ExprList *pEList; /* List of WHEN terms */ |
4784 | struct ExprList_item *aListelem; /* Array of WHEN terms */ |
4785 | Expr opCompare; /* The X==Ei expression */ |
4786 | Expr *pX; /* The X expression */ |
4787 | Expr *pTest = 0; /* X==Ei (form A) or just Ei (form B) */ |
4788 | Expr *pDel = 0; |
4789 | sqlite3 *db = pParse->db; |
4790 | |
4791 | assert( ExprUseXList(pExpr) && pExpr->x.pList!=0 ); |
4792 | assert(pExpr->x.pList->nExpr > 0); |
4793 | pEList = pExpr->x.pList; |
4794 | aListelem = pEList->a; |
4795 | nExpr = pEList->nExpr; |
4796 | endLabel = sqlite3VdbeMakeLabel(pParse); |
4797 | if( (pX = pExpr->pLeft)!=0 ){ |
4798 | pDel = sqlite3ExprDup(db, pX, 0); |
4799 | if( db->mallocFailed ){ |
4800 | sqlite3ExprDelete(db, pDel); |
4801 | break; |
4802 | } |
4803 | testcase( pX->op==TK_COLUMN ); |
4804 | exprToRegister(pDel, exprCodeVector(pParse, pDel, ®Free1)); |
4805 | testcase( regFree1==0 ); |
4806 | memset(&opCompare, 0, sizeof(opCompare)); |
4807 | opCompare.op = TK_EQ; |
4808 | opCompare.pLeft = pDel; |
4809 | pTest = &opCompare; |
4810 | /* Ticket b351d95f9cd5ef17e9d9dbae18f5ca8611190001: |
4811 | ** The value in regFree1 might get SCopy-ed into the file result. |
4812 | ** So make sure that the regFree1 register is not reused for other |
4813 | ** purposes and possibly overwritten. */ |
4814 | regFree1 = 0; |
4815 | } |
4816 | for(i=0; i<nExpr-1; i=i+2){ |
4817 | if( pX ){ |
4818 | assert( pTest!=0 ); |
4819 | opCompare.pRight = aListelem[i].pExpr; |
4820 | }else{ |
4821 | pTest = aListelem[i].pExpr; |
4822 | } |
4823 | nextCase = sqlite3VdbeMakeLabel(pParse); |
4824 | testcase( pTest->op==TK_COLUMN ); |
4825 | sqlite3ExprIfFalse(pParse, pTest, nextCase, SQLITE_JUMPIFNULL); |
4826 | testcase( aListelem[i+1].pExpr->op==TK_COLUMN ); |
4827 | sqlite3ExprCode(pParse, aListelem[i+1].pExpr, target); |
4828 | sqlite3VdbeGoto(v, endLabel); |
4829 | sqlite3VdbeResolveLabel(v, nextCase); |
4830 | } |
4831 | if( (nExpr&1)!=0 ){ |
4832 | sqlite3ExprCode(pParse, pEList->a[nExpr-1].pExpr, target); |
4833 | }else{ |
4834 | sqlite3VdbeAddOp2(v, OP_Null, 0, target); |
4835 | } |
4836 | sqlite3ExprDelete(db, pDel); |
4837 | setDoNotMergeFlagOnCopy(v); |
4838 | sqlite3VdbeResolveLabel(v, endLabel); |
4839 | break; |
4840 | } |
4841 | #ifndef SQLITE_OMIT_TRIGGER |
4842 | case TK_RAISE: { |
4843 | assert( pExpr->affExpr==OE_Rollback |
4844 | || pExpr->affExpr==OE_Abort |
4845 | || pExpr->affExpr==OE_Fail |
4846 | || pExpr->affExpr==OE_Ignore |
4847 | ); |
4848 | if( !pParse->pTriggerTab && !pParse->nested ){ |
4849 | sqlite3ErrorMsg(pParse, |
4850 | "RAISE() may only be used within a trigger-program" ); |
4851 | return 0; |
4852 | } |
4853 | if( pExpr->affExpr==OE_Abort ){ |
4854 | sqlite3MayAbort(pParse); |
4855 | } |
4856 | assert( !ExprHasProperty(pExpr, EP_IntValue) ); |
4857 | if( pExpr->affExpr==OE_Ignore ){ |
4858 | sqlite3VdbeAddOp4( |
4859 | v, OP_Halt, SQLITE_OK, OE_Ignore, 0, pExpr->u.zToken,0); |
4860 | VdbeCoverage(v); |
4861 | }else{ |
4862 | sqlite3HaltConstraint(pParse, |
4863 | pParse->pTriggerTab ? SQLITE_CONSTRAINT_TRIGGER : SQLITE_ERROR, |
4864 | pExpr->affExpr, pExpr->u.zToken, 0, 0); |
4865 | } |
4866 | |
4867 | break; |
4868 | } |
4869 | #endif |
4870 | } |
4871 | sqlite3ReleaseTempReg(pParse, regFree1); |
4872 | sqlite3ReleaseTempReg(pParse, regFree2); |
4873 | return inReg; |
4874 | } |
4875 | |
4876 | /* |
4877 | ** Generate code that will evaluate expression pExpr just one time |
4878 | ** per prepared statement execution. |
4879 | ** |
4880 | ** If the expression uses functions (that might throw an exception) then |
4881 | ** guard them with an OP_Once opcode to ensure that the code is only executed |
4882 | ** once. If no functions are involved, then factor the code out and put it at |
4883 | ** the end of the prepared statement in the initialization section. |
4884 | ** |
4885 | ** If regDest>=0 then the result is always stored in that register and the |
4886 | ** result is not reusable. If regDest<0 then this routine is free to |
4887 | ** store the value whereever it wants. The register where the expression |
4888 | ** is stored is returned. When regDest<0, two identical expressions might |
4889 | ** code to the same register, if they do not contain function calls and hence |
4890 | ** are factored out into the initialization section at the end of the |
4891 | ** prepared statement. |
4892 | */ |
4893 | int sqlite3ExprCodeRunJustOnce( |
4894 | Parse *pParse, /* Parsing context */ |
4895 | Expr *pExpr, /* The expression to code when the VDBE initializes */ |
4896 | int regDest /* Store the value in this register */ |
4897 | ){ |
4898 | ExprList *p; |
4899 | assert( ConstFactorOk(pParse) ); |
4900 | p = pParse->pConstExpr; |
4901 | if( regDest<0 && p ){ |
4902 | struct ExprList_item *pItem; |
4903 | int i; |
4904 | for(pItem=p->a, i=p->nExpr; i>0; pItem++, i--){ |
4905 | if( pItem->fg.reusable |
4906 | && sqlite3ExprCompare(0,pItem->pExpr,pExpr,-1)==0 |
4907 | ){ |
4908 | return pItem->u.iConstExprReg; |
4909 | } |
4910 | } |
4911 | } |
4912 | pExpr = sqlite3ExprDup(pParse->db, pExpr, 0); |
4913 | if( pExpr!=0 && ExprHasProperty(pExpr, EP_HasFunc) ){ |
4914 | Vdbe *v = pParse->pVdbe; |
4915 | int addr; |
4916 | assert( v ); |
4917 | addr = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); |
4918 | pParse->okConstFactor = 0; |
4919 | if( !pParse->db->mallocFailed ){ |
4920 | if( regDest<0 ) regDest = ++pParse->nMem; |
4921 | sqlite3ExprCode(pParse, pExpr, regDest); |
4922 | } |
4923 | pParse->okConstFactor = 1; |
4924 | sqlite3ExprDelete(pParse->db, pExpr); |
4925 | sqlite3VdbeJumpHere(v, addr); |
4926 | }else{ |
4927 | p = sqlite3ExprListAppend(pParse, p, pExpr); |
4928 | if( p ){ |
4929 | struct ExprList_item *pItem = &p->a[p->nExpr-1]; |
4930 | pItem->fg.reusable = regDest<0; |
4931 | if( regDest<0 ) regDest = ++pParse->nMem; |
4932 | pItem->u.iConstExprReg = regDest; |
4933 | } |
4934 | pParse->pConstExpr = p; |
4935 | } |
4936 | return regDest; |
4937 | } |
4938 | |
4939 | /* |
4940 | ** Generate code to evaluate an expression and store the results |
4941 | ** into a register. Return the register number where the results |
4942 | ** are stored. |
4943 | ** |
4944 | ** If the register is a temporary register that can be deallocated, |
4945 | ** then write its number into *pReg. If the result register is not |
4946 | ** a temporary, then set *pReg to zero. |
4947 | ** |
4948 | ** If pExpr is a constant, then this routine might generate this |
4949 | ** code to fill the register in the initialization section of the |
4950 | ** VDBE program, in order to factor it out of the evaluation loop. |
4951 | */ |
4952 | int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){ |
4953 | int r2; |
4954 | pExpr = sqlite3ExprSkipCollateAndLikely(pExpr); |
4955 | if( ConstFactorOk(pParse) |
4956 | && ALWAYS(pExpr!=0) |
4957 | && pExpr->op!=TK_REGISTER |
4958 | && sqlite3ExprIsConstantNotJoin(pExpr) |
4959 | ){ |
4960 | *pReg = 0; |
4961 | r2 = sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1); |
4962 | }else{ |
4963 | int r1 = sqlite3GetTempReg(pParse); |
4964 | r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1); |
4965 | if( r2==r1 ){ |
4966 | *pReg = r1; |
4967 | }else{ |
4968 | sqlite3ReleaseTempReg(pParse, r1); |
4969 | *pReg = 0; |
4970 | } |
4971 | } |
4972 | return r2; |
4973 | } |
4974 | |
4975 | /* |
4976 | ** Generate code that will evaluate expression pExpr and store the |
4977 | ** results in register target. The results are guaranteed to appear |
4978 | ** in register target. |
4979 | */ |
4980 | void sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){ |
4981 | int inReg; |
4982 | |
4983 | assert( pExpr==0 || !ExprHasVVAProperty(pExpr,EP_Immutable) ); |
4984 | assert( target>0 && target<=pParse->nMem ); |
4985 | assert( pParse->pVdbe!=0 || pParse->db->mallocFailed ); |
4986 | if( pParse->pVdbe==0 ) return; |
4987 | inReg = sqlite3ExprCodeTarget(pParse, pExpr, target); |
4988 | if( inReg!=target ){ |
4989 | u8 op; |
4990 | if( ALWAYS(pExpr) && ExprHasProperty(pExpr,EP_Subquery) ){ |
4991 | op = OP_Copy; |
4992 | }else{ |
4993 | op = OP_SCopy; |
4994 | } |
4995 | sqlite3VdbeAddOp2(pParse->pVdbe, op, inReg, target); |
4996 | } |
4997 | } |
4998 | |
4999 | /* |
5000 | ** Make a transient copy of expression pExpr and then code it using |
5001 | ** sqlite3ExprCode(). This routine works just like sqlite3ExprCode() |
5002 | ** except that the input expression is guaranteed to be unchanged. |
5003 | */ |
5004 | void sqlite3ExprCodeCopy(Parse *pParse, Expr *pExpr, int target){ |
5005 | sqlite3 *db = pParse->db; |
5006 | pExpr = sqlite3ExprDup(db, pExpr, 0); |
5007 | if( !db->mallocFailed ) sqlite3ExprCode(pParse, pExpr, target); |
5008 | sqlite3ExprDelete(db, pExpr); |
5009 | } |
5010 | |
5011 | /* |
5012 | ** Generate code that will evaluate expression pExpr and store the |
5013 | ** results in register target. The results are guaranteed to appear |
5014 | ** in register target. If the expression is constant, then this routine |
5015 | ** might choose to code the expression at initialization time. |
5016 | */ |
5017 | void sqlite3ExprCodeFactorable(Parse *pParse, Expr *pExpr, int target){ |
5018 | if( pParse->okConstFactor && sqlite3ExprIsConstantNotJoin(pExpr) ){ |
5019 | sqlite3ExprCodeRunJustOnce(pParse, pExpr, target); |
5020 | }else{ |
5021 | sqlite3ExprCodeCopy(pParse, pExpr, target); |
5022 | } |
5023 | } |
5024 | |
5025 | /* |
5026 | ** Generate code that pushes the value of every element of the given |
5027 | ** expression list into a sequence of registers beginning at target. |
5028 | ** |
5029 | ** Return the number of elements evaluated. The number returned will |
5030 | ** usually be pList->nExpr but might be reduced if SQLITE_ECEL_OMITREF |
5031 | ** is defined. |
5032 | ** |
5033 | ** The SQLITE_ECEL_DUP flag prevents the arguments from being |
5034 | ** filled using OP_SCopy. OP_Copy must be used instead. |
5035 | ** |
5036 | ** The SQLITE_ECEL_FACTOR argument allows constant arguments to be |
5037 | ** factored out into initialization code. |
5038 | ** |
5039 | ** The SQLITE_ECEL_REF flag means that expressions in the list with |
5040 | ** ExprList.a[].u.x.iOrderByCol>0 have already been evaluated and stored |
5041 | ** in registers at srcReg, and so the value can be copied from there. |
5042 | ** If SQLITE_ECEL_OMITREF is also set, then the values with u.x.iOrderByCol>0 |
5043 | ** are simply omitted rather than being copied from srcReg. |
5044 | */ |
5045 | int sqlite3ExprCodeExprList( |
5046 | Parse *pParse, /* Parsing context */ |
5047 | ExprList *pList, /* The expression list to be coded */ |
5048 | int target, /* Where to write results */ |
5049 | int srcReg, /* Source registers if SQLITE_ECEL_REF */ |
5050 | u8 flags /* SQLITE_ECEL_* flags */ |
5051 | ){ |
5052 | struct ExprList_item *pItem; |
5053 | int i, j, n; |
5054 | u8 copyOp = (flags & SQLITE_ECEL_DUP) ? OP_Copy : OP_SCopy; |
5055 | Vdbe *v = pParse->pVdbe; |
5056 | assert( pList!=0 ); |
5057 | assert( target>0 ); |
5058 | assert( pParse->pVdbe!=0 ); /* Never gets this far otherwise */ |
5059 | n = pList->nExpr; |
5060 | if( !ConstFactorOk(pParse) ) flags &= ~SQLITE_ECEL_FACTOR; |
5061 | for(pItem=pList->a, i=0; i<n; i++, pItem++){ |
5062 | Expr *pExpr = pItem->pExpr; |
5063 | #ifdef SQLITE_ENABLE_SORTER_REFERENCES |
5064 | if( pItem->fg.bSorterRef ){ |
5065 | i--; |
5066 | n--; |
5067 | }else |
5068 | #endif |
5069 | if( (flags & SQLITE_ECEL_REF)!=0 && (j = pItem->u.x.iOrderByCol)>0 ){ |
5070 | if( flags & SQLITE_ECEL_OMITREF ){ |
5071 | i--; |
5072 | n--; |
5073 | }else{ |
5074 | sqlite3VdbeAddOp2(v, copyOp, j+srcReg-1, target+i); |
5075 | } |
5076 | }else if( (flags & SQLITE_ECEL_FACTOR)!=0 |
5077 | && sqlite3ExprIsConstantNotJoin(pExpr) |
5078 | ){ |
5079 | sqlite3ExprCodeRunJustOnce(pParse, pExpr, target+i); |
5080 | }else{ |
5081 | int inReg = sqlite3ExprCodeTarget(pParse, pExpr, target+i); |
5082 | if( inReg!=target+i ){ |
5083 | VdbeOp *pOp; |
5084 | if( copyOp==OP_Copy |
5085 | && (pOp=sqlite3VdbeGetLastOp(v))->opcode==OP_Copy |
5086 | && pOp->p1+pOp->p3+1==inReg |
5087 | && pOp->p2+pOp->p3+1==target+i |
5088 | && pOp->p5==0 /* The do-not-merge flag must be clear */ |
5089 | ){ |
5090 | pOp->p3++; |
5091 | }else{ |
5092 | sqlite3VdbeAddOp2(v, copyOp, inReg, target+i); |
5093 | } |
5094 | } |
5095 | } |
5096 | } |
5097 | return n; |
5098 | } |
5099 | |
5100 | /* |
5101 | ** Generate code for a BETWEEN operator. |
5102 | ** |
5103 | ** x BETWEEN y AND z |
5104 | ** |
5105 | ** The above is equivalent to |
5106 | ** |
5107 | ** x>=y AND x<=z |
5108 | ** |
5109 | ** Code it as such, taking care to do the common subexpression |
5110 | ** elimination of x. |
5111 | ** |
5112 | ** The xJumpIf parameter determines details: |
5113 | ** |
5114 | ** NULL: Store the boolean result in reg[dest] |
5115 | ** sqlite3ExprIfTrue: Jump to dest if true |
5116 | ** sqlite3ExprIfFalse: Jump to dest if false |
5117 | ** |
5118 | ** The jumpIfNull parameter is ignored if xJumpIf is NULL. |
5119 | */ |
5120 | static void exprCodeBetween( |
5121 | Parse *pParse, /* Parsing and code generating context */ |
5122 | Expr *pExpr, /* The BETWEEN expression */ |
5123 | int dest, /* Jump destination or storage location */ |
5124 | void (*xJump)(Parse*,Expr*,int,int), /* Action to take */ |
5125 | int jumpIfNull /* Take the jump if the BETWEEN is NULL */ |
5126 | ){ |
5127 | Expr exprAnd; /* The AND operator in x>=y AND x<=z */ |
5128 | Expr compLeft; /* The x>=y term */ |
5129 | Expr compRight; /* The x<=z term */ |
5130 | int regFree1 = 0; /* Temporary use register */ |
5131 | Expr *pDel = 0; |
5132 | sqlite3 *db = pParse->db; |
5133 | |
5134 | memset(&compLeft, 0, sizeof(Expr)); |
5135 | memset(&compRight, 0, sizeof(Expr)); |
5136 | memset(&exprAnd, 0, sizeof(Expr)); |
5137 | |
5138 | assert( ExprUseXList(pExpr) ); |
5139 | pDel = sqlite3ExprDup(db, pExpr->pLeft, 0); |
5140 | if( db->mallocFailed==0 ){ |
5141 | exprAnd.op = TK_AND; |
5142 | exprAnd.pLeft = &compLeft; |
5143 | exprAnd.pRight = &compRight; |
5144 | compLeft.op = TK_GE; |
5145 | compLeft.pLeft = pDel; |
5146 | compLeft.pRight = pExpr->x.pList->a[0].pExpr; |
5147 | compRight.op = TK_LE; |
5148 | compRight.pLeft = pDel; |
5149 | compRight.pRight = pExpr->x.pList->a[1].pExpr; |
5150 | exprToRegister(pDel, exprCodeVector(pParse, pDel, ®Free1)); |
5151 | if( xJump ){ |
5152 | xJump(pParse, &exprAnd, dest, jumpIfNull); |
5153 | }else{ |
5154 | /* Mark the expression is being from the ON or USING clause of a join |
5155 | ** so that the sqlite3ExprCodeTarget() routine will not attempt to move |
5156 | ** it into the Parse.pConstExpr list. We should use a new bit for this, |
5157 | ** for clarity, but we are out of bits in the Expr.flags field so we |
5158 | ** have to reuse the EP_OuterON bit. Bummer. */ |
5159 | pDel->flags |= EP_OuterON; |
5160 | sqlite3ExprCodeTarget(pParse, &exprAnd, dest); |
5161 | } |
5162 | sqlite3ReleaseTempReg(pParse, regFree1); |
5163 | } |
5164 | sqlite3ExprDelete(db, pDel); |
5165 | |
5166 | /* Ensure adequate test coverage */ |
5167 | testcase( xJump==sqlite3ExprIfTrue && jumpIfNull==0 && regFree1==0 ); |
5168 | testcase( xJump==sqlite3ExprIfTrue && jumpIfNull==0 && regFree1!=0 ); |
5169 | testcase( xJump==sqlite3ExprIfTrue && jumpIfNull!=0 && regFree1==0 ); |
5170 | testcase( xJump==sqlite3ExprIfTrue && jumpIfNull!=0 && regFree1!=0 ); |
5171 | testcase( xJump==sqlite3ExprIfFalse && jumpIfNull==0 && regFree1==0 ); |
5172 | testcase( xJump==sqlite3ExprIfFalse && jumpIfNull==0 && regFree1!=0 ); |
5173 | testcase( xJump==sqlite3ExprIfFalse && jumpIfNull!=0 && regFree1==0 ); |
5174 | testcase( xJump==sqlite3ExprIfFalse && jumpIfNull!=0 && regFree1!=0 ); |
5175 | testcase( xJump==0 ); |
5176 | } |
5177 | |
5178 | /* |
5179 | ** Generate code for a boolean expression such that a jump is made |
5180 | ** to the label "dest" if the expression is true but execution |
5181 | ** continues straight thru if the expression is false. |
5182 | ** |
5183 | ** If the expression evaluates to NULL (neither true nor false), then |
5184 | ** take the jump if the jumpIfNull flag is SQLITE_JUMPIFNULL. |
5185 | ** |
5186 | ** This code depends on the fact that certain token values (ex: TK_EQ) |
5187 | ** are the same as opcode values (ex: OP_Eq) that implement the corresponding |
5188 | ** operation. Special comments in vdbe.c and the mkopcodeh.awk script in |
5189 | ** the make process cause these values to align. Assert()s in the code |
5190 | ** below verify that the numbers are aligned correctly. |
5191 | */ |
5192 | void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){ |
5193 | Vdbe *v = pParse->pVdbe; |
5194 | int op = 0; |
5195 | int regFree1 = 0; |
5196 | int regFree2 = 0; |
5197 | int r1, r2; |
5198 | |
5199 | assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 ); |
5200 | if( NEVER(v==0) ) return; /* Existence of VDBE checked by caller */ |
5201 | if( NEVER(pExpr==0) ) return; /* No way this can happen */ |
5202 | assert( !ExprHasVVAProperty(pExpr, EP_Immutable) ); |
5203 | op = pExpr->op; |
5204 | switch( op ){ |
5205 | case TK_AND: |
5206 | case TK_OR: { |
5207 | Expr *pAlt = sqlite3ExprSimplifiedAndOr(pExpr); |
5208 | if( pAlt!=pExpr ){ |
5209 | sqlite3ExprIfTrue(pParse, pAlt, dest, jumpIfNull); |
5210 | }else if( op==TK_AND ){ |
5211 | int d2 = sqlite3VdbeMakeLabel(pParse); |
5212 | testcase( jumpIfNull==0 ); |
5213 | sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2, |
5214 | jumpIfNull^SQLITE_JUMPIFNULL); |
5215 | sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull); |
5216 | sqlite3VdbeResolveLabel(v, d2); |
5217 | }else{ |
5218 | testcase( jumpIfNull==0 ); |
5219 | sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull); |
5220 | sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull); |
5221 | } |
5222 | break; |
5223 | } |
5224 | case TK_NOT: { |
5225 | testcase( jumpIfNull==0 ); |
5226 | sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull); |
5227 | break; |
5228 | } |
5229 | case TK_TRUTH: { |
5230 | int isNot; /* IS NOT TRUE or IS NOT FALSE */ |
5231 | int isTrue; /* IS TRUE or IS NOT TRUE */ |
5232 | testcase( jumpIfNull==0 ); |
5233 | isNot = pExpr->op2==TK_ISNOT; |
5234 | isTrue = sqlite3ExprTruthValue(pExpr->pRight); |
5235 | testcase( isTrue && isNot ); |
5236 | testcase( !isTrue && isNot ); |
5237 | if( isTrue ^ isNot ){ |
5238 | sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, |
5239 | isNot ? SQLITE_JUMPIFNULL : 0); |
5240 | }else{ |
5241 | sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, |
5242 | isNot ? SQLITE_JUMPIFNULL : 0); |
5243 | } |
5244 | break; |
5245 | } |
5246 | case TK_IS: |
5247 | case TK_ISNOT: |
5248 | testcase( op==TK_IS ); |
5249 | testcase( op==TK_ISNOT ); |
5250 | op = (op==TK_IS) ? TK_EQ : TK_NE; |
5251 | jumpIfNull = SQLITE_NULLEQ; |
5252 | /* no break */ deliberate_fall_through |
5253 | case TK_LT: |
5254 | case TK_LE: |
5255 | case TK_GT: |
5256 | case TK_GE: |
5257 | case TK_NE: |
5258 | case TK_EQ: { |
5259 | if( sqlite3ExprIsVector(pExpr->pLeft) ) goto default_expr; |
5260 | testcase( jumpIfNull==0 ); |
5261 | r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); |
5262 | r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2); |
5263 | codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op, |
5264 | r1, r2, dest, jumpIfNull, ExprHasProperty(pExpr,EP_Commuted)); |
5265 | assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt); |
5266 | assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le); |
5267 | assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt); |
5268 | assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge); |
5269 | assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); |
5270 | VdbeCoverageIf(v, op==OP_Eq && jumpIfNull==SQLITE_NULLEQ); |
5271 | VdbeCoverageIf(v, op==OP_Eq && jumpIfNull!=SQLITE_NULLEQ); |
5272 | assert(TK_NE==OP_Ne); testcase(op==OP_Ne); |
5273 | VdbeCoverageIf(v, op==OP_Ne && jumpIfNull==SQLITE_NULLEQ); |
5274 | VdbeCoverageIf(v, op==OP_Ne && jumpIfNull!=SQLITE_NULLEQ); |
5275 | testcase( regFree1==0 ); |
5276 | testcase( regFree2==0 ); |
5277 | break; |
5278 | } |
5279 | case TK_ISNULL: |
5280 | case TK_NOTNULL: { |
5281 | assert( TK_ISNULL==OP_IsNull ); testcase( op==TK_ISNULL ); |
5282 | assert( TK_NOTNULL==OP_NotNull ); testcase( op==TK_NOTNULL ); |
5283 | r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); |
5284 | sqlite3VdbeTypeofColumn(v, r1); |
5285 | sqlite3VdbeAddOp2(v, op, r1, dest); |
5286 | VdbeCoverageIf(v, op==TK_ISNULL); |
5287 | VdbeCoverageIf(v, op==TK_NOTNULL); |
5288 | testcase( regFree1==0 ); |
5289 | break; |
5290 | } |
5291 | case TK_BETWEEN: { |
5292 | testcase( jumpIfNull==0 ); |
5293 | exprCodeBetween(pParse, pExpr, dest, sqlite3ExprIfTrue, jumpIfNull); |
5294 | break; |
5295 | } |
5296 | #ifndef SQLITE_OMIT_SUBQUERY |
5297 | case TK_IN: { |
5298 | int destIfFalse = sqlite3VdbeMakeLabel(pParse); |
5299 | int destIfNull = jumpIfNull ? dest : destIfFalse; |
5300 | sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull); |
5301 | sqlite3VdbeGoto(v, dest); |
5302 | sqlite3VdbeResolveLabel(v, destIfFalse); |
5303 | break; |
5304 | } |
5305 | #endif |
5306 | default: { |
5307 | default_expr: |
5308 | if( ExprAlwaysTrue(pExpr) ){ |
5309 | sqlite3VdbeGoto(v, dest); |
5310 | }else if( ExprAlwaysFalse(pExpr) ){ |
5311 | /* No-op */ |
5312 | }else{ |
5313 | r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1); |
5314 | sqlite3VdbeAddOp3(v, OP_If, r1, dest, jumpIfNull!=0); |
5315 | VdbeCoverage(v); |
5316 | testcase( regFree1==0 ); |
5317 | testcase( jumpIfNull==0 ); |
5318 | } |
5319 | break; |
5320 | } |
5321 | } |
5322 | sqlite3ReleaseTempReg(pParse, regFree1); |
5323 | sqlite3ReleaseTempReg(pParse, regFree2); |
5324 | } |
5325 | |
5326 | /* |
5327 | ** Generate code for a boolean expression such that a jump is made |
5328 | ** to the label "dest" if the expression is false but execution |
5329 | ** continues straight thru if the expression is true. |
5330 | ** |
5331 | ** If the expression evaluates to NULL (neither true nor false) then |
5332 | ** jump if jumpIfNull is SQLITE_JUMPIFNULL or fall through if jumpIfNull |
5333 | ** is 0. |
5334 | */ |
5335 | void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){ |
5336 | Vdbe *v = pParse->pVdbe; |
5337 | int op = 0; |
5338 | int regFree1 = 0; |
5339 | int regFree2 = 0; |
5340 | int r1, r2; |
5341 | |
5342 | assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 ); |
5343 | if( NEVER(v==0) ) return; /* Existence of VDBE checked by caller */ |
5344 | if( pExpr==0 ) return; |
5345 | assert( !ExprHasVVAProperty(pExpr,EP_Immutable) ); |
5346 | |
5347 | /* The value of pExpr->op and op are related as follows: |
5348 | ** |
5349 | ** pExpr->op op |
5350 | ** --------- ---------- |
5351 | ** TK_ISNULL OP_NotNull |
5352 | ** TK_NOTNULL OP_IsNull |
5353 | ** TK_NE OP_Eq |
5354 | ** TK_EQ OP_Ne |
5355 | ** TK_GT OP_Le |
5356 | ** TK_LE OP_Gt |
5357 | ** TK_GE OP_Lt |
5358 | ** TK_LT OP_Ge |
5359 | ** |
5360 | ** For other values of pExpr->op, op is undefined and unused. |
5361 | ** The value of TK_ and OP_ constants are arranged such that we |
5362 | ** can compute the mapping above using the following expression. |
5363 | ** Assert()s verify that the computation is correct. |
5364 | */ |
5365 | op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1); |
5366 | |
5367 | /* Verify correct alignment of TK_ and OP_ constants |
5368 | */ |
5369 | assert( pExpr->op!=TK_ISNULL || op==OP_NotNull ); |
5370 | assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull ); |
5371 | assert( pExpr->op!=TK_NE || op==OP_Eq ); |
5372 | assert( pExpr->op!=TK_EQ || op==OP_Ne ); |
5373 | assert( pExpr->op!=TK_LT || op==OP_Ge ); |
5374 | assert( pExpr->op!=TK_LE || op==OP_Gt ); |
5375 | assert( pExpr->op!=TK_GT || op==OP_Le ); |
5376 | assert( pExpr->op!=TK_GE || op==OP_Lt ); |
5377 | |
5378 | switch( pExpr->op ){ |
5379 | case TK_AND: |
5380 | case TK_OR: { |
5381 | Expr *pAlt = sqlite3ExprSimplifiedAndOr(pExpr); |
5382 | if( pAlt!=pExpr ){ |
5383 | sqlite3ExprIfFalse(pParse, pAlt, dest, jumpIfNull); |
5384 | }else if( pExpr->op==TK_AND ){ |
5385 | testcase( jumpIfNull==0 ); |
5386 | sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull); |
5387 | sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull); |
5388 | }else{ |
5389 | int d2 = sqlite3VdbeMakeLabel(pParse); |
5390 | testcase( jumpIfNull==0 ); |
5391 | sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2, |
5392 | jumpIfNull^SQLITE_JUMPIFNULL); |
5393 | sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull); |
5394 | sqlite3VdbeResolveLabel(v, d2); |
5395 | } |
5396 | break; |
5397 | } |
5398 | case TK_NOT: { |
5399 | testcase( jumpIfNull==0 ); |
5400 | sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull); |
5401 | break; |
5402 | } |
5403 | case TK_TRUTH: { |
5404 | int isNot; /* IS NOT TRUE or IS NOT FALSE */ |
5405 | int isTrue; /* IS TRUE or IS NOT TRUE */ |
5406 | testcase( jumpIfNull==0 ); |
5407 | isNot = pExpr->op2==TK_ISNOT; |
5408 | isTrue = sqlite3ExprTruthValue(pExpr->pRight); |
5409 | testcase( isTrue && isNot ); |
5410 | testcase( !isTrue && isNot ); |
5411 | if( isTrue ^ isNot ){ |
5412 | /* IS TRUE and IS NOT FALSE */ |
5413 | sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, |
5414 | isNot ? 0 : SQLITE_JUMPIFNULL); |
5415 | |
5416 | }else{ |
5417 | /* IS FALSE and IS NOT TRUE */ |
5418 | sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, |
5419 | isNot ? 0 : SQLITE_JUMPIFNULL); |
5420 | } |
5421 | break; |
5422 | } |
5423 | case TK_IS: |
5424 | case TK_ISNOT: |
5425 | testcase( pExpr->op==TK_IS ); |
5426 | testcase( pExpr->op==TK_ISNOT ); |
5427 | op = (pExpr->op==TK_IS) ? TK_NE : TK_EQ; |
5428 | jumpIfNull = SQLITE_NULLEQ; |
5429 | /* no break */ deliberate_fall_through |
5430 | case TK_LT: |
5431 | case TK_LE: |
5432 | case TK_GT: |
5433 | case TK_GE: |
5434 | case TK_NE: |
5435 | case TK_EQ: { |
5436 | if( sqlite3ExprIsVector(pExpr->pLeft) ) goto default_expr; |
5437 | testcase( jumpIfNull==0 ); |
5438 | r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); |
5439 | r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2); |
5440 | codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op, |
5441 | r1, r2, dest, jumpIfNull,ExprHasProperty(pExpr,EP_Commuted)); |
5442 | assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt); |
5443 | assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le); |
5444 | assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt); |
5445 | assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge); |
5446 | assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); |
5447 | VdbeCoverageIf(v, op==OP_Eq && jumpIfNull!=SQLITE_NULLEQ); |
5448 | VdbeCoverageIf(v, op==OP_Eq && jumpIfNull==SQLITE_NULLEQ); |
5449 | assert(TK_NE==OP_Ne); testcase(op==OP_Ne); |
5450 | VdbeCoverageIf(v, op==OP_Ne && jumpIfNull!=SQLITE_NULLEQ); |
5451 | VdbeCoverageIf(v, op==OP_Ne && jumpIfNull==SQLITE_NULLEQ); |
5452 | testcase( regFree1==0 ); |
5453 | testcase( regFree2==0 ); |
5454 | break; |
5455 | } |
5456 | case TK_ISNULL: |
5457 | case TK_NOTNULL: { |
5458 | r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); |
5459 | sqlite3VdbeTypeofColumn(v, r1); |
5460 | sqlite3VdbeAddOp2(v, op, r1, dest); |
5461 | testcase( op==TK_ISNULL ); VdbeCoverageIf(v, op==TK_ISNULL); |
5462 | testcase( op==TK_NOTNULL ); VdbeCoverageIf(v, op==TK_NOTNULL); |
5463 | testcase( regFree1==0 ); |
5464 | break; |
5465 | } |
5466 | case TK_BETWEEN: { |
5467 | testcase( jumpIfNull==0 ); |
5468 | exprCodeBetween(pParse, pExpr, dest, sqlite3ExprIfFalse, jumpIfNull); |
5469 | break; |
5470 | } |
5471 | #ifndef SQLITE_OMIT_SUBQUERY |
5472 | case TK_IN: { |
5473 | if( jumpIfNull ){ |
5474 | sqlite3ExprCodeIN(pParse, pExpr, dest, dest); |
5475 | }else{ |
5476 | int destIfNull = sqlite3VdbeMakeLabel(pParse); |
5477 | sqlite3ExprCodeIN(pParse, pExpr, dest, destIfNull); |
5478 | sqlite3VdbeResolveLabel(v, destIfNull); |
5479 | } |
5480 | break; |
5481 | } |
5482 | #endif |
5483 | default: { |
5484 | default_expr: |
5485 | if( ExprAlwaysFalse(pExpr) ){ |
5486 | sqlite3VdbeGoto(v, dest); |
5487 | }else if( ExprAlwaysTrue(pExpr) ){ |
5488 | /* no-op */ |
5489 | }else{ |
5490 | r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1); |
5491 | sqlite3VdbeAddOp3(v, OP_IfNot, r1, dest, jumpIfNull!=0); |
5492 | VdbeCoverage(v); |
5493 | testcase( regFree1==0 ); |
5494 | testcase( jumpIfNull==0 ); |
5495 | } |
5496 | break; |
5497 | } |
5498 | } |
5499 | sqlite3ReleaseTempReg(pParse, regFree1); |
5500 | sqlite3ReleaseTempReg(pParse, regFree2); |
5501 | } |
5502 | |
5503 | /* |
5504 | ** Like sqlite3ExprIfFalse() except that a copy is made of pExpr before |
5505 | ** code generation, and that copy is deleted after code generation. This |
5506 | ** ensures that the original pExpr is unchanged. |
5507 | */ |
5508 | void sqlite3ExprIfFalseDup(Parse *pParse, Expr *pExpr, int dest,int jumpIfNull){ |
5509 | sqlite3 *db = pParse->db; |
5510 | Expr *pCopy = sqlite3ExprDup(db, pExpr, 0); |
5511 | if( db->mallocFailed==0 ){ |
5512 | sqlite3ExprIfFalse(pParse, pCopy, dest, jumpIfNull); |
5513 | } |
5514 | sqlite3ExprDelete(db, pCopy); |
5515 | } |
5516 | |
5517 | /* |
5518 | ** Expression pVar is guaranteed to be an SQL variable. pExpr may be any |
5519 | ** type of expression. |
5520 | ** |
5521 | ** If pExpr is a simple SQL value - an integer, real, string, blob |
5522 | ** or NULL value - then the VDBE currently being prepared is configured |
5523 | ** to re-prepare each time a new value is bound to variable pVar. |
5524 | ** |
5525 | ** Additionally, if pExpr is a simple SQL value and the value is the |
5526 | ** same as that currently bound to variable pVar, non-zero is returned. |
5527 | ** Otherwise, if the values are not the same or if pExpr is not a simple |
5528 | ** SQL value, zero is returned. |
5529 | */ |
5530 | static int exprCompareVariable( |
5531 | const Parse *pParse, |
5532 | const Expr *pVar, |
5533 | const Expr *pExpr |
5534 | ){ |
5535 | int res = 0; |
5536 | int iVar; |
5537 | sqlite3_value *pL, *pR = 0; |
5538 | |
5539 | sqlite3ValueFromExpr(pParse->db, pExpr, SQLITE_UTF8, SQLITE_AFF_BLOB, &pR); |
5540 | if( pR ){ |
5541 | iVar = pVar->iColumn; |
5542 | sqlite3VdbeSetVarmask(pParse->pVdbe, iVar); |
5543 | pL = sqlite3VdbeGetBoundValue(pParse->pReprepare, iVar, SQLITE_AFF_BLOB); |
5544 | if( pL ){ |
5545 | if( sqlite3_value_type(pL)==SQLITE_TEXT ){ |
5546 | sqlite3_value_text(pL); /* Make sure the encoding is UTF-8 */ |
5547 | } |
5548 | res = 0==sqlite3MemCompare(pL, pR, 0); |
5549 | } |
5550 | sqlite3ValueFree(pR); |
5551 | sqlite3ValueFree(pL); |
5552 | } |
5553 | |
5554 | return res; |
5555 | } |
5556 | |
5557 | /* |
5558 | ** Do a deep comparison of two expression trees. Return 0 if the two |
5559 | ** expressions are completely identical. Return 1 if they differ only |
5560 | ** by a COLLATE operator at the top level. Return 2 if there are differences |
5561 | ** other than the top-level COLLATE operator. |
5562 | ** |
5563 | ** If any subelement of pB has Expr.iTable==(-1) then it is allowed |
5564 | ** to compare equal to an equivalent element in pA with Expr.iTable==iTab. |
5565 | ** |
5566 | ** The pA side might be using TK_REGISTER. If that is the case and pB is |
5567 | ** not using TK_REGISTER but is otherwise equivalent, then still return 0. |
5568 | ** |
5569 | ** Sometimes this routine will return 2 even if the two expressions |
5570 | ** really are equivalent. If we cannot prove that the expressions are |
5571 | ** identical, we return 2 just to be safe. So if this routine |
5572 | ** returns 2, then you do not really know for certain if the two |
5573 | ** expressions are the same. But if you get a 0 or 1 return, then you |
5574 | ** can be sure the expressions are the same. In the places where |
5575 | ** this routine is used, it does not hurt to get an extra 2 - that |
5576 | ** just might result in some slightly slower code. But returning |
5577 | ** an incorrect 0 or 1 could lead to a malfunction. |
5578 | ** |
5579 | ** If pParse is not NULL then TK_VARIABLE terms in pA with bindings in |
5580 | ** pParse->pReprepare can be matched against literals in pB. The |
5581 | ** pParse->pVdbe->expmask bitmask is updated for each variable referenced. |
5582 | ** If pParse is NULL (the normal case) then any TK_VARIABLE term in |
5583 | ** Argument pParse should normally be NULL. If it is not NULL and pA or |
5584 | ** pB causes a return value of 2. |
5585 | */ |
5586 | int sqlite3ExprCompare( |
5587 | const Parse *pParse, |
5588 | const Expr *pA, |
5589 | const Expr *pB, |
5590 | int iTab |
5591 | ){ |
5592 | u32 combinedFlags; |
5593 | if( pA==0 || pB==0 ){ |
5594 | return pB==pA ? 0 : 2; |
5595 | } |
5596 | if( pParse && pA->op==TK_VARIABLE && exprCompareVariable(pParse, pA, pB) ){ |
5597 | return 0; |
5598 | } |
5599 | combinedFlags = pA->flags | pB->flags; |
5600 | if( combinedFlags & EP_IntValue ){ |
5601 | if( (pA->flags&pB->flags&EP_IntValue)!=0 && pA->u.iValue==pB->u.iValue ){ |
5602 | return 0; |
5603 | } |
5604 | return 2; |
5605 | } |
5606 | if( pA->op!=pB->op || pA->op==TK_RAISE ){ |
5607 | if( pA->op==TK_COLLATE && sqlite3ExprCompare(pParse, pA->pLeft,pB,iTab)<2 ){ |
5608 | return 1; |
5609 | } |
5610 | if( pB->op==TK_COLLATE && sqlite3ExprCompare(pParse, pA,pB->pLeft,iTab)<2 ){ |
5611 | return 1; |
5612 | } |
5613 | if( pA->op==TK_AGG_COLUMN && pB->op==TK_COLUMN |
5614 | && pB->iTable<0 && pA->iTable==iTab |
5615 | ){ |
5616 | /* fall through */ |
5617 | }else{ |
5618 | return 2; |
5619 | } |
5620 | } |
5621 | assert( !ExprHasProperty(pA, EP_IntValue) ); |
5622 | assert( !ExprHasProperty(pB, EP_IntValue) ); |
5623 | if( pA->u.zToken ){ |
5624 | if( pA->op==TK_FUNCTION || pA->op==TK_AGG_FUNCTION ){ |
5625 | if( sqlite3StrICmp(pA->u.zToken,pB->u.zToken)!=0 ) return 2; |
5626 | #ifndef SQLITE_OMIT_WINDOWFUNC |
5627 | assert( pA->op==pB->op ); |
5628 | if( ExprHasProperty(pA,EP_WinFunc)!=ExprHasProperty(pB,EP_WinFunc) ){ |
5629 | return 2; |
5630 | } |
5631 | if( ExprHasProperty(pA,EP_WinFunc) ){ |
5632 | if( sqlite3WindowCompare(pParse, pA->y.pWin, pB->y.pWin, 1)!=0 ){ |
5633 | return 2; |
5634 | } |
5635 | } |
5636 | #endif |
5637 | }else if( pA->op==TK_NULL ){ |
5638 | return 0; |
5639 | }else if( pA->op==TK_COLLATE ){ |
5640 | if( sqlite3_stricmp(pA->u.zToken,pB->u.zToken)!=0 ) return 2; |
5641 | }else |
5642 | if( pB->u.zToken!=0 |
5643 | && pA->op!=TK_COLUMN |
5644 | && pA->op!=TK_AGG_COLUMN |
5645 | && strcmp(pA->u.zToken,pB->u.zToken)!=0 |
5646 | ){ |
5647 | return 2; |
5648 | } |
5649 | } |
5650 | if( (pA->flags & (EP_Distinct|EP_Commuted)) |
5651 | != (pB->flags & (EP_Distinct|EP_Commuted)) ) return 2; |
5652 | if( ALWAYS((combinedFlags & EP_TokenOnly)==0) ){ |
5653 | if( combinedFlags & EP_xIsSelect ) return 2; |
5654 | if( (combinedFlags & EP_FixedCol)==0 |
5655 | && sqlite3ExprCompare(pParse, pA->pLeft, pB->pLeft, iTab) ) return 2; |
5656 | if( sqlite3ExprCompare(pParse, pA->pRight, pB->pRight, iTab) ) return 2; |
5657 | if( sqlite3ExprListCompare(pA->x.pList, pB->x.pList, iTab) ) return 2; |
5658 | if( pA->op!=TK_STRING |
5659 | && pA->op!=TK_TRUEFALSE |
5660 | && ALWAYS((combinedFlags & EP_Reduced)==0) |
5661 | ){ |
5662 | if( pA->iColumn!=pB->iColumn ) return 2; |
5663 | if( pA->op2!=pB->op2 && pA->op==TK_TRUTH ) return 2; |
5664 | if( pA->op!=TK_IN && pA->iTable!=pB->iTable && pA->iTable!=iTab ){ |
5665 | return 2; |
5666 | } |
5667 | } |
5668 | } |
5669 | return 0; |
5670 | } |
5671 | |
5672 | /* |
5673 | ** Compare two ExprList objects. Return 0 if they are identical, 1 |
5674 | ** if they are certainly different, or 2 if it is not possible to |
5675 | ** determine if they are identical or not. |
5676 | ** |
5677 | ** If any subelement of pB has Expr.iTable==(-1) then it is allowed |
5678 | ** to compare equal to an equivalent element in pA with Expr.iTable==iTab. |
5679 | ** |
5680 | ** This routine might return non-zero for equivalent ExprLists. The |
5681 | ** only consequence will be disabled optimizations. But this routine |
5682 | ** must never return 0 if the two ExprList objects are different, or |
5683 | ** a malfunction will result. |
5684 | ** |
5685 | ** Two NULL pointers are considered to be the same. But a NULL pointer |
5686 | ** always differs from a non-NULL pointer. |
5687 | */ |
5688 | int sqlite3ExprListCompare(const ExprList *pA, const ExprList *pB, int iTab){ |
5689 | int i; |
5690 | if( pA==0 && pB==0 ) return 0; |
5691 | if( pA==0 || pB==0 ) return 1; |
5692 | if( pA->nExpr!=pB->nExpr ) return 1; |
5693 | for(i=0; i<pA->nExpr; i++){ |
5694 | int res; |
5695 | Expr *pExprA = pA->a[i].pExpr; |
5696 | Expr *pExprB = pB->a[i].pExpr; |
5697 | if( pA->a[i].fg.sortFlags!=pB->a[i].fg.sortFlags ) return 1; |
5698 | if( (res = sqlite3ExprCompare(0, pExprA, pExprB, iTab)) ) return res; |
5699 | } |
5700 | return 0; |
5701 | } |
5702 | |
5703 | /* |
5704 | ** Like sqlite3ExprCompare() except COLLATE operators at the top-level |
5705 | ** are ignored. |
5706 | */ |
5707 | int sqlite3ExprCompareSkip(Expr *pA,Expr *pB, int iTab){ |
5708 | return sqlite3ExprCompare(0, |
5709 | sqlite3ExprSkipCollateAndLikely(pA), |
5710 | sqlite3ExprSkipCollateAndLikely(pB), |
5711 | iTab); |
5712 | } |
5713 | |
5714 | /* |
5715 | ** Return non-zero if Expr p can only be true if pNN is not NULL. |
5716 | ** |
5717 | ** Or if seenNot is true, return non-zero if Expr p can only be |
5718 | ** non-NULL if pNN is not NULL |
5719 | */ |
5720 | static int exprImpliesNotNull( |
5721 | const Parse *pParse,/* Parsing context */ |
5722 | const Expr *p, /* The expression to be checked */ |
5723 | const Expr *pNN, /* The expression that is NOT NULL */ |
5724 | int iTab, /* Table being evaluated */ |
5725 | int seenNot /* Return true only if p can be any non-NULL value */ |
5726 | ){ |
5727 | assert( p ); |
5728 | assert( pNN ); |
5729 | if( sqlite3ExprCompare(pParse, p, pNN, iTab)==0 ){ |
5730 | return pNN->op!=TK_NULL; |
5731 | } |
5732 | switch( p->op ){ |
5733 | case TK_IN: { |
5734 | if( seenNot && ExprHasProperty(p, EP_xIsSelect) ) return 0; |
5735 | assert( ExprUseXSelect(p) || (p->x.pList!=0 && p->x.pList->nExpr>0) ); |
5736 | return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1); |
5737 | } |
5738 | case TK_BETWEEN: { |
5739 | ExprList *pList; |
5740 | assert( ExprUseXList(p) ); |
5741 | pList = p->x.pList; |
5742 | assert( pList!=0 ); |
5743 | assert( pList->nExpr==2 ); |
5744 | if( seenNot ) return 0; |
5745 | if( exprImpliesNotNull(pParse, pList->a[0].pExpr, pNN, iTab, 1) |
5746 | || exprImpliesNotNull(pParse, pList->a[1].pExpr, pNN, iTab, 1) |
5747 | ){ |
5748 | return 1; |
5749 | } |
5750 | return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1); |
5751 | } |
5752 | case TK_EQ: |
5753 | case TK_NE: |
5754 | case TK_LT: |
5755 | case TK_LE: |
5756 | case TK_GT: |
5757 | case TK_GE: |
5758 | case TK_PLUS: |
5759 | case TK_MINUS: |
5760 | case TK_BITOR: |
5761 | case TK_LSHIFT: |
5762 | case TK_RSHIFT: |
5763 | case TK_CONCAT: |
5764 | seenNot = 1; |
5765 | /* no break */ deliberate_fall_through |
5766 | case TK_STAR: |
5767 | case TK_REM: |
5768 | case TK_BITAND: |
5769 | case TK_SLASH: { |
5770 | if( exprImpliesNotNull(pParse, p->pRight, pNN, iTab, seenNot) ) return 1; |
5771 | /* no break */ deliberate_fall_through |
5772 | } |
5773 | case TK_SPAN: |
5774 | case TK_COLLATE: |
5775 | case TK_UPLUS: |
5776 | case TK_UMINUS: { |
5777 | return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, seenNot); |
5778 | } |
5779 | case TK_TRUTH: { |
5780 | if( seenNot ) return 0; |
5781 | if( p->op2!=TK_IS ) return 0; |
5782 | return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1); |
5783 | } |
5784 | case TK_BITNOT: |
5785 | case TK_NOT: { |
5786 | return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1); |
5787 | } |
5788 | } |
5789 | return 0; |
5790 | } |
5791 | |
5792 | /* |
5793 | ** Return true if we can prove the pE2 will always be true if pE1 is |
5794 | ** true. Return false if we cannot complete the proof or if pE2 might |
5795 | ** be false. Examples: |
5796 | ** |
5797 | ** pE1: x==5 pE2: x==5 Result: true |
5798 | ** pE1: x>0 pE2: x==5 Result: false |
5799 | ** pE1: x=21 pE2: x=21 OR y=43 Result: true |
5800 | ** pE1: x!=123 pE2: x IS NOT NULL Result: true |
5801 | ** pE1: x!=?1 pE2: x IS NOT NULL Result: true |
5802 | ** pE1: x IS NULL pE2: x IS NOT NULL Result: false |
5803 | ** pE1: x IS ?2 pE2: x IS NOT NULL Reuslt: false |
5804 | ** |
5805 | ** When comparing TK_COLUMN nodes between pE1 and pE2, if pE2 has |
5806 | ** Expr.iTable<0 then assume a table number given by iTab. |
5807 | ** |
5808 | ** If pParse is not NULL, then the values of bound variables in pE1 are |
5809 | ** compared against literal values in pE2 and pParse->pVdbe->expmask is |
5810 | ** modified to record which bound variables are referenced. If pParse |
5811 | ** is NULL, then false will be returned if pE1 contains any bound variables. |
5812 | ** |
5813 | ** When in doubt, return false. Returning true might give a performance |
5814 | ** improvement. Returning false might cause a performance reduction, but |
5815 | ** it will always give the correct answer and is hence always safe. |
5816 | */ |
5817 | int sqlite3ExprImpliesExpr( |
5818 | const Parse *pParse, |
5819 | const Expr *pE1, |
5820 | const Expr *pE2, |
5821 | int iTab |
5822 | ){ |
5823 | if( sqlite3ExprCompare(pParse, pE1, pE2, iTab)==0 ){ |
5824 | return 1; |
5825 | } |
5826 | if( pE2->op==TK_OR |
5827 | && (sqlite3ExprImpliesExpr(pParse, pE1, pE2->pLeft, iTab) |
5828 | || sqlite3ExprImpliesExpr(pParse, pE1, pE2->pRight, iTab) ) |
5829 | ){ |
5830 | return 1; |
5831 | } |
5832 | if( pE2->op==TK_NOTNULL |
5833 | && exprImpliesNotNull(pParse, pE1, pE2->pLeft, iTab, 0) |
5834 | ){ |
5835 | return 1; |
5836 | } |
5837 | return 0; |
5838 | } |
5839 | |
5840 | /* |
5841 | ** This is the Expr node callback for sqlite3ExprImpliesNonNullRow(). |
5842 | ** If the expression node requires that the table at pWalker->iCur |
5843 | ** have one or more non-NULL column, then set pWalker->eCode to 1 and abort. |
5844 | ** |
5845 | ** This routine controls an optimization. False positives (setting |
5846 | ** pWalker->eCode to 1 when it should not be) are deadly, but false-negatives |
5847 | ** (never setting pWalker->eCode) is a harmless missed optimization. |
5848 | */ |
5849 | static int impliesNotNullRow(Walker *pWalker, Expr *pExpr){ |
5850 | testcase( pExpr->op==TK_AGG_COLUMN ); |
5851 | testcase( pExpr->op==TK_AGG_FUNCTION ); |
5852 | if( ExprHasProperty(pExpr, EP_OuterON) ) return WRC_Prune; |
5853 | switch( pExpr->op ){ |
5854 | case TK_ISNOT: |
5855 | case TK_ISNULL: |
5856 | case TK_NOTNULL: |
5857 | case TK_IS: |
5858 | case TK_OR: |
5859 | case TK_VECTOR: |
5860 | case TK_CASE: |
5861 | case TK_IN: |
5862 | case TK_FUNCTION: |
5863 | case TK_TRUTH: |
5864 | testcase( pExpr->op==TK_ISNOT ); |
5865 | testcase( pExpr->op==TK_ISNULL ); |
5866 | testcase( pExpr->op==TK_NOTNULL ); |
5867 | testcase( pExpr->op==TK_IS ); |
5868 | testcase( pExpr->op==TK_OR ); |
5869 | testcase( pExpr->op==TK_VECTOR ); |
5870 | testcase( pExpr->op==TK_CASE ); |
5871 | testcase( pExpr->op==TK_IN ); |
5872 | testcase( pExpr->op==TK_FUNCTION ); |
5873 | testcase( pExpr->op==TK_TRUTH ); |
5874 | return WRC_Prune; |
5875 | case TK_COLUMN: |
5876 | if( pWalker->u.iCur==pExpr->iTable ){ |
5877 | pWalker->eCode = 1; |
5878 | return WRC_Abort; |
5879 | } |
5880 | return WRC_Prune; |
5881 | |
5882 | case TK_AND: |
5883 | if( pWalker->eCode==0 ){ |
5884 | sqlite3WalkExpr(pWalker, pExpr->pLeft); |
5885 | if( pWalker->eCode ){ |
5886 | pWalker->eCode = 0; |
5887 | sqlite3WalkExpr(pWalker, pExpr->pRight); |
5888 | } |
5889 | } |
5890 | return WRC_Prune; |
5891 | |
5892 | case TK_BETWEEN: |
5893 | if( sqlite3WalkExpr(pWalker, pExpr->pLeft)==WRC_Abort ){ |
5894 | assert( pWalker->eCode ); |
5895 | return WRC_Abort; |
5896 | } |
5897 | return WRC_Prune; |
5898 | |
5899 | /* Virtual tables are allowed to use constraints like x=NULL. So |
5900 | ** a term of the form x=y does not prove that y is not null if x |
5901 | ** is the column of a virtual table */ |
5902 | case TK_EQ: |
5903 | case TK_NE: |
5904 | case TK_LT: |
5905 | case TK_LE: |
5906 | case TK_GT: |
5907 | case TK_GE: { |
5908 | Expr *pLeft = pExpr->pLeft; |
5909 | Expr *pRight = pExpr->pRight; |
5910 | testcase( pExpr->op==TK_EQ ); |
5911 | testcase( pExpr->op==TK_NE ); |
5912 | testcase( pExpr->op==TK_LT ); |
5913 | testcase( pExpr->op==TK_LE ); |
5914 | testcase( pExpr->op==TK_GT ); |
5915 | testcase( pExpr->op==TK_GE ); |
5916 | /* The y.pTab=0 assignment in wherecode.c always happens after the |
5917 | ** impliesNotNullRow() test */ |
5918 | assert( pLeft->op!=TK_COLUMN || ExprUseYTab(pLeft) ); |
5919 | assert( pRight->op!=TK_COLUMN || ExprUseYTab(pRight) ); |
5920 | if( (pLeft->op==TK_COLUMN |
5921 | && ALWAYS(pLeft->y.pTab!=0) |
5922 | && IsVirtual(pLeft->y.pTab)) |
5923 | || (pRight->op==TK_COLUMN |
5924 | && ALWAYS(pRight->y.pTab!=0) |
5925 | && IsVirtual(pRight->y.pTab)) |
5926 | ){ |
5927 | return WRC_Prune; |
5928 | } |
5929 | /* no break */ deliberate_fall_through |
5930 | } |
5931 | default: |
5932 | return WRC_Continue; |
5933 | } |
5934 | } |
5935 | |
5936 | /* |
5937 | ** Return true (non-zero) if expression p can only be true if at least |
5938 | ** one column of table iTab is non-null. In other words, return true |
5939 | ** if expression p will always be NULL or false if every column of iTab |
5940 | ** is NULL. |
5941 | ** |
5942 | ** False negatives are acceptable. In other words, it is ok to return |
5943 | ** zero even if expression p will never be true of every column of iTab |
5944 | ** is NULL. A false negative is merely a missed optimization opportunity. |
5945 | ** |
5946 | ** False positives are not allowed, however. A false positive may result |
5947 | ** in an incorrect answer. |
5948 | ** |
5949 | ** Terms of p that are marked with EP_OuterON (and hence that come from |
5950 | ** the ON or USING clauses of OUTER JOINS) are excluded from the analysis. |
5951 | ** |
5952 | ** This routine is used to check if a LEFT JOIN can be converted into |
5953 | ** an ordinary JOIN. The p argument is the WHERE clause. If the WHERE |
5954 | ** clause requires that some column of the right table of the LEFT JOIN |
5955 | ** be non-NULL, then the LEFT JOIN can be safely converted into an |
5956 | ** ordinary join. |
5957 | */ |
5958 | int sqlite3ExprImpliesNonNullRow(Expr *p, int iTab){ |
5959 | Walker w; |
5960 | p = sqlite3ExprSkipCollateAndLikely(p); |
5961 | if( p==0 ) return 0; |
5962 | if( p->op==TK_NOTNULL ){ |
5963 | p = p->pLeft; |
5964 | }else{ |
5965 | while( p->op==TK_AND ){ |
5966 | if( sqlite3ExprImpliesNonNullRow(p->pLeft, iTab) ) return 1; |
5967 | p = p->pRight; |
5968 | } |
5969 | } |
5970 | w.xExprCallback = impliesNotNullRow; |
5971 | w.xSelectCallback = 0; |
5972 | w.xSelectCallback2 = 0; |
5973 | w.eCode = 0; |
5974 | w.u.iCur = iTab; |
5975 | sqlite3WalkExpr(&w, p); |
5976 | return w.eCode; |
5977 | } |
5978 | |
5979 | /* |
5980 | ** An instance of the following structure is used by the tree walker |
5981 | ** to determine if an expression can be evaluated by reference to the |
5982 | ** index only, without having to do a search for the corresponding |
5983 | ** table entry. The IdxCover.pIdx field is the index. IdxCover.iCur |
5984 | ** is the cursor for the table. |
5985 | */ |
5986 | struct IdxCover { |
5987 | Index *pIdx; /* The index to be tested for coverage */ |
5988 | int iCur; /* Cursor number for the table corresponding to the index */ |
5989 | }; |
5990 | |
5991 | /* |
5992 | ** Check to see if there are references to columns in table |
5993 | ** pWalker->u.pIdxCover->iCur can be satisfied using the index |
5994 | ** pWalker->u.pIdxCover->pIdx. |
5995 | */ |
5996 | static int exprIdxCover(Walker *pWalker, Expr *pExpr){ |
5997 | if( pExpr->op==TK_COLUMN |
5998 | && pExpr->iTable==pWalker->u.pIdxCover->iCur |
5999 | && sqlite3TableColumnToIndex(pWalker->u.pIdxCover->pIdx, pExpr->iColumn)<0 |
6000 | ){ |
6001 | pWalker->eCode = 1; |
6002 | return WRC_Abort; |
6003 | } |
6004 | return WRC_Continue; |
6005 | } |
6006 | |
6007 | /* |
6008 | ** Determine if an index pIdx on table with cursor iCur contains will |
6009 | ** the expression pExpr. Return true if the index does cover the |
6010 | ** expression and false if the pExpr expression references table columns |
6011 | ** that are not found in the index pIdx. |
6012 | ** |
6013 | ** An index covering an expression means that the expression can be |
6014 | ** evaluated using only the index and without having to lookup the |
6015 | ** corresponding table entry. |
6016 | */ |
6017 | int sqlite3ExprCoveredByIndex( |
6018 | Expr *pExpr, /* The index to be tested */ |
6019 | int iCur, /* The cursor number for the corresponding table */ |
6020 | Index *pIdx /* The index that might be used for coverage */ |
6021 | ){ |
6022 | Walker w; |
6023 | struct IdxCover xcov; |
6024 | memset(&w, 0, sizeof(w)); |
6025 | xcov.iCur = iCur; |
6026 | xcov.pIdx = pIdx; |
6027 | w.xExprCallback = exprIdxCover; |
6028 | w.u.pIdxCover = &xcov; |
6029 | sqlite3WalkExpr(&w, pExpr); |
6030 | return !w.eCode; |
6031 | } |
6032 | |
6033 | |
6034 | /* Structure used to pass information throught the Walker in order to |
6035 | ** implement sqlite3ReferencesSrcList(). |
6036 | */ |
6037 | struct RefSrcList { |
6038 | sqlite3 *db; /* Database connection used for sqlite3DbRealloc() */ |
6039 | SrcList *pRef; /* Looking for references to these tables */ |
6040 | i64 nExclude; /* Number of tables to exclude from the search */ |
6041 | int *aiExclude; /* Cursor IDs for tables to exclude from the search */ |
6042 | }; |
6043 | |
6044 | /* |
6045 | ** Walker SELECT callbacks for sqlite3ReferencesSrcList(). |
6046 | ** |
6047 | ** When entering a new subquery on the pExpr argument, add all FROM clause |
6048 | ** entries for that subquery to the exclude list. |
6049 | ** |
6050 | ** When leaving the subquery, remove those entries from the exclude list. |
6051 | */ |
6052 | static int selectRefEnter(Walker *pWalker, Select *pSelect){ |
6053 | struct RefSrcList *p = pWalker->u.pRefSrcList; |
6054 | SrcList *pSrc = pSelect->pSrc; |
6055 | i64 i, j; |
6056 | int *piNew; |
6057 | if( pSrc->nSrc==0 ) return WRC_Continue; |
6058 | j = p->nExclude; |
6059 | p->nExclude += pSrc->nSrc; |
6060 | piNew = sqlite3DbRealloc(p->db, p->aiExclude, p->nExclude*sizeof(int)); |
6061 | if( piNew==0 ){ |
6062 | p->nExclude = 0; |
6063 | return WRC_Abort; |
6064 | }else{ |
6065 | p->aiExclude = piNew; |
6066 | } |
6067 | for(i=0; i<pSrc->nSrc; i++, j++){ |
6068 | p->aiExclude[j] = pSrc->a[i].iCursor; |
6069 | } |
6070 | return WRC_Continue; |
6071 | } |
6072 | static void selectRefLeave(Walker *pWalker, Select *pSelect){ |
6073 | struct RefSrcList *p = pWalker->u.pRefSrcList; |
6074 | SrcList *pSrc = pSelect->pSrc; |
6075 | if( p->nExclude ){ |
6076 | assert( p->nExclude>=pSrc->nSrc ); |
6077 | p->nExclude -= pSrc->nSrc; |
6078 | } |
6079 | } |
6080 | |
6081 | /* This is the Walker EXPR callback for sqlite3ReferencesSrcList(). |
6082 | ** |
6083 | ** Set the 0x01 bit of pWalker->eCode if there is a reference to any |
6084 | ** of the tables shown in RefSrcList.pRef. |
6085 | ** |
6086 | ** Set the 0x02 bit of pWalker->eCode if there is a reference to a |
6087 | ** table is in neither RefSrcList.pRef nor RefSrcList.aiExclude. |
6088 | */ |
6089 | static int exprRefToSrcList(Walker *pWalker, Expr *pExpr){ |
6090 | if( pExpr->op==TK_COLUMN |
6091 | || pExpr->op==TK_AGG_COLUMN |
6092 | ){ |
6093 | int i; |
6094 | struct RefSrcList *p = pWalker->u.pRefSrcList; |
6095 | SrcList *pSrc = p->pRef; |
6096 | int nSrc = pSrc ? pSrc->nSrc : 0; |
6097 | for(i=0; i<nSrc; i++){ |
6098 | if( pExpr->iTable==pSrc->a[i].iCursor ){ |
6099 | pWalker->eCode |= 1; |
6100 | return WRC_Continue; |
6101 | } |
6102 | } |
6103 | for(i=0; i<p->nExclude && p->aiExclude[i]!=pExpr->iTable; i++){} |
6104 | if( i>=p->nExclude ){ |
6105 | pWalker->eCode |= 2; |
6106 | } |
6107 | } |
6108 | return WRC_Continue; |
6109 | } |
6110 | |
6111 | /* |
6112 | ** Check to see if pExpr references any tables in pSrcList. |
6113 | ** Possible return values: |
6114 | ** |
6115 | ** 1 pExpr does references a table in pSrcList. |
6116 | ** |
6117 | ** 0 pExpr references some table that is not defined in either |
6118 | ** pSrcList or in subqueries of pExpr itself. |
6119 | ** |
6120 | ** -1 pExpr only references no tables at all, or it only |
6121 | ** references tables defined in subqueries of pExpr itself. |
6122 | ** |
6123 | ** As currently used, pExpr is always an aggregate function call. That |
6124 | ** fact is exploited for efficiency. |
6125 | */ |
6126 | int sqlite3ReferencesSrcList(Parse *pParse, Expr *pExpr, SrcList *pSrcList){ |
6127 | Walker w; |
6128 | struct RefSrcList x; |
6129 | assert( pParse->db!=0 ); |
6130 | memset(&w, 0, sizeof(w)); |
6131 | memset(&x, 0, sizeof(x)); |
6132 | w.xExprCallback = exprRefToSrcList; |
6133 | w.xSelectCallback = selectRefEnter; |
6134 | w.xSelectCallback2 = selectRefLeave; |
6135 | w.u.pRefSrcList = &x; |
6136 | x.db = pParse->db; |
6137 | x.pRef = pSrcList; |
6138 | assert( pExpr->op==TK_AGG_FUNCTION ); |
6139 | assert( ExprUseXList(pExpr) ); |
6140 | sqlite3WalkExprList(&w, pExpr->x.pList); |
6141 | #ifndef SQLITE_OMIT_WINDOWFUNC |
6142 | if( ExprHasProperty(pExpr, EP_WinFunc) ){ |
6143 | sqlite3WalkExpr(&w, pExpr->y.pWin->pFilter); |
6144 | } |
6145 | #endif |
6146 | if( x.aiExclude ) sqlite3DbNNFreeNN(pParse->db, x.aiExclude); |
6147 | if( w.eCode & 0x01 ){ |
6148 | return 1; |
6149 | }else if( w.eCode ){ |
6150 | return 0; |
6151 | }else{ |
6152 | return -1; |
6153 | } |
6154 | } |
6155 | |
6156 | /* |
6157 | ** This is a Walker expression node callback. |
6158 | ** |
6159 | ** For Expr nodes that contain pAggInfo pointers, make sure the AggInfo |
6160 | ** object that is referenced does not refer directly to the Expr. If |
6161 | ** it does, make a copy. This is done because the pExpr argument is |
6162 | ** subject to change. |
6163 | ** |
6164 | ** The copy is stored on pParse->pConstExpr with a register number of 0. |
6165 | ** This will cause the expression to be deleted automatically when the |
6166 | ** Parse object is destroyed, but the zero register number means that it |
6167 | ** will not generate any code in the preamble. |
6168 | */ |
6169 | static int agginfoPersistExprCb(Walker *pWalker, Expr *pExpr){ |
6170 | if( ALWAYS(!ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced)) |
6171 | && pExpr->pAggInfo!=0 |
6172 | ){ |
6173 | AggInfo *pAggInfo = pExpr->pAggInfo; |
6174 | int iAgg = pExpr->iAgg; |
6175 | Parse *pParse = pWalker->pParse; |
6176 | sqlite3 *db = pParse->db; |
6177 | if( pExpr->op!=TK_AGG_FUNCTION ){ |
6178 | assert( pExpr->op==TK_AGG_COLUMN || pExpr->op==TK_IF_NULL_ROW ); |
6179 | assert( iAgg>=0 && iAgg<pAggInfo->nColumn ); |
6180 | if( pAggInfo->aCol[iAgg].pCExpr==pExpr ){ |
6181 | pExpr = sqlite3ExprDup(db, pExpr, 0); |
6182 | if( pExpr ){ |
6183 | pAggInfo->aCol[iAgg].pCExpr = pExpr; |
6184 | sqlite3ExprDeferredDelete(pParse, pExpr); |
6185 | } |
6186 | } |
6187 | }else{ |
6188 | assert( pExpr->op==TK_AGG_FUNCTION ); |
6189 | assert( iAgg>=0 && iAgg<pAggInfo->nFunc ); |
6190 | if( pAggInfo->aFunc[iAgg].pFExpr==pExpr ){ |
6191 | pExpr = sqlite3ExprDup(db, pExpr, 0); |
6192 | if( pExpr ){ |
6193 | pAggInfo->aFunc[iAgg].pFExpr = pExpr; |
6194 | sqlite3ExprDeferredDelete(pParse, pExpr); |
6195 | } |
6196 | } |
6197 | } |
6198 | } |
6199 | return WRC_Continue; |
6200 | } |
6201 | |
6202 | /* |
6203 | ** Initialize a Walker object so that will persist AggInfo entries referenced |
6204 | ** by the tree that is walked. |
6205 | */ |
6206 | void sqlite3AggInfoPersistWalkerInit(Walker *pWalker, Parse *pParse){ |
6207 | memset(pWalker, 0, sizeof(*pWalker)); |
6208 | pWalker->pParse = pParse; |
6209 | pWalker->xExprCallback = agginfoPersistExprCb; |
6210 | pWalker->xSelectCallback = sqlite3SelectWalkNoop; |
6211 | } |
6212 | |
6213 | /* |
6214 | ** Add a new element to the pAggInfo->aCol[] array. Return the index of |
6215 | ** the new element. Return a negative number if malloc fails. |
6216 | */ |
6217 | static int addAggInfoColumn(sqlite3 *db, AggInfo *pInfo){ |
6218 | int i; |
6219 | pInfo->aCol = sqlite3ArrayAllocate( |
6220 | db, |
6221 | pInfo->aCol, |
6222 | sizeof(pInfo->aCol[0]), |
6223 | &pInfo->nColumn, |
6224 | &i |
6225 | ); |
6226 | return i; |
6227 | } |
6228 | |
6229 | /* |
6230 | ** Add a new element to the pAggInfo->aFunc[] array. Return the index of |
6231 | ** the new element. Return a negative number if malloc fails. |
6232 | */ |
6233 | static int addAggInfoFunc(sqlite3 *db, AggInfo *pInfo){ |
6234 | int i; |
6235 | pInfo->aFunc = sqlite3ArrayAllocate( |
6236 | db, |
6237 | pInfo->aFunc, |
6238 | sizeof(pInfo->aFunc[0]), |
6239 | &pInfo->nFunc, |
6240 | &i |
6241 | ); |
6242 | return i; |
6243 | } |
6244 | |
6245 | /* |
6246 | ** This is the xExprCallback for a tree walker. It is used to |
6247 | ** implement sqlite3ExprAnalyzeAggregates(). See sqlite3ExprAnalyzeAggregates |
6248 | ** for additional information. |
6249 | */ |
6250 | static int analyzeAggregate(Walker *pWalker, Expr *pExpr){ |
6251 | int i; |
6252 | NameContext *pNC = pWalker->u.pNC; |
6253 | Parse *pParse = pNC->pParse; |
6254 | SrcList *pSrcList = pNC->pSrcList; |
6255 | AggInfo *pAggInfo = pNC->uNC.pAggInfo; |
6256 | |
6257 | assert( pNC->ncFlags & NC_UAggInfo ); |
6258 | switch( pExpr->op ){ |
6259 | case TK_IF_NULL_ROW: |
6260 | case TK_AGG_COLUMN: |
6261 | case TK_COLUMN: { |
6262 | testcase( pExpr->op==TK_AGG_COLUMN ); |
6263 | testcase( pExpr->op==TK_COLUMN ); |
6264 | testcase( pExpr->op==TK_IF_NULL_ROW ); |
6265 | /* Check to see if the column is in one of the tables in the FROM |
6266 | ** clause of the aggregate query */ |
6267 | if( ALWAYS(pSrcList!=0) ){ |
6268 | SrcItem *pItem = pSrcList->a; |
6269 | for(i=0; i<pSrcList->nSrc; i++, pItem++){ |
6270 | struct AggInfo_col *pCol; |
6271 | assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) ); |
6272 | if( pExpr->iTable==pItem->iCursor ){ |
6273 | /* If we reach this point, it means that pExpr refers to a table |
6274 | ** that is in the FROM clause of the aggregate query. |
6275 | ** |
6276 | ** Make an entry for the column in pAggInfo->aCol[] if there |
6277 | ** is not an entry there already. |
6278 | */ |
6279 | int k; |
6280 | pCol = pAggInfo->aCol; |
6281 | for(k=0; k<pAggInfo->nColumn; k++, pCol++){ |
6282 | if( pCol->iTable==pExpr->iTable |
6283 | && pCol->iColumn==pExpr->iColumn |
6284 | && pExpr->op!=TK_IF_NULL_ROW |
6285 | ){ |
6286 | break; |
6287 | } |
6288 | } |
6289 | if( (k>=pAggInfo->nColumn) |
6290 | && (k = addAggInfoColumn(pParse->db, pAggInfo))>=0 |
6291 | ){ |
6292 | pCol = &pAggInfo->aCol[k]; |
6293 | assert( ExprUseYTab(pExpr) ); |
6294 | pCol->pTab = pExpr->y.pTab; |
6295 | pCol->iTable = pExpr->iTable; |
6296 | pCol->iColumn = pExpr->iColumn; |
6297 | pCol->iMem = ++pParse->nMem; |
6298 | pCol->iSorterColumn = -1; |
6299 | pCol->pCExpr = pExpr; |
6300 | if( pAggInfo->pGroupBy && pExpr->op!=TK_IF_NULL_ROW ){ |
6301 | int j, n; |
6302 | ExprList *pGB = pAggInfo->pGroupBy; |
6303 | struct ExprList_item *pTerm = pGB->a; |
6304 | n = pGB->nExpr; |
6305 | for(j=0; j<n; j++, pTerm++){ |
6306 | Expr *pE = pTerm->pExpr; |
6307 | if( pE->op==TK_COLUMN |
6308 | && pE->iTable==pExpr->iTable |
6309 | && pE->iColumn==pExpr->iColumn |
6310 | ){ |
6311 | pCol->iSorterColumn = j; |
6312 | break; |
6313 | } |
6314 | } |
6315 | } |
6316 | if( pCol->iSorterColumn<0 ){ |
6317 | pCol->iSorterColumn = pAggInfo->nSortingColumn++; |
6318 | } |
6319 | } |
6320 | /* There is now an entry for pExpr in pAggInfo->aCol[] (either |
6321 | ** because it was there before or because we just created it). |
6322 | ** Convert the pExpr to be a TK_AGG_COLUMN referring to that |
6323 | ** pAggInfo->aCol[] entry. |
6324 | */ |
6325 | ExprSetVVAProperty(pExpr, EP_NoReduce); |
6326 | pExpr->pAggInfo = pAggInfo; |
6327 | if( pExpr->op==TK_COLUMN ){ |
6328 | pExpr->op = TK_AGG_COLUMN; |
6329 | } |
6330 | pExpr->iAgg = (i16)k; |
6331 | break; |
6332 | } /* endif pExpr->iTable==pItem->iCursor */ |
6333 | } /* end loop over pSrcList */ |
6334 | } |
6335 | return WRC_Prune; |
6336 | } |
6337 | case TK_AGG_FUNCTION: { |
6338 | if( (pNC->ncFlags & NC_InAggFunc)==0 |
6339 | && pWalker->walkerDepth==pExpr->op2 |
6340 | ){ |
6341 | /* Check to see if pExpr is a duplicate of another aggregate |
6342 | ** function that is already in the pAggInfo structure |
6343 | */ |
6344 | struct AggInfo_func *pItem = pAggInfo->aFunc; |
6345 | for(i=0; i<pAggInfo->nFunc; i++, pItem++){ |
6346 | if( pItem->pFExpr==pExpr ) break; |
6347 | if( sqlite3ExprCompare(0, pItem->pFExpr, pExpr, -1)==0 ){ |
6348 | break; |
6349 | } |
6350 | } |
6351 | if( i>=pAggInfo->nFunc ){ |
6352 | /* pExpr is original. Make a new entry in pAggInfo->aFunc[] |
6353 | */ |
6354 | u8 enc = ENC(pParse->db); |
6355 | i = addAggInfoFunc(pParse->db, pAggInfo); |
6356 | if( i>=0 ){ |
6357 | assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); |
6358 | pItem = &pAggInfo->aFunc[i]; |
6359 | pItem->pFExpr = pExpr; |
6360 | pItem->iMem = ++pParse->nMem; |
6361 | assert( ExprUseUToken(pExpr) ); |
6362 | pItem->pFunc = sqlite3FindFunction(pParse->db, |
6363 | pExpr->u.zToken, |
6364 | pExpr->x.pList ? pExpr->x.pList->nExpr : 0, enc, 0); |
6365 | if( pExpr->flags & EP_Distinct ){ |
6366 | pItem->iDistinct = pParse->nTab++; |
6367 | }else{ |
6368 | pItem->iDistinct = -1; |
6369 | } |
6370 | } |
6371 | } |
6372 | /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry |
6373 | */ |
6374 | assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) ); |
6375 | ExprSetVVAProperty(pExpr, EP_NoReduce); |
6376 | pExpr->iAgg = (i16)i; |
6377 | pExpr->pAggInfo = pAggInfo; |
6378 | return WRC_Prune; |
6379 | }else{ |
6380 | return WRC_Continue; |
6381 | } |
6382 | } |
6383 | } |
6384 | return WRC_Continue; |
6385 | } |
6386 | |
6387 | /* |
6388 | ** Analyze the pExpr expression looking for aggregate functions and |
6389 | ** for variables that need to be added to AggInfo object that pNC->pAggInfo |
6390 | ** points to. Additional entries are made on the AggInfo object as |
6391 | ** necessary. |
6392 | ** |
6393 | ** This routine should only be called after the expression has been |
6394 | ** analyzed by sqlite3ResolveExprNames(). |
6395 | */ |
6396 | void sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){ |
6397 | Walker w; |
6398 | w.xExprCallback = analyzeAggregate; |
6399 | w.xSelectCallback = sqlite3WalkerDepthIncrease; |
6400 | w.xSelectCallback2 = sqlite3WalkerDepthDecrease; |
6401 | w.walkerDepth = 0; |
6402 | w.u.pNC = pNC; |
6403 | w.pParse = 0; |
6404 | assert( pNC->pSrcList!=0 ); |
6405 | sqlite3WalkExpr(&w, pExpr); |
6406 | } |
6407 | |
6408 | /* |
6409 | ** Call sqlite3ExprAnalyzeAggregates() for every expression in an |
6410 | ** expression list. Return the number of errors. |
6411 | ** |
6412 | ** If an error is found, the analysis is cut short. |
6413 | */ |
6414 | void sqlite3ExprAnalyzeAggList(NameContext *pNC, ExprList *pList){ |
6415 | struct ExprList_item *pItem; |
6416 | int i; |
6417 | if( pList ){ |
6418 | for(pItem=pList->a, i=0; i<pList->nExpr; i++, pItem++){ |
6419 | sqlite3ExprAnalyzeAggregates(pNC, pItem->pExpr); |
6420 | } |
6421 | } |
6422 | } |
6423 | |
6424 | /* |
6425 | ** Allocate a single new register for use to hold some intermediate result. |
6426 | */ |
6427 | int sqlite3GetTempReg(Parse *pParse){ |
6428 | if( pParse->nTempReg==0 ){ |
6429 | return ++pParse->nMem; |
6430 | } |
6431 | return pParse->aTempReg[--pParse->nTempReg]; |
6432 | } |
6433 | |
6434 | /* |
6435 | ** Deallocate a register, making available for reuse for some other |
6436 | ** purpose. |
6437 | */ |
6438 | void sqlite3ReleaseTempReg(Parse *pParse, int iReg){ |
6439 | if( iReg ){ |
6440 | sqlite3VdbeReleaseRegisters(pParse, iReg, 1, 0, 0); |
6441 | if( pParse->nTempReg<ArraySize(pParse->aTempReg) ){ |
6442 | pParse->aTempReg[pParse->nTempReg++] = iReg; |
6443 | } |
6444 | } |
6445 | } |
6446 | |
6447 | /* |
6448 | ** Allocate or deallocate a block of nReg consecutive registers. |
6449 | */ |
6450 | int sqlite3GetTempRange(Parse *pParse, int nReg){ |
6451 | int i, n; |
6452 | if( nReg==1 ) return sqlite3GetTempReg(pParse); |
6453 | i = pParse->iRangeReg; |
6454 | n = pParse->nRangeReg; |
6455 | if( nReg<=n ){ |
6456 | pParse->iRangeReg += nReg; |
6457 | pParse->nRangeReg -= nReg; |
6458 | }else{ |
6459 | i = pParse->nMem+1; |
6460 | pParse->nMem += nReg; |
6461 | } |
6462 | return i; |
6463 | } |
6464 | void sqlite3ReleaseTempRange(Parse *pParse, int iReg, int nReg){ |
6465 | if( nReg==1 ){ |
6466 | sqlite3ReleaseTempReg(pParse, iReg); |
6467 | return; |
6468 | } |
6469 | sqlite3VdbeReleaseRegisters(pParse, iReg, nReg, 0, 0); |
6470 | if( nReg>pParse->nRangeReg ){ |
6471 | pParse->nRangeReg = nReg; |
6472 | pParse->iRangeReg = iReg; |
6473 | } |
6474 | } |
6475 | |
6476 | /* |
6477 | ** Mark all temporary registers as being unavailable for reuse. |
6478 | ** |
6479 | ** Always invoke this procedure after coding a subroutine or co-routine |
6480 | ** that might be invoked from other parts of the code, to ensure that |
6481 | ** the sub/co-routine does not use registers in common with the code that |
6482 | ** invokes the sub/co-routine. |
6483 | */ |
6484 | void sqlite3ClearTempRegCache(Parse *pParse){ |
6485 | pParse->nTempReg = 0; |
6486 | pParse->nRangeReg = 0; |
6487 | } |
6488 | |
6489 | /* |
6490 | ** Validate that no temporary register falls within the range of |
6491 | ** iFirst..iLast, inclusive. This routine is only call from within assert() |
6492 | ** statements. |
6493 | */ |
6494 | #ifdef SQLITE_DEBUG |
6495 | int sqlite3NoTempsInRange(Parse *pParse, int iFirst, int iLast){ |
6496 | int i; |
6497 | if( pParse->nRangeReg>0 |
6498 | && pParse->iRangeReg+pParse->nRangeReg > iFirst |
6499 | && pParse->iRangeReg <= iLast |
6500 | ){ |
6501 | return 0; |
6502 | } |
6503 | for(i=0; i<pParse->nTempReg; i++){ |
6504 | if( pParse->aTempReg[i]>=iFirst && pParse->aTempReg[i]<=iLast ){ |
6505 | return 0; |
6506 | } |
6507 | } |
6508 | return 1; |
6509 | } |
6510 | #endif /* SQLITE_DEBUG */ |
6511 | |