blob: 8e51bee2fcfb9ed42f0b921b818fa9f365e84a08 [file] [log] [blame]
drhcce7d172000-05-31 15:34:51 +00001/*
drhb19a2bc2001-09-16 00:13:26 +00002** 2001 September 15
drhcce7d172000-05-31 15:34:51 +00003**
drhb19a2bc2001-09-16 00:13:26 +00004** The author disclaims copyright to this source code. In place of
5** a legal notice, here is a blessing:
drhcce7d172000-05-31 15:34:51 +00006**
drhb19a2bc2001-09-16 00:13:26 +00007** 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.
drhcce7d172000-05-31 15:34:51 +000010**
11*************************************************************************
drh1ccde152000-06-17 13:12:39 +000012** This file contains routines used for analyzing expressions and
drhb19a2bc2001-09-16 00:13:26 +000013** for generating VDBE code that evaluates expressions in SQLite.
drhcce7d172000-05-31 15:34:51 +000014*/
15#include "sqliteInt.h"
drha2e00042002-01-22 03:13:42 +000016
danielk1977e014a832004-05-17 10:48:57 +000017/*
18** Return the 'affinity' of the expression pExpr if any.
19**
20** If pExpr is a column, a reference to a column via an 'AS' alias,
21** or a sub-select with a column as the return value, then the
22** affinity of that column is returned. Otherwise, 0x00 is returned,
23** indicating no affinity for the expression.
24**
25** i.e. the WHERE clause expresssions in the following statements all
26** have an affinity:
27**
28** CREATE TABLE t1(a);
29** SELECT * FROM t1 WHERE a;
30** SELECT a AS b FROM t1 WHERE b;
31** SELECT * FROM t1 WHERE (select a from t1);
32*/
danielk1977bf3b7212004-05-18 10:06:24 +000033char sqlite3ExprAffinity(Expr *pExpr){
drh487e2622005-06-25 18:42:14 +000034 int op = pExpr->op;
drh487e2622005-06-25 18:42:14 +000035 if( op==TK_SELECT ){
danielk19776ab3a2e2009-02-19 14:39:25 +000036 assert( pExpr->flags&EP_xIsSelect );
37 return sqlite3ExprAffinity(pExpr->x.pSelect->pEList->a[0].pExpr);
danielk1977a37cdde2004-05-16 11:15:36 +000038 }
drh487e2622005-06-25 18:42:14 +000039#ifndef SQLITE_OMIT_CAST
40 if( op==TK_CAST ){
drh33e619f2009-05-28 01:00:55 +000041 assert( !ExprHasProperty(pExpr, EP_IntValue) );
42 return sqlite3AffinityType(pExpr->u.zToken);
drh487e2622005-06-25 18:42:14 +000043 }
44#endif
danielk1977259a4552008-11-12 08:07:12 +000045 if( (op==TK_AGG_COLUMN || op==TK_COLUMN || op==TK_REGISTER)
46 && pExpr->pTab!=0
47 ){
drh7d10d5a2008-08-20 16:35:10 +000048 /* op==TK_REGISTER && pExpr->pTab!=0 happens when pExpr was originally
49 ** a TK_COLUMN but was previously evaluated and cached in a register */
50 int j = pExpr->iColumn;
51 if( j<0 ) return SQLITE_AFF_INTEGER;
52 assert( pExpr->pTab && j<pExpr->pTab->nCol );
53 return pExpr->pTab->aCol[j].affinity;
54 }
danielk1977a37cdde2004-05-16 11:15:36 +000055 return pExpr->affinity;
56}
57
drh53db1452004-05-20 13:54:53 +000058/*
drh8342e492010-07-22 17:49:52 +000059** Set the explicit collating sequence for an expression to the
60** collating sequence supplied in the second argument.
61*/
62Expr *sqlite3ExprSetColl(Expr *pExpr, CollSeq *pColl){
63 if( pExpr && pColl ){
64 pExpr->pColl = pColl;
65 pExpr->flags |= EP_ExpCollate;
66 }
67 return pExpr;
68}
69
70/*
drh8b4c40d2007-02-01 23:02:45 +000071** Set the collating sequence for expression pExpr to be the collating
72** sequence named by pToken. Return a pointer to the revised expression.
drha34001c2007-02-02 12:44:37 +000073** The collating sequence is marked as "explicit" using the EP_ExpCollate
74** flag. An explicit collating sequence will override implicit
75** collating sequences.
drh8b4c40d2007-02-01 23:02:45 +000076*/
drh8342e492010-07-22 17:49:52 +000077Expr *sqlite3ExprSetCollByToken(Parse *pParse, Expr *pExpr, Token *pCollName){
danielk197739002502007-11-12 09:50:26 +000078 char *zColl = 0; /* Dequoted name of collation sequence */
drh8b4c40d2007-02-01 23:02:45 +000079 CollSeq *pColl;
drh633e6d52008-07-28 19:34:53 +000080 sqlite3 *db = pParse->db;
drh7d10d5a2008-08-20 16:35:10 +000081 zColl = sqlite3NameFromToken(db, pCollName);
drh8342e492010-07-22 17:49:52 +000082 pColl = sqlite3LocateCollSeq(pParse, zColl);
83 sqlite3ExprSetColl(pExpr, pColl);
drh633e6d52008-07-28 19:34:53 +000084 sqlite3DbFree(db, zColl);
drh8b4c40d2007-02-01 23:02:45 +000085 return pExpr;
86}
87
88/*
danielk19770202b292004-06-09 09:55:16 +000089** Return the default collation sequence for the expression pExpr. If
90** there is no default collation type, return 0.
91*/
danielk19777cedc8d2004-06-10 10:50:08 +000092CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr){
93 CollSeq *pColl = 0;
drh7d10d5a2008-08-20 16:35:10 +000094 Expr *p = pExpr;
drh84e30ca2011-02-10 17:46:14 +000095 while( p ){
drh7e09fe02007-06-20 16:13:23 +000096 int op;
drh7d10d5a2008-08-20 16:35:10 +000097 pColl = p->pColl;
98 if( pColl ) break;
99 op = p->op;
dan76d462e2009-08-30 11:42:51 +0000100 if( p->pTab!=0 && (
101 op==TK_AGG_COLUMN || op==TK_COLUMN || op==TK_REGISTER || op==TK_TRIGGER
102 )){
drh7d10d5a2008-08-20 16:35:10 +0000103 /* op==TK_REGISTER && p->pTab!=0 happens when pExpr was originally
104 ** a TK_COLUMN but was previously evaluated and cached in a register */
105 const char *zColl;
106 int j = p->iColumn;
107 if( j>=0 ){
108 sqlite3 *db = pParse->db;
109 zColl = p->pTab->aCol[j].zColl;
drhc4a64fa2009-05-11 20:53:28 +0000110 pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0);
drh7d10d5a2008-08-20 16:35:10 +0000111 pExpr->pColl = pColl;
112 }
113 break;
danielk19770202b292004-06-09 09:55:16 +0000114 }
drh7d10d5a2008-08-20 16:35:10 +0000115 if( op!=TK_CAST && op!=TK_UPLUS ){
116 break;
117 }
118 p = p->pLeft;
danielk19770202b292004-06-09 09:55:16 +0000119 }
danielk19777cedc8d2004-06-10 10:50:08 +0000120 if( sqlite3CheckCollSeq(pParse, pColl) ){
121 pColl = 0;
122 }
123 return pColl;
danielk19770202b292004-06-09 09:55:16 +0000124}
125
126/*
drh626a8792005-01-17 22:08:19 +0000127** pExpr is an operand of a comparison operator. aff2 is the
128** type affinity of the other operand. This routine returns the
drh53db1452004-05-20 13:54:53 +0000129** type affinity that should be used for the comparison operator.
130*/
danielk1977e014a832004-05-17 10:48:57 +0000131char sqlite3CompareAffinity(Expr *pExpr, char aff2){
danielk1977bf3b7212004-05-18 10:06:24 +0000132 char aff1 = sqlite3ExprAffinity(pExpr);
danielk1977e014a832004-05-17 10:48:57 +0000133 if( aff1 && aff2 ){
drh8df447f2005-11-01 15:48:24 +0000134 /* Both sides of the comparison are columns. If one has numeric
135 ** affinity, use that. Otherwise use no affinity.
danielk1977e014a832004-05-17 10:48:57 +0000136 */
drh8a512562005-11-14 22:29:05 +0000137 if( sqlite3IsNumericAffinity(aff1) || sqlite3IsNumericAffinity(aff2) ){
danielk1977e014a832004-05-17 10:48:57 +0000138 return SQLITE_AFF_NUMERIC;
139 }else{
140 return SQLITE_AFF_NONE;
141 }
142 }else if( !aff1 && !aff2 ){
drh5f6a87b2004-07-19 00:39:45 +0000143 /* Neither side of the comparison is a column. Compare the
144 ** results directly.
danielk1977e014a832004-05-17 10:48:57 +0000145 */
drh5f6a87b2004-07-19 00:39:45 +0000146 return SQLITE_AFF_NONE;
danielk1977e014a832004-05-17 10:48:57 +0000147 }else{
148 /* One side is a column, the other is not. Use the columns affinity. */
drhfe05af82005-07-21 03:14:59 +0000149 assert( aff1==0 || aff2==0 );
danielk1977e014a832004-05-17 10:48:57 +0000150 return (aff1 + aff2);
151 }
152}
153
drh53db1452004-05-20 13:54:53 +0000154/*
155** pExpr is a comparison operator. Return the type affinity that should
156** be applied to both operands prior to doing the comparison.
157*/
danielk1977e014a832004-05-17 10:48:57 +0000158static char comparisonAffinity(Expr *pExpr){
159 char aff;
160 assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT ||
161 pExpr->op==TK_GT || pExpr->op==TK_GE || pExpr->op==TK_LE ||
drh6a2fe092009-09-23 02:29:36 +0000162 pExpr->op==TK_NE || pExpr->op==TK_IS || pExpr->op==TK_ISNOT );
danielk1977e014a832004-05-17 10:48:57 +0000163 assert( pExpr->pLeft );
danielk1977bf3b7212004-05-18 10:06:24 +0000164 aff = sqlite3ExprAffinity(pExpr->pLeft);
danielk1977e014a832004-05-17 10:48:57 +0000165 if( pExpr->pRight ){
166 aff = sqlite3CompareAffinity(pExpr->pRight, aff);
danielk19776ab3a2e2009-02-19 14:39:25 +0000167 }else if( ExprHasProperty(pExpr, EP_xIsSelect) ){
168 aff = sqlite3CompareAffinity(pExpr->x.pSelect->pEList->a[0].pExpr, aff);
169 }else if( !aff ){
drhde087bd2007-02-23 03:00:44 +0000170 aff = SQLITE_AFF_NONE;
danielk1977e014a832004-05-17 10:48:57 +0000171 }
172 return aff;
173}
174
175/*
176** pExpr is a comparison expression, eg. '=', '<', IN(...) etc.
177** idx_affinity is the affinity of an indexed column. Return true
178** if the index with affinity idx_affinity may be used to implement
179** the comparison in pExpr.
180*/
181int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity){
182 char aff = comparisonAffinity(pExpr);
drh8a512562005-11-14 22:29:05 +0000183 switch( aff ){
184 case SQLITE_AFF_NONE:
185 return 1;
186 case SQLITE_AFF_TEXT:
187 return idx_affinity==SQLITE_AFF_TEXT;
188 default:
189 return sqlite3IsNumericAffinity(idx_affinity);
190 }
danielk1977e014a832004-05-17 10:48:57 +0000191}
192
danielk1977a37cdde2004-05-16 11:15:36 +0000193/*
drh35573352008-01-08 23:54:25 +0000194** Return the P5 value that should be used for a binary comparison
danielk1977a37cdde2004-05-16 11:15:36 +0000195** opcode (OP_Eq, OP_Ge etc.) used to compare pExpr1 and pExpr2.
danielk1977a37cdde2004-05-16 11:15:36 +0000196*/
drh35573352008-01-08 23:54:25 +0000197static u8 binaryCompareP5(Expr *pExpr1, Expr *pExpr2, int jumpIfNull){
198 u8 aff = (char)sqlite3ExprAffinity(pExpr2);
drh1bd10f82008-12-10 21:19:56 +0000199 aff = (u8)sqlite3CompareAffinity(pExpr1, aff) | (u8)jumpIfNull;
drh35573352008-01-08 23:54:25 +0000200 return aff;
danielk1977a37cdde2004-05-16 11:15:36 +0000201}
202
drha2e00042002-01-22 03:13:42 +0000203/*
danielk19770202b292004-06-09 09:55:16 +0000204** Return a pointer to the collation sequence that should be used by
205** a binary comparison operator comparing pLeft and pRight.
206**
207** If the left hand expression has a collating sequence type, then it is
208** used. Otherwise the collation sequence for the right hand expression
209** is used, or the default (BINARY) if neither expression has a collating
210** type.
danielk1977bcbb04e2007-05-29 12:11:29 +0000211**
212** Argument pRight (but not pLeft) may be a null pointer. In this case,
213** it is not considered.
danielk19770202b292004-06-09 09:55:16 +0000214*/
drh0a0e1312007-08-07 17:04:59 +0000215CollSeq *sqlite3BinaryCompareCollSeq(
danielk1977bcbb04e2007-05-29 12:11:29 +0000216 Parse *pParse,
217 Expr *pLeft,
218 Expr *pRight
219){
drhec41dda2007-02-07 13:09:45 +0000220 CollSeq *pColl;
221 assert( pLeft );
drhec41dda2007-02-07 13:09:45 +0000222 if( pLeft->flags & EP_ExpCollate ){
223 assert( pLeft->pColl );
224 pColl = pLeft->pColl;
danielk1977bcbb04e2007-05-29 12:11:29 +0000225 }else if( pRight && pRight->flags & EP_ExpCollate ){
drhec41dda2007-02-07 13:09:45 +0000226 assert( pRight->pColl );
227 pColl = pRight->pColl;
228 }else{
229 pColl = sqlite3ExprCollSeq(pParse, pLeft);
230 if( !pColl ){
231 pColl = sqlite3ExprCollSeq(pParse, pRight);
232 }
danielk19770202b292004-06-09 09:55:16 +0000233 }
234 return pColl;
235}
236
237/*
drhbe5c89a2004-07-26 00:31:09 +0000238** Generate code for a comparison operator.
239*/
240static int codeCompare(
241 Parse *pParse, /* The parsing (and code generating) context */
242 Expr *pLeft, /* The left operand */
243 Expr *pRight, /* The right operand */
244 int opcode, /* The comparison opcode */
drh35573352008-01-08 23:54:25 +0000245 int in1, int in2, /* Register holding operands */
drhbe5c89a2004-07-26 00:31:09 +0000246 int dest, /* Jump here if true. */
247 int jumpIfNull /* If true, jump if either operand is NULL */
248){
drh35573352008-01-08 23:54:25 +0000249 int p5;
250 int addr;
251 CollSeq *p4;
252
253 p4 = sqlite3BinaryCompareCollSeq(pParse, pLeft, pRight);
254 p5 = binaryCompareP5(pLeft, pRight, jumpIfNull);
255 addr = sqlite3VdbeAddOp4(pParse->pVdbe, opcode, in2, dest, in1,
256 (void*)p4, P4_COLLSEQ);
drh1bd10f82008-12-10 21:19:56 +0000257 sqlite3VdbeChangeP5(pParse->pVdbe, (u8)p5);
drh35573352008-01-08 23:54:25 +0000258 return addr;
drhbe5c89a2004-07-26 00:31:09 +0000259}
260
danielk19774b5255a2008-06-05 16:47:39 +0000261#if SQLITE_MAX_EXPR_DEPTH>0
262/*
263** Check that argument nHeight is less than or equal to the maximum
264** expression depth allowed. If it is not, leave an error message in
265** pParse.
266*/
drh7d10d5a2008-08-20 16:35:10 +0000267int sqlite3ExprCheckHeight(Parse *pParse, int nHeight){
danielk19774b5255a2008-06-05 16:47:39 +0000268 int rc = SQLITE_OK;
269 int mxHeight = pParse->db->aLimit[SQLITE_LIMIT_EXPR_DEPTH];
270 if( nHeight>mxHeight ){
271 sqlite3ErrorMsg(pParse,
272 "Expression tree is too large (maximum depth %d)", mxHeight
273 );
274 rc = SQLITE_ERROR;
275 }
276 return rc;
277}
278
279/* The following three functions, heightOfExpr(), heightOfExprList()
280** and heightOfSelect(), are used to determine the maximum height
281** of any expression tree referenced by the structure passed as the
282** first argument.
283**
284** If this maximum height is greater than the current value pointed
285** to by pnHeight, the second parameter, then set *pnHeight to that
286** value.
287*/
288static void heightOfExpr(Expr *p, int *pnHeight){
289 if( p ){
290 if( p->nHeight>*pnHeight ){
291 *pnHeight = p->nHeight;
292 }
293 }
294}
295static void heightOfExprList(ExprList *p, int *pnHeight){
296 if( p ){
297 int i;
298 for(i=0; i<p->nExpr; i++){
299 heightOfExpr(p->a[i].pExpr, pnHeight);
300 }
301 }
302}
303static void heightOfSelect(Select *p, int *pnHeight){
304 if( p ){
305 heightOfExpr(p->pWhere, pnHeight);
306 heightOfExpr(p->pHaving, pnHeight);
307 heightOfExpr(p->pLimit, pnHeight);
308 heightOfExpr(p->pOffset, pnHeight);
309 heightOfExprList(p->pEList, pnHeight);
310 heightOfExprList(p->pGroupBy, pnHeight);
311 heightOfExprList(p->pOrderBy, pnHeight);
312 heightOfSelect(p->pPrior, pnHeight);
313 }
314}
315
316/*
317** Set the Expr.nHeight variable in the structure passed as an
318** argument. An expression with no children, Expr.pList or
319** Expr.pSelect member has a height of 1. Any other expression
320** has a height equal to the maximum height of any other
321** referenced Expr plus one.
322*/
323static void exprSetHeight(Expr *p){
324 int nHeight = 0;
325 heightOfExpr(p->pLeft, &nHeight);
326 heightOfExpr(p->pRight, &nHeight);
danielk19776ab3a2e2009-02-19 14:39:25 +0000327 if( ExprHasProperty(p, EP_xIsSelect) ){
328 heightOfSelect(p->x.pSelect, &nHeight);
329 }else{
330 heightOfExprList(p->x.pList, &nHeight);
331 }
danielk19774b5255a2008-06-05 16:47:39 +0000332 p->nHeight = nHeight + 1;
333}
334
335/*
336** Set the Expr.nHeight variable using the exprSetHeight() function. If
337** the height is greater than the maximum allowed expression depth,
338** leave an error in pParse.
339*/
340void sqlite3ExprSetHeight(Parse *pParse, Expr *p){
341 exprSetHeight(p);
drh7d10d5a2008-08-20 16:35:10 +0000342 sqlite3ExprCheckHeight(pParse, p->nHeight);
danielk19774b5255a2008-06-05 16:47:39 +0000343}
344
345/*
346** Return the maximum height of any expression tree referenced
347** by the select statement passed as an argument.
348*/
349int sqlite3SelectExprHeight(Select *p){
350 int nHeight = 0;
351 heightOfSelect(p, &nHeight);
352 return nHeight;
353}
354#else
danielk19774b5255a2008-06-05 16:47:39 +0000355 #define exprSetHeight(y)
356#endif /* SQLITE_MAX_EXPR_DEPTH>0 */
357
drhbe5c89a2004-07-26 00:31:09 +0000358/*
drhb7916a72009-05-27 10:31:29 +0000359** This routine is the core allocator for Expr nodes.
360**
drha76b5df2002-02-23 02:32:10 +0000361** Construct a new expression node and return a pointer to it. Memory
drhb7916a72009-05-27 10:31:29 +0000362** for this node and for the pToken argument is a single allocation
363** obtained from sqlite3DbMalloc(). The calling function
drha76b5df2002-02-23 02:32:10 +0000364** is responsible for making sure the node eventually gets freed.
drhb7916a72009-05-27 10:31:29 +0000365**
366** If dequote is true, then the token (if it exists) is dequoted.
367** If dequote is false, no dequoting is performance. The deQuote
368** parameter is ignored if pToken is NULL or if the token does not
369** appear to be quoted. If the quotes were of the form "..." (double-quotes)
370** then the EP_DblQuoted flag is set on the expression node.
drh33e619f2009-05-28 01:00:55 +0000371**
372** Special case: If op==TK_INTEGER and pToken points to a string that
373** can be translated into a 32-bit integer, then the token is not
374** stored in u.zToken. Instead, the integer values is written
375** into u.iValue and the EP_IntValue flag is set. No extra storage
376** is allocated to hold the integer text and the dequote flag is ignored.
drha76b5df2002-02-23 02:32:10 +0000377*/
drhb7916a72009-05-27 10:31:29 +0000378Expr *sqlite3ExprAlloc(
danielk1977a1644fd2007-08-29 12:31:25 +0000379 sqlite3 *db, /* Handle for sqlite3DbMallocZero() (may be null) */
drh17435752007-08-16 04:30:38 +0000380 int op, /* Expression opcode */
drhb7916a72009-05-27 10:31:29 +0000381 const Token *pToken, /* Token argument. Might be NULL */
382 int dequote /* True to dequote */
drh17435752007-08-16 04:30:38 +0000383){
drha76b5df2002-02-23 02:32:10 +0000384 Expr *pNew;
drh33e619f2009-05-28 01:00:55 +0000385 int nExtra = 0;
shanecf697392009-06-01 16:53:09 +0000386 int iValue = 0;
danielk1977fc976062007-05-10 10:46:56 +0000387
drhb7916a72009-05-27 10:31:29 +0000388 if( pToken ){
drh33e619f2009-05-28 01:00:55 +0000389 if( op!=TK_INTEGER || pToken->z==0
390 || sqlite3GetInt32(pToken->z, &iValue)==0 ){
391 nExtra = pToken->n+1;
drhd50ffc42011-03-08 02:38:28 +0000392 assert( iValue>=0 );
drh33e619f2009-05-28 01:00:55 +0000393 }
drhb7916a72009-05-27 10:31:29 +0000394 }
395 pNew = sqlite3DbMallocZero(db, sizeof(Expr)+nExtra);
396 if( pNew ){
397 pNew->op = (u8)op;
398 pNew->iAgg = -1;
399 if( pToken ){
drh33e619f2009-05-28 01:00:55 +0000400 if( nExtra==0 ){
401 pNew->flags |= EP_IntValue;
402 pNew->u.iValue = iValue;
403 }else{
404 int c;
405 pNew->u.zToken = (char*)&pNew[1];
drhb07028f2011-10-14 21:49:18 +0000406 assert( pToken->z!=0 || pToken->n==0 );
407 if( pToken->n ) memcpy(pNew->u.zToken, pToken->z, pToken->n);
drh33e619f2009-05-28 01:00:55 +0000408 pNew->u.zToken[pToken->n] = 0;
409 if( dequote && nExtra>=3
410 && ((c = pToken->z[0])=='\'' || c=='"' || c=='[' || c=='`') ){
411 sqlite3Dequote(pNew->u.zToken);
412 if( c=='"' ) pNew->flags |= EP_DblQuoted;
413 }
drhb7916a72009-05-27 10:31:29 +0000414 }
415 }
416#if SQLITE_MAX_EXPR_DEPTH>0
417 pNew->nHeight = 1;
418#endif
419 }
drha76b5df2002-02-23 02:32:10 +0000420 return pNew;
421}
422
423/*
drhb7916a72009-05-27 10:31:29 +0000424** Allocate a new expression node from a zero-terminated token that has
425** already been dequoted.
426*/
427Expr *sqlite3Expr(
428 sqlite3 *db, /* Handle for sqlite3DbMallocZero() (may be null) */
429 int op, /* Expression opcode */
430 const char *zToken /* Token argument. Might be NULL */
431){
432 Token x;
433 x.z = zToken;
434 x.n = zToken ? sqlite3Strlen30(zToken) : 0;
435 return sqlite3ExprAlloc(db, op, &x, 0);
436}
437
438/*
439** Attach subtrees pLeft and pRight to the Expr node pRoot.
440**
441** If pRoot==NULL that means that a memory allocation error has occurred.
442** In that case, delete the subtrees pLeft and pRight.
443*/
444void sqlite3ExprAttachSubtrees(
445 sqlite3 *db,
446 Expr *pRoot,
447 Expr *pLeft,
448 Expr *pRight
449){
450 if( pRoot==0 ){
451 assert( db->mallocFailed );
452 sqlite3ExprDelete(db, pLeft);
453 sqlite3ExprDelete(db, pRight);
454 }else{
455 if( pRight ){
456 pRoot->pRight = pRight;
457 if( pRight->flags & EP_ExpCollate ){
458 pRoot->flags |= EP_ExpCollate;
459 pRoot->pColl = pRight->pColl;
460 }
461 }
462 if( pLeft ){
463 pRoot->pLeft = pLeft;
464 if( pLeft->flags & EP_ExpCollate ){
465 pRoot->flags |= EP_ExpCollate;
466 pRoot->pColl = pLeft->pColl;
467 }
468 }
469 exprSetHeight(pRoot);
470 }
471}
472
473/*
drhbf664462009-06-19 18:32:54 +0000474** Allocate a Expr node which joins as many as two subtrees.
drhb7916a72009-05-27 10:31:29 +0000475**
drhbf664462009-06-19 18:32:54 +0000476** One or both of the subtrees can be NULL. Return a pointer to the new
477** Expr node. Or, if an OOM error occurs, set pParse->db->mallocFailed,
478** free the subtrees and return NULL.
drh206f3d92006-07-11 13:15:08 +0000479*/
drh17435752007-08-16 04:30:38 +0000480Expr *sqlite3PExpr(
481 Parse *pParse, /* Parsing context */
482 int op, /* Expression opcode */
483 Expr *pLeft, /* Left operand */
484 Expr *pRight, /* Right operand */
485 const Token *pToken /* Argument token */
486){
drhb7916a72009-05-27 10:31:29 +0000487 Expr *p = sqlite3ExprAlloc(pParse->db, op, pToken, 1);
488 sqlite3ExprAttachSubtrees(pParse->db, p, pLeft, pRight);
dan2b359bd2010-10-28 11:31:23 +0000489 if( p ) {
490 sqlite3ExprCheckHeight(pParse, p->nHeight);
491 }
drh4e0cff62004-11-05 05:10:28 +0000492 return p;
493}
494
495/*
drh91bb0ee2004-09-01 03:06:34 +0000496** Join two expressions using an AND operator. If either expression is
497** NULL, then just return the other expression.
498*/
danielk19771e536952007-08-16 10:09:01 +0000499Expr *sqlite3ExprAnd(sqlite3 *db, Expr *pLeft, Expr *pRight){
drh91bb0ee2004-09-01 03:06:34 +0000500 if( pLeft==0 ){
501 return pRight;
502 }else if( pRight==0 ){
503 return pLeft;
504 }else{
drhb7916a72009-05-27 10:31:29 +0000505 Expr *pNew = sqlite3ExprAlloc(db, TK_AND, 0, 0);
506 sqlite3ExprAttachSubtrees(db, pNew, pLeft, pRight);
507 return pNew;
drha76b5df2002-02-23 02:32:10 +0000508 }
509}
510
511/*
512** Construct a new expression node for a function with multiple
513** arguments.
514*/
drh17435752007-08-16 04:30:38 +0000515Expr *sqlite3ExprFunction(Parse *pParse, ExprList *pList, Token *pToken){
drha76b5df2002-02-23 02:32:10 +0000516 Expr *pNew;
drh633e6d52008-07-28 19:34:53 +0000517 sqlite3 *db = pParse->db;
danielk19774b202ae2006-01-23 05:50:58 +0000518 assert( pToken );
drhb7916a72009-05-27 10:31:29 +0000519 pNew = sqlite3ExprAlloc(db, TK_FUNCTION, pToken, 1);
drha76b5df2002-02-23 02:32:10 +0000520 if( pNew==0 ){
drhd9da78a2009-03-24 15:08:09 +0000521 sqlite3ExprListDelete(db, pList); /* Avoid memory leak when malloc fails */
drha76b5df2002-02-23 02:32:10 +0000522 return 0;
523 }
danielk19776ab3a2e2009-02-19 14:39:25 +0000524 pNew->x.pList = pList;
525 assert( !ExprHasProperty(pNew, EP_xIsSelect) );
danielk19774b5255a2008-06-05 16:47:39 +0000526 sqlite3ExprSetHeight(pParse, pNew);
drha76b5df2002-02-23 02:32:10 +0000527 return pNew;
528}
529
530/*
drhfa6bc002004-09-07 16:19:52 +0000531** Assign a variable number to an expression that encodes a wildcard
532** in the original SQL statement.
533**
534** Wildcards consisting of a single "?" are assigned the next sequential
535** variable number.
536**
537** Wildcards of the form "?nnn" are assigned the number "nnn". We make
538** sure "nnn" is not too be to avoid a denial of service attack when
539** the SQL statement comes from an external source.
540**
drh51f49f12009-05-21 20:41:32 +0000541** Wildcards of the form ":aaa", "@aaa", or "$aaa" are assigned the same number
drhfa6bc002004-09-07 16:19:52 +0000542** as the previous instance of the same wildcard. Or if this is the first
543** instance of the wildcard, the next sequenial variable number is
544** assigned.
545*/
546void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr){
drh17435752007-08-16 04:30:38 +0000547 sqlite3 *db = pParse->db;
drhb7916a72009-05-27 10:31:29 +0000548 const char *z;
drh17435752007-08-16 04:30:38 +0000549
drhfa6bc002004-09-07 16:19:52 +0000550 if( pExpr==0 ) return;
drh33e619f2009-05-28 01:00:55 +0000551 assert( !ExprHasAnyProperty(pExpr, EP_IntValue|EP_Reduced|EP_TokenOnly) );
552 z = pExpr->u.zToken;
drhb7916a72009-05-27 10:31:29 +0000553 assert( z!=0 );
554 assert( z[0]!=0 );
555 if( z[1]==0 ){
drhfa6bc002004-09-07 16:19:52 +0000556 /* Wildcard of the form "?". Assign the next variable number */
drhb7916a72009-05-27 10:31:29 +0000557 assert( z[0]=='?' );
drh8677d302009-11-04 13:17:14 +0000558 pExpr->iColumn = (ynVar)(++pParse->nVar);
drhfa6bc002004-09-07 16:19:52 +0000559 }else{
drh124c0b42011-06-01 18:15:55 +0000560 ynVar x = 0;
561 u32 n = sqlite3Strlen30(z);
562 if( z[0]=='?' ){
563 /* Wildcard of the form "?nnn". Convert "nnn" to an integer and
564 ** use it as the variable number */
565 i64 i;
566 int bOk = 0==sqlite3Atoi64(&z[1], &i, n-1, SQLITE_UTF8);
567 pExpr->iColumn = x = (ynVar)i;
568 testcase( i==0 );
569 testcase( i==1 );
570 testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]-1 );
571 testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] );
572 if( bOk==0 || i<1 || i>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){
573 sqlite3ErrorMsg(pParse, "variable number must be between ?1 and ?%d",
574 db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]);
575 x = 0;
drhfa6bc002004-09-07 16:19:52 +0000576 }
drh124c0b42011-06-01 18:15:55 +0000577 if( i>pParse->nVar ){
578 pParse->nVar = (int)i;
579 }
580 }else{
581 /* Wildcards like ":aaa", "$aaa" or "@aaa". Reuse the same variable
582 ** number as the prior appearance of the same name, or if the name
583 ** has never appeared before, reuse the same variable number
584 */
585 ynVar i;
586 for(i=0; i<pParse->nzVar; i++){
587 if( pParse->azVar[i] && memcmp(pParse->azVar[i],z,n+1)==0 ){
588 pExpr->iColumn = x = (ynVar)i+1;
589 break;
590 }
591 }
592 if( x==0 ) x = pExpr->iColumn = (ynVar)(++pParse->nVar);
drhfa6bc002004-09-07 16:19:52 +0000593 }
drh124c0b42011-06-01 18:15:55 +0000594 if( x>0 ){
595 if( x>pParse->nzVar ){
596 char **a;
597 a = sqlite3DbRealloc(db, pParse->azVar, x*sizeof(a[0]));
598 if( a==0 ) return; /* Error reported through db->mallocFailed */
599 pParse->azVar = a;
600 memset(&a[pParse->nzVar], 0, (x-pParse->nzVar)*sizeof(a[0]));
601 pParse->nzVar = x;
drhfa6bc002004-09-07 16:19:52 +0000602 }
drh124c0b42011-06-01 18:15:55 +0000603 if( z[0]!='?' || pParse->azVar[x-1]==0 ){
604 sqlite3DbFree(db, pParse->azVar[x-1]);
605 pParse->azVar[x-1] = sqlite3DbStrNDup(db, z, n);
drhfa6bc002004-09-07 16:19:52 +0000606 }
607 }
608 }
drhbb4957f2008-03-20 14:03:29 +0000609 if( !pParse->nErr && pParse->nVar>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){
danielk1977832b2662007-05-09 11:37:22 +0000610 sqlite3ErrorMsg(pParse, "too many SQL variables");
611 }
drhfa6bc002004-09-07 16:19:52 +0000612}
613
614/*
danf6963f92009-11-23 14:39:14 +0000615** Recursively delete an expression tree.
drha2e00042002-01-22 03:13:42 +0000616*/
danf6963f92009-11-23 14:39:14 +0000617void sqlite3ExprDelete(sqlite3 *db, Expr *p){
618 if( p==0 ) return;
drhd50ffc42011-03-08 02:38:28 +0000619 /* Sanity check: Assert that the IntValue is non-negative if it exists */
620 assert( !ExprHasProperty(p, EP_IntValue) || p->u.iValue>=0 );
drhb7916a72009-05-27 10:31:29 +0000621 if( !ExprHasAnyProperty(p, EP_TokenOnly) ){
drh33e619f2009-05-28 01:00:55 +0000622 sqlite3ExprDelete(db, p->pLeft);
623 sqlite3ExprDelete(db, p->pRight);
624 if( !ExprHasProperty(p, EP_Reduced) && (p->flags2 & EP2_MallocedToken)!=0 ){
625 sqlite3DbFree(db, p->u.zToken);
danielk19776ab3a2e2009-02-19 14:39:25 +0000626 }
627 if( ExprHasProperty(p, EP_xIsSelect) ){
628 sqlite3SelectDelete(db, p->x.pSelect);
629 }else{
630 sqlite3ExprListDelete(db, p->x.pList);
631 }
632 }
drh33e619f2009-05-28 01:00:55 +0000633 if( !ExprHasProperty(p, EP_Static) ){
634 sqlite3DbFree(db, p);
635 }
drha2e00042002-01-22 03:13:42 +0000636}
637
drhd2687b72005-08-12 22:56:09 +0000638/*
danielk19776ab3a2e2009-02-19 14:39:25 +0000639** Return the number of bytes allocated for the expression structure
640** passed as the first argument. This is always one of EXPR_FULLSIZE,
641** EXPR_REDUCEDSIZE or EXPR_TOKENONLYSIZE.
642*/
643static int exprStructSize(Expr *p){
644 if( ExprHasProperty(p, EP_TokenOnly) ) return EXPR_TOKENONLYSIZE;
danielk19776ab3a2e2009-02-19 14:39:25 +0000645 if( ExprHasProperty(p, EP_Reduced) ) return EXPR_REDUCEDSIZE;
646 return EXPR_FULLSIZE;
647}
648
649/*
drh33e619f2009-05-28 01:00:55 +0000650** The dupedExpr*Size() routines each return the number of bytes required
651** to store a copy of an expression or expression tree. They differ in
652** how much of the tree is measured.
653**
654** dupedExprStructSize() Size of only the Expr structure
655** dupedExprNodeSize() Size of Expr + space for token
656** dupedExprSize() Expr + token + subtree components
657**
658***************************************************************************
659**
660** The dupedExprStructSize() function returns two values OR-ed together:
661** (1) the space required for a copy of the Expr structure only and
662** (2) the EP_xxx flags that indicate what the structure size should be.
663** The return values is always one of:
664**
665** EXPR_FULLSIZE
666** EXPR_REDUCEDSIZE | EP_Reduced
667** EXPR_TOKENONLYSIZE | EP_TokenOnly
668**
669** The size of the structure can be found by masking the return value
670** of this routine with 0xfff. The flags can be found by masking the
671** return value with EP_Reduced|EP_TokenOnly.
672**
673** Note that with flags==EXPRDUP_REDUCE, this routines works on full-size
674** (unreduced) Expr objects as they or originally constructed by the parser.
675** During expression analysis, extra information is computed and moved into
676** later parts of teh Expr object and that extra information might get chopped
677** off if the expression is reduced. Note also that it does not work to
678** make a EXPRDUP_REDUCE copy of a reduced expression. It is only legal
679** to reduce a pristine expression tree from the parser. The implementation
680** of dupedExprStructSize() contain multiple assert() statements that attempt
681** to enforce this constraint.
danielk19776ab3a2e2009-02-19 14:39:25 +0000682*/
683static int dupedExprStructSize(Expr *p, int flags){
684 int nSize;
drh33e619f2009-05-28 01:00:55 +0000685 assert( flags==EXPRDUP_REDUCE || flags==0 ); /* Only one flag value allowed */
danielk19776ab3a2e2009-02-19 14:39:25 +0000686 if( 0==(flags&EXPRDUP_REDUCE) ){
687 nSize = EXPR_FULLSIZE;
danielk19776ab3a2e2009-02-19 14:39:25 +0000688 }else{
drh33e619f2009-05-28 01:00:55 +0000689 assert( !ExprHasAnyProperty(p, EP_TokenOnly|EP_Reduced) );
690 assert( !ExprHasProperty(p, EP_FromJoin) );
691 assert( (p->flags2 & EP2_MallocedToken)==0 );
692 assert( (p->flags2 & EP2_Irreducible)==0 );
693 if( p->pLeft || p->pRight || p->pColl || p->x.pList ){
694 nSize = EXPR_REDUCEDSIZE | EP_Reduced;
695 }else{
696 nSize = EXPR_TOKENONLYSIZE | EP_TokenOnly;
697 }
danielk19776ab3a2e2009-02-19 14:39:25 +0000698 }
699 return nSize;
700}
701
702/*
drh33e619f2009-05-28 01:00:55 +0000703** This function returns the space in bytes required to store the copy
704** of the Expr structure and a copy of the Expr.u.zToken string (if that
705** string is defined.)
danielk19776ab3a2e2009-02-19 14:39:25 +0000706*/
707static int dupedExprNodeSize(Expr *p, int flags){
drh33e619f2009-05-28 01:00:55 +0000708 int nByte = dupedExprStructSize(p, flags) & 0xfff;
709 if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){
710 nByte += sqlite3Strlen30(p->u.zToken)+1;
danielk19776ab3a2e2009-02-19 14:39:25 +0000711 }
danielk1977bc739712009-03-23 04:33:32 +0000712 return ROUND8(nByte);
danielk19776ab3a2e2009-02-19 14:39:25 +0000713}
714
715/*
716** Return the number of bytes required to create a duplicate of the
717** expression passed as the first argument. The second argument is a
718** mask containing EXPRDUP_XXX flags.
719**
720** The value returned includes space to create a copy of the Expr struct
drh33e619f2009-05-28 01:00:55 +0000721** itself and the buffer referred to by Expr.u.zToken, if any.
danielk19776ab3a2e2009-02-19 14:39:25 +0000722**
723** If the EXPRDUP_REDUCE flag is set, then the return value includes
724** space to duplicate all Expr nodes in the tree formed by Expr.pLeft
725** and Expr.pRight variables (but not for any structures pointed to or
726** descended from the Expr.x.pList or Expr.x.pSelect variables).
727*/
728static int dupedExprSize(Expr *p, int flags){
729 int nByte = 0;
730 if( p ){
731 nByte = dupedExprNodeSize(p, flags);
732 if( flags&EXPRDUP_REDUCE ){
drhb7916a72009-05-27 10:31:29 +0000733 nByte += dupedExprSize(p->pLeft, flags) + dupedExprSize(p->pRight, flags);
danielk19776ab3a2e2009-02-19 14:39:25 +0000734 }
735 }
736 return nByte;
737}
738
739/*
740** This function is similar to sqlite3ExprDup(), except that if pzBuffer
741** is not NULL then *pzBuffer is assumed to point to a buffer large enough
drh33e619f2009-05-28 01:00:55 +0000742** to store the copy of expression p, the copies of p->u.zToken
danielk19776ab3a2e2009-02-19 14:39:25 +0000743** (if applicable), and the copies of the p->pLeft and p->pRight expressions,
744** if any. Before returning, *pzBuffer is set to the first byte passed the
745** portion of the buffer copied into by this function.
746*/
747static Expr *exprDup(sqlite3 *db, Expr *p, int flags, u8 **pzBuffer){
748 Expr *pNew = 0; /* Value to return */
749 if( p ){
danielk19776ab3a2e2009-02-19 14:39:25 +0000750 const int isReduced = (flags&EXPRDUP_REDUCE);
751 u8 *zAlloc;
drh33e619f2009-05-28 01:00:55 +0000752 u32 staticFlag = 0;
danielk19776ab3a2e2009-02-19 14:39:25 +0000753
754 assert( pzBuffer==0 || isReduced );
755
756 /* Figure out where to write the new Expr structure. */
757 if( pzBuffer ){
758 zAlloc = *pzBuffer;
drh33e619f2009-05-28 01:00:55 +0000759 staticFlag = EP_Static;
danielk19776ab3a2e2009-02-19 14:39:25 +0000760 }else{
761 zAlloc = sqlite3DbMallocRaw(db, dupedExprSize(p, flags));
762 }
763 pNew = (Expr *)zAlloc;
764
765 if( pNew ){
766 /* Set nNewSize to the size allocated for the structure pointed to
767 ** by pNew. This is either EXPR_FULLSIZE, EXPR_REDUCEDSIZE or
768 ** EXPR_TOKENONLYSIZE. nToken is set to the number of bytes consumed
drh33e619f2009-05-28 01:00:55 +0000769 ** by the copy of the p->u.zToken string (if any).
danielk19776ab3a2e2009-02-19 14:39:25 +0000770 */
drh33e619f2009-05-28 01:00:55 +0000771 const unsigned nStructSize = dupedExprStructSize(p, flags);
772 const int nNewSize = nStructSize & 0xfff;
773 int nToken;
774 if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){
775 nToken = sqlite3Strlen30(p->u.zToken) + 1;
776 }else{
777 nToken = 0;
778 }
danielk19776ab3a2e2009-02-19 14:39:25 +0000779 if( isReduced ){
780 assert( ExprHasProperty(p, EP_Reduced)==0 );
781 memcpy(zAlloc, p, nNewSize);
782 }else{
783 int nSize = exprStructSize(p);
784 memcpy(zAlloc, p, nSize);
785 memset(&zAlloc[nSize], 0, EXPR_FULLSIZE-nSize);
786 }
787
drh33e619f2009-05-28 01:00:55 +0000788 /* Set the EP_Reduced, EP_TokenOnly, and EP_Static flags appropriately. */
789 pNew->flags &= ~(EP_Reduced|EP_TokenOnly|EP_Static);
790 pNew->flags |= nStructSize & (EP_Reduced|EP_TokenOnly);
791 pNew->flags |= staticFlag;
danielk19776ab3a2e2009-02-19 14:39:25 +0000792
drh33e619f2009-05-28 01:00:55 +0000793 /* Copy the p->u.zToken string, if any. */
danielk19776ab3a2e2009-02-19 14:39:25 +0000794 if( nToken ){
drh33e619f2009-05-28 01:00:55 +0000795 char *zToken = pNew->u.zToken = (char*)&zAlloc[nNewSize];
796 memcpy(zToken, p->u.zToken, nToken);
danielk19776ab3a2e2009-02-19 14:39:25 +0000797 }
798
799 if( 0==((p->flags|pNew->flags) & EP_TokenOnly) ){
danielk19776ab3a2e2009-02-19 14:39:25 +0000800 /* Fill in the pNew->x.pSelect or pNew->x.pList member. */
801 if( ExprHasProperty(p, EP_xIsSelect) ){
802 pNew->x.pSelect = sqlite3SelectDup(db, p->x.pSelect, isReduced);
803 }else{
804 pNew->x.pList = sqlite3ExprListDup(db, p->x.pList, isReduced);
805 }
806 }
807
808 /* Fill in pNew->pLeft and pNew->pRight. */
drhb7916a72009-05-27 10:31:29 +0000809 if( ExprHasAnyProperty(pNew, EP_Reduced|EP_TokenOnly) ){
danielk19776ab3a2e2009-02-19 14:39:25 +0000810 zAlloc += dupedExprNodeSize(p, flags);
811 if( ExprHasProperty(pNew, EP_Reduced) ){
812 pNew->pLeft = exprDup(db, p->pLeft, EXPRDUP_REDUCE, &zAlloc);
813 pNew->pRight = exprDup(db, p->pRight, EXPRDUP_REDUCE, &zAlloc);
814 }
815 if( pzBuffer ){
816 *pzBuffer = zAlloc;
817 }
drhb7916a72009-05-27 10:31:29 +0000818 }else{
819 pNew->flags2 = 0;
820 if( !ExprHasAnyProperty(p, EP_TokenOnly) ){
821 pNew->pLeft = sqlite3ExprDup(db, p->pLeft, 0);
822 pNew->pRight = sqlite3ExprDup(db, p->pRight, 0);
823 }
danielk19776ab3a2e2009-02-19 14:39:25 +0000824 }
drhb7916a72009-05-27 10:31:29 +0000825
danielk19776ab3a2e2009-02-19 14:39:25 +0000826 }
827 }
828 return pNew;
829}
830
831/*
drhff78bd22002-02-27 01:47:11 +0000832** The following group of routines make deep copies of expressions,
833** expression lists, ID lists, and select statements. The copies can
834** be deleted (by being passed to their respective ...Delete() routines)
835** without effecting the originals.
836**
danielk19774adee202004-05-08 08:23:19 +0000837** The expression list, ID, and source lists return by sqlite3ExprListDup(),
838** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded
drhad3cab52002-05-24 02:04:32 +0000839** by subsequent calls to sqlite*ListAppend() routines.
drhff78bd22002-02-27 01:47:11 +0000840**
drhad3cab52002-05-24 02:04:32 +0000841** Any tables that the SrcList might point to are not duplicated.
danielk19776ab3a2e2009-02-19 14:39:25 +0000842**
drhb7916a72009-05-27 10:31:29 +0000843** The flags parameter contains a combination of the EXPRDUP_XXX flags.
danielk19776ab3a2e2009-02-19 14:39:25 +0000844** If the EXPRDUP_REDUCE flag is set, then the structure returned is a
845** truncated version of the usual Expr structure that will be stored as
846** part of the in-memory representation of the database schema.
drhff78bd22002-02-27 01:47:11 +0000847*/
danielk19776ab3a2e2009-02-19 14:39:25 +0000848Expr *sqlite3ExprDup(sqlite3 *db, Expr *p, int flags){
849 return exprDup(db, p, flags, 0);
drhff78bd22002-02-27 01:47:11 +0000850}
danielk19776ab3a2e2009-02-19 14:39:25 +0000851ExprList *sqlite3ExprListDup(sqlite3 *db, ExprList *p, int flags){
drhff78bd22002-02-27 01:47:11 +0000852 ExprList *pNew;
drh145716b2004-09-24 12:24:06 +0000853 struct ExprList_item *pItem, *pOldItem;
drhff78bd22002-02-27 01:47:11 +0000854 int i;
855 if( p==0 ) return 0;
drh17435752007-08-16 04:30:38 +0000856 pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
drhff78bd22002-02-27 01:47:11 +0000857 if( pNew==0 ) return 0;
danielk197731dad9d2007-08-16 11:36:15 +0000858 pNew->iECursor = 0;
drh4305d102003-07-30 12:34:12 +0000859 pNew->nExpr = pNew->nAlloc = p->nExpr;
drh17435752007-08-16 04:30:38 +0000860 pNew->a = pItem = sqlite3DbMallocRaw(db, p->nExpr*sizeof(p->a[0]) );
danielk1977e0048402004-06-15 16:51:01 +0000861 if( pItem==0 ){
drh633e6d52008-07-28 19:34:53 +0000862 sqlite3DbFree(db, pNew);
danielk1977e0048402004-06-15 16:51:01 +0000863 return 0;
864 }
drh145716b2004-09-24 12:24:06 +0000865 pOldItem = p->a;
866 for(i=0; i<p->nExpr; i++, pItem++, pOldItem++){
danielk19776ab3a2e2009-02-19 14:39:25 +0000867 Expr *pOldExpr = pOldItem->pExpr;
drhb5526ea2009-07-16 12:41:05 +0000868 pItem->pExpr = sqlite3ExprDup(db, pOldExpr, flags);
drh17435752007-08-16 04:30:38 +0000869 pItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
drhb7916a72009-05-27 10:31:29 +0000870 pItem->zSpan = sqlite3DbStrDup(db, pOldItem->zSpan);
drh145716b2004-09-24 12:24:06 +0000871 pItem->sortOrder = pOldItem->sortOrder;
drh3e7bc9c2004-02-21 19:17:17 +0000872 pItem->done = 0;
drh7d10d5a2008-08-20 16:35:10 +0000873 pItem->iCol = pOldItem->iCol;
drh8b213892008-08-29 02:14:02 +0000874 pItem->iAlias = pOldItem->iAlias;
drhff78bd22002-02-27 01:47:11 +0000875 }
876 return pNew;
877}
danielk197793758c82005-01-21 08:13:14 +0000878
879/*
880** If cursors, triggers, views and subqueries are all omitted from
881** the build, then none of the following routines, except for
882** sqlite3SelectDup(), can be called. sqlite3SelectDup() is sometimes
883** called with a NULL argument.
884*/
danielk19776a67fe82005-02-04 04:07:16 +0000885#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) \
886 || !defined(SQLITE_OMIT_SUBQUERY)
danielk19776ab3a2e2009-02-19 14:39:25 +0000887SrcList *sqlite3SrcListDup(sqlite3 *db, SrcList *p, int flags){
drhad3cab52002-05-24 02:04:32 +0000888 SrcList *pNew;
889 int i;
drh113088e2003-03-20 01:16:58 +0000890 int nByte;
drhad3cab52002-05-24 02:04:32 +0000891 if( p==0 ) return 0;
drh113088e2003-03-20 01:16:58 +0000892 nByte = sizeof(*p) + (p->nSrc>0 ? sizeof(p->a[0]) * (p->nSrc-1) : 0);
drh17435752007-08-16 04:30:38 +0000893 pNew = sqlite3DbMallocRaw(db, nByte );
drhad3cab52002-05-24 02:04:32 +0000894 if( pNew==0 ) return 0;
drh4305d102003-07-30 12:34:12 +0000895 pNew->nSrc = pNew->nAlloc = p->nSrc;
drhad3cab52002-05-24 02:04:32 +0000896 for(i=0; i<p->nSrc; i++){
drh4efc4752004-01-16 15:55:37 +0000897 struct SrcList_item *pNewItem = &pNew->a[i];
898 struct SrcList_item *pOldItem = &p->a[i];
drhed8a3bb2005-06-06 21:19:56 +0000899 Table *pTab;
drh17435752007-08-16 04:30:38 +0000900 pNewItem->zDatabase = sqlite3DbStrDup(db, pOldItem->zDatabase);
901 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
902 pNewItem->zAlias = sqlite3DbStrDup(db, pOldItem->zAlias);
drh4efc4752004-01-16 15:55:37 +0000903 pNewItem->jointype = pOldItem->jointype;
904 pNewItem->iCursor = pOldItem->iCursor;
drh5b6a9ed2011-09-15 23:58:14 +0000905 pNewItem->addrFillSub = pOldItem->addrFillSub;
906 pNewItem->regReturn = pOldItem->regReturn;
danda79cf02011-07-08 16:10:54 +0000907 pNewItem->isCorrelated = pOldItem->isCorrelated;
danielk197785574e32008-10-06 05:32:18 +0000908 pNewItem->zIndex = sqlite3DbStrDup(db, pOldItem->zIndex);
909 pNewItem->notIndexed = pOldItem->notIndexed;
910 pNewItem->pIndex = pOldItem->pIndex;
drhed8a3bb2005-06-06 21:19:56 +0000911 pTab = pNewItem->pTab = pOldItem->pTab;
912 if( pTab ){
913 pTab->nRef++;
danielk1977a1cb1832005-02-12 08:59:55 +0000914 }
danielk19776ab3a2e2009-02-19 14:39:25 +0000915 pNewItem->pSelect = sqlite3SelectDup(db, pOldItem->pSelect, flags);
916 pNewItem->pOn = sqlite3ExprDup(db, pOldItem->pOn, flags);
drh17435752007-08-16 04:30:38 +0000917 pNewItem->pUsing = sqlite3IdListDup(db, pOldItem->pUsing);
danielk19776c18b6e2005-01-30 09:17:58 +0000918 pNewItem->colUsed = pOldItem->colUsed;
drhad3cab52002-05-24 02:04:32 +0000919 }
920 return pNew;
921}
drh17435752007-08-16 04:30:38 +0000922IdList *sqlite3IdListDup(sqlite3 *db, IdList *p){
drhff78bd22002-02-27 01:47:11 +0000923 IdList *pNew;
924 int i;
925 if( p==0 ) return 0;
drh17435752007-08-16 04:30:38 +0000926 pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
drhff78bd22002-02-27 01:47:11 +0000927 if( pNew==0 ) return 0;
drh4305d102003-07-30 12:34:12 +0000928 pNew->nId = pNew->nAlloc = p->nId;
drh17435752007-08-16 04:30:38 +0000929 pNew->a = sqlite3DbMallocRaw(db, p->nId*sizeof(p->a[0]) );
danielk1977d5d56522005-03-16 12:15:20 +0000930 if( pNew->a==0 ){
drh633e6d52008-07-28 19:34:53 +0000931 sqlite3DbFree(db, pNew);
danielk1977d5d56522005-03-16 12:15:20 +0000932 return 0;
933 }
drhff78bd22002-02-27 01:47:11 +0000934 for(i=0; i<p->nId; i++){
drh4efc4752004-01-16 15:55:37 +0000935 struct IdList_item *pNewItem = &pNew->a[i];
936 struct IdList_item *pOldItem = &p->a[i];
drh17435752007-08-16 04:30:38 +0000937 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
drh4efc4752004-01-16 15:55:37 +0000938 pNewItem->idx = pOldItem->idx;
drhff78bd22002-02-27 01:47:11 +0000939 }
940 return pNew;
941}
danielk19776ab3a2e2009-02-19 14:39:25 +0000942Select *sqlite3SelectDup(sqlite3 *db, Select *p, int flags){
drhe7e6a542011-12-07 01:47:27 +0000943 Select *pNew, *pPrior;
drhff78bd22002-02-27 01:47:11 +0000944 if( p==0 ) return 0;
drh17435752007-08-16 04:30:38 +0000945 pNew = sqlite3DbMallocRaw(db, sizeof(*p) );
drhff78bd22002-02-27 01:47:11 +0000946 if( pNew==0 ) return 0;
drhb7916a72009-05-27 10:31:29 +0000947 pNew->pEList = sqlite3ExprListDup(db, p->pEList, flags);
danielk19776ab3a2e2009-02-19 14:39:25 +0000948 pNew->pSrc = sqlite3SrcListDup(db, p->pSrc, flags);
949 pNew->pWhere = sqlite3ExprDup(db, p->pWhere, flags);
950 pNew->pGroupBy = sqlite3ExprListDup(db, p->pGroupBy, flags);
951 pNew->pHaving = sqlite3ExprDup(db, p->pHaving, flags);
952 pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, flags);
drhff78bd22002-02-27 01:47:11 +0000953 pNew->op = p->op;
drhe7e6a542011-12-07 01:47:27 +0000954 pNew->pPrior = pPrior = sqlite3SelectDup(db, p->pPrior, flags);
955 if( pPrior ) pPrior->pNext = pNew;
956 pNew->pNext = 0;
danielk19776ab3a2e2009-02-19 14:39:25 +0000957 pNew->pLimit = sqlite3ExprDup(db, p->pLimit, flags);
958 pNew->pOffset = sqlite3ExprDup(db, p->pOffset, flags);
drh92b01d52008-06-24 00:32:35 +0000959 pNew->iLimit = 0;
960 pNew->iOffset = 0;
drh7d10d5a2008-08-20 16:35:10 +0000961 pNew->selFlags = p->selFlags & ~SF_UsesEphemeral;
drh0342b1f2005-09-01 03:07:44 +0000962 pNew->pRightmost = 0;
drhb9bb7c12006-06-11 23:41:55 +0000963 pNew->addrOpenEphm[0] = -1;
964 pNew->addrOpenEphm[1] = -1;
965 pNew->addrOpenEphm[2] = -1;
drhff78bd22002-02-27 01:47:11 +0000966 return pNew;
967}
danielk197793758c82005-01-21 08:13:14 +0000968#else
danielk19776ab3a2e2009-02-19 14:39:25 +0000969Select *sqlite3SelectDup(sqlite3 *db, Select *p, int flags){
danielk197793758c82005-01-21 08:13:14 +0000970 assert( p==0 );
971 return 0;
972}
973#endif
drhff78bd22002-02-27 01:47:11 +0000974
975
976/*
drha76b5df2002-02-23 02:32:10 +0000977** Add a new element to the end of an expression list. If pList is
978** initially NULL, then create a new expression list.
drhb7916a72009-05-27 10:31:29 +0000979**
980** If a memory allocation error occurs, the entire list is freed and
981** NULL is returned. If non-NULL is returned, then it is guaranteed
982** that the new entry was successfully appended.
drha76b5df2002-02-23 02:32:10 +0000983*/
drh17435752007-08-16 04:30:38 +0000984ExprList *sqlite3ExprListAppend(
985 Parse *pParse, /* Parsing context */
986 ExprList *pList, /* List to which to append. Might be NULL */
drhb7916a72009-05-27 10:31:29 +0000987 Expr *pExpr /* Expression to be appended. Might be NULL */
drh17435752007-08-16 04:30:38 +0000988){
989 sqlite3 *db = pParse->db;
drha76b5df2002-02-23 02:32:10 +0000990 if( pList==0 ){
drh17435752007-08-16 04:30:38 +0000991 pList = sqlite3DbMallocZero(db, sizeof(ExprList) );
drha76b5df2002-02-23 02:32:10 +0000992 if( pList==0 ){
danielk1977d5d56522005-03-16 12:15:20 +0000993 goto no_mem;
drha76b5df2002-02-23 02:32:10 +0000994 }
drh4efc4752004-01-16 15:55:37 +0000995 assert( pList->nAlloc==0 );
drha76b5df2002-02-23 02:32:10 +0000996 }
drh4305d102003-07-30 12:34:12 +0000997 if( pList->nAlloc<=pList->nExpr ){
danielk1977d5d56522005-03-16 12:15:20 +0000998 struct ExprList_item *a;
999 int n = pList->nAlloc*2 + 4;
danielk197726783a52007-08-29 14:06:22 +00001000 a = sqlite3DbRealloc(db, pList->a, n*sizeof(pList->a[0]));
danielk1977d5d56522005-03-16 12:15:20 +00001001 if( a==0 ){
1002 goto no_mem;
drha76b5df2002-02-23 02:32:10 +00001003 }
danielk1977d5d56522005-03-16 12:15:20 +00001004 pList->a = a;
drh6a1e0712008-12-05 15:24:15 +00001005 pList->nAlloc = sqlite3DbMallocSize(db, a)/sizeof(a[0]);
drha76b5df2002-02-23 02:32:10 +00001006 }
drh4efc4752004-01-16 15:55:37 +00001007 assert( pList->a!=0 );
drhb7916a72009-05-27 10:31:29 +00001008 if( 1 ){
drh4efc4752004-01-16 15:55:37 +00001009 struct ExprList_item *pItem = &pList->a[pList->nExpr++];
1010 memset(pItem, 0, sizeof(*pItem));
danielk1977e94ddc92005-03-21 03:53:38 +00001011 pItem->pExpr = pExpr;
drha76b5df2002-02-23 02:32:10 +00001012 }
1013 return pList;
danielk1977d5d56522005-03-16 12:15:20 +00001014
1015no_mem:
1016 /* Avoid leaking memory if malloc has failed. */
drh633e6d52008-07-28 19:34:53 +00001017 sqlite3ExprDelete(db, pExpr);
1018 sqlite3ExprListDelete(db, pList);
danielk1977d5d56522005-03-16 12:15:20 +00001019 return 0;
drha76b5df2002-02-23 02:32:10 +00001020}
1021
1022/*
drhb7916a72009-05-27 10:31:29 +00001023** Set the ExprList.a[].zName element of the most recently added item
1024** on the expression list.
1025**
1026** pList might be NULL following an OOM error. But pName should never be
1027** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
1028** is set.
1029*/
1030void sqlite3ExprListSetName(
1031 Parse *pParse, /* Parsing context */
1032 ExprList *pList, /* List to which to add the span. */
1033 Token *pName, /* Name to be added */
1034 int dequote /* True to cause the name to be dequoted */
1035){
1036 assert( pList!=0 || pParse->db->mallocFailed!=0 );
1037 if( pList ){
1038 struct ExprList_item *pItem;
1039 assert( pList->nExpr>0 );
1040 pItem = &pList->a[pList->nExpr-1];
1041 assert( pItem->zName==0 );
1042 pItem->zName = sqlite3DbStrNDup(pParse->db, pName->z, pName->n);
1043 if( dequote && pItem->zName ) sqlite3Dequote(pItem->zName);
1044 }
1045}
1046
1047/*
1048** Set the ExprList.a[].zSpan element of the most recently added item
1049** on the expression list.
1050**
1051** pList might be NULL following an OOM error. But pSpan should never be
1052** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
1053** is set.
1054*/
1055void sqlite3ExprListSetSpan(
1056 Parse *pParse, /* Parsing context */
1057 ExprList *pList, /* List to which to add the span. */
1058 ExprSpan *pSpan /* The span to be added */
1059){
1060 sqlite3 *db = pParse->db;
1061 assert( pList!=0 || db->mallocFailed!=0 );
1062 if( pList ){
1063 struct ExprList_item *pItem = &pList->a[pList->nExpr-1];
1064 assert( pList->nExpr>0 );
1065 assert( db->mallocFailed || pItem->pExpr==pSpan->pExpr );
1066 sqlite3DbFree(db, pItem->zSpan);
1067 pItem->zSpan = sqlite3DbStrNDup(db, (char*)pSpan->zStart,
shanecf697392009-06-01 16:53:09 +00001068 (int)(pSpan->zEnd - pSpan->zStart));
drhb7916a72009-05-27 10:31:29 +00001069 }
1070}
1071
1072/*
danielk19777a15a4b2007-05-08 17:54:43 +00001073** If the expression list pEList contains more than iLimit elements,
1074** leave an error message in pParse.
1075*/
1076void sqlite3ExprListCheckLength(
1077 Parse *pParse,
1078 ExprList *pEList,
danielk19777a15a4b2007-05-08 17:54:43 +00001079 const char *zObject
1080){
drhb1a6c3c2008-03-20 16:30:17 +00001081 int mx = pParse->db->aLimit[SQLITE_LIMIT_COLUMN];
drhc5499be2008-04-01 15:06:33 +00001082 testcase( pEList && pEList->nExpr==mx );
1083 testcase( pEList && pEList->nExpr==mx+1 );
drhb1a6c3c2008-03-20 16:30:17 +00001084 if( pEList && pEList->nExpr>mx ){
danielk19777a15a4b2007-05-08 17:54:43 +00001085 sqlite3ErrorMsg(pParse, "too many columns in %s", zObject);
1086 }
1087}
1088
1089/*
drha76b5df2002-02-23 02:32:10 +00001090** Delete an entire expression list.
1091*/
drh633e6d52008-07-28 19:34:53 +00001092void sqlite3ExprListDelete(sqlite3 *db, ExprList *pList){
drha76b5df2002-02-23 02:32:10 +00001093 int i;
drhbe5c89a2004-07-26 00:31:09 +00001094 struct ExprList_item *pItem;
drha76b5df2002-02-23 02:32:10 +00001095 if( pList==0 ) return;
drh1bdd9b52004-04-23 17:04:44 +00001096 assert( pList->a!=0 || (pList->nExpr==0 && pList->nAlloc==0) );
1097 assert( pList->nExpr<=pList->nAlloc );
drhbe5c89a2004-07-26 00:31:09 +00001098 for(pItem=pList->a, i=0; i<pList->nExpr; i++, pItem++){
drh633e6d52008-07-28 19:34:53 +00001099 sqlite3ExprDelete(db, pItem->pExpr);
1100 sqlite3DbFree(db, pItem->zName);
drhb7916a72009-05-27 10:31:29 +00001101 sqlite3DbFree(db, pItem->zSpan);
drha76b5df2002-02-23 02:32:10 +00001102 }
drh633e6d52008-07-28 19:34:53 +00001103 sqlite3DbFree(db, pList->a);
1104 sqlite3DbFree(db, pList);
drha76b5df2002-02-23 02:32:10 +00001105}
1106
1107/*
drh7d10d5a2008-08-20 16:35:10 +00001108** These routines are Walker callbacks. Walker.u.pi is a pointer
1109** to an integer. These routines are checking an expression to see
1110** if it is a constant. Set *Walker.u.pi to 0 if the expression is
1111** not constant.
drh73b211a2005-01-18 04:00:42 +00001112**
drh7d10d5a2008-08-20 16:35:10 +00001113** These callback routines are used to implement the following:
drh626a8792005-01-17 22:08:19 +00001114**
drh7d10d5a2008-08-20 16:35:10 +00001115** sqlite3ExprIsConstant()
1116** sqlite3ExprIsConstantNotJoin()
1117** sqlite3ExprIsConstantOrFunction()
drh87abf5c2005-08-25 12:45:04 +00001118**
drh626a8792005-01-17 22:08:19 +00001119*/
drh7d10d5a2008-08-20 16:35:10 +00001120static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){
drh626a8792005-01-17 22:08:19 +00001121
drh7d10d5a2008-08-20 16:35:10 +00001122 /* If pWalker->u.i is 3 then any term of the expression that comes from
drh0a168372007-06-08 00:20:47 +00001123 ** the ON or USING clauses of a join disqualifies the expression
1124 ** from being considered constant. */
drh7d10d5a2008-08-20 16:35:10 +00001125 if( pWalker->u.i==3 && ExprHasAnyProperty(pExpr, EP_FromJoin) ){
1126 pWalker->u.i = 0;
1127 return WRC_Abort;
drh0a168372007-06-08 00:20:47 +00001128 }
1129
drh626a8792005-01-17 22:08:19 +00001130 switch( pExpr->op ){
drheb55bd22005-06-30 17:04:21 +00001131 /* Consider functions to be constant if all their arguments are constant
drh7d10d5a2008-08-20 16:35:10 +00001132 ** and pWalker->u.i==2 */
drheb55bd22005-06-30 17:04:21 +00001133 case TK_FUNCTION:
drh7d10d5a2008-08-20 16:35:10 +00001134 if( pWalker->u.i==2 ) return 0;
drheb55bd22005-06-30 17:04:21 +00001135 /* Fall through */
drh626a8792005-01-17 22:08:19 +00001136 case TK_ID:
1137 case TK_COLUMN:
drh626a8792005-01-17 22:08:19 +00001138 case TK_AGG_FUNCTION:
drh13449892005-09-07 21:22:45 +00001139 case TK_AGG_COLUMN:
drhc5499be2008-04-01 15:06:33 +00001140 testcase( pExpr->op==TK_ID );
1141 testcase( pExpr->op==TK_COLUMN );
drhc5499be2008-04-01 15:06:33 +00001142 testcase( pExpr->op==TK_AGG_FUNCTION );
1143 testcase( pExpr->op==TK_AGG_COLUMN );
drh7d10d5a2008-08-20 16:35:10 +00001144 pWalker->u.i = 0;
1145 return WRC_Abort;
drh626a8792005-01-17 22:08:19 +00001146 default:
drhb74b1012009-05-28 21:04:37 +00001147 testcase( pExpr->op==TK_SELECT ); /* selectNodeIsConstant will disallow */
1148 testcase( pExpr->op==TK_EXISTS ); /* selectNodeIsConstant will disallow */
drh7d10d5a2008-08-20 16:35:10 +00001149 return WRC_Continue;
drh626a8792005-01-17 22:08:19 +00001150 }
1151}
danielk197762c14b32008-11-19 09:05:26 +00001152static int selectNodeIsConstant(Walker *pWalker, Select *NotUsed){
1153 UNUSED_PARAMETER(NotUsed);
drh7d10d5a2008-08-20 16:35:10 +00001154 pWalker->u.i = 0;
1155 return WRC_Abort;
1156}
1157static int exprIsConst(Expr *p, int initFlag){
1158 Walker w;
1159 w.u.i = initFlag;
1160 w.xExprCallback = exprNodeIsConstant;
1161 w.xSelectCallback = selectNodeIsConstant;
1162 sqlite3WalkExpr(&w, p);
1163 return w.u.i;
1164}
drh626a8792005-01-17 22:08:19 +00001165
1166/*
drhfef52082000-06-06 01:50:43 +00001167** Walk an expression tree. Return 1 if the expression is constant
drheb55bd22005-06-30 17:04:21 +00001168** and 0 if it involves variables or function calls.
drh23989372002-05-21 13:43:04 +00001169**
1170** For the purposes of this function, a double-quoted string (ex: "abc")
1171** is considered a variable but a single-quoted string (ex: 'abc') is
1172** a constant.
drhfef52082000-06-06 01:50:43 +00001173*/
danielk19774adee202004-05-08 08:23:19 +00001174int sqlite3ExprIsConstant(Expr *p){
drh7d10d5a2008-08-20 16:35:10 +00001175 return exprIsConst(p, 1);
drhfef52082000-06-06 01:50:43 +00001176}
1177
1178/*
drheb55bd22005-06-30 17:04:21 +00001179** Walk an expression tree. Return 1 if the expression is constant
drh0a168372007-06-08 00:20:47 +00001180** that does no originate from the ON or USING clauses of a join.
1181** Return 0 if it involves variables or function calls or terms from
1182** an ON or USING clause.
1183*/
1184int sqlite3ExprIsConstantNotJoin(Expr *p){
drh7d10d5a2008-08-20 16:35:10 +00001185 return exprIsConst(p, 3);
drh0a168372007-06-08 00:20:47 +00001186}
1187
1188/*
1189** Walk an expression tree. Return 1 if the expression is constant
drheb55bd22005-06-30 17:04:21 +00001190** or a function call with constant arguments. Return and 0 if there
1191** are any variables.
1192**
1193** For the purposes of this function, a double-quoted string (ex: "abc")
1194** is considered a variable but a single-quoted string (ex: 'abc') is
1195** a constant.
1196*/
1197int sqlite3ExprIsConstantOrFunction(Expr *p){
drh7d10d5a2008-08-20 16:35:10 +00001198 return exprIsConst(p, 2);
drheb55bd22005-06-30 17:04:21 +00001199}
1200
1201/*
drh73b211a2005-01-18 04:00:42 +00001202** If the expression p codes a constant integer that is small enough
drh202b2df2004-01-06 01:13:46 +00001203** to fit in a 32-bit integer, return 1 and put the value of the integer
1204** in *pValue. If the expression is not an integer or if it is too big
1205** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
drhe4de1fe2002-06-02 16:09:01 +00001206*/
danielk19774adee202004-05-08 08:23:19 +00001207int sqlite3ExprIsInteger(Expr *p, int *pValue){
drh92b01d52008-06-24 00:32:35 +00001208 int rc = 0;
drhcd92e842011-02-17 15:58:20 +00001209
1210 /* If an expression is an integer literal that fits in a signed 32-bit
1211 ** integer, then the EP_IntValue flag will have already been set */
1212 assert( p->op!=TK_INTEGER || (p->flags & EP_IntValue)!=0
1213 || sqlite3GetInt32(p->u.zToken, &rc)==0 );
1214
drh92b01d52008-06-24 00:32:35 +00001215 if( p->flags & EP_IntValue ){
drh33e619f2009-05-28 01:00:55 +00001216 *pValue = p->u.iValue;
drh92b01d52008-06-24 00:32:35 +00001217 return 1;
1218 }
drhe4de1fe2002-06-02 16:09:01 +00001219 switch( p->op ){
drh4b59ab52002-08-24 18:24:51 +00001220 case TK_UPLUS: {
drh92b01d52008-06-24 00:32:35 +00001221 rc = sqlite3ExprIsInteger(p->pLeft, pValue);
drhf6e369a2008-06-24 12:46:30 +00001222 break;
drh4b59ab52002-08-24 18:24:51 +00001223 }
drhe4de1fe2002-06-02 16:09:01 +00001224 case TK_UMINUS: {
1225 int v;
danielk19774adee202004-05-08 08:23:19 +00001226 if( sqlite3ExprIsInteger(p->pLeft, &v) ){
drhe4de1fe2002-06-02 16:09:01 +00001227 *pValue = -v;
drh92b01d52008-06-24 00:32:35 +00001228 rc = 1;
drhe4de1fe2002-06-02 16:09:01 +00001229 }
1230 break;
1231 }
1232 default: break;
1233 }
drh92b01d52008-06-24 00:32:35 +00001234 return rc;
drhe4de1fe2002-06-02 16:09:01 +00001235}
1236
1237/*
drh039fc322009-11-17 18:31:47 +00001238** Return FALSE if there is no chance that the expression can be NULL.
1239**
1240** If the expression might be NULL or if the expression is too complex
1241** to tell return TRUE.
1242**
1243** This routine is used as an optimization, to skip OP_IsNull opcodes
1244** when we know that a value cannot be NULL. Hence, a false positive
1245** (returning TRUE when in fact the expression can never be NULL) might
1246** be a small performance hit but is otherwise harmless. On the other
1247** hand, a false negative (returning FALSE when the result could be NULL)
1248** will likely result in an incorrect answer. So when in doubt, return
1249** TRUE.
1250*/
1251int sqlite3ExprCanBeNull(const Expr *p){
1252 u8 op;
drhcd7f4572009-11-19 14:48:40 +00001253 while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ p = p->pLeft; }
drh039fc322009-11-17 18:31:47 +00001254 op = p->op;
1255 if( op==TK_REGISTER ) op = p->op2;
1256 switch( op ){
1257 case TK_INTEGER:
1258 case TK_STRING:
1259 case TK_FLOAT:
1260 case TK_BLOB:
1261 return 0;
1262 default:
1263 return 1;
1264 }
1265}
1266
1267/*
drh2f2855b2009-11-18 01:25:26 +00001268** Generate an OP_IsNull instruction that tests register iReg and jumps
1269** to location iDest if the value in iReg is NULL. The value in iReg
1270** was computed by pExpr. If we can look at pExpr at compile-time and
1271** determine that it can never generate a NULL, then the OP_IsNull operation
1272** can be omitted.
1273*/
1274void sqlite3ExprCodeIsNullJump(
1275 Vdbe *v, /* The VDBE under construction */
1276 const Expr *pExpr, /* Only generate OP_IsNull if this expr can be NULL */
1277 int iReg, /* Test the value in this register for NULL */
1278 int iDest /* Jump here if the value is null */
1279){
1280 if( sqlite3ExprCanBeNull(pExpr) ){
1281 sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iDest);
1282 }
1283}
1284
1285/*
drh039fc322009-11-17 18:31:47 +00001286** Return TRUE if the given expression is a constant which would be
1287** unchanged by OP_Affinity with the affinity given in the second
1288** argument.
1289**
1290** This routine is used to determine if the OP_Affinity operation
1291** can be omitted. When in doubt return FALSE. A false negative
1292** is harmless. A false positive, however, can result in the wrong
1293** answer.
1294*/
1295int sqlite3ExprNeedsNoAffinityChange(const Expr *p, char aff){
1296 u8 op;
1297 if( aff==SQLITE_AFF_NONE ) return 1;
drhcd7f4572009-11-19 14:48:40 +00001298 while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ p = p->pLeft; }
drh039fc322009-11-17 18:31:47 +00001299 op = p->op;
1300 if( op==TK_REGISTER ) op = p->op2;
1301 switch( op ){
1302 case TK_INTEGER: {
1303 return aff==SQLITE_AFF_INTEGER || aff==SQLITE_AFF_NUMERIC;
1304 }
1305 case TK_FLOAT: {
1306 return aff==SQLITE_AFF_REAL || aff==SQLITE_AFF_NUMERIC;
1307 }
1308 case TK_STRING: {
1309 return aff==SQLITE_AFF_TEXT;
1310 }
1311 case TK_BLOB: {
1312 return 1;
1313 }
drh2f2855b2009-11-18 01:25:26 +00001314 case TK_COLUMN: {
drh88376ca2009-11-19 15:44:53 +00001315 assert( p->iTable>=0 ); /* p cannot be part of a CHECK constraint */
1316 return p->iColumn<0
1317 && (aff==SQLITE_AFF_INTEGER || aff==SQLITE_AFF_NUMERIC);
drh2f2855b2009-11-18 01:25:26 +00001318 }
drh039fc322009-11-17 18:31:47 +00001319 default: {
1320 return 0;
1321 }
1322 }
1323}
1324
1325/*
drhc4a3c772001-04-04 11:48:57 +00001326** Return TRUE if the given string is a row-id column name.
1327*/
danielk19774adee202004-05-08 08:23:19 +00001328int sqlite3IsRowid(const char *z){
1329 if( sqlite3StrICmp(z, "_ROWID_")==0 ) return 1;
1330 if( sqlite3StrICmp(z, "ROWID")==0 ) return 1;
1331 if( sqlite3StrICmp(z, "OID")==0 ) return 1;
drhc4a3c772001-04-04 11:48:57 +00001332 return 0;
1333}
1334
danielk19779a96b662007-11-29 17:05:18 +00001335/*
drhb74b1012009-05-28 21:04:37 +00001336** Return true if we are able to the IN operator optimization on a
1337** query of the form
drhb287f4b2008-04-25 00:08:38 +00001338**
drhb74b1012009-05-28 21:04:37 +00001339** x IN (SELECT ...)
drhb287f4b2008-04-25 00:08:38 +00001340**
drhb74b1012009-05-28 21:04:37 +00001341** Where the SELECT... clause is as specified by the parameter to this
1342** routine.
1343**
1344** The Select object passed in has already been preprocessed and no
1345** errors have been found.
drhb287f4b2008-04-25 00:08:38 +00001346*/
1347#ifndef SQLITE_OMIT_SUBQUERY
1348static int isCandidateForInOpt(Select *p){
1349 SrcList *pSrc;
1350 ExprList *pEList;
1351 Table *pTab;
drhb287f4b2008-04-25 00:08:38 +00001352 if( p==0 ) return 0; /* right-hand side of IN is SELECT */
1353 if( p->pPrior ) return 0; /* Not a compound SELECT */
drh7d10d5a2008-08-20 16:35:10 +00001354 if( p->selFlags & (SF_Distinct|SF_Aggregate) ){
drhb74b1012009-05-28 21:04:37 +00001355 testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct );
1356 testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate );
1357 return 0; /* No DISTINCT keyword and no aggregate functions */
drh7d10d5a2008-08-20 16:35:10 +00001358 }
drhb74b1012009-05-28 21:04:37 +00001359 assert( p->pGroupBy==0 ); /* Has no GROUP BY clause */
drhb287f4b2008-04-25 00:08:38 +00001360 if( p->pLimit ) return 0; /* Has no LIMIT clause */
drhb74b1012009-05-28 21:04:37 +00001361 assert( p->pOffset==0 ); /* No LIMIT means no OFFSET */
drhb287f4b2008-04-25 00:08:38 +00001362 if( p->pWhere ) return 0; /* Has no WHERE clause */
1363 pSrc = p->pSrc;
drhd1fa7bc2009-01-10 13:24:50 +00001364 assert( pSrc!=0 );
1365 if( pSrc->nSrc!=1 ) return 0; /* Single term in FROM clause */
drhb74b1012009-05-28 21:04:37 +00001366 if( pSrc->a[0].pSelect ) return 0; /* FROM is not a subquery or view */
drhb287f4b2008-04-25 00:08:38 +00001367 pTab = pSrc->a[0].pTab;
drhb74b1012009-05-28 21:04:37 +00001368 if( NEVER(pTab==0) ) return 0;
1369 assert( pTab->pSelect==0 ); /* FROM clause is not a view */
drhb287f4b2008-04-25 00:08:38 +00001370 if( IsVirtual(pTab) ) return 0; /* FROM clause not a virtual table */
1371 pEList = p->pEList;
1372 if( pEList->nExpr!=1 ) return 0; /* One column in the result set */
1373 if( pEList->a[0].pExpr->op!=TK_COLUMN ) return 0; /* Result is a column */
1374 return 1;
1375}
1376#endif /* SQLITE_OMIT_SUBQUERY */
1377
1378/*
dan1d8cb212011-12-09 13:24:16 +00001379** Code an OP_Once instruction and allocate space for its flag. Return the
1380** address of the new instruction.
1381*/
1382int sqlite3CodeOnce(Parse *pParse){
1383 Vdbe *v = sqlite3GetVdbe(pParse); /* Virtual machine being coded */
1384 return sqlite3VdbeAddOp1(v, OP_Once, pParse->nOnce++);
1385}
1386
1387/*
danielk19779a96b662007-11-29 17:05:18 +00001388** This function is used by the implementation of the IN (...) operator.
1389** It's job is to find or create a b-tree structure that may be used
1390** either to test for membership of the (...) set or to iterate through
drh85b623f2007-12-13 21:54:09 +00001391** its members, skipping duplicates.
danielk19779a96b662007-11-29 17:05:18 +00001392**
drhb74b1012009-05-28 21:04:37 +00001393** The index of the cursor opened on the b-tree (database table, database index
danielk19779a96b662007-11-29 17:05:18 +00001394** or ephermal table) is stored in pX->iTable before this function returns.
drhb74b1012009-05-28 21:04:37 +00001395** The returned value of this function indicates the b-tree type, as follows:
danielk19779a96b662007-11-29 17:05:18 +00001396**
1397** IN_INDEX_ROWID - The cursor was opened on a database table.
drh2d401ab2008-01-10 23:50:11 +00001398** IN_INDEX_INDEX - The cursor was opened on a database index.
danielk19779a96b662007-11-29 17:05:18 +00001399** IN_INDEX_EPH - The cursor was opened on a specially created and
1400** populated epheremal table.
1401**
drhb74b1012009-05-28 21:04:37 +00001402** An existing b-tree may only be used if the SELECT is of the simple
danielk19779a96b662007-11-29 17:05:18 +00001403** form:
1404**
1405** SELECT <column> FROM <table>
1406**
drhb74b1012009-05-28 21:04:37 +00001407** If the prNotFound parameter is 0, then the b-tree will be used to iterate
danielk19779a96b662007-11-29 17:05:18 +00001408** through the set members, skipping any duplicates. In this case an
1409** epheremal table must be used unless the selected <column> is guaranteed
1410** to be unique - either because it is an INTEGER PRIMARY KEY or it
drhb74b1012009-05-28 21:04:37 +00001411** has a UNIQUE constraint or UNIQUE index.
danielk19770cdc0222008-06-26 18:04:03 +00001412**
drhb74b1012009-05-28 21:04:37 +00001413** If the prNotFound parameter is not 0, then the b-tree will be used
danielk19770cdc0222008-06-26 18:04:03 +00001414** for fast set membership tests. In this case an epheremal table must
1415** be used unless <column> is an INTEGER PRIMARY KEY or an index can
1416** be found with <column> as its left-most column.
1417**
drhb74b1012009-05-28 21:04:37 +00001418** When the b-tree is being used for membership tests, the calling function
danielk19770cdc0222008-06-26 18:04:03 +00001419** needs to know whether or not the structure contains an SQL NULL
1420** value in order to correctly evaluate expressions like "X IN (Y, Z)".
drhe3365e62009-11-12 17:52:24 +00001421** If there is any chance that the (...) might contain a NULL value at
danielk19770cdc0222008-06-26 18:04:03 +00001422** runtime, then a register is allocated and the register number written
drhe3365e62009-11-12 17:52:24 +00001423** to *prNotFound. If there is no chance that the (...) contains a
danielk19770cdc0222008-06-26 18:04:03 +00001424** NULL value, then *prNotFound is left unchanged.
1425**
1426** If a register is allocated and its location stored in *prNotFound, then
drhe3365e62009-11-12 17:52:24 +00001427** its initial value is NULL. If the (...) does not remain constant
1428** for the duration of the query (i.e. the SELECT within the (...)
drhb74b1012009-05-28 21:04:37 +00001429** is a correlated subquery) then the value of the allocated register is
drhe3365e62009-11-12 17:52:24 +00001430** reset to NULL each time the subquery is rerun. This allows the
drhb74b1012009-05-28 21:04:37 +00001431** caller to use vdbe code equivalent to the following:
danielk19770cdc0222008-06-26 18:04:03 +00001432**
1433** if( register==NULL ){
1434** has_null = <test if data structure contains null>
1435** register = 1
1436** }
1437**
1438** in order to avoid running the <test if data structure contains null>
1439** test more often than is necessary.
danielk19779a96b662007-11-29 17:05:18 +00001440*/
danielk1977284f4ac2007-12-10 05:03:46 +00001441#ifndef SQLITE_OMIT_SUBQUERY
danielk19770cdc0222008-06-26 18:04:03 +00001442int sqlite3FindInIndex(Parse *pParse, Expr *pX, int *prNotFound){
drhb74b1012009-05-28 21:04:37 +00001443 Select *p; /* SELECT to the right of IN operator */
1444 int eType = 0; /* Type of RHS table. IN_INDEX_* */
1445 int iTab = pParse->nTab++; /* Cursor of the RHS table */
1446 int mustBeUnique = (prNotFound==0); /* True if RHS must be unique */
drhb8475df2011-12-09 16:21:19 +00001447 Vdbe *v = sqlite3GetVdbe(pParse); /* Virtual machine being coded */
danielk19779a96b662007-11-29 17:05:18 +00001448
drh1450bc62009-10-30 13:25:56 +00001449 assert( pX->op==TK_IN );
1450
drhb74b1012009-05-28 21:04:37 +00001451 /* Check to see if an existing table or index can be used to
1452 ** satisfy the query. This is preferable to generating a new
1453 ** ephemeral table.
danielk19779a96b662007-11-29 17:05:18 +00001454 */
danielk19776ab3a2e2009-02-19 14:39:25 +00001455 p = (ExprHasProperty(pX, EP_xIsSelect) ? pX->x.pSelect : 0);
drhfd773cf2009-05-29 14:39:07 +00001456 if( ALWAYS(pParse->nErr==0) && isCandidateForInOpt(p) ){
danielk1977e1fb65a2009-04-02 17:23:32 +00001457 sqlite3 *db = pParse->db; /* Database connection */
drhb07028f2011-10-14 21:49:18 +00001458 Table *pTab; /* Table <table>. */
1459 Expr *pExpr; /* Expression <column> */
1460 int iCol; /* Index of column <column> */
danielk1977e1fb65a2009-04-02 17:23:32 +00001461 int iDb; /* Database idx for pTab */
drhb07028f2011-10-14 21:49:18 +00001462
1463 assert( p ); /* Because of isCandidateForInOpt(p) */
1464 assert( p->pEList!=0 ); /* Because of isCandidateForInOpt(p) */
1465 assert( p->pEList->a[0].pExpr!=0 ); /* Because of isCandidateForInOpt(p) */
1466 assert( p->pSrc!=0 ); /* Because of isCandidateForInOpt(p) */
1467 pTab = p->pSrc->a[0].pTab;
1468 pExpr = p->pEList->a[0].pExpr;
1469 iCol = pExpr->iColumn;
danielk1977e1fb65a2009-04-02 17:23:32 +00001470
1471 /* Code an OP_VerifyCookie and OP_TableLock for <table>. */
1472 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
1473 sqlite3CodeVerifySchema(pParse, iDb);
1474 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
danielk19779a96b662007-11-29 17:05:18 +00001475
1476 /* This function is only called from two places. In both cases the vdbe
1477 ** has already been allocated. So assume sqlite3GetVdbe() is always
1478 ** successful here.
1479 */
1480 assert(v);
1481 if( iCol<0 ){
danielk19779a96b662007-11-29 17:05:18 +00001482 int iAddr;
danielk19779a96b662007-11-29 17:05:18 +00001483
dan1d8cb212011-12-09 13:24:16 +00001484 iAddr = sqlite3CodeOnce(pParse);
danielk19779a96b662007-11-29 17:05:18 +00001485
1486 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
1487 eType = IN_INDEX_ROWID;
1488
1489 sqlite3VdbeJumpHere(v, iAddr);
1490 }else{
danielk1977e1fb65a2009-04-02 17:23:32 +00001491 Index *pIdx; /* Iterator variable */
1492
drhb74b1012009-05-28 21:04:37 +00001493 /* The collation sequence used by the comparison. If an index is to
danielk19779a96b662007-11-29 17:05:18 +00001494 ** be used in place of a temp-table, it must be ordered according
danielk1977e1fb65a2009-04-02 17:23:32 +00001495 ** to this collation sequence. */
danielk19779a96b662007-11-29 17:05:18 +00001496 CollSeq *pReq = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pExpr);
1497
1498 /* Check that the affinity that will be used to perform the
1499 ** comparison is the same as the affinity of the column. If
1500 ** it is not, it is not possible to use any index.
1501 */
danielk19779a96b662007-11-29 17:05:18 +00001502 char aff = comparisonAffinity(pX);
1503 int affinity_ok = (pTab->aCol[iCol].affinity==aff||aff==SQLITE_AFF_NONE);
1504
1505 for(pIdx=pTab->pIndex; pIdx && eType==0 && affinity_ok; pIdx=pIdx->pNext){
1506 if( (pIdx->aiColumn[0]==iCol)
drhb74b1012009-05-28 21:04:37 +00001507 && sqlite3FindCollSeq(db, ENC(db), pIdx->azColl[0], 0)==pReq
danielk19779a96b662007-11-29 17:05:18 +00001508 && (!mustBeUnique || (pIdx->nColumn==1 && pIdx->onError!=OE_None))
1509 ){
danielk19779a96b662007-11-29 17:05:18 +00001510 int iAddr;
1511 char *pKey;
1512
1513 pKey = (char *)sqlite3IndexKeyinfo(pParse, pIdx);
dan1d8cb212011-12-09 13:24:16 +00001514 iAddr = sqlite3CodeOnce(pParse);
danielk19779a96b662007-11-29 17:05:18 +00001515
danielk1977207872a2008-01-03 07:54:23 +00001516 sqlite3VdbeAddOp4(v, OP_OpenRead, iTab, pIdx->tnum, iDb,
drh66a51672008-01-03 00:01:23 +00001517 pKey,P4_KEYINFO_HANDOFF);
danielk1977207872a2008-01-03 07:54:23 +00001518 VdbeComment((v, "%s", pIdx->zName));
danielk19779a96b662007-11-29 17:05:18 +00001519 eType = IN_INDEX_INDEX;
danielk19779a96b662007-11-29 17:05:18 +00001520
1521 sqlite3VdbeJumpHere(v, iAddr);
danielk19770cdc0222008-06-26 18:04:03 +00001522 if( prNotFound && !pTab->aCol[iCol].notNull ){
1523 *prNotFound = ++pParse->nMem;
drhb8475df2011-12-09 16:21:19 +00001524 sqlite3VdbeAddOp2(v, OP_Null, 0, *prNotFound);
danielk19770cdc0222008-06-26 18:04:03 +00001525 }
danielk19779a96b662007-11-29 17:05:18 +00001526 }
1527 }
1528 }
1529 }
1530
1531 if( eType==0 ){
drh1450bc62009-10-30 13:25:56 +00001532 /* Could not found an existing table or index to use as the RHS b-tree.
drhb74b1012009-05-28 21:04:37 +00001533 ** We will have to generate an ephemeral table to do the job.
1534 */
drhcf4d38a2010-07-28 02:53:36 +00001535 double savedNQueryLoop = pParse->nQueryLoop;
danielk19770cdc0222008-06-26 18:04:03 +00001536 int rMayHaveNull = 0;
danielk197741a05b72008-10-02 13:50:55 +00001537 eType = IN_INDEX_EPH;
danielk19770cdc0222008-06-26 18:04:03 +00001538 if( prNotFound ){
1539 *prNotFound = rMayHaveNull = ++pParse->nMem;
drhb8475df2011-12-09 16:21:19 +00001540 sqlite3VdbeAddOp2(v, OP_Null, 0, *prNotFound);
drhcf4d38a2010-07-28 02:53:36 +00001541 }else{
1542 testcase( pParse->nQueryLoop>(double)1 );
1543 pParse->nQueryLoop = (double)1;
1544 if( pX->pLeft->iColumn<0 && !ExprHasAnyProperty(pX, EP_xIsSelect) ){
1545 eType = IN_INDEX_ROWID;
1546 }
danielk19770cdc0222008-06-26 18:04:03 +00001547 }
danielk197741a05b72008-10-02 13:50:55 +00001548 sqlite3CodeSubselect(pParse, pX, rMayHaveNull, eType==IN_INDEX_ROWID);
drhcf4d38a2010-07-28 02:53:36 +00001549 pParse->nQueryLoop = savedNQueryLoop;
danielk19779a96b662007-11-29 17:05:18 +00001550 }else{
1551 pX->iTable = iTab;
1552 }
1553 return eType;
1554}
danielk1977284f4ac2007-12-10 05:03:46 +00001555#endif
drh626a8792005-01-17 22:08:19 +00001556
1557/*
drhd4187c72010-08-30 22:15:45 +00001558** Generate code for scalar subqueries used as a subquery expression, EXISTS,
1559** or IN operators. Examples:
drh626a8792005-01-17 22:08:19 +00001560**
drh9cbe6352005-11-29 03:13:21 +00001561** (SELECT a FROM b) -- subquery
1562** EXISTS (SELECT a FROM b) -- EXISTS subquery
1563** x IN (4,5,11) -- IN operator with list on right-hand side
1564** x IN (SELECT a FROM b) -- IN operator with subquery on the right
drhfef52082000-06-06 01:50:43 +00001565**
drh9cbe6352005-11-29 03:13:21 +00001566** The pExpr parameter describes the expression that contains the IN
1567** operator or subquery.
danielk197741a05b72008-10-02 13:50:55 +00001568**
1569** If parameter isRowid is non-zero, then expression pExpr is guaranteed
1570** to be of the form "<rowid> IN (?, ?, ?)", where <rowid> is a reference
1571** to some integer key column of a table B-Tree. In this case, use an
1572** intkey B-Tree to store the set of IN(...) values instead of the usual
1573** (slower) variable length keys B-Tree.
drhfd773cf2009-05-29 14:39:07 +00001574**
1575** If rMayHaveNull is non-zero, that means that the operation is an IN
1576** (not a SELECT or EXISTS) and that the RHS might contains NULLs.
1577** Furthermore, the IN is in a WHERE clause and that we really want
1578** to iterate over the RHS of the IN operator in order to quickly locate
1579** all corresponding LHS elements. All this routine does is initialize
1580** the register given by rMayHaveNull to NULL. Calling routines will take
1581** care of changing this register value to non-NULL if the RHS is NULL-free.
1582**
1583** If rMayHaveNull is zero, that means that the subquery is being used
1584** for membership testing only. There is no need to initialize any
1585** registers to indicate the presense or absence of NULLs on the RHS.
drh1450bc62009-10-30 13:25:56 +00001586**
1587** For a SELECT or EXISTS operator, return the register that holds the
1588** result. For IN operators or if an error occurs, the return value is 0.
drhcce7d172000-05-31 15:34:51 +00001589*/
drh51522cd2005-01-20 13:36:19 +00001590#ifndef SQLITE_OMIT_SUBQUERY
drh1450bc62009-10-30 13:25:56 +00001591int sqlite3CodeSubselect(
drhfd773cf2009-05-29 14:39:07 +00001592 Parse *pParse, /* Parsing context */
1593 Expr *pExpr, /* The IN, SELECT, or EXISTS operator */
1594 int rMayHaveNull, /* Register that records whether NULLs exist in RHS */
1595 int isRowid /* If true, LHS of IN operator is a rowid */
danielk197741a05b72008-10-02 13:50:55 +00001596){
drhdfd2d9f2011-09-16 22:10:57 +00001597 int testAddr = -1; /* One-time test address */
drh1450bc62009-10-30 13:25:56 +00001598 int rReg = 0; /* Register storing resulting */
danielk1977b3bce662005-01-29 08:32:43 +00001599 Vdbe *v = sqlite3GetVdbe(pParse);
drh1450bc62009-10-30 13:25:56 +00001600 if( NEVER(v==0) ) return 0;
drhceea3322009-04-23 13:22:42 +00001601 sqlite3ExprCachePush(pParse);
danielk1977fc976062007-05-10 10:46:56 +00001602
drh57dbd7b2005-07-08 18:25:26 +00001603 /* This code must be run in its entirety every time it is encountered
1604 ** if any of the following is true:
1605 **
1606 ** * The right-hand side is a correlated subquery
1607 ** * The right-hand side is an expression list containing variables
1608 ** * We are inside a trigger
1609 **
1610 ** If all of the above are false, then we can run this code just once
1611 ** save the results, and reuse the same result on subsequent invocations.
danielk1977b3bce662005-01-29 08:32:43 +00001612 */
dan1d8cb212011-12-09 13:24:16 +00001613 if( !ExprHasAnyProperty(pExpr, EP_VarSelect) ){
1614 testAddr = sqlite3CodeOnce(pParse);
danielk1977b3bce662005-01-29 08:32:43 +00001615 }
1616
dan4a07e3d2010-11-09 14:48:59 +00001617#ifndef SQLITE_OMIT_EXPLAIN
1618 if( pParse->explain==2 ){
1619 char *zMsg = sqlite3MPrintf(
drhdfd2d9f2011-09-16 22:10:57 +00001620 pParse->db, "EXECUTE %s%s SUBQUERY %d", testAddr>=0?"":"CORRELATED ",
dan4a07e3d2010-11-09 14:48:59 +00001621 pExpr->op==TK_IN?"LIST":"SCALAR", pParse->iNextSelectId
1622 );
1623 sqlite3VdbeAddOp4(v, OP_Explain, pParse->iSelectId, 0, 0, zMsg, P4_DYNAMIC);
1624 }
1625#endif
1626
drhcce7d172000-05-31 15:34:51 +00001627 switch( pExpr->op ){
drhfef52082000-06-06 01:50:43 +00001628 case TK_IN: {
drhd4187c72010-08-30 22:15:45 +00001629 char affinity; /* Affinity of the LHS of the IN */
1630 KeyInfo keyInfo; /* Keyinfo for the generated table */
1631 int addr; /* Address of OP_OpenEphemeral instruction */
1632 Expr *pLeft = pExpr->pLeft; /* the LHS of the IN operator */
drhd3d39e92004-05-20 22:16:29 +00001633
danielk19770cdc0222008-06-26 18:04:03 +00001634 if( rMayHaveNull ){
1635 sqlite3VdbeAddOp2(v, OP_Null, 0, rMayHaveNull);
1636 }
1637
danielk197741a05b72008-10-02 13:50:55 +00001638 affinity = sqlite3ExprAffinity(pLeft);
danielk1977e014a832004-05-17 10:48:57 +00001639
1640 /* Whether this is an 'x IN(SELECT...)' or an 'x IN(<exprlist>)'
drh8cff69d2009-11-12 19:59:44 +00001641 ** expression it is handled the same way. An ephemeral table is
danielk1977e014a832004-05-17 10:48:57 +00001642 ** filled with single-field index keys representing the results
1643 ** from the SELECT or the <exprlist>.
1644 **
1645 ** If the 'x' expression is a column value, or the SELECT...
1646 ** statement returns a column value, then the affinity of that
1647 ** column is used to build the index keys. If both 'x' and the
1648 ** SELECT... statement are columns, then numeric affinity is used
1649 ** if either column has NUMERIC or INTEGER affinity. If neither
1650 ** 'x' nor the SELECT... statement are columns, then numeric affinity
1651 ** is used.
1652 */
1653 pExpr->iTable = pParse->nTab++;
danielk197741a05b72008-10-02 13:50:55 +00001654 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, !isRowid);
drhd4187c72010-08-30 22:15:45 +00001655 if( rMayHaveNull==0 ) sqlite3VdbeChangeP5(v, BTREE_UNORDERED);
drhd3d39e92004-05-20 22:16:29 +00001656 memset(&keyInfo, 0, sizeof(keyInfo));
1657 keyInfo.nField = 1;
danielk1977e014a832004-05-17 10:48:57 +00001658
danielk19776ab3a2e2009-02-19 14:39:25 +00001659 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
drhfef52082000-06-06 01:50:43 +00001660 /* Case 1: expr IN (SELECT ...)
1661 **
danielk1977e014a832004-05-17 10:48:57 +00001662 ** Generate code to write the results of the select into the temporary
1663 ** table allocated and opened above.
drhfef52082000-06-06 01:50:43 +00001664 */
drh1013c932008-01-06 00:25:21 +00001665 SelectDest dest;
drhbe5c89a2004-07-26 00:31:09 +00001666 ExprList *pEList;
drh1013c932008-01-06 00:25:21 +00001667
danielk197741a05b72008-10-02 13:50:55 +00001668 assert( !isRowid );
drh1013c932008-01-06 00:25:21 +00001669 sqlite3SelectDestInit(&dest, SRT_Set, pExpr->iTable);
drh1bd10f82008-12-10 21:19:56 +00001670 dest.affinity = (u8)affinity;
danielk1977e014a832004-05-17 10:48:57 +00001671 assert( (pExpr->iTable&0x0000FFFF)==pExpr->iTable );
drh48b5b042010-12-06 18:50:32 +00001672 pExpr->x.pSelect->iLimit = 0;
danielk19776ab3a2e2009-02-19 14:39:25 +00001673 if( sqlite3Select(pParse, pExpr->x.pSelect, &dest) ){
drh1450bc62009-10-30 13:25:56 +00001674 return 0;
drh94ccde52007-04-13 16:06:32 +00001675 }
danielk19776ab3a2e2009-02-19 14:39:25 +00001676 pEList = pExpr->x.pSelect->pEList;
drhfd773cf2009-05-29 14:39:07 +00001677 if( ALWAYS(pEList!=0 && pEList->nExpr>0) ){
danielk1977bcbb04e2007-05-29 12:11:29 +00001678 keyInfo.aColl[0] = sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft,
drhbe5c89a2004-07-26 00:31:09 +00001679 pEList->a[0].pExpr);
danielk19770202b292004-06-09 09:55:16 +00001680 }
drha7d2db12010-07-14 20:23:52 +00001681 }else if( ALWAYS(pExpr->x.pList!=0) ){
drhfef52082000-06-06 01:50:43 +00001682 /* Case 2: expr IN (exprlist)
1683 **
drhfd131da2007-08-07 17:13:03 +00001684 ** For each expression, build an index key from the evaluation and
danielk1977e014a832004-05-17 10:48:57 +00001685 ** store it in the temporary table. If <expr> is a column, then use
1686 ** that columns affinity when building index keys. If <expr> is not
1687 ** a column, use numeric affinity.
drhfef52082000-06-06 01:50:43 +00001688 */
danielk1977e014a832004-05-17 10:48:57 +00001689 int i;
danielk19776ab3a2e2009-02-19 14:39:25 +00001690 ExprList *pList = pExpr->x.pList;
drh57dbd7b2005-07-08 18:25:26 +00001691 struct ExprList_item *pItem;
drhecc31802008-06-26 20:06:06 +00001692 int r1, r2, r3;
drh57dbd7b2005-07-08 18:25:26 +00001693
danielk1977e014a832004-05-17 10:48:57 +00001694 if( !affinity ){
drh8159a352006-05-23 23:22:29 +00001695 affinity = SQLITE_AFF_NONE;
danielk1977e014a832004-05-17 10:48:57 +00001696 }
drh7d10d5a2008-08-20 16:35:10 +00001697 keyInfo.aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
danielk1977e014a832004-05-17 10:48:57 +00001698
1699 /* Loop through each expression in <exprlist>. */
drh2d401ab2008-01-10 23:50:11 +00001700 r1 = sqlite3GetTempReg(pParse);
1701 r2 = sqlite3GetTempReg(pParse);
danielk19774e7f36a2008-10-02 16:42:06 +00001702 sqlite3VdbeAddOp2(v, OP_Null, 0, r2);
drh57dbd7b2005-07-08 18:25:26 +00001703 for(i=pList->nExpr, pItem=pList->a; i>0; i--, pItem++){
1704 Expr *pE2 = pItem->pExpr;
drhe05c9292009-10-29 13:48:10 +00001705 int iValToIns;
danielk1977e014a832004-05-17 10:48:57 +00001706
drh57dbd7b2005-07-08 18:25:26 +00001707 /* If the expression is not constant then we will need to
1708 ** disable the test that was generated above that makes sure
1709 ** this code only executes once. Because for a non-constant
1710 ** expression we need to rerun this code each time.
1711 */
drhdfd2d9f2011-09-16 22:10:57 +00001712 if( testAddr>=0 && !sqlite3ExprIsConstant(pE2) ){
drh48f2d3b2011-09-16 01:34:43 +00001713 sqlite3VdbeChangeToNoop(v, testAddr);
drhdfd2d9f2011-09-16 22:10:57 +00001714 testAddr = -1;
drh4794b982000-06-06 13:54:14 +00001715 }
danielk1977e014a832004-05-17 10:48:57 +00001716
1717 /* Evaluate the expression and insert it into the temp table */
drhe05c9292009-10-29 13:48:10 +00001718 if( isRowid && sqlite3ExprIsInteger(pE2, &iValToIns) ){
1719 sqlite3VdbeAddOp3(v, OP_InsertInt, pExpr->iTable, r2, iValToIns);
danielk197741a05b72008-10-02 13:50:55 +00001720 }else{
drhe05c9292009-10-29 13:48:10 +00001721 r3 = sqlite3ExprCodeTarget(pParse, pE2, r1);
1722 if( isRowid ){
1723 sqlite3VdbeAddOp2(v, OP_MustBeInt, r3,
1724 sqlite3VdbeCurrentAddr(v)+2);
1725 sqlite3VdbeAddOp3(v, OP_Insert, pExpr->iTable, r2, r3);
1726 }else{
1727 sqlite3VdbeAddOp4(v, OP_MakeRecord, r3, 1, r2, &affinity, 1);
1728 sqlite3ExprCacheAffinityChange(pParse, r3, 1);
1729 sqlite3VdbeAddOp2(v, OP_IdxInsert, pExpr->iTable, r2);
1730 }
danielk197741a05b72008-10-02 13:50:55 +00001731 }
drhfef52082000-06-06 01:50:43 +00001732 }
drh2d401ab2008-01-10 23:50:11 +00001733 sqlite3ReleaseTempReg(pParse, r1);
1734 sqlite3ReleaseTempReg(pParse, r2);
drhfef52082000-06-06 01:50:43 +00001735 }
danielk197741a05b72008-10-02 13:50:55 +00001736 if( !isRowid ){
1737 sqlite3VdbeChangeP4(v, addr, (void *)&keyInfo, P4_KEYINFO);
1738 }
danielk1977b3bce662005-01-29 08:32:43 +00001739 break;
drhfef52082000-06-06 01:50:43 +00001740 }
1741
drh51522cd2005-01-20 13:36:19 +00001742 case TK_EXISTS:
drhfd773cf2009-05-29 14:39:07 +00001743 case TK_SELECT:
1744 default: {
drhfd773cf2009-05-29 14:39:07 +00001745 /* If this has to be a scalar SELECT. Generate code to put the
drhfef52082000-06-06 01:50:43 +00001746 ** value of this select in a memory cell and record the number
drhfd773cf2009-05-29 14:39:07 +00001747 ** of the memory cell in iColumn. If this is an EXISTS, write
1748 ** an integer 0 (not exists) or 1 (exists) into a memory cell
1749 ** and record that memory cell in iColumn.
drhfef52082000-06-06 01:50:43 +00001750 */
drhfd773cf2009-05-29 14:39:07 +00001751 Select *pSel; /* SELECT statement to encode */
1752 SelectDest dest; /* How to deal with SELECt result */
drh1398ad32005-01-19 23:24:50 +00001753
shanecf697392009-06-01 16:53:09 +00001754 testcase( pExpr->op==TK_EXISTS );
1755 testcase( pExpr->op==TK_SELECT );
1756 assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT );
1757
danielk19776ab3a2e2009-02-19 14:39:25 +00001758 assert( ExprHasProperty(pExpr, EP_xIsSelect) );
1759 pSel = pExpr->x.pSelect;
drh1013c932008-01-06 00:25:21 +00001760 sqlite3SelectDestInit(&dest, 0, ++pParse->nMem);
drh51522cd2005-01-20 13:36:19 +00001761 if( pExpr->op==TK_SELECT ){
danielk19776c8c8ce2008-01-02 16:27:09 +00001762 dest.eDest = SRT_Mem;
drh4c583122008-01-04 22:01:03 +00001763 sqlite3VdbeAddOp2(v, OP_Null, 0, dest.iParm);
drhd4e70eb2008-01-02 00:34:36 +00001764 VdbeComment((v, "Init subquery result"));
drh51522cd2005-01-20 13:36:19 +00001765 }else{
danielk19776c8c8ce2008-01-02 16:27:09 +00001766 dest.eDest = SRT_Exists;
drh4c583122008-01-04 22:01:03 +00001767 sqlite3VdbeAddOp2(v, OP_Integer, 0, dest.iParm);
drhd4e70eb2008-01-02 00:34:36 +00001768 VdbeComment((v, "Init EXISTS result"));
drh51522cd2005-01-20 13:36:19 +00001769 }
drh633e6d52008-07-28 19:34:53 +00001770 sqlite3ExprDelete(pParse->db, pSel->pLimit);
drh094430e2010-07-14 18:24:06 +00001771 pSel->pLimit = sqlite3PExpr(pParse, TK_INTEGER, 0, 0,
1772 &sqlite3IntTokens[1]);
drh48b5b042010-12-06 18:50:32 +00001773 pSel->iLimit = 0;
drh7d10d5a2008-08-20 16:35:10 +00001774 if( sqlite3Select(pParse, pSel, &dest) ){
drh1450bc62009-10-30 13:25:56 +00001775 return 0;
drh94ccde52007-04-13 16:06:32 +00001776 }
drh1450bc62009-10-30 13:25:56 +00001777 rReg = dest.iParm;
drh33e619f2009-05-28 01:00:55 +00001778 ExprSetIrreducible(pExpr);
danielk1977b3bce662005-01-29 08:32:43 +00001779 break;
drhcce7d172000-05-31 15:34:51 +00001780 }
1781 }
danielk1977b3bce662005-01-29 08:32:43 +00001782
drhdfd2d9f2011-09-16 22:10:57 +00001783 if( testAddr>=0 ){
drh48f2d3b2011-09-16 01:34:43 +00001784 sqlite3VdbeJumpHere(v, testAddr);
danielk1977b3bce662005-01-29 08:32:43 +00001785 }
drhceea3322009-04-23 13:22:42 +00001786 sqlite3ExprCachePop(pParse, 1);
danielk1977fc976062007-05-10 10:46:56 +00001787
drh1450bc62009-10-30 13:25:56 +00001788 return rReg;
drhcce7d172000-05-31 15:34:51 +00001789}
drh51522cd2005-01-20 13:36:19 +00001790#endif /* SQLITE_OMIT_SUBQUERY */
drhcce7d172000-05-31 15:34:51 +00001791
drhe3365e62009-11-12 17:52:24 +00001792#ifndef SQLITE_OMIT_SUBQUERY
1793/*
1794** Generate code for an IN expression.
1795**
1796** x IN (SELECT ...)
1797** x IN (value, value, ...)
1798**
1799** The left-hand side (LHS) is a scalar expression. The right-hand side (RHS)
1800** is an array of zero or more values. The expression is true if the LHS is
1801** contained within the RHS. The value of the expression is unknown (NULL)
1802** if the LHS is NULL or if the LHS is not contained within the RHS and the
1803** RHS contains one or more NULL values.
1804**
1805** This routine generates code will jump to destIfFalse if the LHS is not
1806** contained within the RHS. If due to NULLs we cannot determine if the LHS
1807** is contained in the RHS then jump to destIfNull. If the LHS is contained
1808** within the RHS then fall through.
1809*/
1810static void sqlite3ExprCodeIN(
1811 Parse *pParse, /* Parsing and code generating context */
1812 Expr *pExpr, /* The IN expression */
1813 int destIfFalse, /* Jump here if LHS is not contained in the RHS */
1814 int destIfNull /* Jump here if the results are unknown due to NULLs */
1815){
1816 int rRhsHasNull = 0; /* Register that is true if RHS contains NULL values */
1817 char affinity; /* Comparison affinity to use */
1818 int eType; /* Type of the RHS */
1819 int r1; /* Temporary use register */
1820 Vdbe *v; /* Statement under construction */
1821
1822 /* Compute the RHS. After this step, the table with cursor
1823 ** pExpr->iTable will contains the values that make up the RHS.
1824 */
1825 v = pParse->pVdbe;
1826 assert( v!=0 ); /* OOM detected prior to this routine */
1827 VdbeNoopComment((v, "begin IN expr"));
1828 eType = sqlite3FindInIndex(pParse, pExpr, &rRhsHasNull);
1829
1830 /* Figure out the affinity to use to create a key from the results
1831 ** of the expression. affinityStr stores a static string suitable for
1832 ** P4 of OP_MakeRecord.
1833 */
1834 affinity = comparisonAffinity(pExpr);
1835
1836 /* Code the LHS, the <expr> from "<expr> IN (...)".
1837 */
1838 sqlite3ExprCachePush(pParse);
1839 r1 = sqlite3GetTempReg(pParse);
1840 sqlite3ExprCode(pParse, pExpr->pLeft, r1);
drhe3365e62009-11-12 17:52:24 +00001841
drh094430e2010-07-14 18:24:06 +00001842 /* If the LHS is NULL, then the result is either false or NULL depending
1843 ** on whether the RHS is empty or not, respectively.
1844 */
1845 if( destIfNull==destIfFalse ){
1846 /* Shortcut for the common case where the false and NULL outcomes are
1847 ** the same. */
1848 sqlite3VdbeAddOp2(v, OP_IsNull, r1, destIfNull);
1849 }else{
1850 int addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, r1);
1851 sqlite3VdbeAddOp2(v, OP_Rewind, pExpr->iTable, destIfFalse);
1852 sqlite3VdbeAddOp2(v, OP_Goto, 0, destIfNull);
1853 sqlite3VdbeJumpHere(v, addr1);
1854 }
drhe3365e62009-11-12 17:52:24 +00001855
1856 if( eType==IN_INDEX_ROWID ){
1857 /* In this case, the RHS is the ROWID of table b-tree
1858 */
1859 sqlite3VdbeAddOp2(v, OP_MustBeInt, r1, destIfFalse);
1860 sqlite3VdbeAddOp3(v, OP_NotExists, pExpr->iTable, destIfFalse, r1);
1861 }else{
1862 /* In this case, the RHS is an index b-tree.
1863 */
drh8cff69d2009-11-12 19:59:44 +00001864 sqlite3VdbeAddOp4(v, OP_Affinity, r1, 1, 0, &affinity, 1);
drhe3365e62009-11-12 17:52:24 +00001865
1866 /* If the set membership test fails, then the result of the
1867 ** "x IN (...)" expression must be either 0 or NULL. If the set
1868 ** contains no NULL values, then the result is 0. If the set
1869 ** contains one or more NULL values, then the result of the
1870 ** expression is also NULL.
1871 */
1872 if( rRhsHasNull==0 || destIfFalse==destIfNull ){
1873 /* This branch runs if it is known at compile time that the RHS
1874 ** cannot contain NULL values. This happens as the result
1875 ** of a "NOT NULL" constraint in the database schema.
1876 **
1877 ** Also run this branch if NULL is equivalent to FALSE
1878 ** for this particular IN operator.
1879 */
drh8cff69d2009-11-12 19:59:44 +00001880 sqlite3VdbeAddOp4Int(v, OP_NotFound, pExpr->iTable, destIfFalse, r1, 1);
drhe3365e62009-11-12 17:52:24 +00001881
1882 }else{
1883 /* In this branch, the RHS of the IN might contain a NULL and
1884 ** the presence of a NULL on the RHS makes a difference in the
1885 ** outcome.
1886 */
drhe3365e62009-11-12 17:52:24 +00001887 int j1, j2, j3;
1888
1889 /* First check to see if the LHS is contained in the RHS. If so,
1890 ** then the presence of NULLs in the RHS does not matter, so jump
1891 ** over all of the code that follows.
1892 */
drh8cff69d2009-11-12 19:59:44 +00001893 j1 = sqlite3VdbeAddOp4Int(v, OP_Found, pExpr->iTable, 0, r1, 1);
drhe3365e62009-11-12 17:52:24 +00001894
1895 /* Here we begin generating code that runs if the LHS is not
1896 ** contained within the RHS. Generate additional code that
1897 ** tests the RHS for NULLs. If the RHS contains a NULL then
1898 ** jump to destIfNull. If there are no NULLs in the RHS then
1899 ** jump to destIfFalse.
1900 */
1901 j2 = sqlite3VdbeAddOp1(v, OP_NotNull, rRhsHasNull);
drh8cff69d2009-11-12 19:59:44 +00001902 j3 = sqlite3VdbeAddOp4Int(v, OP_Found, pExpr->iTable, 0, rRhsHasNull, 1);
drhe3365e62009-11-12 17:52:24 +00001903 sqlite3VdbeAddOp2(v, OP_Integer, -1, rRhsHasNull);
1904 sqlite3VdbeJumpHere(v, j3);
1905 sqlite3VdbeAddOp2(v, OP_AddImm, rRhsHasNull, 1);
1906 sqlite3VdbeJumpHere(v, j2);
1907
1908 /* Jump to the appropriate target depending on whether or not
1909 ** the RHS contains a NULL
1910 */
1911 sqlite3VdbeAddOp2(v, OP_If, rRhsHasNull, destIfNull);
1912 sqlite3VdbeAddOp2(v, OP_Goto, 0, destIfFalse);
1913
1914 /* The OP_Found at the top of this branch jumps here when true,
1915 ** causing the overall IN expression evaluation to fall through.
1916 */
1917 sqlite3VdbeJumpHere(v, j1);
1918 }
drhe3365e62009-11-12 17:52:24 +00001919 }
1920 sqlite3ReleaseTempReg(pParse, r1);
1921 sqlite3ExprCachePop(pParse, 1);
1922 VdbeComment((v, "end IN expr"));
1923}
1924#endif /* SQLITE_OMIT_SUBQUERY */
1925
drhcce7d172000-05-31 15:34:51 +00001926/*
drh598f1342007-10-23 15:39:45 +00001927** Duplicate an 8-byte value
1928*/
1929static char *dup8bytes(Vdbe *v, const char *in){
1930 char *out = sqlite3DbMallocRaw(sqlite3VdbeDb(v), 8);
1931 if( out ){
1932 memcpy(out, in, 8);
1933 }
1934 return out;
1935}
1936
drh13573c72010-01-12 17:04:07 +00001937#ifndef SQLITE_OMIT_FLOATING_POINT
drh598f1342007-10-23 15:39:45 +00001938/*
1939** Generate an instruction that will put the floating point
drh9cbf3422008-01-17 16:22:13 +00001940** value described by z[0..n-1] into register iMem.
drh0cf19ed2007-10-23 18:55:48 +00001941**
1942** The z[] string will probably not be zero-terminated. But the
1943** z[n] character is guaranteed to be something that does not look
1944** like the continuation of the number.
drh598f1342007-10-23 15:39:45 +00001945*/
drhb7916a72009-05-27 10:31:29 +00001946static void codeReal(Vdbe *v, const char *z, int negateFlag, int iMem){
drhfd773cf2009-05-29 14:39:07 +00001947 if( ALWAYS(z!=0) ){
drh598f1342007-10-23 15:39:45 +00001948 double value;
1949 char *zV;
drh9339da12010-09-30 00:50:49 +00001950 sqlite3AtoF(z, &value, sqlite3Strlen30(z), SQLITE_UTF8);
drhd0015162009-08-21 13:22:25 +00001951 assert( !sqlite3IsNaN(value) ); /* The new AtoF never returns NaN */
1952 if( negateFlag ) value = -value;
1953 zV = dup8bytes(v, (char*)&value);
1954 sqlite3VdbeAddOp4(v, OP_Real, 0, iMem, 0, zV, P4_REAL);
drh598f1342007-10-23 15:39:45 +00001955 }
1956}
drh13573c72010-01-12 17:04:07 +00001957#endif
drh598f1342007-10-23 15:39:45 +00001958
1959
1960/*
drhfec19aa2004-05-19 20:41:03 +00001961** Generate an instruction that will put the integer describe by
drh9cbf3422008-01-17 16:22:13 +00001962** text z[0..n-1] into register iMem.
drh0cf19ed2007-10-23 18:55:48 +00001963**
shaneh5f1d6b62010-09-30 16:51:25 +00001964** Expr.u.zToken is always UTF8 and zero-terminated.
drhfec19aa2004-05-19 20:41:03 +00001965*/
drh13573c72010-01-12 17:04:07 +00001966static void codeInteger(Parse *pParse, Expr *pExpr, int negFlag, int iMem){
1967 Vdbe *v = pParse->pVdbe;
drh92b01d52008-06-24 00:32:35 +00001968 if( pExpr->flags & EP_IntValue ){
drh33e619f2009-05-28 01:00:55 +00001969 int i = pExpr->u.iValue;
drhd50ffc42011-03-08 02:38:28 +00001970 assert( i>=0 );
drh92b01d52008-06-24 00:32:35 +00001971 if( negFlag ) i = -i;
1972 sqlite3VdbeAddOp2(v, OP_Integer, i, iMem);
drhfd773cf2009-05-29 14:39:07 +00001973 }else{
shaneh5f1d6b62010-09-30 16:51:25 +00001974 int c;
1975 i64 value;
drhfd773cf2009-05-29 14:39:07 +00001976 const char *z = pExpr->u.zToken;
1977 assert( z!=0 );
shaneh5f1d6b62010-09-30 16:51:25 +00001978 c = sqlite3Atoi64(z, &value, sqlite3Strlen30(z), SQLITE_UTF8);
1979 if( c==0 || (c==2 && negFlag) ){
drh598f1342007-10-23 15:39:45 +00001980 char *zV;
drh158b9cb2011-03-05 20:59:46 +00001981 if( negFlag ){ value = c==2 ? SMALLEST_INT64 : -value; }
drh598f1342007-10-23 15:39:45 +00001982 zV = dup8bytes(v, (char*)&value);
drh9de221d2008-01-05 06:51:30 +00001983 sqlite3VdbeAddOp4(v, OP_Int64, 0, iMem, 0, zV, P4_INT64);
danielk1977c9cf9012007-05-30 10:36:47 +00001984 }else{
drh13573c72010-01-12 17:04:07 +00001985#ifdef SQLITE_OMIT_FLOATING_POINT
1986 sqlite3ErrorMsg(pParse, "oversized integer: %s%s", negFlag ? "-" : "", z);
1987#else
drhb7916a72009-05-27 10:31:29 +00001988 codeReal(v, z, negFlag, iMem);
drh13573c72010-01-12 17:04:07 +00001989#endif
danielk1977c9cf9012007-05-30 10:36:47 +00001990 }
drhfec19aa2004-05-19 20:41:03 +00001991 }
1992}
1993
drhceea3322009-04-23 13:22:42 +00001994/*
1995** Clear a cache entry.
1996*/
1997static void cacheEntryClear(Parse *pParse, struct yColCache *p){
1998 if( p->tempReg ){
1999 if( pParse->nTempReg<ArraySize(pParse->aTempReg) ){
2000 pParse->aTempReg[pParse->nTempReg++] = p->iReg;
2001 }
2002 p->tempReg = 0;
2003 }
2004}
2005
2006
2007/*
2008** Record in the column cache that a particular column from a
2009** particular table is stored in a particular register.
2010*/
2011void sqlite3ExprCacheStore(Parse *pParse, int iTab, int iCol, int iReg){
2012 int i;
2013 int minLru;
2014 int idxLru;
2015 struct yColCache *p;
2016
drh20411ea2009-05-29 19:00:12 +00002017 assert( iReg>0 ); /* Register numbers are always positive */
2018 assert( iCol>=-1 && iCol<32768 ); /* Finite column numbers */
2019
drhb6da74e2009-12-24 16:00:28 +00002020 /* The SQLITE_ColumnCache flag disables the column cache. This is used
2021 ** for testing only - to verify that SQLite always gets the same answer
2022 ** with and without the column cache.
2023 */
2024 if( pParse->db->flags & SQLITE_ColumnCache ) return;
2025
drh27ee4062009-12-30 01:13:11 +00002026 /* First replace any existing entry.
2027 **
2028 ** Actually, the way the column cache is currently used, we are guaranteed
2029 ** that the object will never already be in cache. Verify this guarantee.
2030 */
2031#ifndef NDEBUG
drhceea3322009-04-23 13:22:42 +00002032 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
drh27ee4062009-12-30 01:13:11 +00002033#if 0 /* This code wold remove the entry from the cache if it existed */
drhceea3322009-04-23 13:22:42 +00002034 if( p->iReg && p->iTable==iTab && p->iColumn==iCol ){
2035 cacheEntryClear(pParse, p);
2036 p->iLevel = pParse->iCacheLevel;
2037 p->iReg = iReg;
drhceea3322009-04-23 13:22:42 +00002038 p->lru = pParse->iCacheCnt++;
2039 return;
2040 }
drh27ee4062009-12-30 01:13:11 +00002041#endif
2042 assert( p->iReg==0 || p->iTable!=iTab || p->iColumn!=iCol );
drhceea3322009-04-23 13:22:42 +00002043 }
drh27ee4062009-12-30 01:13:11 +00002044#endif
drhceea3322009-04-23 13:22:42 +00002045
2046 /* Find an empty slot and replace it */
2047 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
2048 if( p->iReg==0 ){
2049 p->iLevel = pParse->iCacheLevel;
2050 p->iTable = iTab;
2051 p->iColumn = iCol;
2052 p->iReg = iReg;
drhceea3322009-04-23 13:22:42 +00002053 p->tempReg = 0;
2054 p->lru = pParse->iCacheCnt++;
2055 return;
2056 }
2057 }
2058
2059 /* Replace the last recently used */
2060 minLru = 0x7fffffff;
2061 idxLru = -1;
2062 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
2063 if( p->lru<minLru ){
2064 idxLru = i;
2065 minLru = p->lru;
2066 }
2067 }
drh20411ea2009-05-29 19:00:12 +00002068 if( ALWAYS(idxLru>=0) ){
drhceea3322009-04-23 13:22:42 +00002069 p = &pParse->aColCache[idxLru];
2070 p->iLevel = pParse->iCacheLevel;
2071 p->iTable = iTab;
2072 p->iColumn = iCol;
2073 p->iReg = iReg;
drhceea3322009-04-23 13:22:42 +00002074 p->tempReg = 0;
2075 p->lru = pParse->iCacheCnt++;
2076 return;
2077 }
2078}
2079
2080/*
drhf49f3522009-12-30 14:12:38 +00002081** Indicate that registers between iReg..iReg+nReg-1 are being overwritten.
2082** Purge the range of registers from the column cache.
drhceea3322009-04-23 13:22:42 +00002083*/
drhf49f3522009-12-30 14:12:38 +00002084void sqlite3ExprCacheRemove(Parse *pParse, int iReg, int nReg){
drhceea3322009-04-23 13:22:42 +00002085 int i;
drhf49f3522009-12-30 14:12:38 +00002086 int iLast = iReg + nReg - 1;
drhceea3322009-04-23 13:22:42 +00002087 struct yColCache *p;
2088 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
drhf49f3522009-12-30 14:12:38 +00002089 int r = p->iReg;
2090 if( r>=iReg && r<=iLast ){
drhceea3322009-04-23 13:22:42 +00002091 cacheEntryClear(pParse, p);
2092 p->iReg = 0;
2093 }
2094 }
2095}
2096
2097/*
2098** Remember the current column cache context. Any new entries added
2099** added to the column cache after this call are removed when the
2100** corresponding pop occurs.
2101*/
2102void sqlite3ExprCachePush(Parse *pParse){
2103 pParse->iCacheLevel++;
2104}
2105
2106/*
2107** Remove from the column cache any entries that were added since the
2108** the previous N Push operations. In other words, restore the cache
2109** to the state it was in N Pushes ago.
2110*/
2111void sqlite3ExprCachePop(Parse *pParse, int N){
2112 int i;
2113 struct yColCache *p;
2114 assert( N>0 );
2115 assert( pParse->iCacheLevel>=N );
2116 pParse->iCacheLevel -= N;
2117 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
2118 if( p->iReg && p->iLevel>pParse->iCacheLevel ){
2119 cacheEntryClear(pParse, p);
2120 p->iReg = 0;
2121 }
2122 }
2123}
drh945498f2007-02-24 11:52:52 +00002124
2125/*
drh5cd79232009-05-25 11:46:29 +00002126** When a cached column is reused, make sure that its register is
2127** no longer available as a temp register. ticket #3879: that same
2128** register might be in the cache in multiple places, so be sure to
2129** get them all.
2130*/
2131static void sqlite3ExprCachePinRegister(Parse *pParse, int iReg){
2132 int i;
2133 struct yColCache *p;
2134 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
2135 if( p->iReg==iReg ){
2136 p->tempReg = 0;
2137 }
2138 }
2139}
2140
2141/*
drh5c092e82010-05-14 19:24:02 +00002142** Generate code to extract the value of the iCol-th column of a table.
2143*/
2144void sqlite3ExprCodeGetColumnOfTable(
2145 Vdbe *v, /* The VDBE under construction */
2146 Table *pTab, /* The table containing the value */
2147 int iTabCur, /* The cursor for this table */
2148 int iCol, /* Index of the column to extract */
2149 int regOut /* Extract the valud into this register */
2150){
2151 if( iCol<0 || iCol==pTab->iPKey ){
2152 sqlite3VdbeAddOp2(v, OP_Rowid, iTabCur, regOut);
2153 }else{
2154 int op = IsVirtual(pTab) ? OP_VColumn : OP_Column;
2155 sqlite3VdbeAddOp3(v, op, iTabCur, iCol, regOut);
2156 }
2157 if( iCol>=0 ){
2158 sqlite3ColumnDefault(v, pTab, iCol, regOut);
2159 }
2160}
2161
2162/*
drh945498f2007-02-24 11:52:52 +00002163** Generate code that will extract the iColumn-th column from
drhe55cbd72008-03-31 23:48:03 +00002164** table pTab and store the column value in a register. An effort
2165** is made to store the column value in register iReg, but this is
2166** not guaranteed. The location of the column value is returned.
2167**
2168** There must be an open cursor to pTab in iTable when this routine
2169** is called. If iColumn<0 then code is generated that extracts the rowid.
drh945498f2007-02-24 11:52:52 +00002170*/
drhe55cbd72008-03-31 23:48:03 +00002171int sqlite3ExprCodeGetColumn(
2172 Parse *pParse, /* Parsing and code generating context */
drh2133d822008-01-03 18:44:59 +00002173 Table *pTab, /* Description of the table we are reading from */
2174 int iColumn, /* Index of the table column */
2175 int iTable, /* The cursor pointing to the table */
drhb6da74e2009-12-24 16:00:28 +00002176 int iReg /* Store results here */
drh2133d822008-01-03 18:44:59 +00002177){
drhe55cbd72008-03-31 23:48:03 +00002178 Vdbe *v = pParse->pVdbe;
2179 int i;
drhda250ea2008-04-01 05:07:14 +00002180 struct yColCache *p;
drhe55cbd72008-03-31 23:48:03 +00002181
drhceea3322009-04-23 13:22:42 +00002182 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
drhb6da74e2009-12-24 16:00:28 +00002183 if( p->iReg>0 && p->iTable==iTable && p->iColumn==iColumn ){
drhceea3322009-04-23 13:22:42 +00002184 p->lru = pParse->iCacheCnt++;
drh5cd79232009-05-25 11:46:29 +00002185 sqlite3ExprCachePinRegister(pParse, p->iReg);
drhda250ea2008-04-01 05:07:14 +00002186 return p->iReg;
drhe55cbd72008-03-31 23:48:03 +00002187 }
2188 }
2189 assert( v!=0 );
drh5c092e82010-05-14 19:24:02 +00002190 sqlite3ExprCodeGetColumnOfTable(v, pTab, iTable, iColumn, iReg);
drhceea3322009-04-23 13:22:42 +00002191 sqlite3ExprCacheStore(pParse, iTable, iColumn, iReg);
drhe55cbd72008-03-31 23:48:03 +00002192 return iReg;
2193}
2194
2195/*
drhceea3322009-04-23 13:22:42 +00002196** Clear all column cache entries.
drhe55cbd72008-03-31 23:48:03 +00002197*/
drhceea3322009-04-23 13:22:42 +00002198void sqlite3ExprCacheClear(Parse *pParse){
2199 int i;
2200 struct yColCache *p;
2201
2202 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
2203 if( p->iReg ){
2204 cacheEntryClear(pParse, p);
2205 p->iReg = 0;
drhe55cbd72008-03-31 23:48:03 +00002206 }
drhe55cbd72008-03-31 23:48:03 +00002207 }
2208}
2209
2210/*
drhda250ea2008-04-01 05:07:14 +00002211** Record the fact that an affinity change has occurred on iCount
2212** registers starting with iStart.
drhe55cbd72008-03-31 23:48:03 +00002213*/
drhda250ea2008-04-01 05:07:14 +00002214void sqlite3ExprCacheAffinityChange(Parse *pParse, int iStart, int iCount){
drhf49f3522009-12-30 14:12:38 +00002215 sqlite3ExprCacheRemove(pParse, iStart, iCount);
drhe55cbd72008-03-31 23:48:03 +00002216}
2217
2218/*
drhb21e7c72008-06-22 12:37:57 +00002219** Generate code to move content from registers iFrom...iFrom+nReg-1
2220** over to iTo..iTo+nReg-1. Keep the column cache up-to-date.
drhe55cbd72008-03-31 23:48:03 +00002221*/
drhb21e7c72008-06-22 12:37:57 +00002222void sqlite3ExprCodeMove(Parse *pParse, int iFrom, int iTo, int nReg){
drhe55cbd72008-03-31 23:48:03 +00002223 int i;
drhceea3322009-04-23 13:22:42 +00002224 struct yColCache *p;
drh20411ea2009-05-29 19:00:12 +00002225 if( NEVER(iFrom==iTo) ) return;
drhb21e7c72008-06-22 12:37:57 +00002226 sqlite3VdbeAddOp3(pParse->pVdbe, OP_Move, iFrom, iTo, nReg);
drhceea3322009-04-23 13:22:42 +00002227 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
2228 int x = p->iReg;
drhb21e7c72008-06-22 12:37:57 +00002229 if( x>=iFrom && x<iFrom+nReg ){
drhceea3322009-04-23 13:22:42 +00002230 p->iReg += iTo-iFrom;
drhe55cbd72008-03-31 23:48:03 +00002231 }
2232 }
drh945498f2007-02-24 11:52:52 +00002233}
2234
drhfec19aa2004-05-19 20:41:03 +00002235/*
drh92b01d52008-06-24 00:32:35 +00002236** Generate code to copy content from registers iFrom...iFrom+nReg-1
2237** over to iTo..iTo+nReg-1.
2238*/
2239void sqlite3ExprCodeCopy(Parse *pParse, int iFrom, int iTo, int nReg){
2240 int i;
drh20411ea2009-05-29 19:00:12 +00002241 if( NEVER(iFrom==iTo) ) return;
drh92b01d52008-06-24 00:32:35 +00002242 for(i=0; i<nReg; i++){
2243 sqlite3VdbeAddOp2(pParse->pVdbe, OP_Copy, iFrom+i, iTo+i);
2244 }
2245}
2246
drhf49f3522009-12-30 14:12:38 +00002247#if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST)
drh92b01d52008-06-24 00:32:35 +00002248/*
drh652fbf52008-04-01 01:42:41 +00002249** Return true if any register in the range iFrom..iTo (inclusive)
2250** is used as part of the column cache.
drhf49f3522009-12-30 14:12:38 +00002251**
2252** This routine is used within assert() and testcase() macros only
2253** and does not appear in a normal build.
drh652fbf52008-04-01 01:42:41 +00002254*/
2255static int usedAsColumnCache(Parse *pParse, int iFrom, int iTo){
2256 int i;
drhceea3322009-04-23 13:22:42 +00002257 struct yColCache *p;
2258 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
2259 int r = p->iReg;
drhf49f3522009-12-30 14:12:38 +00002260 if( r>=iFrom && r<=iTo ) return 1; /*NO_TEST*/
drh652fbf52008-04-01 01:42:41 +00002261 }
2262 return 0;
2263}
drhf49f3522009-12-30 14:12:38 +00002264#endif /* SQLITE_DEBUG || SQLITE_COVERAGE_TEST */
drh652fbf52008-04-01 01:42:41 +00002265
2266/*
drhcce7d172000-05-31 15:34:51 +00002267** Generate code into the current Vdbe to evaluate the given
drh2dcef112008-01-12 19:03:48 +00002268** expression. Attempt to store the results in register "target".
2269** Return the register where results are stored.
drh389a1ad2008-01-03 23:44:53 +00002270**
drh8b213892008-08-29 02:14:02 +00002271** With this routine, there is no guarantee that results will
drh2dcef112008-01-12 19:03:48 +00002272** be stored in target. The result might be stored in some other
2273** register if it is convenient to do so. The calling function
2274** must check the return code and move the results to the desired
2275** register.
drhcce7d172000-05-31 15:34:51 +00002276*/
drh678ccce2008-03-31 18:19:54 +00002277int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){
drh2dcef112008-01-12 19:03:48 +00002278 Vdbe *v = pParse->pVdbe; /* The VM under construction */
2279 int op; /* The opcode being coded */
2280 int inReg = target; /* Results stored in register inReg */
2281 int regFree1 = 0; /* If non-zero free this temporary register */
2282 int regFree2 = 0; /* If non-zero free this temporary register */
drh678ccce2008-03-31 18:19:54 +00002283 int r1, r2, r3, r4; /* Various register numbers */
drh20411ea2009-05-29 19:00:12 +00002284 sqlite3 *db = pParse->db; /* The database connection */
drhffe07b22005-11-03 00:41:17 +00002285
drh9cbf3422008-01-17 16:22:13 +00002286 assert( target>0 && target<=pParse->nMem );
drh20411ea2009-05-29 19:00:12 +00002287 if( v==0 ){
2288 assert( pParse->db->mallocFailed );
2289 return 0;
2290 }
drh389a1ad2008-01-03 23:44:53 +00002291
2292 if( pExpr==0 ){
2293 op = TK_NULL;
2294 }else{
2295 op = pExpr->op;
2296 }
drhf2bc0132004-10-04 13:19:23 +00002297 switch( op ){
drh13449892005-09-07 21:22:45 +00002298 case TK_AGG_COLUMN: {
2299 AggInfo *pAggInfo = pExpr->pAggInfo;
2300 struct AggInfo_col *pCol = &pAggInfo->aCol[pExpr->iAgg];
2301 if( !pAggInfo->directMode ){
drh9de221d2008-01-05 06:51:30 +00002302 assert( pCol->iMem>0 );
2303 inReg = pCol->iMem;
drh13449892005-09-07 21:22:45 +00002304 break;
2305 }else if( pAggInfo->useSortingIdx ){
dan5134d132011-09-02 10:31:11 +00002306 sqlite3VdbeAddOp3(v, OP_Column, pAggInfo->sortingIdxPTab,
drh389a1ad2008-01-03 23:44:53 +00002307 pCol->iSorterColumn, target);
drh13449892005-09-07 21:22:45 +00002308 break;
2309 }
2310 /* Otherwise, fall thru into the TK_COLUMN case */
2311 }
drh967e8b72000-06-21 13:59:10 +00002312 case TK_COLUMN: {
drhffe07b22005-11-03 00:41:17 +00002313 if( pExpr->iTable<0 ){
2314 /* This only happens when coding check constraints */
drhaa9b8962008-01-08 02:57:55 +00002315 assert( pParse->ckBase>0 );
2316 inReg = pExpr->iColumn + pParse->ckBase;
drhc4a3c772001-04-04 11:48:57 +00002317 }else{
drhe55cbd72008-03-31 23:48:03 +00002318 inReg = sqlite3ExprCodeGetColumn(pParse, pExpr->pTab,
drhb6da74e2009-12-24 16:00:28 +00002319 pExpr->iColumn, pExpr->iTable, target);
drh22827922000-06-06 17:27:05 +00002320 }
drhcce7d172000-05-31 15:34:51 +00002321 break;
2322 }
2323 case TK_INTEGER: {
drh13573c72010-01-12 17:04:07 +00002324 codeInteger(pParse, pExpr, 0, target);
drhfec19aa2004-05-19 20:41:03 +00002325 break;
2326 }
drh13573c72010-01-12 17:04:07 +00002327#ifndef SQLITE_OMIT_FLOATING_POINT
drh598f1342007-10-23 15:39:45 +00002328 case TK_FLOAT: {
drh33e619f2009-05-28 01:00:55 +00002329 assert( !ExprHasProperty(pExpr, EP_IntValue) );
2330 codeReal(v, pExpr->u.zToken, 0, target);
drh598f1342007-10-23 15:39:45 +00002331 break;
2332 }
drh13573c72010-01-12 17:04:07 +00002333#endif
drhfec19aa2004-05-19 20:41:03 +00002334 case TK_STRING: {
drh33e619f2009-05-28 01:00:55 +00002335 assert( !ExprHasProperty(pExpr, EP_IntValue) );
2336 sqlite3VdbeAddOp4(v, OP_String8, 0, target, 0, pExpr->u.zToken, 0);
drhcce7d172000-05-31 15:34:51 +00002337 break;
2338 }
drhf0863fe2005-06-12 21:35:51 +00002339 case TK_NULL: {
drh9de221d2008-01-05 06:51:30 +00002340 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
drhf0863fe2005-06-12 21:35:51 +00002341 break;
2342 }
danielk19775338a5f2005-01-20 13:03:10 +00002343#ifndef SQLITE_OMIT_BLOB_LITERAL
danielk1977c572ef72004-05-27 09:28:41 +00002344 case TK_BLOB: {
drh6c8c6ce2005-08-23 11:17:58 +00002345 int n;
2346 const char *z;
drhca48c902008-01-18 14:08:24 +00002347 char *zBlob;
drh33e619f2009-05-28 01:00:55 +00002348 assert( !ExprHasProperty(pExpr, EP_IntValue) );
2349 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
2350 assert( pExpr->u.zToken[1]=='\'' );
2351 z = &pExpr->u.zToken[2];
drhb7916a72009-05-27 10:31:29 +00002352 n = sqlite3Strlen30(z) - 1;
2353 assert( z[n]=='\'' );
drhca48c902008-01-18 14:08:24 +00002354 zBlob = sqlite3HexToBlob(sqlite3VdbeDb(v), z, n);
2355 sqlite3VdbeAddOp4(v, OP_Blob, n/2, target, 0, zBlob, P4_DYNAMIC);
danielk1977c572ef72004-05-27 09:28:41 +00002356 break;
2357 }
danielk19775338a5f2005-01-20 13:03:10 +00002358#endif
drh50457892003-09-06 01:10:47 +00002359 case TK_VARIABLE: {
drh33e619f2009-05-28 01:00:55 +00002360 assert( !ExprHasProperty(pExpr, EP_IntValue) );
2361 assert( pExpr->u.zToken!=0 );
2362 assert( pExpr->u.zToken[0]!=0 );
drheaf52d82010-05-12 13:50:23 +00002363 sqlite3VdbeAddOp2(v, OP_Variable, pExpr->iColumn, target);
2364 if( pExpr->u.zToken[1]!=0 ){
drh04e9eea2011-06-01 19:16:06 +00002365 assert( pExpr->u.zToken[0]=='?'
2366 || strcmp(pExpr->u.zToken, pParse->azVar[pExpr->iColumn-1])==0 );
2367 sqlite3VdbeChangeP4(v, -1, pParse->azVar[pExpr->iColumn-1], P4_STATIC);
drh895d7472004-08-20 16:02:39 +00002368 }
drh50457892003-09-06 01:10:47 +00002369 break;
2370 }
drh4e0cff62004-11-05 05:10:28 +00002371 case TK_REGISTER: {
drh9de221d2008-01-05 06:51:30 +00002372 inReg = pExpr->iTable;
drh4e0cff62004-11-05 05:10:28 +00002373 break;
2374 }
drh8b213892008-08-29 02:14:02 +00002375 case TK_AS: {
drh7445ffe2010-09-27 18:14:12 +00002376 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
drh8b213892008-08-29 02:14:02 +00002377 break;
2378 }
drh487e2622005-06-25 18:42:14 +00002379#ifndef SQLITE_OMIT_CAST
2380 case TK_CAST: {
2381 /* Expressions of the form: CAST(pLeft AS token) */
danielk1977f0113002006-01-24 12:09:17 +00002382 int aff, to_op;
drh2dcef112008-01-12 19:03:48 +00002383 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
drh33e619f2009-05-28 01:00:55 +00002384 assert( !ExprHasProperty(pExpr, EP_IntValue) );
2385 aff = sqlite3AffinityType(pExpr->u.zToken);
danielk1977f0113002006-01-24 12:09:17 +00002386 to_op = aff - SQLITE_AFF_TEXT + OP_ToText;
2387 assert( to_op==OP_ToText || aff!=SQLITE_AFF_TEXT );
2388 assert( to_op==OP_ToBlob || aff!=SQLITE_AFF_NONE );
2389 assert( to_op==OP_ToNumeric || aff!=SQLITE_AFF_NUMERIC );
2390 assert( to_op==OP_ToInt || aff!=SQLITE_AFF_INTEGER );
2391 assert( to_op==OP_ToReal || aff!=SQLITE_AFF_REAL );
drhc5499be2008-04-01 15:06:33 +00002392 testcase( to_op==OP_ToText );
2393 testcase( to_op==OP_ToBlob );
2394 testcase( to_op==OP_ToNumeric );
2395 testcase( to_op==OP_ToInt );
2396 testcase( to_op==OP_ToReal );
drh1735fa82008-11-06 15:33:03 +00002397 if( inReg!=target ){
2398 sqlite3VdbeAddOp2(v, OP_SCopy, inReg, target);
2399 inReg = target;
2400 }
drh2dcef112008-01-12 19:03:48 +00002401 sqlite3VdbeAddOp1(v, to_op, inReg);
drhc5499be2008-04-01 15:06:33 +00002402 testcase( usedAsColumnCache(pParse, inReg, inReg) );
drhb3843a82008-04-01 12:24:11 +00002403 sqlite3ExprCacheAffinityChange(pParse, inReg, 1);
drh487e2622005-06-25 18:42:14 +00002404 break;
2405 }
2406#endif /* SQLITE_OMIT_CAST */
drhc9b84a12002-06-20 11:36:48 +00002407 case TK_LT:
2408 case TK_LE:
2409 case TK_GT:
2410 case TK_GE:
2411 case TK_NE:
2412 case TK_EQ: {
drhf2bc0132004-10-04 13:19:23 +00002413 assert( TK_LT==OP_Lt );
2414 assert( TK_LE==OP_Le );
2415 assert( TK_GT==OP_Gt );
2416 assert( TK_GE==OP_Ge );
2417 assert( TK_EQ==OP_Eq );
2418 assert( TK_NE==OP_Ne );
drhc5499be2008-04-01 15:06:33 +00002419 testcase( op==TK_LT );
2420 testcase( op==TK_LE );
2421 testcase( op==TK_GT );
2422 testcase( op==TK_GE );
2423 testcase( op==TK_EQ );
2424 testcase( op==TK_NE );
drhb6da74e2009-12-24 16:00:28 +00002425 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
2426 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
drh35573352008-01-08 23:54:25 +00002427 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
2428 r1, r2, inReg, SQLITE_STOREP2);
drhc5499be2008-04-01 15:06:33 +00002429 testcase( regFree1==0 );
2430 testcase( regFree2==0 );
danielk1977a37cdde2004-05-16 11:15:36 +00002431 break;
drhc9b84a12002-06-20 11:36:48 +00002432 }
drh6a2fe092009-09-23 02:29:36 +00002433 case TK_IS:
2434 case TK_ISNOT: {
2435 testcase( op==TK_IS );
2436 testcase( op==TK_ISNOT );
drhb6da74e2009-12-24 16:00:28 +00002437 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
2438 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
drh6a2fe092009-09-23 02:29:36 +00002439 op = (op==TK_IS) ? TK_EQ : TK_NE;
2440 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
2441 r1, r2, inReg, SQLITE_STOREP2 | SQLITE_NULLEQ);
2442 testcase( regFree1==0 );
2443 testcase( regFree2==0 );
2444 break;
2445 }
drhcce7d172000-05-31 15:34:51 +00002446 case TK_AND:
2447 case TK_OR:
2448 case TK_PLUS:
2449 case TK_STAR:
2450 case TK_MINUS:
drhbf4133c2001-10-13 02:59:08 +00002451 case TK_REM:
2452 case TK_BITAND:
2453 case TK_BITOR:
drh17c40292004-07-21 02:53:29 +00002454 case TK_SLASH:
drhbf4133c2001-10-13 02:59:08 +00002455 case TK_LSHIFT:
drh855eb1c2004-08-31 13:45:11 +00002456 case TK_RSHIFT:
drh00400772000-06-16 20:51:26 +00002457 case TK_CONCAT: {
drhf2bc0132004-10-04 13:19:23 +00002458 assert( TK_AND==OP_And );
2459 assert( TK_OR==OP_Or );
2460 assert( TK_PLUS==OP_Add );
2461 assert( TK_MINUS==OP_Subtract );
2462 assert( TK_REM==OP_Remainder );
2463 assert( TK_BITAND==OP_BitAnd );
2464 assert( TK_BITOR==OP_BitOr );
2465 assert( TK_SLASH==OP_Divide );
2466 assert( TK_LSHIFT==OP_ShiftLeft );
2467 assert( TK_RSHIFT==OP_ShiftRight );
2468 assert( TK_CONCAT==OP_Concat );
drhc5499be2008-04-01 15:06:33 +00002469 testcase( op==TK_AND );
2470 testcase( op==TK_OR );
2471 testcase( op==TK_PLUS );
2472 testcase( op==TK_MINUS );
2473 testcase( op==TK_REM );
2474 testcase( op==TK_BITAND );
2475 testcase( op==TK_BITOR );
2476 testcase( op==TK_SLASH );
2477 testcase( op==TK_LSHIFT );
2478 testcase( op==TK_RSHIFT );
2479 testcase( op==TK_CONCAT );
drh2dcef112008-01-12 19:03:48 +00002480 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
2481 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
drh5b6afba2008-01-05 16:29:28 +00002482 sqlite3VdbeAddOp3(v, op, r2, r1, target);
drhc5499be2008-04-01 15:06:33 +00002483 testcase( regFree1==0 );
2484 testcase( regFree2==0 );
drh00400772000-06-16 20:51:26 +00002485 break;
2486 }
drhcce7d172000-05-31 15:34:51 +00002487 case TK_UMINUS: {
drhfec19aa2004-05-19 20:41:03 +00002488 Expr *pLeft = pExpr->pLeft;
2489 assert( pLeft );
drh13573c72010-01-12 17:04:07 +00002490 if( pLeft->op==TK_INTEGER ){
2491 codeInteger(pParse, pLeft, 1, target);
2492#ifndef SQLITE_OMIT_FLOATING_POINT
2493 }else if( pLeft->op==TK_FLOAT ){
drh33e619f2009-05-28 01:00:55 +00002494 assert( !ExprHasProperty(pExpr, EP_IntValue) );
2495 codeReal(v, pLeft->u.zToken, 1, target);
drh13573c72010-01-12 17:04:07 +00002496#endif
drh3c84ddf2008-01-09 02:15:38 +00002497 }else{
drh2dcef112008-01-12 19:03:48 +00002498 regFree1 = r1 = sqlite3GetTempReg(pParse);
drh3c84ddf2008-01-09 02:15:38 +00002499 sqlite3VdbeAddOp2(v, OP_Integer, 0, r1);
drhe55cbd72008-03-31 23:48:03 +00002500 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree2);
drh2dcef112008-01-12 19:03:48 +00002501 sqlite3VdbeAddOp3(v, OP_Subtract, r2, r1, target);
drhc5499be2008-04-01 15:06:33 +00002502 testcase( regFree2==0 );
drh6e142f52000-06-08 13:36:40 +00002503 }
drh3c84ddf2008-01-09 02:15:38 +00002504 inReg = target;
2505 break;
drh6e142f52000-06-08 13:36:40 +00002506 }
drhbf4133c2001-10-13 02:59:08 +00002507 case TK_BITNOT:
drh6e142f52000-06-08 13:36:40 +00002508 case TK_NOT: {
drhf2bc0132004-10-04 13:19:23 +00002509 assert( TK_BITNOT==OP_BitNot );
2510 assert( TK_NOT==OP_Not );
drhc5499be2008-04-01 15:06:33 +00002511 testcase( op==TK_BITNOT );
2512 testcase( op==TK_NOT );
drhe99fa2a2008-12-15 15:27:51 +00002513 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
2514 testcase( regFree1==0 );
2515 inReg = target;
2516 sqlite3VdbeAddOp2(v, op, r1, inReg);
drhcce7d172000-05-31 15:34:51 +00002517 break;
2518 }
2519 case TK_ISNULL:
2520 case TK_NOTNULL: {
drh6a288a32008-01-07 19:20:24 +00002521 int addr;
drhf2bc0132004-10-04 13:19:23 +00002522 assert( TK_ISNULL==OP_IsNull );
2523 assert( TK_NOTNULL==OP_NotNull );
drhc5499be2008-04-01 15:06:33 +00002524 testcase( op==TK_ISNULL );
2525 testcase( op==TK_NOTNULL );
drh9de221d2008-01-05 06:51:30 +00002526 sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
drh2dcef112008-01-12 19:03:48 +00002527 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
drhc5499be2008-04-01 15:06:33 +00002528 testcase( regFree1==0 );
drh2dcef112008-01-12 19:03:48 +00002529 addr = sqlite3VdbeAddOp1(v, op, r1);
drh9de221d2008-01-05 06:51:30 +00002530 sqlite3VdbeAddOp2(v, OP_AddImm, target, -1);
drh6a288a32008-01-07 19:20:24 +00002531 sqlite3VdbeJumpHere(v, addr);
drhf2bc0132004-10-04 13:19:23 +00002532 break;
drhcce7d172000-05-31 15:34:51 +00002533 }
drh22827922000-06-06 17:27:05 +00002534 case TK_AGG_FUNCTION: {
drh13449892005-09-07 21:22:45 +00002535 AggInfo *pInfo = pExpr->pAggInfo;
drh7e56e712005-11-16 12:53:15 +00002536 if( pInfo==0 ){
drh33e619f2009-05-28 01:00:55 +00002537 assert( !ExprHasProperty(pExpr, EP_IntValue) );
2538 sqlite3ErrorMsg(pParse, "misuse of aggregate: %s()", pExpr->u.zToken);
drh7e56e712005-11-16 12:53:15 +00002539 }else{
drh9de221d2008-01-05 06:51:30 +00002540 inReg = pInfo->aFunc[pExpr->iAgg].iMem;
drh7e56e712005-11-16 12:53:15 +00002541 }
drh22827922000-06-06 17:27:05 +00002542 break;
2543 }
drhb71090f2005-05-23 17:26:51 +00002544 case TK_CONST_FUNC:
drhcce7d172000-05-31 15:34:51 +00002545 case TK_FUNCTION: {
drh12ffee82009-04-08 13:51:51 +00002546 ExprList *pFarg; /* List of function arguments */
2547 int nFarg; /* Number of function arguments */
2548 FuncDef *pDef; /* The function definition object */
2549 int nId; /* Length of the function name in bytes */
2550 const char *zId; /* The function name */
2551 int constMask = 0; /* Mask of function arguments that are constant */
2552 int i; /* Loop counter */
2553 u8 enc = ENC(db); /* The text encoding used by this database */
2554 CollSeq *pColl = 0; /* A collating sequence */
drh17435752007-08-16 04:30:38 +00002555
danielk19776ab3a2e2009-02-19 14:39:25 +00002556 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
drhc5499be2008-04-01 15:06:33 +00002557 testcase( op==TK_CONST_FUNC );
2558 testcase( op==TK_FUNCTION );
drhb7916a72009-05-27 10:31:29 +00002559 if( ExprHasAnyProperty(pExpr, EP_TokenOnly) ){
drh12ffee82009-04-08 13:51:51 +00002560 pFarg = 0;
2561 }else{
2562 pFarg = pExpr->x.pList;
2563 }
2564 nFarg = pFarg ? pFarg->nExpr : 0;
drh33e619f2009-05-28 01:00:55 +00002565 assert( !ExprHasProperty(pExpr, EP_IntValue) );
2566 zId = pExpr->u.zToken;
drhb7916a72009-05-27 10:31:29 +00002567 nId = sqlite3Strlen30(zId);
drh12ffee82009-04-08 13:51:51 +00002568 pDef = sqlite3FindFunction(db, zId, nId, nFarg, enc, 0);
drhfeb306f2009-08-18 16:05:46 +00002569 if( pDef==0 ){
2570 sqlite3ErrorMsg(pParse, "unknown function: %.*s()", nId, zId);
2571 break;
2572 }
drhae6bb952009-11-11 00:24:31 +00002573
2574 /* Attempt a direct implementation of the built-in COALESCE() and
2575 ** IFNULL() functions. This avoids unnecessary evalation of
2576 ** arguments past the first non-NULL argument.
2577 */
2578 if( pDef->flags & SQLITE_FUNC_COALESCE ){
2579 int endCoalesce = sqlite3VdbeMakeLabel(v);
2580 assert( nFarg>=2 );
2581 sqlite3ExprCode(pParse, pFarg->a[0].pExpr, target);
2582 for(i=1; i<nFarg; i++){
2583 sqlite3VdbeAddOp2(v, OP_NotNull, target, endCoalesce);
drhf49f3522009-12-30 14:12:38 +00002584 sqlite3ExprCacheRemove(pParse, target, 1);
drhae6bb952009-11-11 00:24:31 +00002585 sqlite3ExprCachePush(pParse);
2586 sqlite3ExprCode(pParse, pFarg->a[i].pExpr, target);
2587 sqlite3ExprCachePop(pParse, 1);
2588 }
2589 sqlite3VdbeResolveLabel(v, endCoalesce);
2590 break;
2591 }
2592
2593
drh12ffee82009-04-08 13:51:51 +00002594 if( pFarg ){
2595 r1 = sqlite3GetTempRange(pParse, nFarg);
drhd7d385d2009-09-03 01:18:00 +00002596 sqlite3ExprCachePush(pParse); /* Ticket 2ea2425d34be */
drh12ffee82009-04-08 13:51:51 +00002597 sqlite3ExprCodeExprList(pParse, pFarg, r1, 1);
drhd7d385d2009-09-03 01:18:00 +00002598 sqlite3ExprCachePop(pParse, 1); /* Ticket 2ea2425d34be */
drh892d3172008-01-10 03:46:36 +00002599 }else{
drh12ffee82009-04-08 13:51:51 +00002600 r1 = 0;
drh892d3172008-01-10 03:46:36 +00002601 }
drhb7f6f682006-07-08 17:06:43 +00002602#ifndef SQLITE_OMIT_VIRTUALTABLE
drha43fa222006-07-08 18:41:37 +00002603 /* Possibly overload the function if the first argument is
2604 ** a virtual table column.
2605 **
2606 ** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the
2607 ** second argument, not the first, as the argument to test to
2608 ** see if it is a column in a virtual table. This is done because
2609 ** the left operand of infix functions (the operand we want to
2610 ** control overloading) ends up as the second argument to the
2611 ** function. The expression "A glob B" is equivalent to
2612 ** "glob(B,A). We want to use the A in "A glob B" to test
2613 ** for function overloading. But we use the B term in "glob(B,A)".
2614 */
drh12ffee82009-04-08 13:51:51 +00002615 if( nFarg>=2 && (pExpr->flags & EP_InfixFunc) ){
2616 pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[1].pExpr);
2617 }else if( nFarg>0 ){
2618 pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[0].pExpr);
drhb7f6f682006-07-08 17:06:43 +00002619 }
2620#endif
drhf7bca572009-05-30 14:16:31 +00002621 for(i=0; i<nFarg; i++){
2622 if( i<32 && sqlite3ExprIsConstant(pFarg->a[i].pExpr) ){
drh13449892005-09-07 21:22:45 +00002623 constMask |= (1<<i);
danielk1977d02eb1f2004-06-06 09:44:03 +00002624 }
drhe82f5d02008-10-07 19:53:14 +00002625 if( (pDef->flags & SQLITE_FUNC_NEEDCOLL)!=0 && !pColl ){
drh12ffee82009-04-08 13:51:51 +00002626 pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr);
danielk1977dc1bdc42004-06-11 10:51:27 +00002627 }
2628 }
drhe82f5d02008-10-07 19:53:14 +00002629 if( pDef->flags & SQLITE_FUNC_NEEDCOLL ){
drh8b213892008-08-29 02:14:02 +00002630 if( !pColl ) pColl = db->pDfltColl;
drh66a51672008-01-03 00:01:23 +00002631 sqlite3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ);
danielk1977682f68b2004-06-05 10:22:17 +00002632 }
drh2dcef112008-01-12 19:03:48 +00002633 sqlite3VdbeAddOp4(v, OP_Function, constMask, r1, target,
drh66a51672008-01-03 00:01:23 +00002634 (char*)pDef, P4_FUNCDEF);
drh12ffee82009-04-08 13:51:51 +00002635 sqlite3VdbeChangeP5(v, (u8)nFarg);
2636 if( nFarg ){
2637 sqlite3ReleaseTempRange(pParse, r1, nFarg);
drh2dcef112008-01-12 19:03:48 +00002638 }
drhcce7d172000-05-31 15:34:51 +00002639 break;
2640 }
drhfe2093d2005-01-20 22:48:47 +00002641#ifndef SQLITE_OMIT_SUBQUERY
2642 case TK_EXISTS:
drh19a775c2000-06-05 18:54:46 +00002643 case TK_SELECT: {
drhc5499be2008-04-01 15:06:33 +00002644 testcase( op==TK_EXISTS );
2645 testcase( op==TK_SELECT );
drh1450bc62009-10-30 13:25:56 +00002646 inReg = sqlite3CodeSubselect(pParse, pExpr, 0, 0);
drh19a775c2000-06-05 18:54:46 +00002647 break;
2648 }
drhfef52082000-06-06 01:50:43 +00002649 case TK_IN: {
drhe3365e62009-11-12 17:52:24 +00002650 int destIfFalse = sqlite3VdbeMakeLabel(v);
2651 int destIfNull = sqlite3VdbeMakeLabel(v);
2652 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
2653 sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
2654 sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
2655 sqlite3VdbeResolveLabel(v, destIfFalse);
2656 sqlite3VdbeAddOp2(v, OP_AddImm, target, 0);
2657 sqlite3VdbeResolveLabel(v, destIfNull);
drhfef52082000-06-06 01:50:43 +00002658 break;
2659 }
drhe3365e62009-11-12 17:52:24 +00002660#endif /* SQLITE_OMIT_SUBQUERY */
2661
2662
drh2dcef112008-01-12 19:03:48 +00002663 /*
2664 ** x BETWEEN y AND z
2665 **
2666 ** This is equivalent to
2667 **
2668 ** x>=y AND x<=z
2669 **
2670 ** X is stored in pExpr->pLeft.
2671 ** Y is stored in pExpr->pList->a[0].pExpr.
2672 ** Z is stored in pExpr->pList->a[1].pExpr.
2673 */
drhfef52082000-06-06 01:50:43 +00002674 case TK_BETWEEN: {
drhbe5c89a2004-07-26 00:31:09 +00002675 Expr *pLeft = pExpr->pLeft;
danielk19776ab3a2e2009-02-19 14:39:25 +00002676 struct ExprList_item *pLItem = pExpr->x.pList->a;
drhbe5c89a2004-07-26 00:31:09 +00002677 Expr *pRight = pLItem->pExpr;
drh35573352008-01-08 23:54:25 +00002678
drhb6da74e2009-12-24 16:00:28 +00002679 r1 = sqlite3ExprCodeTemp(pParse, pLeft, &regFree1);
2680 r2 = sqlite3ExprCodeTemp(pParse, pRight, &regFree2);
drhc5499be2008-04-01 15:06:33 +00002681 testcase( regFree1==0 );
2682 testcase( regFree2==0 );
drh2dcef112008-01-12 19:03:48 +00002683 r3 = sqlite3GetTempReg(pParse);
drh678ccce2008-03-31 18:19:54 +00002684 r4 = sqlite3GetTempReg(pParse);
drh35573352008-01-08 23:54:25 +00002685 codeCompare(pParse, pLeft, pRight, OP_Ge,
2686 r1, r2, r3, SQLITE_STOREP2);
drhbe5c89a2004-07-26 00:31:09 +00002687 pLItem++;
2688 pRight = pLItem->pExpr;
drh2dcef112008-01-12 19:03:48 +00002689 sqlite3ReleaseTempReg(pParse, regFree2);
2690 r2 = sqlite3ExprCodeTemp(pParse, pRight, &regFree2);
drhc5499be2008-04-01 15:06:33 +00002691 testcase( regFree2==0 );
drh678ccce2008-03-31 18:19:54 +00002692 codeCompare(pParse, pLeft, pRight, OP_Le, r1, r2, r4, SQLITE_STOREP2);
2693 sqlite3VdbeAddOp3(v, OP_And, r3, r4, target);
drh2dcef112008-01-12 19:03:48 +00002694 sqlite3ReleaseTempReg(pParse, r3);
drh678ccce2008-03-31 18:19:54 +00002695 sqlite3ReleaseTempReg(pParse, r4);
drhfef52082000-06-06 01:50:43 +00002696 break;
2697 }
drh4f07e5f2007-05-14 11:34:46 +00002698 case TK_UPLUS: {
drh2dcef112008-01-12 19:03:48 +00002699 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
drha2e00042002-01-22 03:13:42 +00002700 break;
2701 }
drh2dcef112008-01-12 19:03:48 +00002702
dan165921a2009-08-28 18:53:45 +00002703 case TK_TRIGGER: {
dan65a7cd12009-09-01 12:16:01 +00002704 /* If the opcode is TK_TRIGGER, then the expression is a reference
2705 ** to a column in the new.* or old.* pseudo-tables available to
2706 ** trigger programs. In this case Expr.iTable is set to 1 for the
2707 ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
2708 ** is set to the column of the pseudo-table to read, or to -1 to
2709 ** read the rowid field.
2710 **
2711 ** The expression is implemented using an OP_Param opcode. The p1
2712 ** parameter is set to 0 for an old.rowid reference, or to (i+1)
2713 ** to reference another column of the old.* pseudo-table, where
2714 ** i is the index of the column. For a new.rowid reference, p1 is
2715 ** set to (n+1), where n is the number of columns in each pseudo-table.
2716 ** For a reference to any other column in the new.* pseudo-table, p1
2717 ** is set to (n+2+i), where n and i are as defined previously. For
2718 ** example, if the table on which triggers are being fired is
2719 ** declared as:
2720 **
2721 ** CREATE TABLE t1(a, b);
2722 **
2723 ** Then p1 is interpreted as follows:
2724 **
2725 ** p1==0 -> old.rowid p1==3 -> new.rowid
2726 ** p1==1 -> old.a p1==4 -> new.a
2727 ** p1==2 -> old.b p1==5 -> new.b
2728 */
dan2832ad42009-08-31 15:27:27 +00002729 Table *pTab = pExpr->pTab;
dan65a7cd12009-09-01 12:16:01 +00002730 int p1 = pExpr->iTable * (pTab->nCol+1) + 1 + pExpr->iColumn;
2731
2732 assert( pExpr->iTable==0 || pExpr->iTable==1 );
2733 assert( pExpr->iColumn>=-1 && pExpr->iColumn<pTab->nCol );
2734 assert( pTab->iPKey<0 || pExpr->iColumn!=pTab->iPKey );
2735 assert( p1>=0 && p1<(pTab->nCol*2+2) );
2736
2737 sqlite3VdbeAddOp2(v, OP_Param, p1, target);
dan2bd93512009-08-31 08:22:46 +00002738 VdbeComment((v, "%s.%s -> $%d",
2739 (pExpr->iTable ? "new" : "old"),
dan76d462e2009-08-30 11:42:51 +00002740 (pExpr->iColumn<0 ? "rowid" : pExpr->pTab->aCol[pExpr->iColumn].zName),
dan2bd93512009-08-31 08:22:46 +00002741 target
dan165921a2009-08-28 18:53:45 +00002742 ));
dan65a7cd12009-09-01 12:16:01 +00002743
drh44dbca82010-01-13 04:22:20 +00002744#ifndef SQLITE_OMIT_FLOATING_POINT
dan65a7cd12009-09-01 12:16:01 +00002745 /* If the column has REAL affinity, it may currently be stored as an
2746 ** integer. Use OP_RealAffinity to make sure it is really real. */
dan2832ad42009-08-31 15:27:27 +00002747 if( pExpr->iColumn>=0
2748 && pTab->aCol[pExpr->iColumn].affinity==SQLITE_AFF_REAL
2749 ){
2750 sqlite3VdbeAddOp1(v, OP_RealAffinity, target);
2751 }
drh44dbca82010-01-13 04:22:20 +00002752#endif
dan165921a2009-08-28 18:53:45 +00002753 break;
2754 }
2755
2756
drh2dcef112008-01-12 19:03:48 +00002757 /*
2758 ** Form A:
2759 ** CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
2760 **
2761 ** Form B:
2762 ** CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
2763 **
2764 ** Form A is can be transformed into the equivalent form B as follows:
2765 ** CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ...
2766 ** WHEN x=eN THEN rN ELSE y END
2767 **
2768 ** X (if it exists) is in pExpr->pLeft.
2769 ** Y is in pExpr->pRight. The Y is also optional. If there is no
2770 ** ELSE clause and no other term matches, then the result of the
2771 ** exprssion is NULL.
2772 ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1].
2773 **
2774 ** The result of the expression is the Ri for the first matching Ei,
2775 ** or if there is no matching Ei, the ELSE term Y, or if there is
2776 ** no ELSE term, NULL.
2777 */
drh33cd4902009-05-30 20:49:20 +00002778 default: assert( op==TK_CASE ); {
drh2dcef112008-01-12 19:03:48 +00002779 int endLabel; /* GOTO label for end of CASE stmt */
2780 int nextCase; /* GOTO label for next WHEN clause */
2781 int nExpr; /* 2x number of WHEN terms */
2782 int i; /* Loop counter */
2783 ExprList *pEList; /* List of WHEN terms */
2784 struct ExprList_item *aListelem; /* Array of WHEN terms */
2785 Expr opCompare; /* The X==Ei expression */
2786 Expr cacheX; /* Cached expression X */
2787 Expr *pX; /* The X expression */
drh1bd10f82008-12-10 21:19:56 +00002788 Expr *pTest = 0; /* X==Ei (form A) or just Ei (form B) */
drhceea3322009-04-23 13:22:42 +00002789 VVA_ONLY( int iCacheLevel = pParse->iCacheLevel; )
drh17a7f8d2002-03-24 13:13:27 +00002790
danielk19776ab3a2e2009-02-19 14:39:25 +00002791 assert( !ExprHasProperty(pExpr, EP_xIsSelect) && pExpr->x.pList );
2792 assert((pExpr->x.pList->nExpr % 2) == 0);
2793 assert(pExpr->x.pList->nExpr > 0);
2794 pEList = pExpr->x.pList;
drhbe5c89a2004-07-26 00:31:09 +00002795 aListelem = pEList->a;
2796 nExpr = pEList->nExpr;
drh2dcef112008-01-12 19:03:48 +00002797 endLabel = sqlite3VdbeMakeLabel(v);
2798 if( (pX = pExpr->pLeft)!=0 ){
2799 cacheX = *pX;
drh33cd4902009-05-30 20:49:20 +00002800 testcase( pX->op==TK_COLUMN );
2801 testcase( pX->op==TK_REGISTER );
drh2dcef112008-01-12 19:03:48 +00002802 cacheX.iTable = sqlite3ExprCodeTemp(pParse, pX, &regFree1);
drhc5499be2008-04-01 15:06:33 +00002803 testcase( regFree1==0 );
drh2dcef112008-01-12 19:03:48 +00002804 cacheX.op = TK_REGISTER;
2805 opCompare.op = TK_EQ;
2806 opCompare.pLeft = &cacheX;
2807 pTest = &opCompare;
drh8b1db072010-09-28 04:14:03 +00002808 /* Ticket b351d95f9cd5ef17e9d9dbae18f5ca8611190001:
2809 ** The value in regFree1 might get SCopy-ed into the file result.
2810 ** So make sure that the regFree1 register is not reused for other
2811 ** purposes and possibly overwritten. */
2812 regFree1 = 0;
drh17a7f8d2002-03-24 13:13:27 +00002813 }
drhf5905aa2002-05-26 20:54:33 +00002814 for(i=0; i<nExpr; i=i+2){
drhceea3322009-04-23 13:22:42 +00002815 sqlite3ExprCachePush(pParse);
drh2dcef112008-01-12 19:03:48 +00002816 if( pX ){
drh1bd10f82008-12-10 21:19:56 +00002817 assert( pTest!=0 );
drh2dcef112008-01-12 19:03:48 +00002818 opCompare.pRight = aListelem[i].pExpr;
drh17a7f8d2002-03-24 13:13:27 +00002819 }else{
drh2dcef112008-01-12 19:03:48 +00002820 pTest = aListelem[i].pExpr;
drh17a7f8d2002-03-24 13:13:27 +00002821 }
drh2dcef112008-01-12 19:03:48 +00002822 nextCase = sqlite3VdbeMakeLabel(v);
drh33cd4902009-05-30 20:49:20 +00002823 testcase( pTest->op==TK_COLUMN );
drh2dcef112008-01-12 19:03:48 +00002824 sqlite3ExprIfFalse(pParse, pTest, nextCase, SQLITE_JUMPIFNULL);
drhc5499be2008-04-01 15:06:33 +00002825 testcase( aListelem[i+1].pExpr->op==TK_COLUMN );
2826 testcase( aListelem[i+1].pExpr->op==TK_REGISTER );
drh9de221d2008-01-05 06:51:30 +00002827 sqlite3ExprCode(pParse, aListelem[i+1].pExpr, target);
drh2dcef112008-01-12 19:03:48 +00002828 sqlite3VdbeAddOp2(v, OP_Goto, 0, endLabel);
drhceea3322009-04-23 13:22:42 +00002829 sqlite3ExprCachePop(pParse, 1);
drh2dcef112008-01-12 19:03:48 +00002830 sqlite3VdbeResolveLabel(v, nextCase);
drhf570f012002-05-31 15:51:25 +00002831 }
drh17a7f8d2002-03-24 13:13:27 +00002832 if( pExpr->pRight ){
drhceea3322009-04-23 13:22:42 +00002833 sqlite3ExprCachePush(pParse);
drh9de221d2008-01-05 06:51:30 +00002834 sqlite3ExprCode(pParse, pExpr->pRight, target);
drhceea3322009-04-23 13:22:42 +00002835 sqlite3ExprCachePop(pParse, 1);
drh17a7f8d2002-03-24 13:13:27 +00002836 }else{
drh9de221d2008-01-05 06:51:30 +00002837 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
drh17a7f8d2002-03-24 13:13:27 +00002838 }
danielk1977c1f4a192009-04-28 12:08:15 +00002839 assert( db->mallocFailed || pParse->nErr>0
2840 || pParse->iCacheLevel==iCacheLevel );
drh2dcef112008-01-12 19:03:48 +00002841 sqlite3VdbeResolveLabel(v, endLabel);
danielk19776f349032002-06-11 02:25:40 +00002842 break;
2843 }
danielk19775338a5f2005-01-20 13:03:10 +00002844#ifndef SQLITE_OMIT_TRIGGER
danielk19776f349032002-06-11 02:25:40 +00002845 case TK_RAISE: {
dan165921a2009-08-28 18:53:45 +00002846 assert( pExpr->affinity==OE_Rollback
2847 || pExpr->affinity==OE_Abort
2848 || pExpr->affinity==OE_Fail
2849 || pExpr->affinity==OE_Ignore
2850 );
dane0af83a2009-09-08 19:15:01 +00002851 if( !pParse->pTriggerTab ){
2852 sqlite3ErrorMsg(pParse,
2853 "RAISE() may only be used within a trigger-program");
2854 return 0;
2855 }
2856 if( pExpr->affinity==OE_Abort ){
2857 sqlite3MayAbort(pParse);
2858 }
dan165921a2009-08-28 18:53:45 +00002859 assert( !ExprHasProperty(pExpr, EP_IntValue) );
dane0af83a2009-09-08 19:15:01 +00002860 if( pExpr->affinity==OE_Ignore ){
2861 sqlite3VdbeAddOp4(
2862 v, OP_Halt, SQLITE_OK, OE_Ignore, 0, pExpr->u.zToken,0);
2863 }else{
2864 sqlite3HaltConstraint(pParse, pExpr->affinity, pExpr->u.zToken, 0);
2865 }
2866
drhffe07b22005-11-03 00:41:17 +00002867 break;
drh17a7f8d2002-03-24 13:13:27 +00002868 }
danielk19775338a5f2005-01-20 13:03:10 +00002869#endif
drhffe07b22005-11-03 00:41:17 +00002870 }
drh2dcef112008-01-12 19:03:48 +00002871 sqlite3ReleaseTempReg(pParse, regFree1);
2872 sqlite3ReleaseTempReg(pParse, regFree2);
2873 return inReg;
2874}
2875
2876/*
2877** Generate code to evaluate an expression and store the results
2878** into a register. Return the register number where the results
2879** are stored.
2880**
2881** If the register is a temporary register that can be deallocated,
drh678ccce2008-03-31 18:19:54 +00002882** then write its number into *pReg. If the result register is not
drh2dcef112008-01-12 19:03:48 +00002883** a temporary, then set *pReg to zero.
2884*/
2885int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){
2886 int r1 = sqlite3GetTempReg(pParse);
2887 int r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
2888 if( r2==r1 ){
2889 *pReg = r1;
2890 }else{
2891 sqlite3ReleaseTempReg(pParse, r1);
2892 *pReg = 0;
2893 }
2894 return r2;
2895}
2896
2897/*
2898** Generate code that will evaluate expression pExpr and store the
2899** results in register target. The results are guaranteed to appear
2900** in register target.
2901*/
2902int sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){
drh9cbf3422008-01-17 16:22:13 +00002903 int inReg;
2904
2905 assert( target>0 && target<=pParse->nMem );
drhebc16712010-09-28 00:25:58 +00002906 if( pExpr && pExpr->op==TK_REGISTER ){
2907 sqlite3VdbeAddOp2(pParse->pVdbe, OP_Copy, pExpr->iTable, target);
2908 }else{
2909 inReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
2910 assert( pParse->pVdbe || pParse->db->mallocFailed );
2911 if( inReg!=target && pParse->pVdbe ){
2912 sqlite3VdbeAddOp2(pParse->pVdbe, OP_SCopy, inReg, target);
2913 }
drhcce7d172000-05-31 15:34:51 +00002914 }
drh389a1ad2008-01-03 23:44:53 +00002915 return target;
drhcce7d172000-05-31 15:34:51 +00002916}
2917
2918/*
drh2dcef112008-01-12 19:03:48 +00002919** Generate code that evalutes the given expression and puts the result
drhde4fcfd2008-01-19 23:50:26 +00002920** in register target.
drh25303782004-12-07 15:41:48 +00002921**
drh2dcef112008-01-12 19:03:48 +00002922** Also make a copy of the expression results into another "cache" register
2923** and modify the expression so that the next time it is evaluated,
2924** the result is a copy of the cache register.
2925**
2926** This routine is used for expressions that are used multiple
2927** times. They are evaluated once and the results of the expression
2928** are reused.
drh25303782004-12-07 15:41:48 +00002929*/
drh2dcef112008-01-12 19:03:48 +00002930int sqlite3ExprCodeAndCache(Parse *pParse, Expr *pExpr, int target){
drh25303782004-12-07 15:41:48 +00002931 Vdbe *v = pParse->pVdbe;
drh2dcef112008-01-12 19:03:48 +00002932 int inReg;
2933 inReg = sqlite3ExprCode(pParse, pExpr, target);
drhde4fcfd2008-01-19 23:50:26 +00002934 assert( target>0 );
drh20bc3932009-05-30 23:35:43 +00002935 /* This routine is called for terms to INSERT or UPDATE. And the only
2936 ** other place where expressions can be converted into TK_REGISTER is
2937 ** in WHERE clause processing. So as currently implemented, there is
2938 ** no way for a TK_REGISTER to exist here. But it seems prudent to
2939 ** keep the ALWAYS() in case the conditions above change with future
2940 ** modifications or enhancements. */
2941 if( ALWAYS(pExpr->op!=TK_REGISTER) ){
drh2dcef112008-01-12 19:03:48 +00002942 int iMem;
drhde4fcfd2008-01-19 23:50:26 +00002943 iMem = ++pParse->nMem;
2944 sqlite3VdbeAddOp2(v, OP_Copy, inReg, iMem);
drh2dcef112008-01-12 19:03:48 +00002945 pExpr->iTable = iMem;
dan937d0de2009-10-15 18:35:38 +00002946 pExpr->op2 = pExpr->op;
drh25303782004-12-07 15:41:48 +00002947 pExpr->op = TK_REGISTER;
2948 }
drh2dcef112008-01-12 19:03:48 +00002949 return inReg;
drh25303782004-12-07 15:41:48 +00002950}
drh2dcef112008-01-12 19:03:48 +00002951
drh7e02e5e2011-12-06 19:44:51 +00002952#if defined(SQLITE_DEBUG)
2953/*
2954** Generate a human-readable explanation of an expression tree.
2955*/
drha84203a2011-12-07 01:23:51 +00002956void sqlite3ExplainExpr(Vdbe *pOut, Expr *pExpr){
2957 int op; /* The opcode being coded */
2958 const char *zBinOp = 0; /* Binary operator */
2959 const char *zUniOp = 0; /* Unary operator */
2960 if( pExpr==0 ){
2961 op = TK_NULL;
drh7e02e5e2011-12-06 19:44:51 +00002962 }else{
drha84203a2011-12-07 01:23:51 +00002963 op = pExpr->op;
drh7e02e5e2011-12-06 19:44:51 +00002964 }
drha84203a2011-12-07 01:23:51 +00002965 switch( op ){
2966 case TK_AGG_COLUMN: {
drh04b83422011-12-07 15:33:14 +00002967 sqlite3ExplainPrintf(pOut, "AGG{%d:%d}",
2968 pExpr->iTable, pExpr->iColumn);
drha84203a2011-12-07 01:23:51 +00002969 break;
2970 }
2971 case TK_COLUMN: {
2972 if( pExpr->iTable<0 ){
2973 /* This only happens when coding check constraints */
2974 sqlite3ExplainPrintf(pOut, "COLUMN(%d)", pExpr->iColumn);
2975 }else{
drh04b83422011-12-07 15:33:14 +00002976 sqlite3ExplainPrintf(pOut, "{%d:%d}",
2977 pExpr->iTable, pExpr->iColumn);
drha84203a2011-12-07 01:23:51 +00002978 }
2979 break;
2980 }
2981 case TK_INTEGER: {
2982 if( pExpr->flags & EP_IntValue ){
drh04b83422011-12-07 15:33:14 +00002983 sqlite3ExplainPrintf(pOut, "%d", pExpr->u.iValue);
drha84203a2011-12-07 01:23:51 +00002984 }else{
drh04b83422011-12-07 15:33:14 +00002985 sqlite3ExplainPrintf(pOut, "%s", pExpr->u.zToken);
drha84203a2011-12-07 01:23:51 +00002986 }
2987 break;
2988 }
2989#ifndef SQLITE_OMIT_FLOATING_POINT
2990 case TK_FLOAT: {
drh04b83422011-12-07 15:33:14 +00002991 sqlite3ExplainPrintf(pOut,"%s", pExpr->u.zToken);
drha84203a2011-12-07 01:23:51 +00002992 break;
2993 }
2994#endif
2995 case TK_STRING: {
drh04b83422011-12-07 15:33:14 +00002996 sqlite3ExplainPrintf(pOut,"%Q", pExpr->u.zToken);
drha84203a2011-12-07 01:23:51 +00002997 break;
2998 }
2999 case TK_NULL: {
3000 sqlite3ExplainPrintf(pOut,"NULL");
3001 break;
3002 }
3003#ifndef SQLITE_OMIT_BLOB_LITERAL
3004 case TK_BLOB: {
drh04b83422011-12-07 15:33:14 +00003005 sqlite3ExplainPrintf(pOut,"%s", pExpr->u.zToken);
drha84203a2011-12-07 01:23:51 +00003006 break;
3007 }
3008#endif
3009 case TK_VARIABLE: {
3010 sqlite3ExplainPrintf(pOut,"VARIABLE(%s,%d)",
3011 pExpr->u.zToken, pExpr->iColumn);
3012 break;
3013 }
3014 case TK_REGISTER: {
3015 sqlite3ExplainPrintf(pOut,"REGISTER(%d)", pExpr->iTable);
3016 break;
3017 }
3018 case TK_AS: {
3019 sqlite3ExplainExpr(pOut, pExpr->pLeft);
3020 break;
3021 }
3022#ifndef SQLITE_OMIT_CAST
3023 case TK_CAST: {
3024 /* Expressions of the form: CAST(pLeft AS token) */
3025 const char *zAff = "unk";
3026 switch( sqlite3AffinityType(pExpr->u.zToken) ){
3027 case SQLITE_AFF_TEXT: zAff = "TEXT"; break;
3028 case SQLITE_AFF_NONE: zAff = "NONE"; break;
3029 case SQLITE_AFF_NUMERIC: zAff = "NUMERIC"; break;
3030 case SQLITE_AFF_INTEGER: zAff = "INTEGER"; break;
3031 case SQLITE_AFF_REAL: zAff = "REAL"; break;
3032 }
3033 sqlite3ExplainPrintf(pOut, "CAST-%s(", zAff);
3034 sqlite3ExplainExpr(pOut, pExpr->pLeft);
3035 sqlite3ExplainPrintf(pOut, ")");
3036 break;
3037 }
3038#endif /* SQLITE_OMIT_CAST */
3039 case TK_LT: zBinOp = "LT"; break;
3040 case TK_LE: zBinOp = "LE"; break;
3041 case TK_GT: zBinOp = "GT"; break;
3042 case TK_GE: zBinOp = "GE"; break;
3043 case TK_NE: zBinOp = "NE"; break;
3044 case TK_EQ: zBinOp = "EQ"; break;
3045 case TK_IS: zBinOp = "IS"; break;
3046 case TK_ISNOT: zBinOp = "ISNOT"; break;
3047 case TK_AND: zBinOp = "AND"; break;
3048 case TK_OR: zBinOp = "OR"; break;
3049 case TK_PLUS: zBinOp = "ADD"; break;
3050 case TK_STAR: zBinOp = "MUL"; break;
3051 case TK_MINUS: zBinOp = "SUB"; break;
3052 case TK_REM: zBinOp = "REM"; break;
3053 case TK_BITAND: zBinOp = "BITAND"; break;
3054 case TK_BITOR: zBinOp = "BITOR"; break;
3055 case TK_SLASH: zBinOp = "DIV"; break;
3056 case TK_LSHIFT: zBinOp = "LSHIFT"; break;
3057 case TK_RSHIFT: zBinOp = "RSHIFT"; break;
3058 case TK_CONCAT: zBinOp = "CONCAT"; break;
3059
3060 case TK_UMINUS: zUniOp = "UMINUS"; break;
3061 case TK_UPLUS: zUniOp = "UPLUS"; break;
3062 case TK_BITNOT: zUniOp = "BITNOT"; break;
3063 case TK_NOT: zUniOp = "NOT"; break;
3064 case TK_ISNULL: zUniOp = "ISNULL"; break;
3065 case TK_NOTNULL: zUniOp = "NOTNULL"; break;
3066
3067 case TK_AGG_FUNCTION:
3068 case TK_CONST_FUNC:
3069 case TK_FUNCTION: {
3070 ExprList *pFarg; /* List of function arguments */
3071 if( ExprHasAnyProperty(pExpr, EP_TokenOnly) ){
3072 pFarg = 0;
3073 }else{
3074 pFarg = pExpr->x.pList;
3075 }
3076 sqlite3ExplainPrintf(pOut, "%sFUNCTION:%s(",
3077 op==TK_AGG_FUNCTION ? "AGG_" : "",
3078 pExpr->u.zToken);
3079 if( pFarg ){
3080 sqlite3ExplainExprList(pOut, pFarg);
3081 }
3082 sqlite3ExplainPrintf(pOut, ")");
3083 break;
3084 }
3085#ifndef SQLITE_OMIT_SUBQUERY
3086 case TK_EXISTS: {
3087 sqlite3ExplainPrintf(pOut, "EXISTS(");
3088 sqlite3ExplainSelect(pOut, pExpr->x.pSelect);
3089 sqlite3ExplainPrintf(pOut,")");
3090 break;
3091 }
3092 case TK_SELECT: {
3093 sqlite3ExplainPrintf(pOut, "(");
3094 sqlite3ExplainSelect(pOut, pExpr->x.pSelect);
3095 sqlite3ExplainPrintf(pOut, ")");
3096 break;
3097 }
3098 case TK_IN: {
3099 sqlite3ExplainPrintf(pOut, "IN(");
3100 sqlite3ExplainExpr(pOut, pExpr->pLeft);
3101 sqlite3ExplainPrintf(pOut, ",");
3102 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
3103 sqlite3ExplainSelect(pOut, pExpr->x.pSelect);
3104 }else{
3105 sqlite3ExplainExprList(pOut, pExpr->x.pList);
3106 }
3107 sqlite3ExplainPrintf(pOut, ")");
3108 break;
3109 }
3110#endif /* SQLITE_OMIT_SUBQUERY */
3111
3112 /*
3113 ** x BETWEEN y AND z
3114 **
3115 ** This is equivalent to
3116 **
3117 ** x>=y AND x<=z
3118 **
3119 ** X is stored in pExpr->pLeft.
3120 ** Y is stored in pExpr->pList->a[0].pExpr.
3121 ** Z is stored in pExpr->pList->a[1].pExpr.
3122 */
3123 case TK_BETWEEN: {
3124 Expr *pX = pExpr->pLeft;
3125 Expr *pY = pExpr->x.pList->a[0].pExpr;
3126 Expr *pZ = pExpr->x.pList->a[1].pExpr;
3127 sqlite3ExplainPrintf(pOut, "BETWEEN(");
3128 sqlite3ExplainExpr(pOut, pX);
3129 sqlite3ExplainPrintf(pOut, ",");
3130 sqlite3ExplainExpr(pOut, pY);
3131 sqlite3ExplainPrintf(pOut, ",");
3132 sqlite3ExplainExpr(pOut, pZ);
3133 sqlite3ExplainPrintf(pOut, ")");
3134 break;
3135 }
3136 case TK_TRIGGER: {
3137 /* If the opcode is TK_TRIGGER, then the expression is a reference
3138 ** to a column in the new.* or old.* pseudo-tables available to
3139 ** trigger programs. In this case Expr.iTable is set to 1 for the
3140 ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
3141 ** is set to the column of the pseudo-table to read, or to -1 to
3142 ** read the rowid field.
3143 */
3144 sqlite3ExplainPrintf(pOut, "%s(%d)",
3145 pExpr->iTable ? "NEW" : "OLD", pExpr->iColumn);
3146 break;
3147 }
3148 case TK_CASE: {
3149 sqlite3ExplainPrintf(pOut, "CASE(");
3150 sqlite3ExplainExpr(pOut, pExpr->pLeft);
3151 sqlite3ExplainPrintf(pOut, ",");
3152 sqlite3ExplainExprList(pOut, pExpr->x.pList);
3153 break;
3154 }
3155#ifndef SQLITE_OMIT_TRIGGER
3156 case TK_RAISE: {
3157 const char *zType = "unk";
3158 switch( pExpr->affinity ){
3159 case OE_Rollback: zType = "rollback"; break;
3160 case OE_Abort: zType = "abort"; break;
3161 case OE_Fail: zType = "fail"; break;
3162 case OE_Ignore: zType = "ignore"; break;
3163 }
3164 sqlite3ExplainPrintf(pOut, "RAISE-%s(%s)", zType, pExpr->u.zToken);
3165 break;
3166 }
3167#endif
drh7e02e5e2011-12-06 19:44:51 +00003168 }
drha84203a2011-12-07 01:23:51 +00003169 if( zBinOp ){
3170 sqlite3ExplainPrintf(pOut,"%s(", zBinOp);
3171 sqlite3ExplainExpr(pOut, pExpr->pLeft);
3172 sqlite3ExplainPrintf(pOut,",");
3173 sqlite3ExplainExpr(pOut, pExpr->pRight);
3174 sqlite3ExplainPrintf(pOut,")");
3175 }else if( zUniOp ){
3176 sqlite3ExplainPrintf(pOut,"%s(", zUniOp);
3177 sqlite3ExplainExpr(pOut, pExpr->pLeft);
3178 sqlite3ExplainPrintf(pOut,")");
drh7e02e5e2011-12-06 19:44:51 +00003179 }
drh7e02e5e2011-12-06 19:44:51 +00003180}
3181#endif /* defined(SQLITE_DEBUG) */
3182
3183#if defined(SQLITE_DEBUG)
3184/*
3185** Generate a human-readable explanation of an expression list.
3186*/
3187void sqlite3ExplainExprList(Vdbe *pOut, ExprList *pList){
3188 int i;
drha84203a2011-12-07 01:23:51 +00003189 if( pList==0 || pList->nExpr==0 ){
drh7e02e5e2011-12-06 19:44:51 +00003190 sqlite3ExplainPrintf(pOut, "(empty-list)");
3191 return;
drha84203a2011-12-07 01:23:51 +00003192 }else if( pList->nExpr==1 ){
3193 sqlite3ExplainExpr(pOut, pList->a[0].pExpr);
3194 }else{
drh7e02e5e2011-12-06 19:44:51 +00003195 sqlite3ExplainPush(pOut);
drha84203a2011-12-07 01:23:51 +00003196 for(i=0; i<pList->nExpr; i++){
3197 sqlite3ExplainPrintf(pOut, "item[%d] = ", i);
3198 sqlite3ExplainPush(pOut);
3199 sqlite3ExplainExpr(pOut, pList->a[i].pExpr);
3200 sqlite3ExplainPop(pOut);
3201 if( i<pList->nExpr-1 ){
3202 sqlite3ExplainNL(pOut);
3203 }
drh7e02e5e2011-12-06 19:44:51 +00003204 }
drha84203a2011-12-07 01:23:51 +00003205 sqlite3ExplainPop(pOut);
drh7e02e5e2011-12-06 19:44:51 +00003206 }
drh7e02e5e2011-12-06 19:44:51 +00003207}
3208#endif /* SQLITE_DEBUG */
3209
drh678ccce2008-03-31 18:19:54 +00003210/*
drh47de9552008-04-01 18:04:11 +00003211** Return TRUE if pExpr is an constant expression that is appropriate
3212** for factoring out of a loop. Appropriate expressions are:
3213**
3214** * Any expression that evaluates to two or more opcodes.
3215**
3216** * Any OP_Integer, OP_Real, OP_String, OP_Blob, OP_Null,
3217** or OP_Variable that does not need to be placed in a
3218** specific register.
3219**
3220** There is no point in factoring out single-instruction constant
3221** expressions that need to be placed in a particular register.
3222** We could factor them out, but then we would end up adding an
3223** OP_SCopy instruction to move the value into the correct register
3224** later. We might as well just use the original instruction and
3225** avoid the OP_SCopy.
3226*/
3227static int isAppropriateForFactoring(Expr *p){
3228 if( !sqlite3ExprIsConstantNotJoin(p) ){
3229 return 0; /* Only constant expressions are appropriate for factoring */
3230 }
3231 if( (p->flags & EP_FixedDest)==0 ){
3232 return 1; /* Any constant without a fixed destination is appropriate */
3233 }
3234 while( p->op==TK_UPLUS ) p = p->pLeft;
3235 switch( p->op ){
3236#ifndef SQLITE_OMIT_BLOB_LITERAL
3237 case TK_BLOB:
3238#endif
3239 case TK_VARIABLE:
3240 case TK_INTEGER:
3241 case TK_FLOAT:
3242 case TK_NULL:
3243 case TK_STRING: {
3244 testcase( p->op==TK_BLOB );
3245 testcase( p->op==TK_VARIABLE );
3246 testcase( p->op==TK_INTEGER );
3247 testcase( p->op==TK_FLOAT );
3248 testcase( p->op==TK_NULL );
3249 testcase( p->op==TK_STRING );
3250 /* Single-instruction constants with a fixed destination are
3251 ** better done in-line. If we factor them, they will just end
3252 ** up generating an OP_SCopy to move the value to the destination
3253 ** register. */
3254 return 0;
3255 }
3256 case TK_UMINUS: {
drh20bc3932009-05-30 23:35:43 +00003257 if( p->pLeft->op==TK_FLOAT || p->pLeft->op==TK_INTEGER ){
3258 return 0;
3259 }
3260 break;
drh47de9552008-04-01 18:04:11 +00003261 }
3262 default: {
3263 break;
3264 }
3265 }
3266 return 1;
3267}
3268
3269/*
3270** If pExpr is a constant expression that is appropriate for
3271** factoring out of a loop, then evaluate the expression
drh678ccce2008-03-31 18:19:54 +00003272** into a register and convert the expression into a TK_REGISTER
3273** expression.
3274*/
drh7d10d5a2008-08-20 16:35:10 +00003275static int evalConstExpr(Walker *pWalker, Expr *pExpr){
3276 Parse *pParse = pWalker->pParse;
drh47de9552008-04-01 18:04:11 +00003277 switch( pExpr->op ){
drhe05c9292009-10-29 13:48:10 +00003278 case TK_IN:
drh47de9552008-04-01 18:04:11 +00003279 case TK_REGISTER: {
drh33cd4902009-05-30 20:49:20 +00003280 return WRC_Prune;
drh47de9552008-04-01 18:04:11 +00003281 }
3282 case TK_FUNCTION:
3283 case TK_AGG_FUNCTION:
3284 case TK_CONST_FUNC: {
3285 /* The arguments to a function have a fixed destination.
3286 ** Mark them this way to avoid generated unneeded OP_SCopy
3287 ** instructions.
3288 */
danielk19776ab3a2e2009-02-19 14:39:25 +00003289 ExprList *pList = pExpr->x.pList;
3290 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
drh47de9552008-04-01 18:04:11 +00003291 if( pList ){
3292 int i = pList->nExpr;
3293 struct ExprList_item *pItem = pList->a;
3294 for(; i>0; i--, pItem++){
drh33cd4902009-05-30 20:49:20 +00003295 if( ALWAYS(pItem->pExpr) ) pItem->pExpr->flags |= EP_FixedDest;
drh47de9552008-04-01 18:04:11 +00003296 }
3297 }
3298 break;
3299 }
drh678ccce2008-03-31 18:19:54 +00003300 }
drh47de9552008-04-01 18:04:11 +00003301 if( isAppropriateForFactoring(pExpr) ){
drh678ccce2008-03-31 18:19:54 +00003302 int r1 = ++pParse->nMem;
3303 int r2;
3304 r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
drh33cd4902009-05-30 20:49:20 +00003305 if( NEVER(r1!=r2) ) sqlite3ReleaseTempReg(pParse, r1);
danfcd4a152009-08-19 17:17:00 +00003306 pExpr->op2 = pExpr->op;
drh678ccce2008-03-31 18:19:54 +00003307 pExpr->op = TK_REGISTER;
3308 pExpr->iTable = r2;
drh7d10d5a2008-08-20 16:35:10 +00003309 return WRC_Prune;
drh678ccce2008-03-31 18:19:54 +00003310 }
drh7d10d5a2008-08-20 16:35:10 +00003311 return WRC_Continue;
drh678ccce2008-03-31 18:19:54 +00003312}
3313
3314/*
3315** Preevaluate constant subexpressions within pExpr and store the
3316** results in registers. Modify pExpr so that the constant subexpresions
3317** are TK_REGISTER opcodes that refer to the precomputed values.
drhf58ee7f2010-12-06 21:06:09 +00003318**
3319** This routine is a no-op if the jump to the cookie-check code has
3320** already occur. Since the cookie-check jump is generated prior to
3321** any other serious processing, this check ensures that there is no
3322** way to accidently bypass the constant initializations.
3323**
3324** This routine is also a no-op if the SQLITE_FactorOutConst optimization
3325** is disabled via the sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS)
3326** interface. This allows test logic to verify that the same answer is
3327** obtained for queries regardless of whether or not constants are
3328** precomputed into registers or if they are inserted in-line.
drh678ccce2008-03-31 18:19:54 +00003329*/
3330void sqlite3ExprCodeConstants(Parse *pParse, Expr *pExpr){
drh7d10d5a2008-08-20 16:35:10 +00003331 Walker w;
drh48b5b042010-12-06 18:50:32 +00003332 if( pParse->cookieGoto ) return;
drhf58ee7f2010-12-06 21:06:09 +00003333 if( (pParse->db->flags & SQLITE_FactorOutConst)!=0 ) return;
drh7d10d5a2008-08-20 16:35:10 +00003334 w.xExprCallback = evalConstExpr;
drhef4c0592010-12-06 18:59:13 +00003335 w.xSelectCallback = 0;
drh7d10d5a2008-08-20 16:35:10 +00003336 w.pParse = pParse;
3337 sqlite3WalkExpr(&w, pExpr);
drh678ccce2008-03-31 18:19:54 +00003338}
3339
drh25303782004-12-07 15:41:48 +00003340
3341/*
drh268380c2004-02-25 13:47:31 +00003342** Generate code that pushes the value of every element of the given
drh9cbf3422008-01-17 16:22:13 +00003343** expression list into a sequence of registers beginning at target.
drh268380c2004-02-25 13:47:31 +00003344**
drh892d3172008-01-10 03:46:36 +00003345** Return the number of elements evaluated.
drh268380c2004-02-25 13:47:31 +00003346*/
danielk19774adee202004-05-08 08:23:19 +00003347int sqlite3ExprCodeExprList(
drh268380c2004-02-25 13:47:31 +00003348 Parse *pParse, /* Parsing context */
drh389a1ad2008-01-03 23:44:53 +00003349 ExprList *pList, /* The expression list to be coded */
drh191b54c2008-04-15 12:14:21 +00003350 int target, /* Where to write results */
drhd1766112008-09-17 00:13:12 +00003351 int doHardCopy /* Make a hard copy of every element */
drh268380c2004-02-25 13:47:31 +00003352){
3353 struct ExprList_item *pItem;
drh9cbf3422008-01-17 16:22:13 +00003354 int i, n;
drh9d8b3072008-08-22 16:29:51 +00003355 assert( pList!=0 );
drh9cbf3422008-01-17 16:22:13 +00003356 assert( target>0 );
drhd81a1422010-09-28 07:11:24 +00003357 assert( pParse->pVdbe!=0 ); /* Never gets this far otherwise */
drh268380c2004-02-25 13:47:31 +00003358 n = pList->nExpr;
drh191b54c2008-04-15 12:14:21 +00003359 for(pItem=pList->a, i=0; i<n; i++, pItem++){
drh7445ffe2010-09-27 18:14:12 +00003360 Expr *pExpr = pItem->pExpr;
3361 int inReg = sqlite3ExprCodeTarget(pParse, pExpr, target+i);
drh746fd9c2010-09-28 06:00:47 +00003362 if( inReg!=target+i ){
drh7445ffe2010-09-27 18:14:12 +00003363 sqlite3VdbeAddOp2(pParse->pVdbe, doHardCopy ? OP_Copy : OP_SCopy,
3364 inReg, target+i);
drhd1766112008-09-17 00:13:12 +00003365 }
drh268380c2004-02-25 13:47:31 +00003366 }
drhf9b596e2004-05-26 16:54:42 +00003367 return n;
drh268380c2004-02-25 13:47:31 +00003368}
3369
3370/*
drh36c563a2009-11-12 13:32:22 +00003371** Generate code for a BETWEEN operator.
3372**
3373** x BETWEEN y AND z
3374**
3375** The above is equivalent to
3376**
3377** x>=y AND x<=z
3378**
3379** Code it as such, taking care to do the common subexpression
3380** elementation of x.
3381*/
3382static void exprCodeBetween(
3383 Parse *pParse, /* Parsing and code generating context */
3384 Expr *pExpr, /* The BETWEEN expression */
3385 int dest, /* Jump here if the jump is taken */
3386 int jumpIfTrue, /* Take the jump if the BETWEEN is true */
3387 int jumpIfNull /* Take the jump if the BETWEEN is NULL */
3388){
3389 Expr exprAnd; /* The AND operator in x>=y AND x<=z */
3390 Expr compLeft; /* The x>=y term */
3391 Expr compRight; /* The x<=z term */
3392 Expr exprX; /* The x subexpression */
3393 int regFree1 = 0; /* Temporary use register */
3394
3395 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
3396 exprX = *pExpr->pLeft;
3397 exprAnd.op = TK_AND;
3398 exprAnd.pLeft = &compLeft;
3399 exprAnd.pRight = &compRight;
3400 compLeft.op = TK_GE;
3401 compLeft.pLeft = &exprX;
3402 compLeft.pRight = pExpr->x.pList->a[0].pExpr;
3403 compRight.op = TK_LE;
3404 compRight.pLeft = &exprX;
3405 compRight.pRight = pExpr->x.pList->a[1].pExpr;
3406 exprX.iTable = sqlite3ExprCodeTemp(pParse, &exprX, &regFree1);
3407 exprX.op = TK_REGISTER;
3408 if( jumpIfTrue ){
3409 sqlite3ExprIfTrue(pParse, &exprAnd, dest, jumpIfNull);
3410 }else{
3411 sqlite3ExprIfFalse(pParse, &exprAnd, dest, jumpIfNull);
3412 }
3413 sqlite3ReleaseTempReg(pParse, regFree1);
3414
3415 /* Ensure adequate test coverage */
3416 testcase( jumpIfTrue==0 && jumpIfNull==0 && regFree1==0 );
3417 testcase( jumpIfTrue==0 && jumpIfNull==0 && regFree1!=0 );
3418 testcase( jumpIfTrue==0 && jumpIfNull!=0 && regFree1==0 );
3419 testcase( jumpIfTrue==0 && jumpIfNull!=0 && regFree1!=0 );
3420 testcase( jumpIfTrue!=0 && jumpIfNull==0 && regFree1==0 );
3421 testcase( jumpIfTrue!=0 && jumpIfNull==0 && regFree1!=0 );
3422 testcase( jumpIfTrue!=0 && jumpIfNull!=0 && regFree1==0 );
3423 testcase( jumpIfTrue!=0 && jumpIfNull!=0 && regFree1!=0 );
3424}
3425
3426/*
drhcce7d172000-05-31 15:34:51 +00003427** Generate code for a boolean expression such that a jump is made
3428** to the label "dest" if the expression is true but execution
3429** continues straight thru if the expression is false.
drhf5905aa2002-05-26 20:54:33 +00003430**
3431** If the expression evaluates to NULL (neither true nor false), then
drh35573352008-01-08 23:54:25 +00003432** take the jump if the jumpIfNull flag is SQLITE_JUMPIFNULL.
drhf2bc0132004-10-04 13:19:23 +00003433**
3434** This code depends on the fact that certain token values (ex: TK_EQ)
3435** are the same as opcode values (ex: OP_Eq) that implement the corresponding
3436** operation. Special comments in vdbe.c and the mkopcodeh.awk script in
3437** the make process cause these values to align. Assert()s in the code
3438** below verify that the numbers are aligned correctly.
drhcce7d172000-05-31 15:34:51 +00003439*/
danielk19774adee202004-05-08 08:23:19 +00003440void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
drhcce7d172000-05-31 15:34:51 +00003441 Vdbe *v = pParse->pVdbe;
3442 int op = 0;
drh2dcef112008-01-12 19:03:48 +00003443 int regFree1 = 0;
3444 int regFree2 = 0;
3445 int r1, r2;
3446
drh35573352008-01-08 23:54:25 +00003447 assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 );
drh33cd4902009-05-30 20:49:20 +00003448 if( NEVER(v==0) ) return; /* Existance of VDBE checked by caller */
3449 if( NEVER(pExpr==0) ) return; /* No way this can happen */
drhf2bc0132004-10-04 13:19:23 +00003450 op = pExpr->op;
3451 switch( op ){
drhcce7d172000-05-31 15:34:51 +00003452 case TK_AND: {
danielk19774adee202004-05-08 08:23:19 +00003453 int d2 = sqlite3VdbeMakeLabel(v);
drhc5499be2008-04-01 15:06:33 +00003454 testcase( jumpIfNull==0 );
drhceea3322009-04-23 13:22:42 +00003455 sqlite3ExprCachePush(pParse);
drh35573352008-01-08 23:54:25 +00003456 sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2,jumpIfNull^SQLITE_JUMPIFNULL);
danielk19774adee202004-05-08 08:23:19 +00003457 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
3458 sqlite3VdbeResolveLabel(v, d2);
drhceea3322009-04-23 13:22:42 +00003459 sqlite3ExprCachePop(pParse, 1);
drhcce7d172000-05-31 15:34:51 +00003460 break;
3461 }
3462 case TK_OR: {
drhc5499be2008-04-01 15:06:33 +00003463 testcase( jumpIfNull==0 );
danielk19774adee202004-05-08 08:23:19 +00003464 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
3465 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
drhcce7d172000-05-31 15:34:51 +00003466 break;
3467 }
3468 case TK_NOT: {
drhc5499be2008-04-01 15:06:33 +00003469 testcase( jumpIfNull==0 );
danielk19774adee202004-05-08 08:23:19 +00003470 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
drhcce7d172000-05-31 15:34:51 +00003471 break;
3472 }
3473 case TK_LT:
3474 case TK_LE:
3475 case TK_GT:
3476 case TK_GE:
3477 case TK_NE:
drh0ac65892002-04-20 14:24:41 +00003478 case TK_EQ: {
drhf2bc0132004-10-04 13:19:23 +00003479 assert( TK_LT==OP_Lt );
3480 assert( TK_LE==OP_Le );
3481 assert( TK_GT==OP_Gt );
3482 assert( TK_GE==OP_Ge );
3483 assert( TK_EQ==OP_Eq );
3484 assert( TK_NE==OP_Ne );
drhc5499be2008-04-01 15:06:33 +00003485 testcase( op==TK_LT );
3486 testcase( op==TK_LE );
3487 testcase( op==TK_GT );
3488 testcase( op==TK_GE );
3489 testcase( op==TK_EQ );
3490 testcase( op==TK_NE );
3491 testcase( jumpIfNull==0 );
drhb6da74e2009-12-24 16:00:28 +00003492 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
3493 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
drh35573352008-01-08 23:54:25 +00003494 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
drh2dcef112008-01-12 19:03:48 +00003495 r1, r2, dest, jumpIfNull);
drhc5499be2008-04-01 15:06:33 +00003496 testcase( regFree1==0 );
3497 testcase( regFree2==0 );
drhcce7d172000-05-31 15:34:51 +00003498 break;
3499 }
drh6a2fe092009-09-23 02:29:36 +00003500 case TK_IS:
3501 case TK_ISNOT: {
3502 testcase( op==TK_IS );
3503 testcase( op==TK_ISNOT );
drhb6da74e2009-12-24 16:00:28 +00003504 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
3505 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
drh6a2fe092009-09-23 02:29:36 +00003506 op = (op==TK_IS) ? TK_EQ : TK_NE;
3507 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
3508 r1, r2, dest, SQLITE_NULLEQ);
3509 testcase( regFree1==0 );
3510 testcase( regFree2==0 );
3511 break;
3512 }
drhcce7d172000-05-31 15:34:51 +00003513 case TK_ISNULL:
3514 case TK_NOTNULL: {
drhf2bc0132004-10-04 13:19:23 +00003515 assert( TK_ISNULL==OP_IsNull );
3516 assert( TK_NOTNULL==OP_NotNull );
drhc5499be2008-04-01 15:06:33 +00003517 testcase( op==TK_ISNULL );
3518 testcase( op==TK_NOTNULL );
drh2dcef112008-01-12 19:03:48 +00003519 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
3520 sqlite3VdbeAddOp2(v, op, r1, dest);
drhc5499be2008-04-01 15:06:33 +00003521 testcase( regFree1==0 );
drhcce7d172000-05-31 15:34:51 +00003522 break;
3523 }
drhfef52082000-06-06 01:50:43 +00003524 case TK_BETWEEN: {
drh5c03f302009-11-13 15:03:59 +00003525 testcase( jumpIfNull==0 );
drh36c563a2009-11-12 13:32:22 +00003526 exprCodeBetween(pParse, pExpr, dest, 1, jumpIfNull);
drhfef52082000-06-06 01:50:43 +00003527 break;
3528 }
drh84e30ca2011-02-10 17:46:14 +00003529#ifndef SQLITE_OMIT_SUBQUERY
drhe3365e62009-11-12 17:52:24 +00003530 case TK_IN: {
3531 int destIfFalse = sqlite3VdbeMakeLabel(v);
3532 int destIfNull = jumpIfNull ? dest : destIfFalse;
3533 sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
3534 sqlite3VdbeAddOp2(v, OP_Goto, 0, dest);
3535 sqlite3VdbeResolveLabel(v, destIfFalse);
3536 break;
3537 }
shanehbb201342011-02-09 19:55:20 +00003538#endif
drhcce7d172000-05-31 15:34:51 +00003539 default: {
drh2dcef112008-01-12 19:03:48 +00003540 r1 = sqlite3ExprCodeTemp(pParse, pExpr, &regFree1);
3541 sqlite3VdbeAddOp3(v, OP_If, r1, dest, jumpIfNull!=0);
drhc5499be2008-04-01 15:06:33 +00003542 testcase( regFree1==0 );
3543 testcase( jumpIfNull==0 );
drhcce7d172000-05-31 15:34:51 +00003544 break;
3545 }
3546 }
drh2dcef112008-01-12 19:03:48 +00003547 sqlite3ReleaseTempReg(pParse, regFree1);
3548 sqlite3ReleaseTempReg(pParse, regFree2);
drhcce7d172000-05-31 15:34:51 +00003549}
3550
3551/*
drh66b89c82000-11-28 20:47:17 +00003552** Generate code for a boolean expression such that a jump is made
drhcce7d172000-05-31 15:34:51 +00003553** to the label "dest" if the expression is false but execution
3554** continues straight thru if the expression is true.
drhf5905aa2002-05-26 20:54:33 +00003555**
3556** If the expression evaluates to NULL (neither true nor false) then
drh35573352008-01-08 23:54:25 +00003557** jump if jumpIfNull is SQLITE_JUMPIFNULL or fall through if jumpIfNull
3558** is 0.
drhcce7d172000-05-31 15:34:51 +00003559*/
danielk19774adee202004-05-08 08:23:19 +00003560void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
drhcce7d172000-05-31 15:34:51 +00003561 Vdbe *v = pParse->pVdbe;
3562 int op = 0;
drh2dcef112008-01-12 19:03:48 +00003563 int regFree1 = 0;
3564 int regFree2 = 0;
3565 int r1, r2;
3566
drh35573352008-01-08 23:54:25 +00003567 assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 );
drh33cd4902009-05-30 20:49:20 +00003568 if( NEVER(v==0) ) return; /* Existance of VDBE checked by caller */
3569 if( pExpr==0 ) return;
drhf2bc0132004-10-04 13:19:23 +00003570
3571 /* The value of pExpr->op and op are related as follows:
3572 **
3573 ** pExpr->op op
3574 ** --------- ----------
3575 ** TK_ISNULL OP_NotNull
3576 ** TK_NOTNULL OP_IsNull
3577 ** TK_NE OP_Eq
3578 ** TK_EQ OP_Ne
3579 ** TK_GT OP_Le
3580 ** TK_LE OP_Gt
3581 ** TK_GE OP_Lt
3582 ** TK_LT OP_Ge
3583 **
3584 ** For other values of pExpr->op, op is undefined and unused.
3585 ** The value of TK_ and OP_ constants are arranged such that we
3586 ** can compute the mapping above using the following expression.
3587 ** Assert()s verify that the computation is correct.
3588 */
3589 op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1);
3590
3591 /* Verify correct alignment of TK_ and OP_ constants
3592 */
3593 assert( pExpr->op!=TK_ISNULL || op==OP_NotNull );
3594 assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull );
3595 assert( pExpr->op!=TK_NE || op==OP_Eq );
3596 assert( pExpr->op!=TK_EQ || op==OP_Ne );
3597 assert( pExpr->op!=TK_LT || op==OP_Ge );
3598 assert( pExpr->op!=TK_LE || op==OP_Gt );
3599 assert( pExpr->op!=TK_GT || op==OP_Le );
3600 assert( pExpr->op!=TK_GE || op==OP_Lt );
3601
drhcce7d172000-05-31 15:34:51 +00003602 switch( pExpr->op ){
3603 case TK_AND: {
drhc5499be2008-04-01 15:06:33 +00003604 testcase( jumpIfNull==0 );
danielk19774adee202004-05-08 08:23:19 +00003605 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
3606 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
drhcce7d172000-05-31 15:34:51 +00003607 break;
3608 }
3609 case TK_OR: {
danielk19774adee202004-05-08 08:23:19 +00003610 int d2 = sqlite3VdbeMakeLabel(v);
drhc5499be2008-04-01 15:06:33 +00003611 testcase( jumpIfNull==0 );
drhceea3322009-04-23 13:22:42 +00003612 sqlite3ExprCachePush(pParse);
drh35573352008-01-08 23:54:25 +00003613 sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2, jumpIfNull^SQLITE_JUMPIFNULL);
danielk19774adee202004-05-08 08:23:19 +00003614 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
3615 sqlite3VdbeResolveLabel(v, d2);
drhceea3322009-04-23 13:22:42 +00003616 sqlite3ExprCachePop(pParse, 1);
drhcce7d172000-05-31 15:34:51 +00003617 break;
3618 }
3619 case TK_NOT: {
drh5c03f302009-11-13 15:03:59 +00003620 testcase( jumpIfNull==0 );
danielk19774adee202004-05-08 08:23:19 +00003621 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
drhcce7d172000-05-31 15:34:51 +00003622 break;
3623 }
3624 case TK_LT:
3625 case TK_LE:
3626 case TK_GT:
3627 case TK_GE:
3628 case TK_NE:
3629 case TK_EQ: {
drhc5499be2008-04-01 15:06:33 +00003630 testcase( op==TK_LT );
3631 testcase( op==TK_LE );
3632 testcase( op==TK_GT );
3633 testcase( op==TK_GE );
3634 testcase( op==TK_EQ );
3635 testcase( op==TK_NE );
3636 testcase( jumpIfNull==0 );
drhb6da74e2009-12-24 16:00:28 +00003637 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
3638 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
drh35573352008-01-08 23:54:25 +00003639 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
drh2dcef112008-01-12 19:03:48 +00003640 r1, r2, dest, jumpIfNull);
drhc5499be2008-04-01 15:06:33 +00003641 testcase( regFree1==0 );
3642 testcase( regFree2==0 );
drhcce7d172000-05-31 15:34:51 +00003643 break;
3644 }
drh6a2fe092009-09-23 02:29:36 +00003645 case TK_IS:
3646 case TK_ISNOT: {
drh6d4486a2009-09-23 14:45:05 +00003647 testcase( pExpr->op==TK_IS );
3648 testcase( pExpr->op==TK_ISNOT );
drhb6da74e2009-12-24 16:00:28 +00003649 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
3650 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
drh6a2fe092009-09-23 02:29:36 +00003651 op = (pExpr->op==TK_IS) ? TK_NE : TK_EQ;
3652 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
3653 r1, r2, dest, SQLITE_NULLEQ);
3654 testcase( regFree1==0 );
3655 testcase( regFree2==0 );
3656 break;
3657 }
drhcce7d172000-05-31 15:34:51 +00003658 case TK_ISNULL:
3659 case TK_NOTNULL: {
drhc5499be2008-04-01 15:06:33 +00003660 testcase( op==TK_ISNULL );
3661 testcase( op==TK_NOTNULL );
drh2dcef112008-01-12 19:03:48 +00003662 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
3663 sqlite3VdbeAddOp2(v, op, r1, dest);
drhc5499be2008-04-01 15:06:33 +00003664 testcase( regFree1==0 );
drhcce7d172000-05-31 15:34:51 +00003665 break;
3666 }
drhfef52082000-06-06 01:50:43 +00003667 case TK_BETWEEN: {
drh5c03f302009-11-13 15:03:59 +00003668 testcase( jumpIfNull==0 );
drh36c563a2009-11-12 13:32:22 +00003669 exprCodeBetween(pParse, pExpr, dest, 0, jumpIfNull);
drhfef52082000-06-06 01:50:43 +00003670 break;
3671 }
drh84e30ca2011-02-10 17:46:14 +00003672#ifndef SQLITE_OMIT_SUBQUERY
drhe3365e62009-11-12 17:52:24 +00003673 case TK_IN: {
3674 if( jumpIfNull ){
3675 sqlite3ExprCodeIN(pParse, pExpr, dest, dest);
3676 }else{
3677 int destIfNull = sqlite3VdbeMakeLabel(v);
3678 sqlite3ExprCodeIN(pParse, pExpr, dest, destIfNull);
3679 sqlite3VdbeResolveLabel(v, destIfNull);
3680 }
3681 break;
3682 }
shanehbb201342011-02-09 19:55:20 +00003683#endif
drhcce7d172000-05-31 15:34:51 +00003684 default: {
drh2dcef112008-01-12 19:03:48 +00003685 r1 = sqlite3ExprCodeTemp(pParse, pExpr, &regFree1);
3686 sqlite3VdbeAddOp3(v, OP_IfNot, r1, dest, jumpIfNull!=0);
drhc5499be2008-04-01 15:06:33 +00003687 testcase( regFree1==0 );
3688 testcase( jumpIfNull==0 );
drhcce7d172000-05-31 15:34:51 +00003689 break;
3690 }
3691 }
drh2dcef112008-01-12 19:03:48 +00003692 sqlite3ReleaseTempReg(pParse, regFree1);
3693 sqlite3ReleaseTempReg(pParse, regFree2);
drhcce7d172000-05-31 15:34:51 +00003694}
drh22827922000-06-06 17:27:05 +00003695
3696/*
drh1d9da702010-01-07 15:17:02 +00003697** Do a deep comparison of two expression trees. Return 0 if the two
3698** expressions are completely identical. Return 1 if they differ only
3699** by a COLLATE operator at the top level. Return 2 if there are differences
3700** other than the top-level COLLATE operator.
drhd40aab02007-02-24 15:29:03 +00003701**
drh1d9da702010-01-07 15:17:02 +00003702** Sometimes this routine will return 2 even if the two expressions
drhd40aab02007-02-24 15:29:03 +00003703** really are equivalent. If we cannot prove that the expressions are
drh1d9da702010-01-07 15:17:02 +00003704** identical, we return 2 just to be safe. So if this routine
3705** returns 2, then you do not really know for certain if the two
3706** expressions are the same. But if you get a 0 or 1 return, then you
drhd40aab02007-02-24 15:29:03 +00003707** can be sure the expressions are the same. In the places where
drh1d9da702010-01-07 15:17:02 +00003708** this routine is used, it does not hurt to get an extra 2 - that
drhd40aab02007-02-24 15:29:03 +00003709** just might result in some slightly slower code. But returning
drh1d9da702010-01-07 15:17:02 +00003710** an incorrect 0 or 1 could lead to a malfunction.
drh22827922000-06-06 17:27:05 +00003711*/
danielk19774adee202004-05-08 08:23:19 +00003712int sqlite3ExprCompare(Expr *pA, Expr *pB){
danielk19774b202ae2006-01-23 05:50:58 +00003713 if( pA==0||pB==0 ){
drh1d9da702010-01-07 15:17:02 +00003714 return pB==pA ? 0 : 2;
drh22827922000-06-06 17:27:05 +00003715 }
drh33e619f2009-05-28 01:00:55 +00003716 assert( !ExprHasAnyProperty(pA, EP_TokenOnly|EP_Reduced) );
3717 assert( !ExprHasAnyProperty(pB, EP_TokenOnly|EP_Reduced) );
danielk19776ab3a2e2009-02-19 14:39:25 +00003718 if( ExprHasProperty(pA, EP_xIsSelect) || ExprHasProperty(pB, EP_xIsSelect) ){
drh1d9da702010-01-07 15:17:02 +00003719 return 2;
drh22827922000-06-06 17:27:05 +00003720 }
drh1d9da702010-01-07 15:17:02 +00003721 if( (pA->flags & EP_Distinct)!=(pB->flags & EP_Distinct) ) return 2;
3722 if( pA->op!=pB->op ) return 2;
3723 if( sqlite3ExprCompare(pA->pLeft, pB->pLeft) ) return 2;
3724 if( sqlite3ExprCompare(pA->pRight, pB->pRight) ) return 2;
drh8c6f6662010-04-26 19:17:26 +00003725 if( sqlite3ExprListCompare(pA->x.pList, pB->x.pList) ) return 2;
drh1d9da702010-01-07 15:17:02 +00003726 if( pA->iTable!=pB->iTable || pA->iColumn!=pB->iColumn ) return 2;
drh33e619f2009-05-28 01:00:55 +00003727 if( ExprHasProperty(pA, EP_IntValue) ){
3728 if( !ExprHasProperty(pB, EP_IntValue) || pA->u.iValue!=pB->u.iValue ){
drh1d9da702010-01-07 15:17:02 +00003729 return 2;
drh33e619f2009-05-28 01:00:55 +00003730 }
3731 }else if( pA->op!=TK_COLUMN && pA->u.zToken ){
drh1d9da702010-01-07 15:17:02 +00003732 if( ExprHasProperty(pB, EP_IntValue) || NEVER(pB->u.zToken==0) ) return 2;
drh6b93c9a2011-10-13 15:35:52 +00003733 if( strcmp(pA->u.zToken,pB->u.zToken)!=0 ){
drh1d9da702010-01-07 15:17:02 +00003734 return 2;
drh2646da72005-12-09 20:02:05 +00003735 }
drh22827922000-06-06 17:27:05 +00003736 }
drh1d9da702010-01-07 15:17:02 +00003737 if( (pA->flags & EP_ExpCollate)!=(pB->flags & EP_ExpCollate) ) return 1;
3738 if( (pA->flags & EP_ExpCollate)!=0 && pA->pColl!=pB->pColl ) return 2;
3739 return 0;
drh22827922000-06-06 17:27:05 +00003740}
3741
drh8c6f6662010-04-26 19:17:26 +00003742/*
3743** Compare two ExprList objects. Return 0 if they are identical and
3744** non-zero if they differ in any way.
3745**
3746** This routine might return non-zero for equivalent ExprLists. The
3747** only consequence will be disabled optimizations. But this routine
3748** must never return 0 if the two ExprList objects are different, or
3749** a malfunction will result.
3750**
3751** Two NULL pointers are considered to be the same. But a NULL pointer
3752** always differs from a non-NULL pointer.
3753*/
3754int sqlite3ExprListCompare(ExprList *pA, ExprList *pB){
3755 int i;
3756 if( pA==0 && pB==0 ) return 0;
3757 if( pA==0 || pB==0 ) return 1;
3758 if( pA->nExpr!=pB->nExpr ) return 1;
3759 for(i=0; i<pA->nExpr; i++){
3760 Expr *pExprA = pA->a[i].pExpr;
3761 Expr *pExprB = pB->a[i].pExpr;
3762 if( pA->a[i].sortOrder!=pB->a[i].sortOrder ) return 1;
3763 if( sqlite3ExprCompare(pExprA, pExprB) ) return 1;
3764 }
3765 return 0;
3766}
drh13449892005-09-07 21:22:45 +00003767
drh22827922000-06-06 17:27:05 +00003768/*
drh13449892005-09-07 21:22:45 +00003769** Add a new element to the pAggInfo->aCol[] array. Return the index of
3770** the new element. Return a negative number if malloc fails.
drh22827922000-06-06 17:27:05 +00003771*/
drh17435752007-08-16 04:30:38 +00003772static int addAggInfoColumn(sqlite3 *db, AggInfo *pInfo){
drh13449892005-09-07 21:22:45 +00003773 int i;
drhcf643722007-03-27 13:36:37 +00003774 pInfo->aCol = sqlite3ArrayAllocate(
drh17435752007-08-16 04:30:38 +00003775 db,
drhcf643722007-03-27 13:36:37 +00003776 pInfo->aCol,
3777 sizeof(pInfo->aCol[0]),
3778 3,
3779 &pInfo->nColumn,
3780 &pInfo->nColumnAlloc,
3781 &i
3782 );
drh13449892005-09-07 21:22:45 +00003783 return i;
3784}
3785
3786/*
3787** Add a new element to the pAggInfo->aFunc[] array. Return the index of
3788** the new element. Return a negative number if malloc fails.
3789*/
drh17435752007-08-16 04:30:38 +00003790static int addAggInfoFunc(sqlite3 *db, AggInfo *pInfo){
drh13449892005-09-07 21:22:45 +00003791 int i;
drhcf643722007-03-27 13:36:37 +00003792 pInfo->aFunc = sqlite3ArrayAllocate(
drh17435752007-08-16 04:30:38 +00003793 db,
drhcf643722007-03-27 13:36:37 +00003794 pInfo->aFunc,
3795 sizeof(pInfo->aFunc[0]),
3796 3,
3797 &pInfo->nFunc,
3798 &pInfo->nFuncAlloc,
3799 &i
3800 );
drh13449892005-09-07 21:22:45 +00003801 return i;
3802}
drh22827922000-06-06 17:27:05 +00003803
3804/*
drh7d10d5a2008-08-20 16:35:10 +00003805** This is the xExprCallback for a tree walker. It is used to
3806** implement sqlite3ExprAnalyzeAggregates(). See sqlite3ExprAnalyzeAggregates
drh626a8792005-01-17 22:08:19 +00003807** for additional information.
drh22827922000-06-06 17:27:05 +00003808*/
drh7d10d5a2008-08-20 16:35:10 +00003809static int analyzeAggregate(Walker *pWalker, Expr *pExpr){
drh22827922000-06-06 17:27:05 +00003810 int i;
drh7d10d5a2008-08-20 16:35:10 +00003811 NameContext *pNC = pWalker->u.pNC;
danielk1977a58fdfb2005-02-08 07:50:40 +00003812 Parse *pParse = pNC->pParse;
3813 SrcList *pSrcList = pNC->pSrcList;
drh13449892005-09-07 21:22:45 +00003814 AggInfo *pAggInfo = pNC->pAggInfo;
drh22827922000-06-06 17:27:05 +00003815
drh22827922000-06-06 17:27:05 +00003816 switch( pExpr->op ){
drh89c69d02007-01-04 01:20:28 +00003817 case TK_AGG_COLUMN:
drh967e8b72000-06-21 13:59:10 +00003818 case TK_COLUMN: {
drh8b213892008-08-29 02:14:02 +00003819 testcase( pExpr->op==TK_AGG_COLUMN );
3820 testcase( pExpr->op==TK_COLUMN );
drh13449892005-09-07 21:22:45 +00003821 /* Check to see if the column is in one of the tables in the FROM
3822 ** clause of the aggregate query */
drh20bc3932009-05-30 23:35:43 +00003823 if( ALWAYS(pSrcList!=0) ){
drh13449892005-09-07 21:22:45 +00003824 struct SrcList_item *pItem = pSrcList->a;
3825 for(i=0; i<pSrcList->nSrc; i++, pItem++){
3826 struct AggInfo_col *pCol;
drh33e619f2009-05-28 01:00:55 +00003827 assert( !ExprHasAnyProperty(pExpr, EP_TokenOnly|EP_Reduced) );
drh13449892005-09-07 21:22:45 +00003828 if( pExpr->iTable==pItem->iCursor ){
3829 /* If we reach this point, it means that pExpr refers to a table
3830 ** that is in the FROM clause of the aggregate query.
3831 **
3832 ** Make an entry for the column in pAggInfo->aCol[] if there
3833 ** is not an entry there already.
3834 */
drh7f906d62007-03-12 23:48:52 +00003835 int k;
drh13449892005-09-07 21:22:45 +00003836 pCol = pAggInfo->aCol;
drh7f906d62007-03-12 23:48:52 +00003837 for(k=0; k<pAggInfo->nColumn; k++, pCol++){
drh13449892005-09-07 21:22:45 +00003838 if( pCol->iTable==pExpr->iTable &&
3839 pCol->iColumn==pExpr->iColumn ){
3840 break;
3841 }
danielk1977a58fdfb2005-02-08 07:50:40 +00003842 }
danielk19771e536952007-08-16 10:09:01 +00003843 if( (k>=pAggInfo->nColumn)
3844 && (k = addAggInfoColumn(pParse->db, pAggInfo))>=0
3845 ){
drh7f906d62007-03-12 23:48:52 +00003846 pCol = &pAggInfo->aCol[k];
danielk19770817d0d2007-02-14 09:19:36 +00003847 pCol->pTab = pExpr->pTab;
drh13449892005-09-07 21:22:45 +00003848 pCol->iTable = pExpr->iTable;
3849 pCol->iColumn = pExpr->iColumn;
drh0a07c102008-01-03 18:03:08 +00003850 pCol->iMem = ++pParse->nMem;
drh13449892005-09-07 21:22:45 +00003851 pCol->iSorterColumn = -1;
drh5774b802005-09-07 22:48:16 +00003852 pCol->pExpr = pExpr;
drh13449892005-09-07 21:22:45 +00003853 if( pAggInfo->pGroupBy ){
3854 int j, n;
3855 ExprList *pGB = pAggInfo->pGroupBy;
3856 struct ExprList_item *pTerm = pGB->a;
3857 n = pGB->nExpr;
3858 for(j=0; j<n; j++, pTerm++){
3859 Expr *pE = pTerm->pExpr;
3860 if( pE->op==TK_COLUMN && pE->iTable==pExpr->iTable &&
3861 pE->iColumn==pExpr->iColumn ){
3862 pCol->iSorterColumn = j;
3863 break;
3864 }
3865 }
3866 }
3867 if( pCol->iSorterColumn<0 ){
3868 pCol->iSorterColumn = pAggInfo->nSortingColumn++;
3869 }
3870 }
3871 /* There is now an entry for pExpr in pAggInfo->aCol[] (either
3872 ** because it was there before or because we just created it).
3873 ** Convert the pExpr to be a TK_AGG_COLUMN referring to that
3874 ** pAggInfo->aCol[] entry.
3875 */
drh33e619f2009-05-28 01:00:55 +00003876 ExprSetIrreducible(pExpr);
drh13449892005-09-07 21:22:45 +00003877 pExpr->pAggInfo = pAggInfo;
3878 pExpr->op = TK_AGG_COLUMN;
shanecf697392009-06-01 16:53:09 +00003879 pExpr->iAgg = (i16)k;
drh13449892005-09-07 21:22:45 +00003880 break;
3881 } /* endif pExpr->iTable==pItem->iCursor */
3882 } /* end loop over pSrcList */
drh22827922000-06-06 17:27:05 +00003883 }
drh7d10d5a2008-08-20 16:35:10 +00003884 return WRC_Prune;
drh22827922000-06-06 17:27:05 +00003885 }
3886 case TK_AGG_FUNCTION: {
drh13449892005-09-07 21:22:45 +00003887 /* The pNC->nDepth==0 test causes aggregate functions in subqueries
3888 ** to be ignored */
danielk1977a58fdfb2005-02-08 07:50:40 +00003889 if( pNC->nDepth==0 ){
drh13449892005-09-07 21:22:45 +00003890 /* Check to see if pExpr is a duplicate of another aggregate
3891 ** function that is already in the pAggInfo structure
3892 */
3893 struct AggInfo_func *pItem = pAggInfo->aFunc;
3894 for(i=0; i<pAggInfo->nFunc; i++, pItem++){
drh1d9da702010-01-07 15:17:02 +00003895 if( sqlite3ExprCompare(pItem->pExpr, pExpr)==0 ){
danielk1977a58fdfb2005-02-08 07:50:40 +00003896 break;
3897 }
drh22827922000-06-06 17:27:05 +00003898 }
drh13449892005-09-07 21:22:45 +00003899 if( i>=pAggInfo->nFunc ){
3900 /* pExpr is original. Make a new entry in pAggInfo->aFunc[]
3901 */
danielk197714db2662006-01-09 16:12:04 +00003902 u8 enc = ENC(pParse->db);
danielk19771e536952007-08-16 10:09:01 +00003903 i = addAggInfoFunc(pParse->db, pAggInfo);
drh13449892005-09-07 21:22:45 +00003904 if( i>=0 ){
danielk19776ab3a2e2009-02-19 14:39:25 +00003905 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
drh13449892005-09-07 21:22:45 +00003906 pItem = &pAggInfo->aFunc[i];
3907 pItem->pExpr = pExpr;
drh0a07c102008-01-03 18:03:08 +00003908 pItem->iMem = ++pParse->nMem;
drh33e619f2009-05-28 01:00:55 +00003909 assert( !ExprHasProperty(pExpr, EP_IntValue) );
drh13449892005-09-07 21:22:45 +00003910 pItem->pFunc = sqlite3FindFunction(pParse->db,
drh33e619f2009-05-28 01:00:55 +00003911 pExpr->u.zToken, sqlite3Strlen30(pExpr->u.zToken),
danielk19776ab3a2e2009-02-19 14:39:25 +00003912 pExpr->x.pList ? pExpr->x.pList->nExpr : 0, enc, 0);
drhfd357972005-09-09 01:33:19 +00003913 if( pExpr->flags & EP_Distinct ){
3914 pItem->iDistinct = pParse->nTab++;
3915 }else{
3916 pItem->iDistinct = -1;
3917 }
drh13449892005-09-07 21:22:45 +00003918 }
danielk1977a58fdfb2005-02-08 07:50:40 +00003919 }
drh13449892005-09-07 21:22:45 +00003920 /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry
3921 */
drh33e619f2009-05-28 01:00:55 +00003922 assert( !ExprHasAnyProperty(pExpr, EP_TokenOnly|EP_Reduced) );
3923 ExprSetIrreducible(pExpr);
shanecf697392009-06-01 16:53:09 +00003924 pExpr->iAgg = (i16)i;
drh13449892005-09-07 21:22:45 +00003925 pExpr->pAggInfo = pAggInfo;
drh7d10d5a2008-08-20 16:35:10 +00003926 return WRC_Prune;
drh22827922000-06-06 17:27:05 +00003927 }
drh22827922000-06-06 17:27:05 +00003928 }
3929 }
drh7d10d5a2008-08-20 16:35:10 +00003930 return WRC_Continue;
3931}
3932static int analyzeAggregatesInSelect(Walker *pWalker, Select *pSelect){
3933 NameContext *pNC = pWalker->u.pNC;
3934 if( pNC->nDepth==0 ){
danielk1977a58fdfb2005-02-08 07:50:40 +00003935 pNC->nDepth++;
drh7d10d5a2008-08-20 16:35:10 +00003936 sqlite3WalkSelect(pWalker, pSelect);
danielk1977a58fdfb2005-02-08 07:50:40 +00003937 pNC->nDepth--;
drh7d10d5a2008-08-20 16:35:10 +00003938 return WRC_Prune;
3939 }else{
3940 return WRC_Continue;
danielk1977a58fdfb2005-02-08 07:50:40 +00003941 }
drh626a8792005-01-17 22:08:19 +00003942}
3943
3944/*
3945** Analyze the given expression looking for aggregate functions and
3946** for variables that need to be added to the pParse->aAgg[] array.
3947** Make additional entries to the pParse->aAgg[] array as necessary.
3948**
3949** This routine should only be called after the expression has been
drh7d10d5a2008-08-20 16:35:10 +00003950** analyzed by sqlite3ResolveExprNames().
drh626a8792005-01-17 22:08:19 +00003951*/
drhd2b3e232008-01-23 14:51:49 +00003952void sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){
drh7d10d5a2008-08-20 16:35:10 +00003953 Walker w;
3954 w.xExprCallback = analyzeAggregate;
3955 w.xSelectCallback = analyzeAggregatesInSelect;
3956 w.u.pNC = pNC;
drh20bc3932009-05-30 23:35:43 +00003957 assert( pNC->pSrcList!=0 );
drh7d10d5a2008-08-20 16:35:10 +00003958 sqlite3WalkExpr(&w, pExpr);
drh22827922000-06-06 17:27:05 +00003959}
drh5d9a4af2005-08-30 00:54:01 +00003960
3961/*
3962** Call sqlite3ExprAnalyzeAggregates() for every expression in an
3963** expression list. Return the number of errors.
3964**
3965** If an error is found, the analysis is cut short.
3966*/
drhd2b3e232008-01-23 14:51:49 +00003967void sqlite3ExprAnalyzeAggList(NameContext *pNC, ExprList *pList){
drh5d9a4af2005-08-30 00:54:01 +00003968 struct ExprList_item *pItem;
3969 int i;
drh5d9a4af2005-08-30 00:54:01 +00003970 if( pList ){
drhd2b3e232008-01-23 14:51:49 +00003971 for(pItem=pList->a, i=0; i<pList->nExpr; i++, pItem++){
3972 sqlite3ExprAnalyzeAggregates(pNC, pItem->pExpr);
drh5d9a4af2005-08-30 00:54:01 +00003973 }
3974 }
drh5d9a4af2005-08-30 00:54:01 +00003975}
drh892d3172008-01-10 03:46:36 +00003976
3977/*
drhceea3322009-04-23 13:22:42 +00003978** Allocate a single new register for use to hold some intermediate result.
drh892d3172008-01-10 03:46:36 +00003979*/
3980int sqlite3GetTempReg(Parse *pParse){
drhe55cbd72008-03-31 23:48:03 +00003981 if( pParse->nTempReg==0 ){
drh892d3172008-01-10 03:46:36 +00003982 return ++pParse->nMem;
3983 }
danielk19772f425f62008-07-04 09:41:39 +00003984 return pParse->aTempReg[--pParse->nTempReg];
drh892d3172008-01-10 03:46:36 +00003985}
drhceea3322009-04-23 13:22:42 +00003986
3987/*
3988** Deallocate a register, making available for reuse for some other
3989** purpose.
3990**
3991** If a register is currently being used by the column cache, then
3992** the dallocation is deferred until the column cache line that uses
3993** the register becomes stale.
3994*/
drh892d3172008-01-10 03:46:36 +00003995void sqlite3ReleaseTempReg(Parse *pParse, int iReg){
drh2dcef112008-01-12 19:03:48 +00003996 if( iReg && pParse->nTempReg<ArraySize(pParse->aTempReg) ){
drhceea3322009-04-23 13:22:42 +00003997 int i;
3998 struct yColCache *p;
3999 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
4000 if( p->iReg==iReg ){
4001 p->tempReg = 1;
4002 return;
4003 }
4004 }
drh892d3172008-01-10 03:46:36 +00004005 pParse->aTempReg[pParse->nTempReg++] = iReg;
4006 }
4007}
4008
4009/*
4010** Allocate or deallocate a block of nReg consecutive registers
4011*/
4012int sqlite3GetTempRange(Parse *pParse, int nReg){
drhe55cbd72008-03-31 23:48:03 +00004013 int i, n;
4014 i = pParse->iRangeReg;
4015 n = pParse->nRangeReg;
drhf49f3522009-12-30 14:12:38 +00004016 if( nReg<=n ){
4017 assert( !usedAsColumnCache(pParse, i, i+n-1) );
drh892d3172008-01-10 03:46:36 +00004018 pParse->iRangeReg += nReg;
4019 pParse->nRangeReg -= nReg;
4020 }else{
4021 i = pParse->nMem+1;
4022 pParse->nMem += nReg;
4023 }
4024 return i;
4025}
4026void sqlite3ReleaseTempRange(Parse *pParse, int iReg, int nReg){
drhf49f3522009-12-30 14:12:38 +00004027 sqlite3ExprCacheRemove(pParse, iReg, nReg);
drh892d3172008-01-10 03:46:36 +00004028 if( nReg>pParse->nRangeReg ){
4029 pParse->nRangeReg = nReg;
4030 pParse->iRangeReg = iReg;
4031 }
4032}
drhcdc69552011-12-06 13:24:59 +00004033
4034/*
4035** Mark all temporary registers as being unavailable for reuse.
4036*/
4037void sqlite3ClearTempRegCache(Parse *pParse){
4038 pParse->nTempReg = 0;
4039 pParse->nRangeReg = 0;
4040}