blob: ce6e295787fbb6caf74a33a27d48ed3307217494 [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/*
drh8b4c40d2007-02-01 23:02:45 +000059** Set the collating sequence for expression pExpr to be the collating
drhae80dde2012-12-06 21:16:43 +000060** sequence named by pToken. Return a pointer to a new Expr node that
61** implements the COLLATE operator.
drh0a8a4062012-12-07 18:38:16 +000062**
63** If a memory allocation error occurs, that fact is recorded in pParse->db
64** and the pExpr parameter is returned unchanged.
drh8b4c40d2007-02-01 23:02:45 +000065*/
drh0a8a4062012-12-07 18:38:16 +000066Expr *sqlite3ExprAddCollateToken(Parse *pParse, Expr *pExpr, Token *pCollName){
67 if( pCollName->n>0 ){
68 Expr *pNew = sqlite3ExprAlloc(pParse->db, TK_COLLATE, pCollName, 1);
69 if( pNew ){
70 pNew->pLeft = pExpr;
71 pNew->flags |= EP_Collate;
72 pExpr = pNew;
73 }
drhae80dde2012-12-06 21:16:43 +000074 }
drh0a8a4062012-12-07 18:38:16 +000075 return pExpr;
76}
77Expr *sqlite3ExprAddCollateString(Parse *pParse, Expr *pExpr, const char *zC){
78 if( zC ){
79 Token s;
80 s.z = zC;
81 s.n = sqlite3Strlen30(s.z);
82 pExpr = sqlite3ExprAddCollateToken(pParse, pExpr, &s);
83 }
84 return pExpr;
85}
86
87/*
88** Skip over any TK_COLLATE operator in an expression.
89*/
90Expr *sqlite3ExprSkipCollate(Expr *pExpr){
91 if( pExpr && pExpr->op==TK_COLLATE ) pExpr = pExpr->pLeft;
92 return pExpr;
drh8b4c40d2007-02-01 23:02:45 +000093}
94
95/*
drhae80dde2012-12-06 21:16:43 +000096** Return the collation sequence for the expression pExpr. If
97** there is no defined collating sequence, return NULL.
98**
99** The collating sequence might be determined by a COLLATE operator
100** or by the presence of a column with a defined collating sequence.
101** COLLATE operators take first precedence. Left operands take
102** precedence over right operands.
danielk19770202b292004-06-09 09:55:16 +0000103*/
danielk19777cedc8d2004-06-10 10:50:08 +0000104CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr){
drhae80dde2012-12-06 21:16:43 +0000105 sqlite3 *db = pParse->db;
danielk19777cedc8d2004-06-10 10:50:08 +0000106 CollSeq *pColl = 0;
drh7d10d5a2008-08-20 16:35:10 +0000107 Expr *p = pExpr;
drhae80dde2012-12-06 21:16:43 +0000108 while( p && pColl==0 ){
109 int op = p->op;
110 if( op==TK_CAST || op==TK_UPLUS ){
111 p = p->pLeft;
112 continue;
113 }
114 if( op==TK_COLLATE ){
drh7a66da12012-12-07 20:31:11 +0000115 pColl = sqlite3GetCollSeq(pParse, ENC(db), 0, p->u.zToken);
drhae80dde2012-12-06 21:16:43 +0000116 break;
117 }
118 if( p->pTab!=0
119 && (op==TK_AGG_COLUMN || op==TK_COLUMN
120 || op==TK_REGISTER || op==TK_TRIGGER)
121 ){
drh7d10d5a2008-08-20 16:35:10 +0000122 /* op==TK_REGISTER && p->pTab!=0 happens when pExpr was originally
123 ** a TK_COLUMN but was previously evaluated and cached in a register */
drh7d10d5a2008-08-20 16:35:10 +0000124 int j = p->iColumn;
125 if( j>=0 ){
drhae80dde2012-12-06 21:16:43 +0000126 const char *zColl = p->pTab->aCol[j].zColl;
drhc4a64fa2009-05-11 20:53:28 +0000127 pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0);
drh7d10d5a2008-08-20 16:35:10 +0000128 }
129 break;
danielk19770202b292004-06-09 09:55:16 +0000130 }
drhae80dde2012-12-06 21:16:43 +0000131 if( p->flags & EP_Collate ){
drh4b17cf52012-12-07 14:02:14 +0000132 if( p->pLeft && (p->pLeft->flags & EP_Collate)!=0 ){
drhae80dde2012-12-06 21:16:43 +0000133 p = p->pLeft;
134 }else{
135 p = p->pRight;
136 }
137 }else{
drh7d10d5a2008-08-20 16:35:10 +0000138 break;
139 }
danielk19770202b292004-06-09 09:55:16 +0000140 }
danielk19777cedc8d2004-06-10 10:50:08 +0000141 if( sqlite3CheckCollSeq(pParse, pColl) ){
142 pColl = 0;
143 }
144 return pColl;
danielk19770202b292004-06-09 09:55:16 +0000145}
146
147/*
drh626a8792005-01-17 22:08:19 +0000148** pExpr is an operand of a comparison operator. aff2 is the
149** type affinity of the other operand. This routine returns the
drh53db1452004-05-20 13:54:53 +0000150** type affinity that should be used for the comparison operator.
151*/
danielk1977e014a832004-05-17 10:48:57 +0000152char sqlite3CompareAffinity(Expr *pExpr, char aff2){
danielk1977bf3b7212004-05-18 10:06:24 +0000153 char aff1 = sqlite3ExprAffinity(pExpr);
danielk1977e014a832004-05-17 10:48:57 +0000154 if( aff1 && aff2 ){
drh8df447f2005-11-01 15:48:24 +0000155 /* Both sides of the comparison are columns. If one has numeric
156 ** affinity, use that. Otherwise use no affinity.
danielk1977e014a832004-05-17 10:48:57 +0000157 */
drh8a512562005-11-14 22:29:05 +0000158 if( sqlite3IsNumericAffinity(aff1) || sqlite3IsNumericAffinity(aff2) ){
danielk1977e014a832004-05-17 10:48:57 +0000159 return SQLITE_AFF_NUMERIC;
160 }else{
161 return SQLITE_AFF_NONE;
162 }
163 }else if( !aff1 && !aff2 ){
drh5f6a87b2004-07-19 00:39:45 +0000164 /* Neither side of the comparison is a column. Compare the
165 ** results directly.
danielk1977e014a832004-05-17 10:48:57 +0000166 */
drh5f6a87b2004-07-19 00:39:45 +0000167 return SQLITE_AFF_NONE;
danielk1977e014a832004-05-17 10:48:57 +0000168 }else{
169 /* One side is a column, the other is not. Use the columns affinity. */
drhfe05af82005-07-21 03:14:59 +0000170 assert( aff1==0 || aff2==0 );
danielk1977e014a832004-05-17 10:48:57 +0000171 return (aff1 + aff2);
172 }
173}
174
drh53db1452004-05-20 13:54:53 +0000175/*
176** pExpr is a comparison operator. Return the type affinity that should
177** be applied to both operands prior to doing the comparison.
178*/
danielk1977e014a832004-05-17 10:48:57 +0000179static char comparisonAffinity(Expr *pExpr){
180 char aff;
181 assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT ||
182 pExpr->op==TK_GT || pExpr->op==TK_GE || pExpr->op==TK_LE ||
drh6a2fe092009-09-23 02:29:36 +0000183 pExpr->op==TK_NE || pExpr->op==TK_IS || pExpr->op==TK_ISNOT );
danielk1977e014a832004-05-17 10:48:57 +0000184 assert( pExpr->pLeft );
danielk1977bf3b7212004-05-18 10:06:24 +0000185 aff = sqlite3ExprAffinity(pExpr->pLeft);
danielk1977e014a832004-05-17 10:48:57 +0000186 if( pExpr->pRight ){
187 aff = sqlite3CompareAffinity(pExpr->pRight, aff);
danielk19776ab3a2e2009-02-19 14:39:25 +0000188 }else if( ExprHasProperty(pExpr, EP_xIsSelect) ){
189 aff = sqlite3CompareAffinity(pExpr->x.pSelect->pEList->a[0].pExpr, aff);
190 }else if( !aff ){
drhde087bd2007-02-23 03:00:44 +0000191 aff = SQLITE_AFF_NONE;
danielk1977e014a832004-05-17 10:48:57 +0000192 }
193 return aff;
194}
195
196/*
197** pExpr is a comparison expression, eg. '=', '<', IN(...) etc.
198** idx_affinity is the affinity of an indexed column. Return true
199** if the index with affinity idx_affinity may be used to implement
200** the comparison in pExpr.
201*/
202int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity){
203 char aff = comparisonAffinity(pExpr);
drh8a512562005-11-14 22:29:05 +0000204 switch( aff ){
205 case SQLITE_AFF_NONE:
206 return 1;
207 case SQLITE_AFF_TEXT:
208 return idx_affinity==SQLITE_AFF_TEXT;
209 default:
210 return sqlite3IsNumericAffinity(idx_affinity);
211 }
danielk1977e014a832004-05-17 10:48:57 +0000212}
213
danielk1977a37cdde2004-05-16 11:15:36 +0000214/*
drh35573352008-01-08 23:54:25 +0000215** Return the P5 value that should be used for a binary comparison
danielk1977a37cdde2004-05-16 11:15:36 +0000216** opcode (OP_Eq, OP_Ge etc.) used to compare pExpr1 and pExpr2.
danielk1977a37cdde2004-05-16 11:15:36 +0000217*/
drh35573352008-01-08 23:54:25 +0000218static u8 binaryCompareP5(Expr *pExpr1, Expr *pExpr2, int jumpIfNull){
219 u8 aff = (char)sqlite3ExprAffinity(pExpr2);
drh1bd10f82008-12-10 21:19:56 +0000220 aff = (u8)sqlite3CompareAffinity(pExpr1, aff) | (u8)jumpIfNull;
drh35573352008-01-08 23:54:25 +0000221 return aff;
danielk1977a37cdde2004-05-16 11:15:36 +0000222}
223
drha2e00042002-01-22 03:13:42 +0000224/*
danielk19770202b292004-06-09 09:55:16 +0000225** Return a pointer to the collation sequence that should be used by
226** a binary comparison operator comparing pLeft and pRight.
227**
228** If the left hand expression has a collating sequence type, then it is
229** used. Otherwise the collation sequence for the right hand expression
230** is used, or the default (BINARY) if neither expression has a collating
231** type.
danielk1977bcbb04e2007-05-29 12:11:29 +0000232**
233** Argument pRight (but not pLeft) may be a null pointer. In this case,
234** it is not considered.
danielk19770202b292004-06-09 09:55:16 +0000235*/
drh0a0e1312007-08-07 17:04:59 +0000236CollSeq *sqlite3BinaryCompareCollSeq(
danielk1977bcbb04e2007-05-29 12:11:29 +0000237 Parse *pParse,
238 Expr *pLeft,
239 Expr *pRight
240){
drhec41dda2007-02-07 13:09:45 +0000241 CollSeq *pColl;
242 assert( pLeft );
drhae80dde2012-12-06 21:16:43 +0000243 if( pLeft->flags & EP_Collate ){
244 pColl = sqlite3ExprCollSeq(pParse, pLeft);
245 }else if( pRight && (pRight->flags & EP_Collate)!=0 ){
246 pColl = sqlite3ExprCollSeq(pParse, pRight);
drhec41dda2007-02-07 13:09:45 +0000247 }else{
248 pColl = sqlite3ExprCollSeq(pParse, pLeft);
249 if( !pColl ){
250 pColl = sqlite3ExprCollSeq(pParse, pRight);
251 }
danielk19770202b292004-06-09 09:55:16 +0000252 }
253 return pColl;
254}
255
256/*
drhbe5c89a2004-07-26 00:31:09 +0000257** Generate code for a comparison operator.
258*/
259static int codeCompare(
260 Parse *pParse, /* The parsing (and code generating) context */
261 Expr *pLeft, /* The left operand */
262 Expr *pRight, /* The right operand */
263 int opcode, /* The comparison opcode */
drh35573352008-01-08 23:54:25 +0000264 int in1, int in2, /* Register holding operands */
drhbe5c89a2004-07-26 00:31:09 +0000265 int dest, /* Jump here if true. */
266 int jumpIfNull /* If true, jump if either operand is NULL */
267){
drh35573352008-01-08 23:54:25 +0000268 int p5;
269 int addr;
270 CollSeq *p4;
271
272 p4 = sqlite3BinaryCompareCollSeq(pParse, pLeft, pRight);
273 p5 = binaryCompareP5(pLeft, pRight, jumpIfNull);
274 addr = sqlite3VdbeAddOp4(pParse->pVdbe, opcode, in2, dest, in1,
275 (void*)p4, P4_COLLSEQ);
drh1bd10f82008-12-10 21:19:56 +0000276 sqlite3VdbeChangeP5(pParse->pVdbe, (u8)p5);
drh35573352008-01-08 23:54:25 +0000277 return addr;
drhbe5c89a2004-07-26 00:31:09 +0000278}
279
danielk19774b5255a2008-06-05 16:47:39 +0000280#if SQLITE_MAX_EXPR_DEPTH>0
281/*
282** Check that argument nHeight is less than or equal to the maximum
283** expression depth allowed. If it is not, leave an error message in
284** pParse.
285*/
drh7d10d5a2008-08-20 16:35:10 +0000286int sqlite3ExprCheckHeight(Parse *pParse, int nHeight){
danielk19774b5255a2008-06-05 16:47:39 +0000287 int rc = SQLITE_OK;
288 int mxHeight = pParse->db->aLimit[SQLITE_LIMIT_EXPR_DEPTH];
289 if( nHeight>mxHeight ){
290 sqlite3ErrorMsg(pParse,
291 "Expression tree is too large (maximum depth %d)", mxHeight
292 );
293 rc = SQLITE_ERROR;
294 }
295 return rc;
296}
297
298/* The following three functions, heightOfExpr(), heightOfExprList()
299** and heightOfSelect(), are used to determine the maximum height
300** of any expression tree referenced by the structure passed as the
301** first argument.
302**
303** If this maximum height is greater than the current value pointed
304** to by pnHeight, the second parameter, then set *pnHeight to that
305** value.
306*/
307static void heightOfExpr(Expr *p, int *pnHeight){
308 if( p ){
309 if( p->nHeight>*pnHeight ){
310 *pnHeight = p->nHeight;
311 }
312 }
313}
314static void heightOfExprList(ExprList *p, int *pnHeight){
315 if( p ){
316 int i;
317 for(i=0; i<p->nExpr; i++){
318 heightOfExpr(p->a[i].pExpr, pnHeight);
319 }
320 }
321}
322static void heightOfSelect(Select *p, int *pnHeight){
323 if( p ){
324 heightOfExpr(p->pWhere, pnHeight);
325 heightOfExpr(p->pHaving, pnHeight);
326 heightOfExpr(p->pLimit, pnHeight);
327 heightOfExpr(p->pOffset, pnHeight);
328 heightOfExprList(p->pEList, pnHeight);
329 heightOfExprList(p->pGroupBy, pnHeight);
330 heightOfExprList(p->pOrderBy, pnHeight);
331 heightOfSelect(p->pPrior, pnHeight);
332 }
333}
334
335/*
336** Set the Expr.nHeight variable in the structure passed as an
337** argument. An expression with no children, Expr.pList or
338** Expr.pSelect member has a height of 1. Any other expression
339** has a height equal to the maximum height of any other
340** referenced Expr plus one.
341*/
342static void exprSetHeight(Expr *p){
343 int nHeight = 0;
344 heightOfExpr(p->pLeft, &nHeight);
345 heightOfExpr(p->pRight, &nHeight);
danielk19776ab3a2e2009-02-19 14:39:25 +0000346 if( ExprHasProperty(p, EP_xIsSelect) ){
347 heightOfSelect(p->x.pSelect, &nHeight);
348 }else{
349 heightOfExprList(p->x.pList, &nHeight);
350 }
danielk19774b5255a2008-06-05 16:47:39 +0000351 p->nHeight = nHeight + 1;
352}
353
354/*
355** Set the Expr.nHeight variable using the exprSetHeight() function. If
356** the height is greater than the maximum allowed expression depth,
357** leave an error in pParse.
358*/
359void sqlite3ExprSetHeight(Parse *pParse, Expr *p){
360 exprSetHeight(p);
drh7d10d5a2008-08-20 16:35:10 +0000361 sqlite3ExprCheckHeight(pParse, p->nHeight);
danielk19774b5255a2008-06-05 16:47:39 +0000362}
363
364/*
365** Return the maximum height of any expression tree referenced
366** by the select statement passed as an argument.
367*/
368int sqlite3SelectExprHeight(Select *p){
369 int nHeight = 0;
370 heightOfSelect(p, &nHeight);
371 return nHeight;
372}
373#else
danielk19774b5255a2008-06-05 16:47:39 +0000374 #define exprSetHeight(y)
375#endif /* SQLITE_MAX_EXPR_DEPTH>0 */
376
drhbe5c89a2004-07-26 00:31:09 +0000377/*
drhb7916a72009-05-27 10:31:29 +0000378** This routine is the core allocator for Expr nodes.
379**
drha76b5df2002-02-23 02:32:10 +0000380** Construct a new expression node and return a pointer to it. Memory
drhb7916a72009-05-27 10:31:29 +0000381** for this node and for the pToken argument is a single allocation
382** obtained from sqlite3DbMalloc(). The calling function
drha76b5df2002-02-23 02:32:10 +0000383** is responsible for making sure the node eventually gets freed.
drhb7916a72009-05-27 10:31:29 +0000384**
385** If dequote is true, then the token (if it exists) is dequoted.
386** If dequote is false, no dequoting is performance. The deQuote
387** parameter is ignored if pToken is NULL or if the token does not
388** appear to be quoted. If the quotes were of the form "..." (double-quotes)
389** then the EP_DblQuoted flag is set on the expression node.
drh33e619f2009-05-28 01:00:55 +0000390**
391** Special case: If op==TK_INTEGER and pToken points to a string that
392** can be translated into a 32-bit integer, then the token is not
393** stored in u.zToken. Instead, the integer values is written
394** into u.iValue and the EP_IntValue flag is set. No extra storage
395** is allocated to hold the integer text and the dequote flag is ignored.
drha76b5df2002-02-23 02:32:10 +0000396*/
drhb7916a72009-05-27 10:31:29 +0000397Expr *sqlite3ExprAlloc(
danielk1977a1644fd2007-08-29 12:31:25 +0000398 sqlite3 *db, /* Handle for sqlite3DbMallocZero() (may be null) */
drh17435752007-08-16 04:30:38 +0000399 int op, /* Expression opcode */
drhb7916a72009-05-27 10:31:29 +0000400 const Token *pToken, /* Token argument. Might be NULL */
401 int dequote /* True to dequote */
drh17435752007-08-16 04:30:38 +0000402){
drha76b5df2002-02-23 02:32:10 +0000403 Expr *pNew;
drh33e619f2009-05-28 01:00:55 +0000404 int nExtra = 0;
shanecf697392009-06-01 16:53:09 +0000405 int iValue = 0;
danielk1977fc976062007-05-10 10:46:56 +0000406
drhb7916a72009-05-27 10:31:29 +0000407 if( pToken ){
drh33e619f2009-05-28 01:00:55 +0000408 if( op!=TK_INTEGER || pToken->z==0
409 || sqlite3GetInt32(pToken->z, &iValue)==0 ){
410 nExtra = pToken->n+1;
drhd50ffc42011-03-08 02:38:28 +0000411 assert( iValue>=0 );
drh33e619f2009-05-28 01:00:55 +0000412 }
drhb7916a72009-05-27 10:31:29 +0000413 }
414 pNew = sqlite3DbMallocZero(db, sizeof(Expr)+nExtra);
415 if( pNew ){
416 pNew->op = (u8)op;
417 pNew->iAgg = -1;
418 if( pToken ){
drh33e619f2009-05-28 01:00:55 +0000419 if( nExtra==0 ){
420 pNew->flags |= EP_IntValue;
421 pNew->u.iValue = iValue;
422 }else{
423 int c;
424 pNew->u.zToken = (char*)&pNew[1];
drhb07028f2011-10-14 21:49:18 +0000425 assert( pToken->z!=0 || pToken->n==0 );
426 if( pToken->n ) memcpy(pNew->u.zToken, pToken->z, pToken->n);
drh33e619f2009-05-28 01:00:55 +0000427 pNew->u.zToken[pToken->n] = 0;
428 if( dequote && nExtra>=3
429 && ((c = pToken->z[0])=='\'' || c=='"' || c=='[' || c=='`') ){
430 sqlite3Dequote(pNew->u.zToken);
431 if( c=='"' ) pNew->flags |= EP_DblQuoted;
432 }
drhb7916a72009-05-27 10:31:29 +0000433 }
434 }
435#if SQLITE_MAX_EXPR_DEPTH>0
436 pNew->nHeight = 1;
437#endif
438 }
drha76b5df2002-02-23 02:32:10 +0000439 return pNew;
440}
441
442/*
drhb7916a72009-05-27 10:31:29 +0000443** Allocate a new expression node from a zero-terminated token that has
444** already been dequoted.
445*/
446Expr *sqlite3Expr(
447 sqlite3 *db, /* Handle for sqlite3DbMallocZero() (may be null) */
448 int op, /* Expression opcode */
449 const char *zToken /* Token argument. Might be NULL */
450){
451 Token x;
452 x.z = zToken;
453 x.n = zToken ? sqlite3Strlen30(zToken) : 0;
454 return sqlite3ExprAlloc(db, op, &x, 0);
455}
456
457/*
458** Attach subtrees pLeft and pRight to the Expr node pRoot.
459**
460** If pRoot==NULL that means that a memory allocation error has occurred.
461** In that case, delete the subtrees pLeft and pRight.
462*/
463void sqlite3ExprAttachSubtrees(
464 sqlite3 *db,
465 Expr *pRoot,
466 Expr *pLeft,
467 Expr *pRight
468){
469 if( pRoot==0 ){
470 assert( db->mallocFailed );
471 sqlite3ExprDelete(db, pLeft);
472 sqlite3ExprDelete(db, pRight);
473 }else{
474 if( pRight ){
475 pRoot->pRight = pRight;
drhae80dde2012-12-06 21:16:43 +0000476 pRoot->flags |= EP_Collate & pRight->flags;
drhb7916a72009-05-27 10:31:29 +0000477 }
478 if( pLeft ){
479 pRoot->pLeft = pLeft;
drhae80dde2012-12-06 21:16:43 +0000480 pRoot->flags |= EP_Collate & pLeft->flags;
drhb7916a72009-05-27 10:31:29 +0000481 }
482 exprSetHeight(pRoot);
483 }
484}
485
486/*
drhbf664462009-06-19 18:32:54 +0000487** Allocate a Expr node which joins as many as two subtrees.
drhb7916a72009-05-27 10:31:29 +0000488**
drhbf664462009-06-19 18:32:54 +0000489** One or both of the subtrees can be NULL. Return a pointer to the new
490** Expr node. Or, if an OOM error occurs, set pParse->db->mallocFailed,
491** free the subtrees and return NULL.
drh206f3d92006-07-11 13:15:08 +0000492*/
drh17435752007-08-16 04:30:38 +0000493Expr *sqlite3PExpr(
494 Parse *pParse, /* Parsing context */
495 int op, /* Expression opcode */
496 Expr *pLeft, /* Left operand */
497 Expr *pRight, /* Right operand */
498 const Token *pToken /* Argument token */
499){
drh5fb52ca2012-03-31 02:34:35 +0000500 Expr *p;
501 if( op==TK_AND && pLeft && pRight ){
502 /* Take advantage of short-circuit false optimization for AND */
503 p = sqlite3ExprAnd(pParse->db, pLeft, pRight);
504 }else{
505 p = sqlite3ExprAlloc(pParse->db, op, pToken, 1);
506 sqlite3ExprAttachSubtrees(pParse->db, p, pLeft, pRight);
507 }
dan2b359bd2010-10-28 11:31:23 +0000508 if( p ) {
509 sqlite3ExprCheckHeight(pParse, p->nHeight);
510 }
drh4e0cff62004-11-05 05:10:28 +0000511 return p;
512}
513
514/*
drh5fb52ca2012-03-31 02:34:35 +0000515** Return 1 if an expression must be FALSE in all cases and 0 if the
516** expression might be true. This is an optimization. If is OK to
517** return 0 here even if the expression really is always false (a
518** false negative). But it is a bug to return 1 if the expression
519** might be true in some rare circumstances (a false positive.)
520**
521** Note that if the expression is part of conditional for a
522** LEFT JOIN, then we cannot determine at compile-time whether or not
523** is it true or false, so always return 0.
524*/
525static int exprAlwaysFalse(Expr *p){
526 int v = 0;
527 if( ExprHasProperty(p, EP_FromJoin) ) return 0;
528 if( !sqlite3ExprIsInteger(p, &v) ) return 0;
529 return v==0;
530}
531
532/*
drh91bb0ee2004-09-01 03:06:34 +0000533** Join two expressions using an AND operator. If either expression is
534** NULL, then just return the other expression.
drh5fb52ca2012-03-31 02:34:35 +0000535**
536** If one side or the other of the AND is known to be false, then instead
537** of returning an AND expression, just return a constant expression with
538** a value of false.
drh91bb0ee2004-09-01 03:06:34 +0000539*/
danielk19771e536952007-08-16 10:09:01 +0000540Expr *sqlite3ExprAnd(sqlite3 *db, Expr *pLeft, Expr *pRight){
drh91bb0ee2004-09-01 03:06:34 +0000541 if( pLeft==0 ){
542 return pRight;
543 }else if( pRight==0 ){
544 return pLeft;
drh5fb52ca2012-03-31 02:34:35 +0000545 }else if( exprAlwaysFalse(pLeft) || exprAlwaysFalse(pRight) ){
546 sqlite3ExprDelete(db, pLeft);
547 sqlite3ExprDelete(db, pRight);
548 return sqlite3ExprAlloc(db, TK_INTEGER, &sqlite3IntTokens[0], 0);
drh91bb0ee2004-09-01 03:06:34 +0000549 }else{
drhb7916a72009-05-27 10:31:29 +0000550 Expr *pNew = sqlite3ExprAlloc(db, TK_AND, 0, 0);
551 sqlite3ExprAttachSubtrees(db, pNew, pLeft, pRight);
552 return pNew;
drha76b5df2002-02-23 02:32:10 +0000553 }
554}
555
556/*
557** Construct a new expression node for a function with multiple
558** arguments.
559*/
drh17435752007-08-16 04:30:38 +0000560Expr *sqlite3ExprFunction(Parse *pParse, ExprList *pList, Token *pToken){
drha76b5df2002-02-23 02:32:10 +0000561 Expr *pNew;
drh633e6d52008-07-28 19:34:53 +0000562 sqlite3 *db = pParse->db;
danielk19774b202ae2006-01-23 05:50:58 +0000563 assert( pToken );
drhb7916a72009-05-27 10:31:29 +0000564 pNew = sqlite3ExprAlloc(db, TK_FUNCTION, pToken, 1);
drha76b5df2002-02-23 02:32:10 +0000565 if( pNew==0 ){
drhd9da78a2009-03-24 15:08:09 +0000566 sqlite3ExprListDelete(db, pList); /* Avoid memory leak when malloc fails */
drha76b5df2002-02-23 02:32:10 +0000567 return 0;
568 }
danielk19776ab3a2e2009-02-19 14:39:25 +0000569 pNew->x.pList = pList;
570 assert( !ExprHasProperty(pNew, EP_xIsSelect) );
danielk19774b5255a2008-06-05 16:47:39 +0000571 sqlite3ExprSetHeight(pParse, pNew);
drha76b5df2002-02-23 02:32:10 +0000572 return pNew;
573}
574
575/*
drhfa6bc002004-09-07 16:19:52 +0000576** Assign a variable number to an expression that encodes a wildcard
577** in the original SQL statement.
578**
579** Wildcards consisting of a single "?" are assigned the next sequential
580** variable number.
581**
582** Wildcards of the form "?nnn" are assigned the number "nnn". We make
583** sure "nnn" is not too be to avoid a denial of service attack when
584** the SQL statement comes from an external source.
585**
drh51f49f12009-05-21 20:41:32 +0000586** Wildcards of the form ":aaa", "@aaa", or "$aaa" are assigned the same number
drhfa6bc002004-09-07 16:19:52 +0000587** as the previous instance of the same wildcard. Or if this is the first
588** instance of the wildcard, the next sequenial variable number is
589** assigned.
590*/
591void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr){
drh17435752007-08-16 04:30:38 +0000592 sqlite3 *db = pParse->db;
drhb7916a72009-05-27 10:31:29 +0000593 const char *z;
drh17435752007-08-16 04:30:38 +0000594
drhfa6bc002004-09-07 16:19:52 +0000595 if( pExpr==0 ) return;
drh33e619f2009-05-28 01:00:55 +0000596 assert( !ExprHasAnyProperty(pExpr, EP_IntValue|EP_Reduced|EP_TokenOnly) );
597 z = pExpr->u.zToken;
drhb7916a72009-05-27 10:31:29 +0000598 assert( z!=0 );
599 assert( z[0]!=0 );
600 if( z[1]==0 ){
drhfa6bc002004-09-07 16:19:52 +0000601 /* Wildcard of the form "?". Assign the next variable number */
drhb7916a72009-05-27 10:31:29 +0000602 assert( z[0]=='?' );
drh8677d302009-11-04 13:17:14 +0000603 pExpr->iColumn = (ynVar)(++pParse->nVar);
drhfa6bc002004-09-07 16:19:52 +0000604 }else{
drh124c0b42011-06-01 18:15:55 +0000605 ynVar x = 0;
606 u32 n = sqlite3Strlen30(z);
607 if( z[0]=='?' ){
608 /* Wildcard of the form "?nnn". Convert "nnn" to an integer and
609 ** use it as the variable number */
610 i64 i;
611 int bOk = 0==sqlite3Atoi64(&z[1], &i, n-1, SQLITE_UTF8);
612 pExpr->iColumn = x = (ynVar)i;
613 testcase( i==0 );
614 testcase( i==1 );
615 testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]-1 );
616 testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] );
617 if( bOk==0 || i<1 || i>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){
618 sqlite3ErrorMsg(pParse, "variable number must be between ?1 and ?%d",
619 db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]);
620 x = 0;
drhfa6bc002004-09-07 16:19:52 +0000621 }
drh124c0b42011-06-01 18:15:55 +0000622 if( i>pParse->nVar ){
623 pParse->nVar = (int)i;
624 }
625 }else{
626 /* Wildcards like ":aaa", "$aaa" or "@aaa". Reuse the same variable
627 ** number as the prior appearance of the same name, or if the name
628 ** has never appeared before, reuse the same variable number
629 */
630 ynVar i;
631 for(i=0; i<pParse->nzVar; i++){
632 if( pParse->azVar[i] && memcmp(pParse->azVar[i],z,n+1)==0 ){
633 pExpr->iColumn = x = (ynVar)i+1;
634 break;
635 }
636 }
637 if( x==0 ) x = pExpr->iColumn = (ynVar)(++pParse->nVar);
drhfa6bc002004-09-07 16:19:52 +0000638 }
drh124c0b42011-06-01 18:15:55 +0000639 if( x>0 ){
640 if( x>pParse->nzVar ){
641 char **a;
642 a = sqlite3DbRealloc(db, pParse->azVar, x*sizeof(a[0]));
643 if( a==0 ) return; /* Error reported through db->mallocFailed */
644 pParse->azVar = a;
645 memset(&a[pParse->nzVar], 0, (x-pParse->nzVar)*sizeof(a[0]));
646 pParse->nzVar = x;
drhfa6bc002004-09-07 16:19:52 +0000647 }
drh124c0b42011-06-01 18:15:55 +0000648 if( z[0]!='?' || pParse->azVar[x-1]==0 ){
649 sqlite3DbFree(db, pParse->azVar[x-1]);
650 pParse->azVar[x-1] = sqlite3DbStrNDup(db, z, n);
drhfa6bc002004-09-07 16:19:52 +0000651 }
652 }
653 }
drhbb4957f2008-03-20 14:03:29 +0000654 if( !pParse->nErr && pParse->nVar>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){
danielk1977832b2662007-05-09 11:37:22 +0000655 sqlite3ErrorMsg(pParse, "too many SQL variables");
656 }
drhfa6bc002004-09-07 16:19:52 +0000657}
658
659/*
danf6963f92009-11-23 14:39:14 +0000660** Recursively delete an expression tree.
drha2e00042002-01-22 03:13:42 +0000661*/
danf6963f92009-11-23 14:39:14 +0000662void sqlite3ExprDelete(sqlite3 *db, Expr *p){
663 if( p==0 ) return;
drhd50ffc42011-03-08 02:38:28 +0000664 /* Sanity check: Assert that the IntValue is non-negative if it exists */
665 assert( !ExprHasProperty(p, EP_IntValue) || p->u.iValue>=0 );
drhb7916a72009-05-27 10:31:29 +0000666 if( !ExprHasAnyProperty(p, EP_TokenOnly) ){
drh33e619f2009-05-28 01:00:55 +0000667 sqlite3ExprDelete(db, p->pLeft);
668 sqlite3ExprDelete(db, p->pRight);
669 if( !ExprHasProperty(p, EP_Reduced) && (p->flags2 & EP2_MallocedToken)!=0 ){
670 sqlite3DbFree(db, p->u.zToken);
danielk19776ab3a2e2009-02-19 14:39:25 +0000671 }
672 if( ExprHasProperty(p, EP_xIsSelect) ){
673 sqlite3SelectDelete(db, p->x.pSelect);
674 }else{
675 sqlite3ExprListDelete(db, p->x.pList);
676 }
677 }
drh33e619f2009-05-28 01:00:55 +0000678 if( !ExprHasProperty(p, EP_Static) ){
679 sqlite3DbFree(db, p);
680 }
drha2e00042002-01-22 03:13:42 +0000681}
682
drhd2687b72005-08-12 22:56:09 +0000683/*
danielk19776ab3a2e2009-02-19 14:39:25 +0000684** Return the number of bytes allocated for the expression structure
685** passed as the first argument. This is always one of EXPR_FULLSIZE,
686** EXPR_REDUCEDSIZE or EXPR_TOKENONLYSIZE.
687*/
688static int exprStructSize(Expr *p){
689 if( ExprHasProperty(p, EP_TokenOnly) ) return EXPR_TOKENONLYSIZE;
danielk19776ab3a2e2009-02-19 14:39:25 +0000690 if( ExprHasProperty(p, EP_Reduced) ) return EXPR_REDUCEDSIZE;
691 return EXPR_FULLSIZE;
692}
693
694/*
drh33e619f2009-05-28 01:00:55 +0000695** The dupedExpr*Size() routines each return the number of bytes required
696** to store a copy of an expression or expression tree. They differ in
697** how much of the tree is measured.
698**
699** dupedExprStructSize() Size of only the Expr structure
700** dupedExprNodeSize() Size of Expr + space for token
701** dupedExprSize() Expr + token + subtree components
702**
703***************************************************************************
704**
705** The dupedExprStructSize() function returns two values OR-ed together:
706** (1) the space required for a copy of the Expr structure only and
707** (2) the EP_xxx flags that indicate what the structure size should be.
708** The return values is always one of:
709**
710** EXPR_FULLSIZE
711** EXPR_REDUCEDSIZE | EP_Reduced
712** EXPR_TOKENONLYSIZE | EP_TokenOnly
713**
714** The size of the structure can be found by masking the return value
715** of this routine with 0xfff. The flags can be found by masking the
716** return value with EP_Reduced|EP_TokenOnly.
717**
718** Note that with flags==EXPRDUP_REDUCE, this routines works on full-size
719** (unreduced) Expr objects as they or originally constructed by the parser.
720** During expression analysis, extra information is computed and moved into
721** later parts of teh Expr object and that extra information might get chopped
722** off if the expression is reduced. Note also that it does not work to
723** make a EXPRDUP_REDUCE copy of a reduced expression. It is only legal
724** to reduce a pristine expression tree from the parser. The implementation
725** of dupedExprStructSize() contain multiple assert() statements that attempt
726** to enforce this constraint.
danielk19776ab3a2e2009-02-19 14:39:25 +0000727*/
728static int dupedExprStructSize(Expr *p, int flags){
729 int nSize;
drh33e619f2009-05-28 01:00:55 +0000730 assert( flags==EXPRDUP_REDUCE || flags==0 ); /* Only one flag value allowed */
danielk19776ab3a2e2009-02-19 14:39:25 +0000731 if( 0==(flags&EXPRDUP_REDUCE) ){
732 nSize = EXPR_FULLSIZE;
danielk19776ab3a2e2009-02-19 14:39:25 +0000733 }else{
drh33e619f2009-05-28 01:00:55 +0000734 assert( !ExprHasAnyProperty(p, EP_TokenOnly|EP_Reduced) );
735 assert( !ExprHasProperty(p, EP_FromJoin) );
736 assert( (p->flags2 & EP2_MallocedToken)==0 );
737 assert( (p->flags2 & EP2_Irreducible)==0 );
drhae80dde2012-12-06 21:16:43 +0000738 if( p->pLeft || p->pRight || p->x.pList ){
drh33e619f2009-05-28 01:00:55 +0000739 nSize = EXPR_REDUCEDSIZE | EP_Reduced;
740 }else{
741 nSize = EXPR_TOKENONLYSIZE | EP_TokenOnly;
742 }
danielk19776ab3a2e2009-02-19 14:39:25 +0000743 }
744 return nSize;
745}
746
747/*
drh33e619f2009-05-28 01:00:55 +0000748** This function returns the space in bytes required to store the copy
749** of the Expr structure and a copy of the Expr.u.zToken string (if that
750** string is defined.)
danielk19776ab3a2e2009-02-19 14:39:25 +0000751*/
752static int dupedExprNodeSize(Expr *p, int flags){
drh33e619f2009-05-28 01:00:55 +0000753 int nByte = dupedExprStructSize(p, flags) & 0xfff;
754 if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){
755 nByte += sqlite3Strlen30(p->u.zToken)+1;
danielk19776ab3a2e2009-02-19 14:39:25 +0000756 }
danielk1977bc739712009-03-23 04:33:32 +0000757 return ROUND8(nByte);
danielk19776ab3a2e2009-02-19 14:39:25 +0000758}
759
760/*
761** Return the number of bytes required to create a duplicate of the
762** expression passed as the first argument. The second argument is a
763** mask containing EXPRDUP_XXX flags.
764**
765** The value returned includes space to create a copy of the Expr struct
drh33e619f2009-05-28 01:00:55 +0000766** itself and the buffer referred to by Expr.u.zToken, if any.
danielk19776ab3a2e2009-02-19 14:39:25 +0000767**
768** If the EXPRDUP_REDUCE flag is set, then the return value includes
769** space to duplicate all Expr nodes in the tree formed by Expr.pLeft
770** and Expr.pRight variables (but not for any structures pointed to or
771** descended from the Expr.x.pList or Expr.x.pSelect variables).
772*/
773static int dupedExprSize(Expr *p, int flags){
774 int nByte = 0;
775 if( p ){
776 nByte = dupedExprNodeSize(p, flags);
777 if( flags&EXPRDUP_REDUCE ){
drhb7916a72009-05-27 10:31:29 +0000778 nByte += dupedExprSize(p->pLeft, flags) + dupedExprSize(p->pRight, flags);
danielk19776ab3a2e2009-02-19 14:39:25 +0000779 }
780 }
781 return nByte;
782}
783
784/*
785** This function is similar to sqlite3ExprDup(), except that if pzBuffer
786** is not NULL then *pzBuffer is assumed to point to a buffer large enough
drh33e619f2009-05-28 01:00:55 +0000787** to store the copy of expression p, the copies of p->u.zToken
danielk19776ab3a2e2009-02-19 14:39:25 +0000788** (if applicable), and the copies of the p->pLeft and p->pRight expressions,
789** if any. Before returning, *pzBuffer is set to the first byte passed the
790** portion of the buffer copied into by this function.
791*/
792static Expr *exprDup(sqlite3 *db, Expr *p, int flags, u8 **pzBuffer){
793 Expr *pNew = 0; /* Value to return */
794 if( p ){
danielk19776ab3a2e2009-02-19 14:39:25 +0000795 const int isReduced = (flags&EXPRDUP_REDUCE);
796 u8 *zAlloc;
drh33e619f2009-05-28 01:00:55 +0000797 u32 staticFlag = 0;
danielk19776ab3a2e2009-02-19 14:39:25 +0000798
799 assert( pzBuffer==0 || isReduced );
800
801 /* Figure out where to write the new Expr structure. */
802 if( pzBuffer ){
803 zAlloc = *pzBuffer;
drh33e619f2009-05-28 01:00:55 +0000804 staticFlag = EP_Static;
danielk19776ab3a2e2009-02-19 14:39:25 +0000805 }else{
806 zAlloc = sqlite3DbMallocRaw(db, dupedExprSize(p, flags));
807 }
808 pNew = (Expr *)zAlloc;
809
810 if( pNew ){
811 /* Set nNewSize to the size allocated for the structure pointed to
812 ** by pNew. This is either EXPR_FULLSIZE, EXPR_REDUCEDSIZE or
813 ** EXPR_TOKENONLYSIZE. nToken is set to the number of bytes consumed
drh33e619f2009-05-28 01:00:55 +0000814 ** by the copy of the p->u.zToken string (if any).
danielk19776ab3a2e2009-02-19 14:39:25 +0000815 */
drh33e619f2009-05-28 01:00:55 +0000816 const unsigned nStructSize = dupedExprStructSize(p, flags);
817 const int nNewSize = nStructSize & 0xfff;
818 int nToken;
819 if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){
820 nToken = sqlite3Strlen30(p->u.zToken) + 1;
821 }else{
822 nToken = 0;
823 }
danielk19776ab3a2e2009-02-19 14:39:25 +0000824 if( isReduced ){
825 assert( ExprHasProperty(p, EP_Reduced)==0 );
826 memcpy(zAlloc, p, nNewSize);
827 }else{
828 int nSize = exprStructSize(p);
829 memcpy(zAlloc, p, nSize);
830 memset(&zAlloc[nSize], 0, EXPR_FULLSIZE-nSize);
831 }
832
drh33e619f2009-05-28 01:00:55 +0000833 /* Set the EP_Reduced, EP_TokenOnly, and EP_Static flags appropriately. */
834 pNew->flags &= ~(EP_Reduced|EP_TokenOnly|EP_Static);
835 pNew->flags |= nStructSize & (EP_Reduced|EP_TokenOnly);
836 pNew->flags |= staticFlag;
danielk19776ab3a2e2009-02-19 14:39:25 +0000837
drh33e619f2009-05-28 01:00:55 +0000838 /* Copy the p->u.zToken string, if any. */
danielk19776ab3a2e2009-02-19 14:39:25 +0000839 if( nToken ){
drh33e619f2009-05-28 01:00:55 +0000840 char *zToken = pNew->u.zToken = (char*)&zAlloc[nNewSize];
841 memcpy(zToken, p->u.zToken, nToken);
danielk19776ab3a2e2009-02-19 14:39:25 +0000842 }
843
844 if( 0==((p->flags|pNew->flags) & EP_TokenOnly) ){
danielk19776ab3a2e2009-02-19 14:39:25 +0000845 /* Fill in the pNew->x.pSelect or pNew->x.pList member. */
846 if( ExprHasProperty(p, EP_xIsSelect) ){
847 pNew->x.pSelect = sqlite3SelectDup(db, p->x.pSelect, isReduced);
848 }else{
849 pNew->x.pList = sqlite3ExprListDup(db, p->x.pList, isReduced);
850 }
851 }
852
853 /* Fill in pNew->pLeft and pNew->pRight. */
drhb7916a72009-05-27 10:31:29 +0000854 if( ExprHasAnyProperty(pNew, EP_Reduced|EP_TokenOnly) ){
danielk19776ab3a2e2009-02-19 14:39:25 +0000855 zAlloc += dupedExprNodeSize(p, flags);
856 if( ExprHasProperty(pNew, EP_Reduced) ){
857 pNew->pLeft = exprDup(db, p->pLeft, EXPRDUP_REDUCE, &zAlloc);
858 pNew->pRight = exprDup(db, p->pRight, EXPRDUP_REDUCE, &zAlloc);
859 }
860 if( pzBuffer ){
861 *pzBuffer = zAlloc;
862 }
drhb7916a72009-05-27 10:31:29 +0000863 }else{
864 pNew->flags2 = 0;
865 if( !ExprHasAnyProperty(p, EP_TokenOnly) ){
866 pNew->pLeft = sqlite3ExprDup(db, p->pLeft, 0);
867 pNew->pRight = sqlite3ExprDup(db, p->pRight, 0);
868 }
danielk19776ab3a2e2009-02-19 14:39:25 +0000869 }
drhb7916a72009-05-27 10:31:29 +0000870
danielk19776ab3a2e2009-02-19 14:39:25 +0000871 }
872 }
873 return pNew;
874}
875
876/*
drhff78bd22002-02-27 01:47:11 +0000877** The following group of routines make deep copies of expressions,
878** expression lists, ID lists, and select statements. The copies can
879** be deleted (by being passed to their respective ...Delete() routines)
880** without effecting the originals.
881**
danielk19774adee202004-05-08 08:23:19 +0000882** The expression list, ID, and source lists return by sqlite3ExprListDup(),
883** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded
drhad3cab52002-05-24 02:04:32 +0000884** by subsequent calls to sqlite*ListAppend() routines.
drhff78bd22002-02-27 01:47:11 +0000885**
drhad3cab52002-05-24 02:04:32 +0000886** Any tables that the SrcList might point to are not duplicated.
danielk19776ab3a2e2009-02-19 14:39:25 +0000887**
drhb7916a72009-05-27 10:31:29 +0000888** The flags parameter contains a combination of the EXPRDUP_XXX flags.
danielk19776ab3a2e2009-02-19 14:39:25 +0000889** If the EXPRDUP_REDUCE flag is set, then the structure returned is a
890** truncated version of the usual Expr structure that will be stored as
891** part of the in-memory representation of the database schema.
drhff78bd22002-02-27 01:47:11 +0000892*/
danielk19776ab3a2e2009-02-19 14:39:25 +0000893Expr *sqlite3ExprDup(sqlite3 *db, Expr *p, int flags){
894 return exprDup(db, p, flags, 0);
drhff78bd22002-02-27 01:47:11 +0000895}
danielk19776ab3a2e2009-02-19 14:39:25 +0000896ExprList *sqlite3ExprListDup(sqlite3 *db, ExprList *p, int flags){
drhff78bd22002-02-27 01:47:11 +0000897 ExprList *pNew;
drh145716b2004-09-24 12:24:06 +0000898 struct ExprList_item *pItem, *pOldItem;
drhff78bd22002-02-27 01:47:11 +0000899 int i;
900 if( p==0 ) return 0;
drh17435752007-08-16 04:30:38 +0000901 pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
drhff78bd22002-02-27 01:47:11 +0000902 if( pNew==0 ) return 0;
danielk197731dad9d2007-08-16 11:36:15 +0000903 pNew->iECursor = 0;
drhd872bb12012-02-02 01:58:08 +0000904 pNew->nExpr = i = p->nExpr;
905 if( (flags & EXPRDUP_REDUCE)==0 ) for(i=1; i<p->nExpr; i+=i){}
906 pNew->a = pItem = sqlite3DbMallocRaw(db, i*sizeof(p->a[0]) );
danielk1977e0048402004-06-15 16:51:01 +0000907 if( pItem==0 ){
drh633e6d52008-07-28 19:34:53 +0000908 sqlite3DbFree(db, pNew);
danielk1977e0048402004-06-15 16:51:01 +0000909 return 0;
910 }
drh145716b2004-09-24 12:24:06 +0000911 pOldItem = p->a;
912 for(i=0; i<p->nExpr; i++, pItem++, pOldItem++){
danielk19776ab3a2e2009-02-19 14:39:25 +0000913 Expr *pOldExpr = pOldItem->pExpr;
drhb5526ea2009-07-16 12:41:05 +0000914 pItem->pExpr = sqlite3ExprDup(db, pOldExpr, flags);
drh17435752007-08-16 04:30:38 +0000915 pItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
drhb7916a72009-05-27 10:31:29 +0000916 pItem->zSpan = sqlite3DbStrDup(db, pOldItem->zSpan);
drh145716b2004-09-24 12:24:06 +0000917 pItem->sortOrder = pOldItem->sortOrder;
drh3e7bc9c2004-02-21 19:17:17 +0000918 pItem->done = 0;
drh4b3ac732011-12-10 23:18:32 +0000919 pItem->iOrderByCol = pOldItem->iOrderByCol;
drh8b213892008-08-29 02:14:02 +0000920 pItem->iAlias = pOldItem->iAlias;
drhff78bd22002-02-27 01:47:11 +0000921 }
922 return pNew;
923}
danielk197793758c82005-01-21 08:13:14 +0000924
925/*
926** If cursors, triggers, views and subqueries are all omitted from
927** the build, then none of the following routines, except for
928** sqlite3SelectDup(), can be called. sqlite3SelectDup() is sometimes
929** called with a NULL argument.
930*/
danielk19776a67fe82005-02-04 04:07:16 +0000931#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) \
932 || !defined(SQLITE_OMIT_SUBQUERY)
danielk19776ab3a2e2009-02-19 14:39:25 +0000933SrcList *sqlite3SrcListDup(sqlite3 *db, SrcList *p, int flags){
drhad3cab52002-05-24 02:04:32 +0000934 SrcList *pNew;
935 int i;
drh113088e2003-03-20 01:16:58 +0000936 int nByte;
drhad3cab52002-05-24 02:04:32 +0000937 if( p==0 ) return 0;
drh113088e2003-03-20 01:16:58 +0000938 nByte = sizeof(*p) + (p->nSrc>0 ? sizeof(p->a[0]) * (p->nSrc-1) : 0);
drh17435752007-08-16 04:30:38 +0000939 pNew = sqlite3DbMallocRaw(db, nByte );
drhad3cab52002-05-24 02:04:32 +0000940 if( pNew==0 ) return 0;
drh4305d102003-07-30 12:34:12 +0000941 pNew->nSrc = pNew->nAlloc = p->nSrc;
drhad3cab52002-05-24 02:04:32 +0000942 for(i=0; i<p->nSrc; i++){
drh4efc4752004-01-16 15:55:37 +0000943 struct SrcList_item *pNewItem = &pNew->a[i];
944 struct SrcList_item *pOldItem = &p->a[i];
drhed8a3bb2005-06-06 21:19:56 +0000945 Table *pTab;
dan41fb5cd2012-10-04 19:33:00 +0000946 pNewItem->pSchema = pOldItem->pSchema;
drh17435752007-08-16 04:30:38 +0000947 pNewItem->zDatabase = sqlite3DbStrDup(db, pOldItem->zDatabase);
948 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
949 pNewItem->zAlias = sqlite3DbStrDup(db, pOldItem->zAlias);
drh4efc4752004-01-16 15:55:37 +0000950 pNewItem->jointype = pOldItem->jointype;
951 pNewItem->iCursor = pOldItem->iCursor;
drh5b6a9ed2011-09-15 23:58:14 +0000952 pNewItem->addrFillSub = pOldItem->addrFillSub;
953 pNewItem->regReturn = pOldItem->regReturn;
danda79cf02011-07-08 16:10:54 +0000954 pNewItem->isCorrelated = pOldItem->isCorrelated;
drh21172c42012-10-30 00:29:07 +0000955 pNewItem->viaCoroutine = pOldItem->viaCoroutine;
danielk197785574e32008-10-06 05:32:18 +0000956 pNewItem->zIndex = sqlite3DbStrDup(db, pOldItem->zIndex);
957 pNewItem->notIndexed = pOldItem->notIndexed;
958 pNewItem->pIndex = pOldItem->pIndex;
drhed8a3bb2005-06-06 21:19:56 +0000959 pTab = pNewItem->pTab = pOldItem->pTab;
960 if( pTab ){
961 pTab->nRef++;
danielk1977a1cb1832005-02-12 08:59:55 +0000962 }
danielk19776ab3a2e2009-02-19 14:39:25 +0000963 pNewItem->pSelect = sqlite3SelectDup(db, pOldItem->pSelect, flags);
964 pNewItem->pOn = sqlite3ExprDup(db, pOldItem->pOn, flags);
drh17435752007-08-16 04:30:38 +0000965 pNewItem->pUsing = sqlite3IdListDup(db, pOldItem->pUsing);
danielk19776c18b6e2005-01-30 09:17:58 +0000966 pNewItem->colUsed = pOldItem->colUsed;
drhad3cab52002-05-24 02:04:32 +0000967 }
968 return pNew;
969}
drh17435752007-08-16 04:30:38 +0000970IdList *sqlite3IdListDup(sqlite3 *db, IdList *p){
drhff78bd22002-02-27 01:47:11 +0000971 IdList *pNew;
972 int i;
973 if( p==0 ) return 0;
drh17435752007-08-16 04:30:38 +0000974 pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
drhff78bd22002-02-27 01:47:11 +0000975 if( pNew==0 ) return 0;
drh6c535152012-02-02 03:38:30 +0000976 pNew->nId = p->nId;
drh17435752007-08-16 04:30:38 +0000977 pNew->a = sqlite3DbMallocRaw(db, p->nId*sizeof(p->a[0]) );
danielk1977d5d56522005-03-16 12:15:20 +0000978 if( pNew->a==0 ){
drh633e6d52008-07-28 19:34:53 +0000979 sqlite3DbFree(db, pNew);
danielk1977d5d56522005-03-16 12:15:20 +0000980 return 0;
981 }
drh6c535152012-02-02 03:38:30 +0000982 /* Note that because the size of the allocation for p->a[] is not
983 ** necessarily a power of two, sqlite3IdListAppend() may not be called
984 ** on the duplicate created by this function. */
drhff78bd22002-02-27 01:47:11 +0000985 for(i=0; i<p->nId; i++){
drh4efc4752004-01-16 15:55:37 +0000986 struct IdList_item *pNewItem = &pNew->a[i];
987 struct IdList_item *pOldItem = &p->a[i];
drh17435752007-08-16 04:30:38 +0000988 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
drh4efc4752004-01-16 15:55:37 +0000989 pNewItem->idx = pOldItem->idx;
drhff78bd22002-02-27 01:47:11 +0000990 }
991 return pNew;
992}
danielk19776ab3a2e2009-02-19 14:39:25 +0000993Select *sqlite3SelectDup(sqlite3 *db, Select *p, int flags){
drh23b1b372011-12-07 01:55:51 +0000994 Select *pNew, *pPrior;
drhff78bd22002-02-27 01:47:11 +0000995 if( p==0 ) return 0;
drh17435752007-08-16 04:30:38 +0000996 pNew = sqlite3DbMallocRaw(db, sizeof(*p) );
drhff78bd22002-02-27 01:47:11 +0000997 if( pNew==0 ) return 0;
drhb7916a72009-05-27 10:31:29 +0000998 pNew->pEList = sqlite3ExprListDup(db, p->pEList, flags);
danielk19776ab3a2e2009-02-19 14:39:25 +0000999 pNew->pSrc = sqlite3SrcListDup(db, p->pSrc, flags);
1000 pNew->pWhere = sqlite3ExprDup(db, p->pWhere, flags);
1001 pNew->pGroupBy = sqlite3ExprListDup(db, p->pGroupBy, flags);
1002 pNew->pHaving = sqlite3ExprDup(db, p->pHaving, flags);
1003 pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, flags);
drhff78bd22002-02-27 01:47:11 +00001004 pNew->op = p->op;
drh23b1b372011-12-07 01:55:51 +00001005 pNew->pPrior = pPrior = sqlite3SelectDup(db, p->pPrior, flags);
1006 if( pPrior ) pPrior->pNext = pNew;
1007 pNew->pNext = 0;
danielk19776ab3a2e2009-02-19 14:39:25 +00001008 pNew->pLimit = sqlite3ExprDup(db, p->pLimit, flags);
1009 pNew->pOffset = sqlite3ExprDup(db, p->pOffset, flags);
drh92b01d52008-06-24 00:32:35 +00001010 pNew->iLimit = 0;
1011 pNew->iOffset = 0;
drh7d10d5a2008-08-20 16:35:10 +00001012 pNew->selFlags = p->selFlags & ~SF_UsesEphemeral;
drh0342b1f2005-09-01 03:07:44 +00001013 pNew->pRightmost = 0;
drhb9bb7c12006-06-11 23:41:55 +00001014 pNew->addrOpenEphm[0] = -1;
1015 pNew->addrOpenEphm[1] = -1;
1016 pNew->addrOpenEphm[2] = -1;
drhff78bd22002-02-27 01:47:11 +00001017 return pNew;
1018}
danielk197793758c82005-01-21 08:13:14 +00001019#else
danielk19776ab3a2e2009-02-19 14:39:25 +00001020Select *sqlite3SelectDup(sqlite3 *db, Select *p, int flags){
danielk197793758c82005-01-21 08:13:14 +00001021 assert( p==0 );
1022 return 0;
1023}
1024#endif
drhff78bd22002-02-27 01:47:11 +00001025
1026
1027/*
drha76b5df2002-02-23 02:32:10 +00001028** Add a new element to the end of an expression list. If pList is
1029** initially NULL, then create a new expression list.
drhb7916a72009-05-27 10:31:29 +00001030**
1031** If a memory allocation error occurs, the entire list is freed and
1032** NULL is returned. If non-NULL is returned, then it is guaranteed
1033** that the new entry was successfully appended.
drha76b5df2002-02-23 02:32:10 +00001034*/
drh17435752007-08-16 04:30:38 +00001035ExprList *sqlite3ExprListAppend(
1036 Parse *pParse, /* Parsing context */
1037 ExprList *pList, /* List to which to append. Might be NULL */
drhb7916a72009-05-27 10:31:29 +00001038 Expr *pExpr /* Expression to be appended. Might be NULL */
drh17435752007-08-16 04:30:38 +00001039){
1040 sqlite3 *db = pParse->db;
drha76b5df2002-02-23 02:32:10 +00001041 if( pList==0 ){
drh17435752007-08-16 04:30:38 +00001042 pList = sqlite3DbMallocZero(db, sizeof(ExprList) );
drha76b5df2002-02-23 02:32:10 +00001043 if( pList==0 ){
danielk1977d5d56522005-03-16 12:15:20 +00001044 goto no_mem;
drha76b5df2002-02-23 02:32:10 +00001045 }
drhd872bb12012-02-02 01:58:08 +00001046 pList->a = sqlite3DbMallocRaw(db, sizeof(pList->a[0]));
1047 if( pList->a==0 ) goto no_mem;
1048 }else if( (pList->nExpr & (pList->nExpr-1))==0 ){
danielk1977d5d56522005-03-16 12:15:20 +00001049 struct ExprList_item *a;
drhd872bb12012-02-02 01:58:08 +00001050 assert( pList->nExpr>0 );
1051 a = sqlite3DbRealloc(db, pList->a, pList->nExpr*2*sizeof(pList->a[0]));
danielk1977d5d56522005-03-16 12:15:20 +00001052 if( a==0 ){
1053 goto no_mem;
drha76b5df2002-02-23 02:32:10 +00001054 }
danielk1977d5d56522005-03-16 12:15:20 +00001055 pList->a = a;
drha76b5df2002-02-23 02:32:10 +00001056 }
drh4efc4752004-01-16 15:55:37 +00001057 assert( pList->a!=0 );
drhb7916a72009-05-27 10:31:29 +00001058 if( 1 ){
drh4efc4752004-01-16 15:55:37 +00001059 struct ExprList_item *pItem = &pList->a[pList->nExpr++];
1060 memset(pItem, 0, sizeof(*pItem));
danielk1977e94ddc92005-03-21 03:53:38 +00001061 pItem->pExpr = pExpr;
drha76b5df2002-02-23 02:32:10 +00001062 }
1063 return pList;
danielk1977d5d56522005-03-16 12:15:20 +00001064
1065no_mem:
1066 /* Avoid leaking memory if malloc has failed. */
drh633e6d52008-07-28 19:34:53 +00001067 sqlite3ExprDelete(db, pExpr);
1068 sqlite3ExprListDelete(db, pList);
danielk1977d5d56522005-03-16 12:15:20 +00001069 return 0;
drha76b5df2002-02-23 02:32:10 +00001070}
1071
1072/*
drhb7916a72009-05-27 10:31:29 +00001073** Set the ExprList.a[].zName element of the most recently added item
1074** on the expression list.
1075**
1076** pList might be NULL following an OOM error. But pName should never be
1077** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
1078** is set.
1079*/
1080void sqlite3ExprListSetName(
1081 Parse *pParse, /* Parsing context */
1082 ExprList *pList, /* List to which to add the span. */
1083 Token *pName, /* Name to be added */
1084 int dequote /* True to cause the name to be dequoted */
1085){
1086 assert( pList!=0 || pParse->db->mallocFailed!=0 );
1087 if( pList ){
1088 struct ExprList_item *pItem;
1089 assert( pList->nExpr>0 );
1090 pItem = &pList->a[pList->nExpr-1];
1091 assert( pItem->zName==0 );
1092 pItem->zName = sqlite3DbStrNDup(pParse->db, pName->z, pName->n);
1093 if( dequote && pItem->zName ) sqlite3Dequote(pItem->zName);
1094 }
1095}
1096
1097/*
1098** Set the ExprList.a[].zSpan element of the most recently added item
1099** on the expression list.
1100**
1101** pList might be NULL following an OOM error. But pSpan should never be
1102** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
1103** is set.
1104*/
1105void sqlite3ExprListSetSpan(
1106 Parse *pParse, /* Parsing context */
1107 ExprList *pList, /* List to which to add the span. */
1108 ExprSpan *pSpan /* The span to be added */
1109){
1110 sqlite3 *db = pParse->db;
1111 assert( pList!=0 || db->mallocFailed!=0 );
1112 if( pList ){
1113 struct ExprList_item *pItem = &pList->a[pList->nExpr-1];
1114 assert( pList->nExpr>0 );
1115 assert( db->mallocFailed || pItem->pExpr==pSpan->pExpr );
1116 sqlite3DbFree(db, pItem->zSpan);
1117 pItem->zSpan = sqlite3DbStrNDup(db, (char*)pSpan->zStart,
shanecf697392009-06-01 16:53:09 +00001118 (int)(pSpan->zEnd - pSpan->zStart));
drhb7916a72009-05-27 10:31:29 +00001119 }
1120}
1121
1122/*
danielk19777a15a4b2007-05-08 17:54:43 +00001123** If the expression list pEList contains more than iLimit elements,
1124** leave an error message in pParse.
1125*/
1126void sqlite3ExprListCheckLength(
1127 Parse *pParse,
1128 ExprList *pEList,
danielk19777a15a4b2007-05-08 17:54:43 +00001129 const char *zObject
1130){
drhb1a6c3c2008-03-20 16:30:17 +00001131 int mx = pParse->db->aLimit[SQLITE_LIMIT_COLUMN];
drhc5499be2008-04-01 15:06:33 +00001132 testcase( pEList && pEList->nExpr==mx );
1133 testcase( pEList && pEList->nExpr==mx+1 );
drhb1a6c3c2008-03-20 16:30:17 +00001134 if( pEList && pEList->nExpr>mx ){
danielk19777a15a4b2007-05-08 17:54:43 +00001135 sqlite3ErrorMsg(pParse, "too many columns in %s", zObject);
1136 }
1137}
1138
1139/*
drha76b5df2002-02-23 02:32:10 +00001140** Delete an entire expression list.
1141*/
drh633e6d52008-07-28 19:34:53 +00001142void sqlite3ExprListDelete(sqlite3 *db, ExprList *pList){
drha76b5df2002-02-23 02:32:10 +00001143 int i;
drhbe5c89a2004-07-26 00:31:09 +00001144 struct ExprList_item *pItem;
drha76b5df2002-02-23 02:32:10 +00001145 if( pList==0 ) return;
drhd872bb12012-02-02 01:58:08 +00001146 assert( pList->a!=0 || pList->nExpr==0 );
drhbe5c89a2004-07-26 00:31:09 +00001147 for(pItem=pList->a, i=0; i<pList->nExpr; i++, pItem++){
drh633e6d52008-07-28 19:34:53 +00001148 sqlite3ExprDelete(db, pItem->pExpr);
1149 sqlite3DbFree(db, pItem->zName);
drhb7916a72009-05-27 10:31:29 +00001150 sqlite3DbFree(db, pItem->zSpan);
drha76b5df2002-02-23 02:32:10 +00001151 }
drh633e6d52008-07-28 19:34:53 +00001152 sqlite3DbFree(db, pList->a);
1153 sqlite3DbFree(db, pList);
drha76b5df2002-02-23 02:32:10 +00001154}
1155
1156/*
drh7d10d5a2008-08-20 16:35:10 +00001157** These routines are Walker callbacks. Walker.u.pi is a pointer
1158** to an integer. These routines are checking an expression to see
1159** if it is a constant. Set *Walker.u.pi to 0 if the expression is
1160** not constant.
drh73b211a2005-01-18 04:00:42 +00001161**
drh7d10d5a2008-08-20 16:35:10 +00001162** These callback routines are used to implement the following:
drh626a8792005-01-17 22:08:19 +00001163**
drh7d10d5a2008-08-20 16:35:10 +00001164** sqlite3ExprIsConstant()
1165** sqlite3ExprIsConstantNotJoin()
1166** sqlite3ExprIsConstantOrFunction()
drh87abf5c2005-08-25 12:45:04 +00001167**
drh626a8792005-01-17 22:08:19 +00001168*/
drh7d10d5a2008-08-20 16:35:10 +00001169static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){
drh626a8792005-01-17 22:08:19 +00001170
drh7d10d5a2008-08-20 16:35:10 +00001171 /* If pWalker->u.i is 3 then any term of the expression that comes from
drh0a168372007-06-08 00:20:47 +00001172 ** the ON or USING clauses of a join disqualifies the expression
1173 ** from being considered constant. */
drh7d10d5a2008-08-20 16:35:10 +00001174 if( pWalker->u.i==3 && ExprHasAnyProperty(pExpr, EP_FromJoin) ){
1175 pWalker->u.i = 0;
1176 return WRC_Abort;
drh0a168372007-06-08 00:20:47 +00001177 }
1178
drh626a8792005-01-17 22:08:19 +00001179 switch( pExpr->op ){
drheb55bd22005-06-30 17:04:21 +00001180 /* Consider functions to be constant if all their arguments are constant
drh7d10d5a2008-08-20 16:35:10 +00001181 ** and pWalker->u.i==2 */
drheb55bd22005-06-30 17:04:21 +00001182 case TK_FUNCTION:
drh7d10d5a2008-08-20 16:35:10 +00001183 if( pWalker->u.i==2 ) return 0;
drheb55bd22005-06-30 17:04:21 +00001184 /* Fall through */
drh626a8792005-01-17 22:08:19 +00001185 case TK_ID:
1186 case TK_COLUMN:
drh626a8792005-01-17 22:08:19 +00001187 case TK_AGG_FUNCTION:
drh13449892005-09-07 21:22:45 +00001188 case TK_AGG_COLUMN:
drhc5499be2008-04-01 15:06:33 +00001189 testcase( pExpr->op==TK_ID );
1190 testcase( pExpr->op==TK_COLUMN );
drhc5499be2008-04-01 15:06:33 +00001191 testcase( pExpr->op==TK_AGG_FUNCTION );
1192 testcase( pExpr->op==TK_AGG_COLUMN );
drh7d10d5a2008-08-20 16:35:10 +00001193 pWalker->u.i = 0;
1194 return WRC_Abort;
drh626a8792005-01-17 22:08:19 +00001195 default:
drhb74b1012009-05-28 21:04:37 +00001196 testcase( pExpr->op==TK_SELECT ); /* selectNodeIsConstant will disallow */
1197 testcase( pExpr->op==TK_EXISTS ); /* selectNodeIsConstant will disallow */
drh7d10d5a2008-08-20 16:35:10 +00001198 return WRC_Continue;
drh626a8792005-01-17 22:08:19 +00001199 }
1200}
danielk197762c14b32008-11-19 09:05:26 +00001201static int selectNodeIsConstant(Walker *pWalker, Select *NotUsed){
1202 UNUSED_PARAMETER(NotUsed);
drh7d10d5a2008-08-20 16:35:10 +00001203 pWalker->u.i = 0;
1204 return WRC_Abort;
1205}
1206static int exprIsConst(Expr *p, int initFlag){
1207 Walker w;
1208 w.u.i = initFlag;
1209 w.xExprCallback = exprNodeIsConstant;
1210 w.xSelectCallback = selectNodeIsConstant;
1211 sqlite3WalkExpr(&w, p);
1212 return w.u.i;
1213}
drh626a8792005-01-17 22:08:19 +00001214
1215/*
drhfef52082000-06-06 01:50:43 +00001216** Walk an expression tree. Return 1 if the expression is constant
drheb55bd22005-06-30 17:04:21 +00001217** and 0 if it involves variables or function calls.
drh23989372002-05-21 13:43:04 +00001218**
1219** For the purposes of this function, a double-quoted string (ex: "abc")
1220** is considered a variable but a single-quoted string (ex: 'abc') is
1221** a constant.
drhfef52082000-06-06 01:50:43 +00001222*/
danielk19774adee202004-05-08 08:23:19 +00001223int sqlite3ExprIsConstant(Expr *p){
drh7d10d5a2008-08-20 16:35:10 +00001224 return exprIsConst(p, 1);
drhfef52082000-06-06 01:50:43 +00001225}
1226
1227/*
drheb55bd22005-06-30 17:04:21 +00001228** Walk an expression tree. Return 1 if the expression is constant
drh0a168372007-06-08 00:20:47 +00001229** that does no originate from the ON or USING clauses of a join.
1230** Return 0 if it involves variables or function calls or terms from
1231** an ON or USING clause.
1232*/
1233int sqlite3ExprIsConstantNotJoin(Expr *p){
drh7d10d5a2008-08-20 16:35:10 +00001234 return exprIsConst(p, 3);
drh0a168372007-06-08 00:20:47 +00001235}
1236
1237/*
1238** Walk an expression tree. Return 1 if the expression is constant
drheb55bd22005-06-30 17:04:21 +00001239** or a function call with constant arguments. Return and 0 if there
1240** are any variables.
1241**
1242** For the purposes of this function, a double-quoted string (ex: "abc")
1243** is considered a variable but a single-quoted string (ex: 'abc') is
1244** a constant.
1245*/
1246int sqlite3ExprIsConstantOrFunction(Expr *p){
drh7d10d5a2008-08-20 16:35:10 +00001247 return exprIsConst(p, 2);
drheb55bd22005-06-30 17:04:21 +00001248}
1249
1250/*
drh73b211a2005-01-18 04:00:42 +00001251** If the expression p codes a constant integer that is small enough
drh202b2df2004-01-06 01:13:46 +00001252** to fit in a 32-bit integer, return 1 and put the value of the integer
1253** in *pValue. If the expression is not an integer or if it is too big
1254** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
drhe4de1fe2002-06-02 16:09:01 +00001255*/
danielk19774adee202004-05-08 08:23:19 +00001256int sqlite3ExprIsInteger(Expr *p, int *pValue){
drh92b01d52008-06-24 00:32:35 +00001257 int rc = 0;
drhcd92e842011-02-17 15:58:20 +00001258
1259 /* If an expression is an integer literal that fits in a signed 32-bit
1260 ** integer, then the EP_IntValue flag will have already been set */
1261 assert( p->op!=TK_INTEGER || (p->flags & EP_IntValue)!=0
1262 || sqlite3GetInt32(p->u.zToken, &rc)==0 );
1263
drh92b01d52008-06-24 00:32:35 +00001264 if( p->flags & EP_IntValue ){
drh33e619f2009-05-28 01:00:55 +00001265 *pValue = p->u.iValue;
drh92b01d52008-06-24 00:32:35 +00001266 return 1;
1267 }
drhe4de1fe2002-06-02 16:09:01 +00001268 switch( p->op ){
drh4b59ab52002-08-24 18:24:51 +00001269 case TK_UPLUS: {
drh92b01d52008-06-24 00:32:35 +00001270 rc = sqlite3ExprIsInteger(p->pLeft, pValue);
drhf6e369a2008-06-24 12:46:30 +00001271 break;
drh4b59ab52002-08-24 18:24:51 +00001272 }
drhe4de1fe2002-06-02 16:09:01 +00001273 case TK_UMINUS: {
1274 int v;
danielk19774adee202004-05-08 08:23:19 +00001275 if( sqlite3ExprIsInteger(p->pLeft, &v) ){
drhe4de1fe2002-06-02 16:09:01 +00001276 *pValue = -v;
drh92b01d52008-06-24 00:32:35 +00001277 rc = 1;
drhe4de1fe2002-06-02 16:09:01 +00001278 }
1279 break;
1280 }
1281 default: break;
1282 }
drh92b01d52008-06-24 00:32:35 +00001283 return rc;
drhe4de1fe2002-06-02 16:09:01 +00001284}
1285
1286/*
drh039fc322009-11-17 18:31:47 +00001287** Return FALSE if there is no chance that the expression can be NULL.
1288**
1289** If the expression might be NULL or if the expression is too complex
1290** to tell return TRUE.
1291**
1292** This routine is used as an optimization, to skip OP_IsNull opcodes
1293** when we know that a value cannot be NULL. Hence, a false positive
1294** (returning TRUE when in fact the expression can never be NULL) might
1295** be a small performance hit but is otherwise harmless. On the other
1296** hand, a false negative (returning FALSE when the result could be NULL)
1297** will likely result in an incorrect answer. So when in doubt, return
1298** TRUE.
1299*/
1300int sqlite3ExprCanBeNull(const Expr *p){
1301 u8 op;
drhcd7f4572009-11-19 14:48:40 +00001302 while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ p = p->pLeft; }
drh039fc322009-11-17 18:31:47 +00001303 op = p->op;
1304 if( op==TK_REGISTER ) op = p->op2;
1305 switch( op ){
1306 case TK_INTEGER:
1307 case TK_STRING:
1308 case TK_FLOAT:
1309 case TK_BLOB:
1310 return 0;
1311 default:
1312 return 1;
1313 }
1314}
1315
1316/*
drh2f2855b2009-11-18 01:25:26 +00001317** Generate an OP_IsNull instruction that tests register iReg and jumps
1318** to location iDest if the value in iReg is NULL. The value in iReg
1319** was computed by pExpr. If we can look at pExpr at compile-time and
1320** determine that it can never generate a NULL, then the OP_IsNull operation
1321** can be omitted.
1322*/
1323void sqlite3ExprCodeIsNullJump(
1324 Vdbe *v, /* The VDBE under construction */
1325 const Expr *pExpr, /* Only generate OP_IsNull if this expr can be NULL */
1326 int iReg, /* Test the value in this register for NULL */
1327 int iDest /* Jump here if the value is null */
1328){
1329 if( sqlite3ExprCanBeNull(pExpr) ){
1330 sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iDest);
1331 }
1332}
1333
1334/*
drh039fc322009-11-17 18:31:47 +00001335** Return TRUE if the given expression is a constant which would be
1336** unchanged by OP_Affinity with the affinity given in the second
1337** argument.
1338**
1339** This routine is used to determine if the OP_Affinity operation
1340** can be omitted. When in doubt return FALSE. A false negative
1341** is harmless. A false positive, however, can result in the wrong
1342** answer.
1343*/
1344int sqlite3ExprNeedsNoAffinityChange(const Expr *p, char aff){
1345 u8 op;
1346 if( aff==SQLITE_AFF_NONE ) return 1;
drhcd7f4572009-11-19 14:48:40 +00001347 while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ p = p->pLeft; }
drh039fc322009-11-17 18:31:47 +00001348 op = p->op;
1349 if( op==TK_REGISTER ) op = p->op2;
1350 switch( op ){
1351 case TK_INTEGER: {
1352 return aff==SQLITE_AFF_INTEGER || aff==SQLITE_AFF_NUMERIC;
1353 }
1354 case TK_FLOAT: {
1355 return aff==SQLITE_AFF_REAL || aff==SQLITE_AFF_NUMERIC;
1356 }
1357 case TK_STRING: {
1358 return aff==SQLITE_AFF_TEXT;
1359 }
1360 case TK_BLOB: {
1361 return 1;
1362 }
drh2f2855b2009-11-18 01:25:26 +00001363 case TK_COLUMN: {
drh88376ca2009-11-19 15:44:53 +00001364 assert( p->iTable>=0 ); /* p cannot be part of a CHECK constraint */
1365 return p->iColumn<0
1366 && (aff==SQLITE_AFF_INTEGER || aff==SQLITE_AFF_NUMERIC);
drh2f2855b2009-11-18 01:25:26 +00001367 }
drh039fc322009-11-17 18:31:47 +00001368 default: {
1369 return 0;
1370 }
1371 }
1372}
1373
1374/*
drhc4a3c772001-04-04 11:48:57 +00001375** Return TRUE if the given string is a row-id column name.
1376*/
danielk19774adee202004-05-08 08:23:19 +00001377int sqlite3IsRowid(const char *z){
1378 if( sqlite3StrICmp(z, "_ROWID_")==0 ) return 1;
1379 if( sqlite3StrICmp(z, "ROWID")==0 ) return 1;
1380 if( sqlite3StrICmp(z, "OID")==0 ) return 1;
drhc4a3c772001-04-04 11:48:57 +00001381 return 0;
1382}
1383
danielk19779a96b662007-11-29 17:05:18 +00001384/*
drhb74b1012009-05-28 21:04:37 +00001385** Return true if we are able to the IN operator optimization on a
1386** query of the form
drhb287f4b2008-04-25 00:08:38 +00001387**
drhb74b1012009-05-28 21:04:37 +00001388** x IN (SELECT ...)
drhb287f4b2008-04-25 00:08:38 +00001389**
drhb74b1012009-05-28 21:04:37 +00001390** Where the SELECT... clause is as specified by the parameter to this
1391** routine.
1392**
1393** The Select object passed in has already been preprocessed and no
1394** errors have been found.
drhb287f4b2008-04-25 00:08:38 +00001395*/
1396#ifndef SQLITE_OMIT_SUBQUERY
1397static int isCandidateForInOpt(Select *p){
1398 SrcList *pSrc;
1399 ExprList *pEList;
1400 Table *pTab;
drhb287f4b2008-04-25 00:08:38 +00001401 if( p==0 ) return 0; /* right-hand side of IN is SELECT */
1402 if( p->pPrior ) return 0; /* Not a compound SELECT */
drh7d10d5a2008-08-20 16:35:10 +00001403 if( p->selFlags & (SF_Distinct|SF_Aggregate) ){
drhb74b1012009-05-28 21:04:37 +00001404 testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct );
1405 testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate );
1406 return 0; /* No DISTINCT keyword and no aggregate functions */
drh7d10d5a2008-08-20 16:35:10 +00001407 }
drhb74b1012009-05-28 21:04:37 +00001408 assert( p->pGroupBy==0 ); /* Has no GROUP BY clause */
drhb287f4b2008-04-25 00:08:38 +00001409 if( p->pLimit ) return 0; /* Has no LIMIT clause */
drhb74b1012009-05-28 21:04:37 +00001410 assert( p->pOffset==0 ); /* No LIMIT means no OFFSET */
drhb287f4b2008-04-25 00:08:38 +00001411 if( p->pWhere ) return 0; /* Has no WHERE clause */
1412 pSrc = p->pSrc;
drhd1fa7bc2009-01-10 13:24:50 +00001413 assert( pSrc!=0 );
1414 if( pSrc->nSrc!=1 ) return 0; /* Single term in FROM clause */
drhb74b1012009-05-28 21:04:37 +00001415 if( pSrc->a[0].pSelect ) return 0; /* FROM is not a subquery or view */
drhb287f4b2008-04-25 00:08:38 +00001416 pTab = pSrc->a[0].pTab;
drhb74b1012009-05-28 21:04:37 +00001417 if( NEVER(pTab==0) ) return 0;
1418 assert( pTab->pSelect==0 ); /* FROM clause is not a view */
drhb287f4b2008-04-25 00:08:38 +00001419 if( IsVirtual(pTab) ) return 0; /* FROM clause not a virtual table */
1420 pEList = p->pEList;
1421 if( pEList->nExpr!=1 ) return 0; /* One column in the result set */
1422 if( pEList->a[0].pExpr->op!=TK_COLUMN ) return 0; /* Result is a column */
1423 return 1;
1424}
1425#endif /* SQLITE_OMIT_SUBQUERY */
1426
1427/*
dan1d8cb212011-12-09 13:24:16 +00001428** Code an OP_Once instruction and allocate space for its flag. Return the
1429** address of the new instruction.
1430*/
1431int sqlite3CodeOnce(Parse *pParse){
1432 Vdbe *v = sqlite3GetVdbe(pParse); /* Virtual machine being coded */
1433 return sqlite3VdbeAddOp1(v, OP_Once, pParse->nOnce++);
1434}
1435
1436/*
danielk19779a96b662007-11-29 17:05:18 +00001437** This function is used by the implementation of the IN (...) operator.
drhd4305ca2012-09-18 17:08:33 +00001438** The pX parameter is the expression on the RHS of the IN operator, which
1439** might be either a list of expressions or a subquery.
danielk19779a96b662007-11-29 17:05:18 +00001440**
drhd4305ca2012-09-18 17:08:33 +00001441** The job of this routine is to find or create a b-tree object that can
1442** be used either to test for membership in the RHS set or to iterate through
1443** all members of the RHS set, skipping duplicates.
1444**
1445** A cursor is opened on the b-tree object that the RHS of the IN operator
1446** and pX->iTable is set to the index of that cursor.
1447**
drhb74b1012009-05-28 21:04:37 +00001448** The returned value of this function indicates the b-tree type, as follows:
danielk19779a96b662007-11-29 17:05:18 +00001449**
1450** IN_INDEX_ROWID - The cursor was opened on a database table.
drh2d401ab2008-01-10 23:50:11 +00001451** IN_INDEX_INDEX - The cursor was opened on a database index.
danielk19779a96b662007-11-29 17:05:18 +00001452** IN_INDEX_EPH - The cursor was opened on a specially created and
1453** populated epheremal table.
1454**
drhd4305ca2012-09-18 17:08:33 +00001455** An existing b-tree might be used if the RHS expression pX is a simple
1456** subquery such as:
danielk19779a96b662007-11-29 17:05:18 +00001457**
1458** SELECT <column> FROM <table>
1459**
drhd4305ca2012-09-18 17:08:33 +00001460** If the RHS of the IN operator is a list or a more complex subquery, then
1461** an ephemeral table might need to be generated from the RHS and then
1462** pX->iTable made to point to the ephermeral table instead of an
1463** existing table.
1464**
drhb74b1012009-05-28 21:04:37 +00001465** If the prNotFound parameter is 0, then the b-tree will be used to iterate
danielk19779a96b662007-11-29 17:05:18 +00001466** through the set members, skipping any duplicates. In this case an
1467** epheremal table must be used unless the selected <column> is guaranteed
1468** to be unique - either because it is an INTEGER PRIMARY KEY or it
drhb74b1012009-05-28 21:04:37 +00001469** has a UNIQUE constraint or UNIQUE index.
danielk19770cdc0222008-06-26 18:04:03 +00001470**
drhb74b1012009-05-28 21:04:37 +00001471** If the prNotFound parameter is not 0, then the b-tree will be used
danielk19770cdc0222008-06-26 18:04:03 +00001472** for fast set membership tests. In this case an epheremal table must
1473** be used unless <column> is an INTEGER PRIMARY KEY or an index can
1474** be found with <column> as its left-most column.
1475**
drhb74b1012009-05-28 21:04:37 +00001476** When the b-tree is being used for membership tests, the calling function
danielk19770cdc0222008-06-26 18:04:03 +00001477** needs to know whether or not the structure contains an SQL NULL
1478** value in order to correctly evaluate expressions like "X IN (Y, Z)".
drhe3365e62009-11-12 17:52:24 +00001479** If there is any chance that the (...) might contain a NULL value at
danielk19770cdc0222008-06-26 18:04:03 +00001480** runtime, then a register is allocated and the register number written
drhe3365e62009-11-12 17:52:24 +00001481** to *prNotFound. If there is no chance that the (...) contains a
danielk19770cdc0222008-06-26 18:04:03 +00001482** NULL value, then *prNotFound is left unchanged.
1483**
1484** If a register is allocated and its location stored in *prNotFound, then
drhe3365e62009-11-12 17:52:24 +00001485** its initial value is NULL. If the (...) does not remain constant
1486** for the duration of the query (i.e. the SELECT within the (...)
drhb74b1012009-05-28 21:04:37 +00001487** is a correlated subquery) then the value of the allocated register is
drhe3365e62009-11-12 17:52:24 +00001488** reset to NULL each time the subquery is rerun. This allows the
drhb74b1012009-05-28 21:04:37 +00001489** caller to use vdbe code equivalent to the following:
danielk19770cdc0222008-06-26 18:04:03 +00001490**
1491** if( register==NULL ){
1492** has_null = <test if data structure contains null>
1493** register = 1
1494** }
1495**
1496** in order to avoid running the <test if data structure contains null>
1497** test more often than is necessary.
danielk19779a96b662007-11-29 17:05:18 +00001498*/
danielk1977284f4ac2007-12-10 05:03:46 +00001499#ifndef SQLITE_OMIT_SUBQUERY
danielk19770cdc0222008-06-26 18:04:03 +00001500int sqlite3FindInIndex(Parse *pParse, Expr *pX, int *prNotFound){
drhb74b1012009-05-28 21:04:37 +00001501 Select *p; /* SELECT to the right of IN operator */
1502 int eType = 0; /* Type of RHS table. IN_INDEX_* */
1503 int iTab = pParse->nTab++; /* Cursor of the RHS table */
1504 int mustBeUnique = (prNotFound==0); /* True if RHS must be unique */
drhb8475df2011-12-09 16:21:19 +00001505 Vdbe *v = sqlite3GetVdbe(pParse); /* Virtual machine being coded */
danielk19779a96b662007-11-29 17:05:18 +00001506
drh1450bc62009-10-30 13:25:56 +00001507 assert( pX->op==TK_IN );
1508
drhb74b1012009-05-28 21:04:37 +00001509 /* Check to see if an existing table or index can be used to
1510 ** satisfy the query. This is preferable to generating a new
1511 ** ephemeral table.
danielk19779a96b662007-11-29 17:05:18 +00001512 */
danielk19776ab3a2e2009-02-19 14:39:25 +00001513 p = (ExprHasProperty(pX, EP_xIsSelect) ? pX->x.pSelect : 0);
drhfd773cf2009-05-29 14:39:07 +00001514 if( ALWAYS(pParse->nErr==0) && isCandidateForInOpt(p) ){
danielk1977e1fb65a2009-04-02 17:23:32 +00001515 sqlite3 *db = pParse->db; /* Database connection */
drhb07028f2011-10-14 21:49:18 +00001516 Table *pTab; /* Table <table>. */
1517 Expr *pExpr; /* Expression <column> */
1518 int iCol; /* Index of column <column> */
danielk1977e1fb65a2009-04-02 17:23:32 +00001519 int iDb; /* Database idx for pTab */
drhb07028f2011-10-14 21:49:18 +00001520
1521 assert( p ); /* Because of isCandidateForInOpt(p) */
1522 assert( p->pEList!=0 ); /* Because of isCandidateForInOpt(p) */
1523 assert( p->pEList->a[0].pExpr!=0 ); /* Because of isCandidateForInOpt(p) */
1524 assert( p->pSrc!=0 ); /* Because of isCandidateForInOpt(p) */
1525 pTab = p->pSrc->a[0].pTab;
1526 pExpr = p->pEList->a[0].pExpr;
1527 iCol = pExpr->iColumn;
danielk1977e1fb65a2009-04-02 17:23:32 +00001528
1529 /* Code an OP_VerifyCookie and OP_TableLock for <table>. */
1530 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
1531 sqlite3CodeVerifySchema(pParse, iDb);
1532 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
danielk19779a96b662007-11-29 17:05:18 +00001533
1534 /* This function is only called from two places. In both cases the vdbe
1535 ** has already been allocated. So assume sqlite3GetVdbe() is always
1536 ** successful here.
1537 */
1538 assert(v);
1539 if( iCol<0 ){
danielk19779a96b662007-11-29 17:05:18 +00001540 int iAddr;
danielk19779a96b662007-11-29 17:05:18 +00001541
dan1d8cb212011-12-09 13:24:16 +00001542 iAddr = sqlite3CodeOnce(pParse);
danielk19779a96b662007-11-29 17:05:18 +00001543
1544 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
1545 eType = IN_INDEX_ROWID;
1546
1547 sqlite3VdbeJumpHere(v, iAddr);
1548 }else{
danielk1977e1fb65a2009-04-02 17:23:32 +00001549 Index *pIdx; /* Iterator variable */
1550
drhb74b1012009-05-28 21:04:37 +00001551 /* The collation sequence used by the comparison. If an index is to
danielk19779a96b662007-11-29 17:05:18 +00001552 ** be used in place of a temp-table, it must be ordered according
danielk1977e1fb65a2009-04-02 17:23:32 +00001553 ** to this collation sequence. */
danielk19779a96b662007-11-29 17:05:18 +00001554 CollSeq *pReq = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pExpr);
1555
1556 /* Check that the affinity that will be used to perform the
1557 ** comparison is the same as the affinity of the column. If
1558 ** it is not, it is not possible to use any index.
1559 */
drhdbaee5e2012-09-18 19:29:06 +00001560 int affinity_ok = sqlite3IndexAffinityOk(pX, pTab->aCol[iCol].affinity);
danielk19779a96b662007-11-29 17:05:18 +00001561
1562 for(pIdx=pTab->pIndex; pIdx && eType==0 && affinity_ok; pIdx=pIdx->pNext){
1563 if( (pIdx->aiColumn[0]==iCol)
drhb74b1012009-05-28 21:04:37 +00001564 && sqlite3FindCollSeq(db, ENC(db), pIdx->azColl[0], 0)==pReq
danielk19779a96b662007-11-29 17:05:18 +00001565 && (!mustBeUnique || (pIdx->nColumn==1 && pIdx->onError!=OE_None))
1566 ){
danielk19779a96b662007-11-29 17:05:18 +00001567 int iAddr;
1568 char *pKey;
1569
1570 pKey = (char *)sqlite3IndexKeyinfo(pParse, pIdx);
dan1d8cb212011-12-09 13:24:16 +00001571 iAddr = sqlite3CodeOnce(pParse);
danielk19779a96b662007-11-29 17:05:18 +00001572
danielk1977207872a2008-01-03 07:54:23 +00001573 sqlite3VdbeAddOp4(v, OP_OpenRead, iTab, pIdx->tnum, iDb,
drh66a51672008-01-03 00:01:23 +00001574 pKey,P4_KEYINFO_HANDOFF);
danielk1977207872a2008-01-03 07:54:23 +00001575 VdbeComment((v, "%s", pIdx->zName));
danielk19779a96b662007-11-29 17:05:18 +00001576 eType = IN_INDEX_INDEX;
danielk19779a96b662007-11-29 17:05:18 +00001577
1578 sqlite3VdbeJumpHere(v, iAddr);
danielk19770cdc0222008-06-26 18:04:03 +00001579 if( prNotFound && !pTab->aCol[iCol].notNull ){
1580 *prNotFound = ++pParse->nMem;
drhb8475df2011-12-09 16:21:19 +00001581 sqlite3VdbeAddOp2(v, OP_Null, 0, *prNotFound);
danielk19770cdc0222008-06-26 18:04:03 +00001582 }
danielk19779a96b662007-11-29 17:05:18 +00001583 }
1584 }
1585 }
1586 }
1587
1588 if( eType==0 ){
drh1450bc62009-10-30 13:25:56 +00001589 /* Could not found an existing table or index to use as the RHS b-tree.
drhb74b1012009-05-28 21:04:37 +00001590 ** We will have to generate an ephemeral table to do the job.
1591 */
drhcf4d38a2010-07-28 02:53:36 +00001592 double savedNQueryLoop = pParse->nQueryLoop;
danielk19770cdc0222008-06-26 18:04:03 +00001593 int rMayHaveNull = 0;
danielk197741a05b72008-10-02 13:50:55 +00001594 eType = IN_INDEX_EPH;
danielk19770cdc0222008-06-26 18:04:03 +00001595 if( prNotFound ){
1596 *prNotFound = rMayHaveNull = ++pParse->nMem;
drhb8475df2011-12-09 16:21:19 +00001597 sqlite3VdbeAddOp2(v, OP_Null, 0, *prNotFound);
drhcf4d38a2010-07-28 02:53:36 +00001598 }else{
1599 testcase( pParse->nQueryLoop>(double)1 );
1600 pParse->nQueryLoop = (double)1;
1601 if( pX->pLeft->iColumn<0 && !ExprHasAnyProperty(pX, EP_xIsSelect) ){
1602 eType = IN_INDEX_ROWID;
1603 }
danielk19770cdc0222008-06-26 18:04:03 +00001604 }
danielk197741a05b72008-10-02 13:50:55 +00001605 sqlite3CodeSubselect(pParse, pX, rMayHaveNull, eType==IN_INDEX_ROWID);
drhcf4d38a2010-07-28 02:53:36 +00001606 pParse->nQueryLoop = savedNQueryLoop;
danielk19779a96b662007-11-29 17:05:18 +00001607 }else{
1608 pX->iTable = iTab;
1609 }
1610 return eType;
1611}
danielk1977284f4ac2007-12-10 05:03:46 +00001612#endif
drh626a8792005-01-17 22:08:19 +00001613
1614/*
drhd4187c72010-08-30 22:15:45 +00001615** Generate code for scalar subqueries used as a subquery expression, EXISTS,
1616** or IN operators. Examples:
drh626a8792005-01-17 22:08:19 +00001617**
drh9cbe6352005-11-29 03:13:21 +00001618** (SELECT a FROM b) -- subquery
1619** EXISTS (SELECT a FROM b) -- EXISTS subquery
1620** x IN (4,5,11) -- IN operator with list on right-hand side
1621** x IN (SELECT a FROM b) -- IN operator with subquery on the right
drhfef52082000-06-06 01:50:43 +00001622**
drh9cbe6352005-11-29 03:13:21 +00001623** The pExpr parameter describes the expression that contains the IN
1624** operator or subquery.
danielk197741a05b72008-10-02 13:50:55 +00001625**
1626** If parameter isRowid is non-zero, then expression pExpr is guaranteed
1627** to be of the form "<rowid> IN (?, ?, ?)", where <rowid> is a reference
1628** to some integer key column of a table B-Tree. In this case, use an
1629** intkey B-Tree to store the set of IN(...) values instead of the usual
1630** (slower) variable length keys B-Tree.
drhfd773cf2009-05-29 14:39:07 +00001631**
1632** If rMayHaveNull is non-zero, that means that the operation is an IN
1633** (not a SELECT or EXISTS) and that the RHS might contains NULLs.
1634** Furthermore, the IN is in a WHERE clause and that we really want
1635** to iterate over the RHS of the IN operator in order to quickly locate
1636** all corresponding LHS elements. All this routine does is initialize
1637** the register given by rMayHaveNull to NULL. Calling routines will take
1638** care of changing this register value to non-NULL if the RHS is NULL-free.
1639**
1640** If rMayHaveNull is zero, that means that the subquery is being used
1641** for membership testing only. There is no need to initialize any
1642** registers to indicate the presense or absence of NULLs on the RHS.
drh1450bc62009-10-30 13:25:56 +00001643**
1644** For a SELECT or EXISTS operator, return the register that holds the
1645** result. For IN operators or if an error occurs, the return value is 0.
drhcce7d172000-05-31 15:34:51 +00001646*/
drh51522cd2005-01-20 13:36:19 +00001647#ifndef SQLITE_OMIT_SUBQUERY
drh1450bc62009-10-30 13:25:56 +00001648int sqlite3CodeSubselect(
drhfd773cf2009-05-29 14:39:07 +00001649 Parse *pParse, /* Parsing context */
1650 Expr *pExpr, /* The IN, SELECT, or EXISTS operator */
1651 int rMayHaveNull, /* Register that records whether NULLs exist in RHS */
1652 int isRowid /* If true, LHS of IN operator is a rowid */
danielk197741a05b72008-10-02 13:50:55 +00001653){
drhdfd2d9f2011-09-16 22:10:57 +00001654 int testAddr = -1; /* One-time test address */
drh1450bc62009-10-30 13:25:56 +00001655 int rReg = 0; /* Register storing resulting */
danielk1977b3bce662005-01-29 08:32:43 +00001656 Vdbe *v = sqlite3GetVdbe(pParse);
drh1450bc62009-10-30 13:25:56 +00001657 if( NEVER(v==0) ) return 0;
drhceea3322009-04-23 13:22:42 +00001658 sqlite3ExprCachePush(pParse);
danielk1977fc976062007-05-10 10:46:56 +00001659
drh57dbd7b2005-07-08 18:25:26 +00001660 /* This code must be run in its entirety every time it is encountered
1661 ** if any of the following is true:
1662 **
1663 ** * The right-hand side is a correlated subquery
1664 ** * The right-hand side is an expression list containing variables
1665 ** * We are inside a trigger
1666 **
1667 ** If all of the above are false, then we can run this code just once
1668 ** save the results, and reuse the same result on subsequent invocations.
danielk1977b3bce662005-01-29 08:32:43 +00001669 */
dan1d8cb212011-12-09 13:24:16 +00001670 if( !ExprHasAnyProperty(pExpr, EP_VarSelect) ){
1671 testAddr = sqlite3CodeOnce(pParse);
danielk1977b3bce662005-01-29 08:32:43 +00001672 }
1673
dan4a07e3d2010-11-09 14:48:59 +00001674#ifndef SQLITE_OMIT_EXPLAIN
1675 if( pParse->explain==2 ){
1676 char *zMsg = sqlite3MPrintf(
drhdfd2d9f2011-09-16 22:10:57 +00001677 pParse->db, "EXECUTE %s%s SUBQUERY %d", testAddr>=0?"":"CORRELATED ",
dan4a07e3d2010-11-09 14:48:59 +00001678 pExpr->op==TK_IN?"LIST":"SCALAR", pParse->iNextSelectId
1679 );
1680 sqlite3VdbeAddOp4(v, OP_Explain, pParse->iSelectId, 0, 0, zMsg, P4_DYNAMIC);
1681 }
1682#endif
1683
drhcce7d172000-05-31 15:34:51 +00001684 switch( pExpr->op ){
drhfef52082000-06-06 01:50:43 +00001685 case TK_IN: {
drhd4187c72010-08-30 22:15:45 +00001686 char affinity; /* Affinity of the LHS of the IN */
1687 KeyInfo keyInfo; /* Keyinfo for the generated table */
drhe1a022e2012-09-17 17:16:53 +00001688 static u8 sortOrder = 0; /* Fake aSortOrder for keyInfo */
drhd4187c72010-08-30 22:15:45 +00001689 int addr; /* Address of OP_OpenEphemeral instruction */
1690 Expr *pLeft = pExpr->pLeft; /* the LHS of the IN operator */
drhd3d39e92004-05-20 22:16:29 +00001691
danielk19770cdc0222008-06-26 18:04:03 +00001692 if( rMayHaveNull ){
1693 sqlite3VdbeAddOp2(v, OP_Null, 0, rMayHaveNull);
1694 }
1695
danielk197741a05b72008-10-02 13:50:55 +00001696 affinity = sqlite3ExprAffinity(pLeft);
danielk1977e014a832004-05-17 10:48:57 +00001697
1698 /* Whether this is an 'x IN(SELECT...)' or an 'x IN(<exprlist>)'
drh8cff69d2009-11-12 19:59:44 +00001699 ** expression it is handled the same way. An ephemeral table is
danielk1977e014a832004-05-17 10:48:57 +00001700 ** filled with single-field index keys representing the results
1701 ** from the SELECT or the <exprlist>.
1702 **
1703 ** If the 'x' expression is a column value, or the SELECT...
1704 ** statement returns a column value, then the affinity of that
1705 ** column is used to build the index keys. If both 'x' and the
1706 ** SELECT... statement are columns, then numeric affinity is used
1707 ** if either column has NUMERIC or INTEGER affinity. If neither
1708 ** 'x' nor the SELECT... statement are columns, then numeric affinity
1709 ** is used.
1710 */
1711 pExpr->iTable = pParse->nTab++;
danielk197741a05b72008-10-02 13:50:55 +00001712 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, !isRowid);
drhd4187c72010-08-30 22:15:45 +00001713 if( rMayHaveNull==0 ) sqlite3VdbeChangeP5(v, BTREE_UNORDERED);
drhd3d39e92004-05-20 22:16:29 +00001714 memset(&keyInfo, 0, sizeof(keyInfo));
1715 keyInfo.nField = 1;
drhe1a022e2012-09-17 17:16:53 +00001716 keyInfo.aSortOrder = &sortOrder;
danielk1977e014a832004-05-17 10:48:57 +00001717
danielk19776ab3a2e2009-02-19 14:39:25 +00001718 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
drhfef52082000-06-06 01:50:43 +00001719 /* Case 1: expr IN (SELECT ...)
1720 **
danielk1977e014a832004-05-17 10:48:57 +00001721 ** Generate code to write the results of the select into the temporary
1722 ** table allocated and opened above.
drhfef52082000-06-06 01:50:43 +00001723 */
drh1013c932008-01-06 00:25:21 +00001724 SelectDest dest;
drhbe5c89a2004-07-26 00:31:09 +00001725 ExprList *pEList;
drh1013c932008-01-06 00:25:21 +00001726
danielk197741a05b72008-10-02 13:50:55 +00001727 assert( !isRowid );
drh1013c932008-01-06 00:25:21 +00001728 sqlite3SelectDestInit(&dest, SRT_Set, pExpr->iTable);
drh2b596da2012-07-23 21:43:19 +00001729 dest.affSdst = (u8)affinity;
danielk1977e014a832004-05-17 10:48:57 +00001730 assert( (pExpr->iTable&0x0000FFFF)==pExpr->iTable );
drh48b5b042010-12-06 18:50:32 +00001731 pExpr->x.pSelect->iLimit = 0;
danielk19776ab3a2e2009-02-19 14:39:25 +00001732 if( sqlite3Select(pParse, pExpr->x.pSelect, &dest) ){
drh1450bc62009-10-30 13:25:56 +00001733 return 0;
drh94ccde52007-04-13 16:06:32 +00001734 }
danielk19776ab3a2e2009-02-19 14:39:25 +00001735 pEList = pExpr->x.pSelect->pEList;
drhfd773cf2009-05-29 14:39:07 +00001736 if( ALWAYS(pEList!=0 && pEList->nExpr>0) ){
danielk1977bcbb04e2007-05-29 12:11:29 +00001737 keyInfo.aColl[0] = sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft,
drhbe5c89a2004-07-26 00:31:09 +00001738 pEList->a[0].pExpr);
danielk19770202b292004-06-09 09:55:16 +00001739 }
drha7d2db12010-07-14 20:23:52 +00001740 }else if( ALWAYS(pExpr->x.pList!=0) ){
drhfef52082000-06-06 01:50:43 +00001741 /* Case 2: expr IN (exprlist)
1742 **
drhfd131da2007-08-07 17:13:03 +00001743 ** For each expression, build an index key from the evaluation and
danielk1977e014a832004-05-17 10:48:57 +00001744 ** store it in the temporary table. If <expr> is a column, then use
1745 ** that columns affinity when building index keys. If <expr> is not
1746 ** a column, use numeric affinity.
drhfef52082000-06-06 01:50:43 +00001747 */
danielk1977e014a832004-05-17 10:48:57 +00001748 int i;
danielk19776ab3a2e2009-02-19 14:39:25 +00001749 ExprList *pList = pExpr->x.pList;
drh57dbd7b2005-07-08 18:25:26 +00001750 struct ExprList_item *pItem;
drhecc31802008-06-26 20:06:06 +00001751 int r1, r2, r3;
drh57dbd7b2005-07-08 18:25:26 +00001752
danielk1977e014a832004-05-17 10:48:57 +00001753 if( !affinity ){
drh8159a352006-05-23 23:22:29 +00001754 affinity = SQLITE_AFF_NONE;
danielk1977e014a832004-05-17 10:48:57 +00001755 }
drh7d10d5a2008-08-20 16:35:10 +00001756 keyInfo.aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
drhe1a022e2012-09-17 17:16:53 +00001757 keyInfo.aSortOrder = &sortOrder;
danielk1977e014a832004-05-17 10:48:57 +00001758
1759 /* Loop through each expression in <exprlist>. */
drh2d401ab2008-01-10 23:50:11 +00001760 r1 = sqlite3GetTempReg(pParse);
1761 r2 = sqlite3GetTempReg(pParse);
danielk19774e7f36a2008-10-02 16:42:06 +00001762 sqlite3VdbeAddOp2(v, OP_Null, 0, r2);
drh57dbd7b2005-07-08 18:25:26 +00001763 for(i=pList->nExpr, pItem=pList->a; i>0; i--, pItem++){
1764 Expr *pE2 = pItem->pExpr;
drhe05c9292009-10-29 13:48:10 +00001765 int iValToIns;
danielk1977e014a832004-05-17 10:48:57 +00001766
drh57dbd7b2005-07-08 18:25:26 +00001767 /* If the expression is not constant then we will need to
1768 ** disable the test that was generated above that makes sure
1769 ** this code only executes once. Because for a non-constant
1770 ** expression we need to rerun this code each time.
1771 */
drhdfd2d9f2011-09-16 22:10:57 +00001772 if( testAddr>=0 && !sqlite3ExprIsConstant(pE2) ){
drh48f2d3b2011-09-16 01:34:43 +00001773 sqlite3VdbeChangeToNoop(v, testAddr);
drhdfd2d9f2011-09-16 22:10:57 +00001774 testAddr = -1;
drh4794b982000-06-06 13:54:14 +00001775 }
danielk1977e014a832004-05-17 10:48:57 +00001776
1777 /* Evaluate the expression and insert it into the temp table */
drhe05c9292009-10-29 13:48:10 +00001778 if( isRowid && sqlite3ExprIsInteger(pE2, &iValToIns) ){
1779 sqlite3VdbeAddOp3(v, OP_InsertInt, pExpr->iTable, r2, iValToIns);
danielk197741a05b72008-10-02 13:50:55 +00001780 }else{
drhe05c9292009-10-29 13:48:10 +00001781 r3 = sqlite3ExprCodeTarget(pParse, pE2, r1);
1782 if( isRowid ){
1783 sqlite3VdbeAddOp2(v, OP_MustBeInt, r3,
1784 sqlite3VdbeCurrentAddr(v)+2);
1785 sqlite3VdbeAddOp3(v, OP_Insert, pExpr->iTable, r2, r3);
1786 }else{
1787 sqlite3VdbeAddOp4(v, OP_MakeRecord, r3, 1, r2, &affinity, 1);
1788 sqlite3ExprCacheAffinityChange(pParse, r3, 1);
1789 sqlite3VdbeAddOp2(v, OP_IdxInsert, pExpr->iTable, r2);
1790 }
danielk197741a05b72008-10-02 13:50:55 +00001791 }
drhfef52082000-06-06 01:50:43 +00001792 }
drh2d401ab2008-01-10 23:50:11 +00001793 sqlite3ReleaseTempReg(pParse, r1);
1794 sqlite3ReleaseTempReg(pParse, r2);
drhfef52082000-06-06 01:50:43 +00001795 }
danielk197741a05b72008-10-02 13:50:55 +00001796 if( !isRowid ){
1797 sqlite3VdbeChangeP4(v, addr, (void *)&keyInfo, P4_KEYINFO);
1798 }
danielk1977b3bce662005-01-29 08:32:43 +00001799 break;
drhfef52082000-06-06 01:50:43 +00001800 }
1801
drh51522cd2005-01-20 13:36:19 +00001802 case TK_EXISTS:
drhfd773cf2009-05-29 14:39:07 +00001803 case TK_SELECT:
1804 default: {
drhfd773cf2009-05-29 14:39:07 +00001805 /* If this has to be a scalar SELECT. Generate code to put the
drhfef52082000-06-06 01:50:43 +00001806 ** value of this select in a memory cell and record the number
drhfd773cf2009-05-29 14:39:07 +00001807 ** of the memory cell in iColumn. If this is an EXISTS, write
1808 ** an integer 0 (not exists) or 1 (exists) into a memory cell
1809 ** and record that memory cell in iColumn.
drhfef52082000-06-06 01:50:43 +00001810 */
drhfd773cf2009-05-29 14:39:07 +00001811 Select *pSel; /* SELECT statement to encode */
1812 SelectDest dest; /* How to deal with SELECt result */
drh1398ad32005-01-19 23:24:50 +00001813
shanecf697392009-06-01 16:53:09 +00001814 testcase( pExpr->op==TK_EXISTS );
1815 testcase( pExpr->op==TK_SELECT );
1816 assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT );
1817
danielk19776ab3a2e2009-02-19 14:39:25 +00001818 assert( ExprHasProperty(pExpr, EP_xIsSelect) );
1819 pSel = pExpr->x.pSelect;
drh1013c932008-01-06 00:25:21 +00001820 sqlite3SelectDestInit(&dest, 0, ++pParse->nMem);
drh51522cd2005-01-20 13:36:19 +00001821 if( pExpr->op==TK_SELECT ){
danielk19776c8c8ce2008-01-02 16:27:09 +00001822 dest.eDest = SRT_Mem;
drh2b596da2012-07-23 21:43:19 +00001823 sqlite3VdbeAddOp2(v, OP_Null, 0, dest.iSDParm);
drhd4e70eb2008-01-02 00:34:36 +00001824 VdbeComment((v, "Init subquery result"));
drh51522cd2005-01-20 13:36:19 +00001825 }else{
danielk19776c8c8ce2008-01-02 16:27:09 +00001826 dest.eDest = SRT_Exists;
drh2b596da2012-07-23 21:43:19 +00001827 sqlite3VdbeAddOp2(v, OP_Integer, 0, dest.iSDParm);
drhd4e70eb2008-01-02 00:34:36 +00001828 VdbeComment((v, "Init EXISTS result"));
drh51522cd2005-01-20 13:36:19 +00001829 }
drh633e6d52008-07-28 19:34:53 +00001830 sqlite3ExprDelete(pParse->db, pSel->pLimit);
drh094430e2010-07-14 18:24:06 +00001831 pSel->pLimit = sqlite3PExpr(pParse, TK_INTEGER, 0, 0,
1832 &sqlite3IntTokens[1]);
drh48b5b042010-12-06 18:50:32 +00001833 pSel->iLimit = 0;
drh7d10d5a2008-08-20 16:35:10 +00001834 if( sqlite3Select(pParse, pSel, &dest) ){
drh1450bc62009-10-30 13:25:56 +00001835 return 0;
drh94ccde52007-04-13 16:06:32 +00001836 }
drh2b596da2012-07-23 21:43:19 +00001837 rReg = dest.iSDParm;
drh33e619f2009-05-28 01:00:55 +00001838 ExprSetIrreducible(pExpr);
danielk1977b3bce662005-01-29 08:32:43 +00001839 break;
drhcce7d172000-05-31 15:34:51 +00001840 }
1841 }
danielk1977b3bce662005-01-29 08:32:43 +00001842
drhdfd2d9f2011-09-16 22:10:57 +00001843 if( testAddr>=0 ){
drh48f2d3b2011-09-16 01:34:43 +00001844 sqlite3VdbeJumpHere(v, testAddr);
danielk1977b3bce662005-01-29 08:32:43 +00001845 }
drhceea3322009-04-23 13:22:42 +00001846 sqlite3ExprCachePop(pParse, 1);
danielk1977fc976062007-05-10 10:46:56 +00001847
drh1450bc62009-10-30 13:25:56 +00001848 return rReg;
drhcce7d172000-05-31 15:34:51 +00001849}
drh51522cd2005-01-20 13:36:19 +00001850#endif /* SQLITE_OMIT_SUBQUERY */
drhcce7d172000-05-31 15:34:51 +00001851
drhe3365e62009-11-12 17:52:24 +00001852#ifndef SQLITE_OMIT_SUBQUERY
1853/*
1854** Generate code for an IN expression.
1855**
1856** x IN (SELECT ...)
1857** x IN (value, value, ...)
1858**
1859** The left-hand side (LHS) is a scalar expression. The right-hand side (RHS)
1860** is an array of zero or more values. The expression is true if the LHS is
1861** contained within the RHS. The value of the expression is unknown (NULL)
1862** if the LHS is NULL or if the LHS is not contained within the RHS and the
1863** RHS contains one or more NULL values.
1864**
1865** This routine generates code will jump to destIfFalse if the LHS is not
1866** contained within the RHS. If due to NULLs we cannot determine if the LHS
1867** is contained in the RHS then jump to destIfNull. If the LHS is contained
1868** within the RHS then fall through.
1869*/
1870static void sqlite3ExprCodeIN(
1871 Parse *pParse, /* Parsing and code generating context */
1872 Expr *pExpr, /* The IN expression */
1873 int destIfFalse, /* Jump here if LHS is not contained in the RHS */
1874 int destIfNull /* Jump here if the results are unknown due to NULLs */
1875){
1876 int rRhsHasNull = 0; /* Register that is true if RHS contains NULL values */
1877 char affinity; /* Comparison affinity to use */
1878 int eType; /* Type of the RHS */
1879 int r1; /* Temporary use register */
1880 Vdbe *v; /* Statement under construction */
1881
1882 /* Compute the RHS. After this step, the table with cursor
1883 ** pExpr->iTable will contains the values that make up the RHS.
1884 */
1885 v = pParse->pVdbe;
1886 assert( v!=0 ); /* OOM detected prior to this routine */
1887 VdbeNoopComment((v, "begin IN expr"));
1888 eType = sqlite3FindInIndex(pParse, pExpr, &rRhsHasNull);
1889
1890 /* Figure out the affinity to use to create a key from the results
1891 ** of the expression. affinityStr stores a static string suitable for
1892 ** P4 of OP_MakeRecord.
1893 */
1894 affinity = comparisonAffinity(pExpr);
1895
1896 /* Code the LHS, the <expr> from "<expr> IN (...)".
1897 */
1898 sqlite3ExprCachePush(pParse);
1899 r1 = sqlite3GetTempReg(pParse);
1900 sqlite3ExprCode(pParse, pExpr->pLeft, r1);
drhe3365e62009-11-12 17:52:24 +00001901
drh094430e2010-07-14 18:24:06 +00001902 /* If the LHS is NULL, then the result is either false or NULL depending
1903 ** on whether the RHS is empty or not, respectively.
1904 */
1905 if( destIfNull==destIfFalse ){
1906 /* Shortcut for the common case where the false and NULL outcomes are
1907 ** the same. */
1908 sqlite3VdbeAddOp2(v, OP_IsNull, r1, destIfNull);
1909 }else{
1910 int addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, r1);
1911 sqlite3VdbeAddOp2(v, OP_Rewind, pExpr->iTable, destIfFalse);
1912 sqlite3VdbeAddOp2(v, OP_Goto, 0, destIfNull);
1913 sqlite3VdbeJumpHere(v, addr1);
1914 }
drhe3365e62009-11-12 17:52:24 +00001915
1916 if( eType==IN_INDEX_ROWID ){
1917 /* In this case, the RHS is the ROWID of table b-tree
1918 */
1919 sqlite3VdbeAddOp2(v, OP_MustBeInt, r1, destIfFalse);
1920 sqlite3VdbeAddOp3(v, OP_NotExists, pExpr->iTable, destIfFalse, r1);
1921 }else{
1922 /* In this case, the RHS is an index b-tree.
1923 */
drh8cff69d2009-11-12 19:59:44 +00001924 sqlite3VdbeAddOp4(v, OP_Affinity, r1, 1, 0, &affinity, 1);
drhe3365e62009-11-12 17:52:24 +00001925
1926 /* If the set membership test fails, then the result of the
1927 ** "x IN (...)" expression must be either 0 or NULL. If the set
1928 ** contains no NULL values, then the result is 0. If the set
1929 ** contains one or more NULL values, then the result of the
1930 ** expression is also NULL.
1931 */
1932 if( rRhsHasNull==0 || destIfFalse==destIfNull ){
1933 /* This branch runs if it is known at compile time that the RHS
1934 ** cannot contain NULL values. This happens as the result
1935 ** of a "NOT NULL" constraint in the database schema.
1936 **
1937 ** Also run this branch if NULL is equivalent to FALSE
1938 ** for this particular IN operator.
1939 */
drh8cff69d2009-11-12 19:59:44 +00001940 sqlite3VdbeAddOp4Int(v, OP_NotFound, pExpr->iTable, destIfFalse, r1, 1);
drhe3365e62009-11-12 17:52:24 +00001941
1942 }else{
1943 /* In this branch, the RHS of the IN might contain a NULL and
1944 ** the presence of a NULL on the RHS makes a difference in the
1945 ** outcome.
1946 */
drhe3365e62009-11-12 17:52:24 +00001947 int j1, j2, j3;
1948
1949 /* First check to see if the LHS is contained in the RHS. If so,
1950 ** then the presence of NULLs in the RHS does not matter, so jump
1951 ** over all of the code that follows.
1952 */
drh8cff69d2009-11-12 19:59:44 +00001953 j1 = sqlite3VdbeAddOp4Int(v, OP_Found, pExpr->iTable, 0, r1, 1);
drhe3365e62009-11-12 17:52:24 +00001954
1955 /* Here we begin generating code that runs if the LHS is not
1956 ** contained within the RHS. Generate additional code that
1957 ** tests the RHS for NULLs. If the RHS contains a NULL then
1958 ** jump to destIfNull. If there are no NULLs in the RHS then
1959 ** jump to destIfFalse.
1960 */
1961 j2 = sqlite3VdbeAddOp1(v, OP_NotNull, rRhsHasNull);
drh8cff69d2009-11-12 19:59:44 +00001962 j3 = sqlite3VdbeAddOp4Int(v, OP_Found, pExpr->iTable, 0, rRhsHasNull, 1);
drhe3365e62009-11-12 17:52:24 +00001963 sqlite3VdbeAddOp2(v, OP_Integer, -1, rRhsHasNull);
1964 sqlite3VdbeJumpHere(v, j3);
1965 sqlite3VdbeAddOp2(v, OP_AddImm, rRhsHasNull, 1);
1966 sqlite3VdbeJumpHere(v, j2);
1967
1968 /* Jump to the appropriate target depending on whether or not
1969 ** the RHS contains a NULL
1970 */
1971 sqlite3VdbeAddOp2(v, OP_If, rRhsHasNull, destIfNull);
1972 sqlite3VdbeAddOp2(v, OP_Goto, 0, destIfFalse);
1973
1974 /* The OP_Found at the top of this branch jumps here when true,
1975 ** causing the overall IN expression evaluation to fall through.
1976 */
1977 sqlite3VdbeJumpHere(v, j1);
1978 }
drhe3365e62009-11-12 17:52:24 +00001979 }
1980 sqlite3ReleaseTempReg(pParse, r1);
1981 sqlite3ExprCachePop(pParse, 1);
1982 VdbeComment((v, "end IN expr"));
1983}
1984#endif /* SQLITE_OMIT_SUBQUERY */
1985
drhcce7d172000-05-31 15:34:51 +00001986/*
drh598f1342007-10-23 15:39:45 +00001987** Duplicate an 8-byte value
1988*/
1989static char *dup8bytes(Vdbe *v, const char *in){
1990 char *out = sqlite3DbMallocRaw(sqlite3VdbeDb(v), 8);
1991 if( out ){
1992 memcpy(out, in, 8);
1993 }
1994 return out;
1995}
1996
drh13573c72010-01-12 17:04:07 +00001997#ifndef SQLITE_OMIT_FLOATING_POINT
drh598f1342007-10-23 15:39:45 +00001998/*
1999** Generate an instruction that will put the floating point
drh9cbf3422008-01-17 16:22:13 +00002000** value described by z[0..n-1] into register iMem.
drh0cf19ed2007-10-23 18:55:48 +00002001**
2002** The z[] string will probably not be zero-terminated. But the
2003** z[n] character is guaranteed to be something that does not look
2004** like the continuation of the number.
drh598f1342007-10-23 15:39:45 +00002005*/
drhb7916a72009-05-27 10:31:29 +00002006static void codeReal(Vdbe *v, const char *z, int negateFlag, int iMem){
drhfd773cf2009-05-29 14:39:07 +00002007 if( ALWAYS(z!=0) ){
drh598f1342007-10-23 15:39:45 +00002008 double value;
2009 char *zV;
drh9339da12010-09-30 00:50:49 +00002010 sqlite3AtoF(z, &value, sqlite3Strlen30(z), SQLITE_UTF8);
drhd0015162009-08-21 13:22:25 +00002011 assert( !sqlite3IsNaN(value) ); /* The new AtoF never returns NaN */
2012 if( negateFlag ) value = -value;
2013 zV = dup8bytes(v, (char*)&value);
2014 sqlite3VdbeAddOp4(v, OP_Real, 0, iMem, 0, zV, P4_REAL);
drh598f1342007-10-23 15:39:45 +00002015 }
2016}
drh13573c72010-01-12 17:04:07 +00002017#endif
drh598f1342007-10-23 15:39:45 +00002018
2019
2020/*
drhfec19aa2004-05-19 20:41:03 +00002021** Generate an instruction that will put the integer describe by
drh9cbf3422008-01-17 16:22:13 +00002022** text z[0..n-1] into register iMem.
drh0cf19ed2007-10-23 18:55:48 +00002023**
shaneh5f1d6b62010-09-30 16:51:25 +00002024** Expr.u.zToken is always UTF8 and zero-terminated.
drhfec19aa2004-05-19 20:41:03 +00002025*/
drh13573c72010-01-12 17:04:07 +00002026static void codeInteger(Parse *pParse, Expr *pExpr, int negFlag, int iMem){
2027 Vdbe *v = pParse->pVdbe;
drh92b01d52008-06-24 00:32:35 +00002028 if( pExpr->flags & EP_IntValue ){
drh33e619f2009-05-28 01:00:55 +00002029 int i = pExpr->u.iValue;
drhd50ffc42011-03-08 02:38:28 +00002030 assert( i>=0 );
drh92b01d52008-06-24 00:32:35 +00002031 if( negFlag ) i = -i;
2032 sqlite3VdbeAddOp2(v, OP_Integer, i, iMem);
drhfd773cf2009-05-29 14:39:07 +00002033 }else{
shaneh5f1d6b62010-09-30 16:51:25 +00002034 int c;
2035 i64 value;
drhfd773cf2009-05-29 14:39:07 +00002036 const char *z = pExpr->u.zToken;
2037 assert( z!=0 );
shaneh5f1d6b62010-09-30 16:51:25 +00002038 c = sqlite3Atoi64(z, &value, sqlite3Strlen30(z), SQLITE_UTF8);
2039 if( c==0 || (c==2 && negFlag) ){
drh598f1342007-10-23 15:39:45 +00002040 char *zV;
drh158b9cb2011-03-05 20:59:46 +00002041 if( negFlag ){ value = c==2 ? SMALLEST_INT64 : -value; }
drh598f1342007-10-23 15:39:45 +00002042 zV = dup8bytes(v, (char*)&value);
drh9de221d2008-01-05 06:51:30 +00002043 sqlite3VdbeAddOp4(v, OP_Int64, 0, iMem, 0, zV, P4_INT64);
danielk1977c9cf9012007-05-30 10:36:47 +00002044 }else{
drh13573c72010-01-12 17:04:07 +00002045#ifdef SQLITE_OMIT_FLOATING_POINT
2046 sqlite3ErrorMsg(pParse, "oversized integer: %s%s", negFlag ? "-" : "", z);
2047#else
drhb7916a72009-05-27 10:31:29 +00002048 codeReal(v, z, negFlag, iMem);
drh13573c72010-01-12 17:04:07 +00002049#endif
danielk1977c9cf9012007-05-30 10:36:47 +00002050 }
drhfec19aa2004-05-19 20:41:03 +00002051 }
2052}
2053
drhceea3322009-04-23 13:22:42 +00002054/*
2055** Clear a cache entry.
2056*/
2057static void cacheEntryClear(Parse *pParse, struct yColCache *p){
2058 if( p->tempReg ){
2059 if( pParse->nTempReg<ArraySize(pParse->aTempReg) ){
2060 pParse->aTempReg[pParse->nTempReg++] = p->iReg;
2061 }
2062 p->tempReg = 0;
2063 }
2064}
2065
2066
2067/*
2068** Record in the column cache that a particular column from a
2069** particular table is stored in a particular register.
2070*/
2071void sqlite3ExprCacheStore(Parse *pParse, int iTab, int iCol, int iReg){
2072 int i;
2073 int minLru;
2074 int idxLru;
2075 struct yColCache *p;
2076
drh20411ea2009-05-29 19:00:12 +00002077 assert( iReg>0 ); /* Register numbers are always positive */
2078 assert( iCol>=-1 && iCol<32768 ); /* Finite column numbers */
2079
drhb6da74e2009-12-24 16:00:28 +00002080 /* The SQLITE_ColumnCache flag disables the column cache. This is used
2081 ** for testing only - to verify that SQLite always gets the same answer
2082 ** with and without the column cache.
2083 */
drh7e5418e2012-09-27 15:05:54 +00002084 if( OptimizationDisabled(pParse->db, SQLITE_ColumnCache) ) return;
drhb6da74e2009-12-24 16:00:28 +00002085
drh27ee4062009-12-30 01:13:11 +00002086 /* First replace any existing entry.
2087 **
2088 ** Actually, the way the column cache is currently used, we are guaranteed
2089 ** that the object will never already be in cache. Verify this guarantee.
2090 */
2091#ifndef NDEBUG
drhceea3322009-04-23 13:22:42 +00002092 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
drh27ee4062009-12-30 01:13:11 +00002093 assert( p->iReg==0 || p->iTable!=iTab || p->iColumn!=iCol );
drhceea3322009-04-23 13:22:42 +00002094 }
drh27ee4062009-12-30 01:13:11 +00002095#endif
drhceea3322009-04-23 13:22:42 +00002096
2097 /* Find an empty slot and replace it */
2098 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
2099 if( p->iReg==0 ){
2100 p->iLevel = pParse->iCacheLevel;
2101 p->iTable = iTab;
2102 p->iColumn = iCol;
2103 p->iReg = iReg;
drhceea3322009-04-23 13:22:42 +00002104 p->tempReg = 0;
2105 p->lru = pParse->iCacheCnt++;
2106 return;
2107 }
2108 }
2109
2110 /* Replace the last recently used */
2111 minLru = 0x7fffffff;
2112 idxLru = -1;
2113 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
2114 if( p->lru<minLru ){
2115 idxLru = i;
2116 minLru = p->lru;
2117 }
2118 }
drh20411ea2009-05-29 19:00:12 +00002119 if( ALWAYS(idxLru>=0) ){
drhceea3322009-04-23 13:22:42 +00002120 p = &pParse->aColCache[idxLru];
2121 p->iLevel = pParse->iCacheLevel;
2122 p->iTable = iTab;
2123 p->iColumn = iCol;
2124 p->iReg = iReg;
drhceea3322009-04-23 13:22:42 +00002125 p->tempReg = 0;
2126 p->lru = pParse->iCacheCnt++;
2127 return;
2128 }
2129}
2130
2131/*
drhf49f3522009-12-30 14:12:38 +00002132** Indicate that registers between iReg..iReg+nReg-1 are being overwritten.
2133** Purge the range of registers from the column cache.
drhceea3322009-04-23 13:22:42 +00002134*/
drhf49f3522009-12-30 14:12:38 +00002135void sqlite3ExprCacheRemove(Parse *pParse, int iReg, int nReg){
drhceea3322009-04-23 13:22:42 +00002136 int i;
drhf49f3522009-12-30 14:12:38 +00002137 int iLast = iReg + nReg - 1;
drhceea3322009-04-23 13:22:42 +00002138 struct yColCache *p;
2139 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
drhf49f3522009-12-30 14:12:38 +00002140 int r = p->iReg;
2141 if( r>=iReg && r<=iLast ){
drhceea3322009-04-23 13:22:42 +00002142 cacheEntryClear(pParse, p);
2143 p->iReg = 0;
2144 }
2145 }
2146}
2147
2148/*
2149** Remember the current column cache context. Any new entries added
2150** added to the column cache after this call are removed when the
2151** corresponding pop occurs.
2152*/
2153void sqlite3ExprCachePush(Parse *pParse){
2154 pParse->iCacheLevel++;
2155}
2156
2157/*
2158** Remove from the column cache any entries that were added since the
2159** the previous N Push operations. In other words, restore the cache
2160** to the state it was in N Pushes ago.
2161*/
2162void sqlite3ExprCachePop(Parse *pParse, int N){
2163 int i;
2164 struct yColCache *p;
2165 assert( N>0 );
2166 assert( pParse->iCacheLevel>=N );
2167 pParse->iCacheLevel -= N;
2168 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
2169 if( p->iReg && p->iLevel>pParse->iCacheLevel ){
2170 cacheEntryClear(pParse, p);
2171 p->iReg = 0;
2172 }
2173 }
2174}
drh945498f2007-02-24 11:52:52 +00002175
2176/*
drh5cd79232009-05-25 11:46:29 +00002177** When a cached column is reused, make sure that its register is
2178** no longer available as a temp register. ticket #3879: that same
2179** register might be in the cache in multiple places, so be sure to
2180** get them all.
2181*/
2182static void sqlite3ExprCachePinRegister(Parse *pParse, int iReg){
2183 int i;
2184 struct yColCache *p;
2185 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
2186 if( p->iReg==iReg ){
2187 p->tempReg = 0;
2188 }
2189 }
2190}
2191
2192/*
drh5c092e82010-05-14 19:24:02 +00002193** Generate code to extract the value of the iCol-th column of a table.
2194*/
2195void sqlite3ExprCodeGetColumnOfTable(
2196 Vdbe *v, /* The VDBE under construction */
2197 Table *pTab, /* The table containing the value */
2198 int iTabCur, /* The cursor for this table */
2199 int iCol, /* Index of the column to extract */
2200 int regOut /* Extract the valud into this register */
2201){
2202 if( iCol<0 || iCol==pTab->iPKey ){
2203 sqlite3VdbeAddOp2(v, OP_Rowid, iTabCur, regOut);
2204 }else{
2205 int op = IsVirtual(pTab) ? OP_VColumn : OP_Column;
2206 sqlite3VdbeAddOp3(v, op, iTabCur, iCol, regOut);
2207 }
2208 if( iCol>=0 ){
2209 sqlite3ColumnDefault(v, pTab, iCol, regOut);
2210 }
2211}
2212
2213/*
drh945498f2007-02-24 11:52:52 +00002214** Generate code that will extract the iColumn-th column from
drhe55cbd72008-03-31 23:48:03 +00002215** table pTab and store the column value in a register. An effort
2216** is made to store the column value in register iReg, but this is
2217** not guaranteed. The location of the column value is returned.
2218**
2219** There must be an open cursor to pTab in iTable when this routine
2220** is called. If iColumn<0 then code is generated that extracts the rowid.
drh945498f2007-02-24 11:52:52 +00002221*/
drhe55cbd72008-03-31 23:48:03 +00002222int sqlite3ExprCodeGetColumn(
2223 Parse *pParse, /* Parsing and code generating context */
drh2133d822008-01-03 18:44:59 +00002224 Table *pTab, /* Description of the table we are reading from */
2225 int iColumn, /* Index of the table column */
2226 int iTable, /* The cursor pointing to the table */
drha748fdc2012-03-28 01:34:47 +00002227 int iReg, /* Store results here */
2228 u8 p5 /* P5 value for OP_Column */
drh2133d822008-01-03 18:44:59 +00002229){
drhe55cbd72008-03-31 23:48:03 +00002230 Vdbe *v = pParse->pVdbe;
2231 int i;
drhda250ea2008-04-01 05:07:14 +00002232 struct yColCache *p;
drhe55cbd72008-03-31 23:48:03 +00002233
drhceea3322009-04-23 13:22:42 +00002234 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
drhb6da74e2009-12-24 16:00:28 +00002235 if( p->iReg>0 && p->iTable==iTable && p->iColumn==iColumn ){
drhceea3322009-04-23 13:22:42 +00002236 p->lru = pParse->iCacheCnt++;
drh5cd79232009-05-25 11:46:29 +00002237 sqlite3ExprCachePinRegister(pParse, p->iReg);
drhda250ea2008-04-01 05:07:14 +00002238 return p->iReg;
drhe55cbd72008-03-31 23:48:03 +00002239 }
2240 }
2241 assert( v!=0 );
drh5c092e82010-05-14 19:24:02 +00002242 sqlite3ExprCodeGetColumnOfTable(v, pTab, iTable, iColumn, iReg);
drha748fdc2012-03-28 01:34:47 +00002243 if( p5 ){
2244 sqlite3VdbeChangeP5(v, p5);
2245 }else{
2246 sqlite3ExprCacheStore(pParse, iTable, iColumn, iReg);
2247 }
drhe55cbd72008-03-31 23:48:03 +00002248 return iReg;
2249}
2250
2251/*
drhceea3322009-04-23 13:22:42 +00002252** Clear all column cache entries.
drhe55cbd72008-03-31 23:48:03 +00002253*/
drhceea3322009-04-23 13:22:42 +00002254void sqlite3ExprCacheClear(Parse *pParse){
2255 int i;
2256 struct yColCache *p;
2257
2258 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
2259 if( p->iReg ){
2260 cacheEntryClear(pParse, p);
2261 p->iReg = 0;
drhe55cbd72008-03-31 23:48:03 +00002262 }
drhe55cbd72008-03-31 23:48:03 +00002263 }
2264}
2265
2266/*
drhda250ea2008-04-01 05:07:14 +00002267** Record the fact that an affinity change has occurred on iCount
2268** registers starting with iStart.
drhe55cbd72008-03-31 23:48:03 +00002269*/
drhda250ea2008-04-01 05:07:14 +00002270void sqlite3ExprCacheAffinityChange(Parse *pParse, int iStart, int iCount){
drhf49f3522009-12-30 14:12:38 +00002271 sqlite3ExprCacheRemove(pParse, iStart, iCount);
drhe55cbd72008-03-31 23:48:03 +00002272}
2273
2274/*
drhb21e7c72008-06-22 12:37:57 +00002275** Generate code to move content from registers iFrom...iFrom+nReg-1
2276** over to iTo..iTo+nReg-1. Keep the column cache up-to-date.
drhe55cbd72008-03-31 23:48:03 +00002277*/
drhb21e7c72008-06-22 12:37:57 +00002278void sqlite3ExprCodeMove(Parse *pParse, int iFrom, int iTo, int nReg){
drhe55cbd72008-03-31 23:48:03 +00002279 int i;
drhceea3322009-04-23 13:22:42 +00002280 struct yColCache *p;
drhe8e4af72012-09-21 00:04:28 +00002281 assert( iFrom>=iTo+nReg || iFrom+nReg<=iTo );
2282 sqlite3VdbeAddOp3(pParse->pVdbe, OP_Move, iFrom, iTo, nReg-1);
drhceea3322009-04-23 13:22:42 +00002283 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
2284 int x = p->iReg;
drhb21e7c72008-06-22 12:37:57 +00002285 if( x>=iFrom && x<iFrom+nReg ){
drhceea3322009-04-23 13:22:42 +00002286 p->iReg += iTo-iFrom;
drhe55cbd72008-03-31 23:48:03 +00002287 }
2288 }
drh945498f2007-02-24 11:52:52 +00002289}
2290
drhf49f3522009-12-30 14:12:38 +00002291#if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST)
drh92b01d52008-06-24 00:32:35 +00002292/*
drh652fbf52008-04-01 01:42:41 +00002293** Return true if any register in the range iFrom..iTo (inclusive)
2294** is used as part of the column cache.
drhf49f3522009-12-30 14:12:38 +00002295**
2296** This routine is used within assert() and testcase() macros only
2297** and does not appear in a normal build.
drh652fbf52008-04-01 01:42:41 +00002298*/
2299static int usedAsColumnCache(Parse *pParse, int iFrom, int iTo){
2300 int i;
drhceea3322009-04-23 13:22:42 +00002301 struct yColCache *p;
2302 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
2303 int r = p->iReg;
drhf49f3522009-12-30 14:12:38 +00002304 if( r>=iFrom && r<=iTo ) return 1; /*NO_TEST*/
drh652fbf52008-04-01 01:42:41 +00002305 }
2306 return 0;
2307}
drhf49f3522009-12-30 14:12:38 +00002308#endif /* SQLITE_DEBUG || SQLITE_COVERAGE_TEST */
drh652fbf52008-04-01 01:42:41 +00002309
2310/*
drhcce7d172000-05-31 15:34:51 +00002311** Generate code into the current Vdbe to evaluate the given
drh2dcef112008-01-12 19:03:48 +00002312** expression. Attempt to store the results in register "target".
2313** Return the register where results are stored.
drh389a1ad2008-01-03 23:44:53 +00002314**
drh8b213892008-08-29 02:14:02 +00002315** With this routine, there is no guarantee that results will
drh2dcef112008-01-12 19:03:48 +00002316** be stored in target. The result might be stored in some other
2317** register if it is convenient to do so. The calling function
2318** must check the return code and move the results to the desired
2319** register.
drhcce7d172000-05-31 15:34:51 +00002320*/
drh678ccce2008-03-31 18:19:54 +00002321int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){
drh2dcef112008-01-12 19:03:48 +00002322 Vdbe *v = pParse->pVdbe; /* The VM under construction */
2323 int op; /* The opcode being coded */
2324 int inReg = target; /* Results stored in register inReg */
2325 int regFree1 = 0; /* If non-zero free this temporary register */
2326 int regFree2 = 0; /* If non-zero free this temporary register */
drh678ccce2008-03-31 18:19:54 +00002327 int r1, r2, r3, r4; /* Various register numbers */
drh20411ea2009-05-29 19:00:12 +00002328 sqlite3 *db = pParse->db; /* The database connection */
drhffe07b22005-11-03 00:41:17 +00002329
drh9cbf3422008-01-17 16:22:13 +00002330 assert( target>0 && target<=pParse->nMem );
drh20411ea2009-05-29 19:00:12 +00002331 if( v==0 ){
2332 assert( pParse->db->mallocFailed );
2333 return 0;
2334 }
drh389a1ad2008-01-03 23:44:53 +00002335
2336 if( pExpr==0 ){
2337 op = TK_NULL;
2338 }else{
2339 op = pExpr->op;
2340 }
drhf2bc0132004-10-04 13:19:23 +00002341 switch( op ){
drh13449892005-09-07 21:22:45 +00002342 case TK_AGG_COLUMN: {
2343 AggInfo *pAggInfo = pExpr->pAggInfo;
2344 struct AggInfo_col *pCol = &pAggInfo->aCol[pExpr->iAgg];
2345 if( !pAggInfo->directMode ){
drh9de221d2008-01-05 06:51:30 +00002346 assert( pCol->iMem>0 );
2347 inReg = pCol->iMem;
drh13449892005-09-07 21:22:45 +00002348 break;
2349 }else if( pAggInfo->useSortingIdx ){
dan5134d132011-09-02 10:31:11 +00002350 sqlite3VdbeAddOp3(v, OP_Column, pAggInfo->sortingIdxPTab,
drh389a1ad2008-01-03 23:44:53 +00002351 pCol->iSorterColumn, target);
drh13449892005-09-07 21:22:45 +00002352 break;
2353 }
2354 /* Otherwise, fall thru into the TK_COLUMN case */
2355 }
drh967e8b72000-06-21 13:59:10 +00002356 case TK_COLUMN: {
drhffe07b22005-11-03 00:41:17 +00002357 if( pExpr->iTable<0 ){
2358 /* This only happens when coding check constraints */
drhaa9b8962008-01-08 02:57:55 +00002359 assert( pParse->ckBase>0 );
2360 inReg = pExpr->iColumn + pParse->ckBase;
drhc4a3c772001-04-04 11:48:57 +00002361 }else{
drhe55cbd72008-03-31 23:48:03 +00002362 inReg = sqlite3ExprCodeGetColumn(pParse, pExpr->pTab,
drha748fdc2012-03-28 01:34:47 +00002363 pExpr->iColumn, pExpr->iTable, target,
2364 pExpr->op2);
drh22827922000-06-06 17:27:05 +00002365 }
drhcce7d172000-05-31 15:34:51 +00002366 break;
2367 }
2368 case TK_INTEGER: {
drh13573c72010-01-12 17:04:07 +00002369 codeInteger(pParse, pExpr, 0, target);
drhfec19aa2004-05-19 20:41:03 +00002370 break;
2371 }
drh13573c72010-01-12 17:04:07 +00002372#ifndef SQLITE_OMIT_FLOATING_POINT
drh598f1342007-10-23 15:39:45 +00002373 case TK_FLOAT: {
drh33e619f2009-05-28 01:00:55 +00002374 assert( !ExprHasProperty(pExpr, EP_IntValue) );
2375 codeReal(v, pExpr->u.zToken, 0, target);
drh598f1342007-10-23 15:39:45 +00002376 break;
2377 }
drh13573c72010-01-12 17:04:07 +00002378#endif
drhfec19aa2004-05-19 20:41:03 +00002379 case TK_STRING: {
drh33e619f2009-05-28 01:00:55 +00002380 assert( !ExprHasProperty(pExpr, EP_IntValue) );
2381 sqlite3VdbeAddOp4(v, OP_String8, 0, target, 0, pExpr->u.zToken, 0);
drhcce7d172000-05-31 15:34:51 +00002382 break;
2383 }
drhf0863fe2005-06-12 21:35:51 +00002384 case TK_NULL: {
drh9de221d2008-01-05 06:51:30 +00002385 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
drhf0863fe2005-06-12 21:35:51 +00002386 break;
2387 }
danielk19775338a5f2005-01-20 13:03:10 +00002388#ifndef SQLITE_OMIT_BLOB_LITERAL
danielk1977c572ef72004-05-27 09:28:41 +00002389 case TK_BLOB: {
drh6c8c6ce2005-08-23 11:17:58 +00002390 int n;
2391 const char *z;
drhca48c902008-01-18 14:08:24 +00002392 char *zBlob;
drh33e619f2009-05-28 01:00:55 +00002393 assert( !ExprHasProperty(pExpr, EP_IntValue) );
2394 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
2395 assert( pExpr->u.zToken[1]=='\'' );
2396 z = &pExpr->u.zToken[2];
drhb7916a72009-05-27 10:31:29 +00002397 n = sqlite3Strlen30(z) - 1;
2398 assert( z[n]=='\'' );
drhca48c902008-01-18 14:08:24 +00002399 zBlob = sqlite3HexToBlob(sqlite3VdbeDb(v), z, n);
2400 sqlite3VdbeAddOp4(v, OP_Blob, n/2, target, 0, zBlob, P4_DYNAMIC);
danielk1977c572ef72004-05-27 09:28:41 +00002401 break;
2402 }
danielk19775338a5f2005-01-20 13:03:10 +00002403#endif
drh50457892003-09-06 01:10:47 +00002404 case TK_VARIABLE: {
drh33e619f2009-05-28 01:00:55 +00002405 assert( !ExprHasProperty(pExpr, EP_IntValue) );
2406 assert( pExpr->u.zToken!=0 );
2407 assert( pExpr->u.zToken[0]!=0 );
drheaf52d82010-05-12 13:50:23 +00002408 sqlite3VdbeAddOp2(v, OP_Variable, pExpr->iColumn, target);
2409 if( pExpr->u.zToken[1]!=0 ){
drh04e9eea2011-06-01 19:16:06 +00002410 assert( pExpr->u.zToken[0]=='?'
2411 || strcmp(pExpr->u.zToken, pParse->azVar[pExpr->iColumn-1])==0 );
2412 sqlite3VdbeChangeP4(v, -1, pParse->azVar[pExpr->iColumn-1], P4_STATIC);
drh895d7472004-08-20 16:02:39 +00002413 }
drh50457892003-09-06 01:10:47 +00002414 break;
2415 }
drh4e0cff62004-11-05 05:10:28 +00002416 case TK_REGISTER: {
drh9de221d2008-01-05 06:51:30 +00002417 inReg = pExpr->iTable;
drh4e0cff62004-11-05 05:10:28 +00002418 break;
2419 }
drh8b213892008-08-29 02:14:02 +00002420 case TK_AS: {
drh7445ffe2010-09-27 18:14:12 +00002421 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
drh8b213892008-08-29 02:14:02 +00002422 break;
2423 }
drh487e2622005-06-25 18:42:14 +00002424#ifndef SQLITE_OMIT_CAST
2425 case TK_CAST: {
2426 /* Expressions of the form: CAST(pLeft AS token) */
danielk1977f0113002006-01-24 12:09:17 +00002427 int aff, to_op;
drh2dcef112008-01-12 19:03:48 +00002428 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
drh33e619f2009-05-28 01:00:55 +00002429 assert( !ExprHasProperty(pExpr, EP_IntValue) );
2430 aff = sqlite3AffinityType(pExpr->u.zToken);
danielk1977f0113002006-01-24 12:09:17 +00002431 to_op = aff - SQLITE_AFF_TEXT + OP_ToText;
2432 assert( to_op==OP_ToText || aff!=SQLITE_AFF_TEXT );
2433 assert( to_op==OP_ToBlob || aff!=SQLITE_AFF_NONE );
2434 assert( to_op==OP_ToNumeric || aff!=SQLITE_AFF_NUMERIC );
2435 assert( to_op==OP_ToInt || aff!=SQLITE_AFF_INTEGER );
2436 assert( to_op==OP_ToReal || aff!=SQLITE_AFF_REAL );
drhc5499be2008-04-01 15:06:33 +00002437 testcase( to_op==OP_ToText );
2438 testcase( to_op==OP_ToBlob );
2439 testcase( to_op==OP_ToNumeric );
2440 testcase( to_op==OP_ToInt );
2441 testcase( to_op==OP_ToReal );
drh1735fa82008-11-06 15:33:03 +00002442 if( inReg!=target ){
2443 sqlite3VdbeAddOp2(v, OP_SCopy, inReg, target);
2444 inReg = target;
2445 }
drh2dcef112008-01-12 19:03:48 +00002446 sqlite3VdbeAddOp1(v, to_op, inReg);
drhc5499be2008-04-01 15:06:33 +00002447 testcase( usedAsColumnCache(pParse, inReg, inReg) );
drhb3843a82008-04-01 12:24:11 +00002448 sqlite3ExprCacheAffinityChange(pParse, inReg, 1);
drh487e2622005-06-25 18:42:14 +00002449 break;
2450 }
2451#endif /* SQLITE_OMIT_CAST */
drhc9b84a12002-06-20 11:36:48 +00002452 case TK_LT:
2453 case TK_LE:
2454 case TK_GT:
2455 case TK_GE:
2456 case TK_NE:
2457 case TK_EQ: {
drhf2bc0132004-10-04 13:19:23 +00002458 assert( TK_LT==OP_Lt );
2459 assert( TK_LE==OP_Le );
2460 assert( TK_GT==OP_Gt );
2461 assert( TK_GE==OP_Ge );
2462 assert( TK_EQ==OP_Eq );
2463 assert( TK_NE==OP_Ne );
drhc5499be2008-04-01 15:06:33 +00002464 testcase( op==TK_LT );
2465 testcase( op==TK_LE );
2466 testcase( op==TK_GT );
2467 testcase( op==TK_GE );
2468 testcase( op==TK_EQ );
2469 testcase( op==TK_NE );
drhb6da74e2009-12-24 16:00:28 +00002470 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
2471 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
drh35573352008-01-08 23:54:25 +00002472 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
2473 r1, r2, inReg, SQLITE_STOREP2);
drhc5499be2008-04-01 15:06:33 +00002474 testcase( regFree1==0 );
2475 testcase( regFree2==0 );
danielk1977a37cdde2004-05-16 11:15:36 +00002476 break;
drhc9b84a12002-06-20 11:36:48 +00002477 }
drh6a2fe092009-09-23 02:29:36 +00002478 case TK_IS:
2479 case TK_ISNOT: {
2480 testcase( op==TK_IS );
2481 testcase( op==TK_ISNOT );
drhb6da74e2009-12-24 16:00:28 +00002482 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
2483 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
drh6a2fe092009-09-23 02:29:36 +00002484 op = (op==TK_IS) ? TK_EQ : TK_NE;
2485 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
2486 r1, r2, inReg, SQLITE_STOREP2 | SQLITE_NULLEQ);
2487 testcase( regFree1==0 );
2488 testcase( regFree2==0 );
2489 break;
2490 }
drhcce7d172000-05-31 15:34:51 +00002491 case TK_AND:
2492 case TK_OR:
2493 case TK_PLUS:
2494 case TK_STAR:
2495 case TK_MINUS:
drhbf4133c2001-10-13 02:59:08 +00002496 case TK_REM:
2497 case TK_BITAND:
2498 case TK_BITOR:
drh17c40292004-07-21 02:53:29 +00002499 case TK_SLASH:
drhbf4133c2001-10-13 02:59:08 +00002500 case TK_LSHIFT:
drh855eb1c2004-08-31 13:45:11 +00002501 case TK_RSHIFT:
drh00400772000-06-16 20:51:26 +00002502 case TK_CONCAT: {
drhf2bc0132004-10-04 13:19:23 +00002503 assert( TK_AND==OP_And );
2504 assert( TK_OR==OP_Or );
2505 assert( TK_PLUS==OP_Add );
2506 assert( TK_MINUS==OP_Subtract );
2507 assert( TK_REM==OP_Remainder );
2508 assert( TK_BITAND==OP_BitAnd );
2509 assert( TK_BITOR==OP_BitOr );
2510 assert( TK_SLASH==OP_Divide );
2511 assert( TK_LSHIFT==OP_ShiftLeft );
2512 assert( TK_RSHIFT==OP_ShiftRight );
2513 assert( TK_CONCAT==OP_Concat );
drhc5499be2008-04-01 15:06:33 +00002514 testcase( op==TK_AND );
2515 testcase( op==TK_OR );
2516 testcase( op==TK_PLUS );
2517 testcase( op==TK_MINUS );
2518 testcase( op==TK_REM );
2519 testcase( op==TK_BITAND );
2520 testcase( op==TK_BITOR );
2521 testcase( op==TK_SLASH );
2522 testcase( op==TK_LSHIFT );
2523 testcase( op==TK_RSHIFT );
2524 testcase( op==TK_CONCAT );
drh2dcef112008-01-12 19:03:48 +00002525 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
2526 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
drh5b6afba2008-01-05 16:29:28 +00002527 sqlite3VdbeAddOp3(v, op, r2, r1, target);
drhc5499be2008-04-01 15:06:33 +00002528 testcase( regFree1==0 );
2529 testcase( regFree2==0 );
drh00400772000-06-16 20:51:26 +00002530 break;
2531 }
drhcce7d172000-05-31 15:34:51 +00002532 case TK_UMINUS: {
drhfec19aa2004-05-19 20:41:03 +00002533 Expr *pLeft = pExpr->pLeft;
2534 assert( pLeft );
drh13573c72010-01-12 17:04:07 +00002535 if( pLeft->op==TK_INTEGER ){
2536 codeInteger(pParse, pLeft, 1, target);
2537#ifndef SQLITE_OMIT_FLOATING_POINT
2538 }else if( pLeft->op==TK_FLOAT ){
drh33e619f2009-05-28 01:00:55 +00002539 assert( !ExprHasProperty(pExpr, EP_IntValue) );
2540 codeReal(v, pLeft->u.zToken, 1, target);
drh13573c72010-01-12 17:04:07 +00002541#endif
drh3c84ddf2008-01-09 02:15:38 +00002542 }else{
drh2dcef112008-01-12 19:03:48 +00002543 regFree1 = r1 = sqlite3GetTempReg(pParse);
drh3c84ddf2008-01-09 02:15:38 +00002544 sqlite3VdbeAddOp2(v, OP_Integer, 0, r1);
drhe55cbd72008-03-31 23:48:03 +00002545 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree2);
drh2dcef112008-01-12 19:03:48 +00002546 sqlite3VdbeAddOp3(v, OP_Subtract, r2, r1, target);
drhc5499be2008-04-01 15:06:33 +00002547 testcase( regFree2==0 );
drh6e142f52000-06-08 13:36:40 +00002548 }
drh3c84ddf2008-01-09 02:15:38 +00002549 inReg = target;
2550 break;
drh6e142f52000-06-08 13:36:40 +00002551 }
drhbf4133c2001-10-13 02:59:08 +00002552 case TK_BITNOT:
drh6e142f52000-06-08 13:36:40 +00002553 case TK_NOT: {
drhf2bc0132004-10-04 13:19:23 +00002554 assert( TK_BITNOT==OP_BitNot );
2555 assert( TK_NOT==OP_Not );
drhc5499be2008-04-01 15:06:33 +00002556 testcase( op==TK_BITNOT );
2557 testcase( op==TK_NOT );
drhe99fa2a2008-12-15 15:27:51 +00002558 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
2559 testcase( regFree1==0 );
2560 inReg = target;
2561 sqlite3VdbeAddOp2(v, op, r1, inReg);
drhcce7d172000-05-31 15:34:51 +00002562 break;
2563 }
2564 case TK_ISNULL:
2565 case TK_NOTNULL: {
drh6a288a32008-01-07 19:20:24 +00002566 int addr;
drhf2bc0132004-10-04 13:19:23 +00002567 assert( TK_ISNULL==OP_IsNull );
2568 assert( TK_NOTNULL==OP_NotNull );
drhc5499be2008-04-01 15:06:33 +00002569 testcase( op==TK_ISNULL );
2570 testcase( op==TK_NOTNULL );
drh9de221d2008-01-05 06:51:30 +00002571 sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
drh2dcef112008-01-12 19:03:48 +00002572 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
drhc5499be2008-04-01 15:06:33 +00002573 testcase( regFree1==0 );
drh2dcef112008-01-12 19:03:48 +00002574 addr = sqlite3VdbeAddOp1(v, op, r1);
drh9de221d2008-01-05 06:51:30 +00002575 sqlite3VdbeAddOp2(v, OP_AddImm, target, -1);
drh6a288a32008-01-07 19:20:24 +00002576 sqlite3VdbeJumpHere(v, addr);
drhf2bc0132004-10-04 13:19:23 +00002577 break;
drhcce7d172000-05-31 15:34:51 +00002578 }
drh22827922000-06-06 17:27:05 +00002579 case TK_AGG_FUNCTION: {
drh13449892005-09-07 21:22:45 +00002580 AggInfo *pInfo = pExpr->pAggInfo;
drh7e56e712005-11-16 12:53:15 +00002581 if( pInfo==0 ){
drh33e619f2009-05-28 01:00:55 +00002582 assert( !ExprHasProperty(pExpr, EP_IntValue) );
2583 sqlite3ErrorMsg(pParse, "misuse of aggregate: %s()", pExpr->u.zToken);
drh7e56e712005-11-16 12:53:15 +00002584 }else{
drh9de221d2008-01-05 06:51:30 +00002585 inReg = pInfo->aFunc[pExpr->iAgg].iMem;
drh7e56e712005-11-16 12:53:15 +00002586 }
drh22827922000-06-06 17:27:05 +00002587 break;
2588 }
drhb71090f2005-05-23 17:26:51 +00002589 case TK_CONST_FUNC:
drhcce7d172000-05-31 15:34:51 +00002590 case TK_FUNCTION: {
drh12ffee82009-04-08 13:51:51 +00002591 ExprList *pFarg; /* List of function arguments */
2592 int nFarg; /* Number of function arguments */
2593 FuncDef *pDef; /* The function definition object */
2594 int nId; /* Length of the function name in bytes */
2595 const char *zId; /* The function name */
2596 int constMask = 0; /* Mask of function arguments that are constant */
2597 int i; /* Loop counter */
2598 u8 enc = ENC(db); /* The text encoding used by this database */
2599 CollSeq *pColl = 0; /* A collating sequence */
drh17435752007-08-16 04:30:38 +00002600
danielk19776ab3a2e2009-02-19 14:39:25 +00002601 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
drhc5499be2008-04-01 15:06:33 +00002602 testcase( op==TK_CONST_FUNC );
2603 testcase( op==TK_FUNCTION );
drhb7916a72009-05-27 10:31:29 +00002604 if( ExprHasAnyProperty(pExpr, EP_TokenOnly) ){
drh12ffee82009-04-08 13:51:51 +00002605 pFarg = 0;
2606 }else{
2607 pFarg = pExpr->x.pList;
2608 }
2609 nFarg = pFarg ? pFarg->nExpr : 0;
drh33e619f2009-05-28 01:00:55 +00002610 assert( !ExprHasProperty(pExpr, EP_IntValue) );
2611 zId = pExpr->u.zToken;
drhb7916a72009-05-27 10:31:29 +00002612 nId = sqlite3Strlen30(zId);
drh12ffee82009-04-08 13:51:51 +00002613 pDef = sqlite3FindFunction(db, zId, nId, nFarg, enc, 0);
drhfeb306f2009-08-18 16:05:46 +00002614 if( pDef==0 ){
2615 sqlite3ErrorMsg(pParse, "unknown function: %.*s()", nId, zId);
2616 break;
2617 }
drhae6bb952009-11-11 00:24:31 +00002618
2619 /* Attempt a direct implementation of the built-in COALESCE() and
2620 ** IFNULL() functions. This avoids unnecessary evalation of
2621 ** arguments past the first non-NULL argument.
2622 */
2623 if( pDef->flags & SQLITE_FUNC_COALESCE ){
2624 int endCoalesce = sqlite3VdbeMakeLabel(v);
2625 assert( nFarg>=2 );
2626 sqlite3ExprCode(pParse, pFarg->a[0].pExpr, target);
2627 for(i=1; i<nFarg; i++){
2628 sqlite3VdbeAddOp2(v, OP_NotNull, target, endCoalesce);
drhf49f3522009-12-30 14:12:38 +00002629 sqlite3ExprCacheRemove(pParse, target, 1);
drhae6bb952009-11-11 00:24:31 +00002630 sqlite3ExprCachePush(pParse);
2631 sqlite3ExprCode(pParse, pFarg->a[i].pExpr, target);
2632 sqlite3ExprCachePop(pParse, 1);
2633 }
2634 sqlite3VdbeResolveLabel(v, endCoalesce);
2635 break;
2636 }
2637
2638
drh12ffee82009-04-08 13:51:51 +00002639 if( pFarg ){
2640 r1 = sqlite3GetTempRange(pParse, nFarg);
drha748fdc2012-03-28 01:34:47 +00002641
2642 /* For length() and typeof() functions with a column argument,
2643 ** set the P5 parameter to the OP_Column opcode to OPFLAG_LENGTHARG
2644 ** or OPFLAG_TYPEOFARG respectively, to avoid unnecessary data
2645 ** loading.
2646 */
2647 if( (pDef->flags & (SQLITE_FUNC_LENGTH|SQLITE_FUNC_TYPEOF))!=0 ){
drh4e245a42012-03-30 00:00:36 +00002648 u8 exprOp;
drha748fdc2012-03-28 01:34:47 +00002649 assert( nFarg==1 );
2650 assert( pFarg->a[0].pExpr!=0 );
drh4e245a42012-03-30 00:00:36 +00002651 exprOp = pFarg->a[0].pExpr->op;
2652 if( exprOp==TK_COLUMN || exprOp==TK_AGG_COLUMN ){
drha748fdc2012-03-28 01:34:47 +00002653 assert( SQLITE_FUNC_LENGTH==OPFLAG_LENGTHARG );
2654 assert( SQLITE_FUNC_TYPEOF==OPFLAG_TYPEOFARG );
2655 testcase( pDef->flags==SQLITE_FUNC_LENGTH );
2656 pFarg->a[0].pExpr->op2 = pDef->flags;
2657 }
2658 }
2659
drhd7d385d2009-09-03 01:18:00 +00002660 sqlite3ExprCachePush(pParse); /* Ticket 2ea2425d34be */
drh12ffee82009-04-08 13:51:51 +00002661 sqlite3ExprCodeExprList(pParse, pFarg, r1, 1);
drhd7d385d2009-09-03 01:18:00 +00002662 sqlite3ExprCachePop(pParse, 1); /* Ticket 2ea2425d34be */
drh892d3172008-01-10 03:46:36 +00002663 }else{
drh12ffee82009-04-08 13:51:51 +00002664 r1 = 0;
drh892d3172008-01-10 03:46:36 +00002665 }
drhb7f6f682006-07-08 17:06:43 +00002666#ifndef SQLITE_OMIT_VIRTUALTABLE
drha43fa222006-07-08 18:41:37 +00002667 /* Possibly overload the function if the first argument is
2668 ** a virtual table column.
2669 **
2670 ** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the
2671 ** second argument, not the first, as the argument to test to
2672 ** see if it is a column in a virtual table. This is done because
2673 ** the left operand of infix functions (the operand we want to
2674 ** control overloading) ends up as the second argument to the
2675 ** function. The expression "A glob B" is equivalent to
2676 ** "glob(B,A). We want to use the A in "A glob B" to test
2677 ** for function overloading. But we use the B term in "glob(B,A)".
2678 */
drh12ffee82009-04-08 13:51:51 +00002679 if( nFarg>=2 && (pExpr->flags & EP_InfixFunc) ){
2680 pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[1].pExpr);
2681 }else if( nFarg>0 ){
2682 pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[0].pExpr);
drhb7f6f682006-07-08 17:06:43 +00002683 }
2684#endif
drhf7bca572009-05-30 14:16:31 +00002685 for(i=0; i<nFarg; i++){
2686 if( i<32 && sqlite3ExprIsConstant(pFarg->a[i].pExpr) ){
drh13449892005-09-07 21:22:45 +00002687 constMask |= (1<<i);
danielk1977d02eb1f2004-06-06 09:44:03 +00002688 }
drhe82f5d02008-10-07 19:53:14 +00002689 if( (pDef->flags & SQLITE_FUNC_NEEDCOLL)!=0 && !pColl ){
drh12ffee82009-04-08 13:51:51 +00002690 pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr);
danielk1977dc1bdc42004-06-11 10:51:27 +00002691 }
2692 }
drhe82f5d02008-10-07 19:53:14 +00002693 if( pDef->flags & SQLITE_FUNC_NEEDCOLL ){
drh8b213892008-08-29 02:14:02 +00002694 if( !pColl ) pColl = db->pDfltColl;
drh66a51672008-01-03 00:01:23 +00002695 sqlite3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ);
danielk1977682f68b2004-06-05 10:22:17 +00002696 }
drh2dcef112008-01-12 19:03:48 +00002697 sqlite3VdbeAddOp4(v, OP_Function, constMask, r1, target,
drh66a51672008-01-03 00:01:23 +00002698 (char*)pDef, P4_FUNCDEF);
drh12ffee82009-04-08 13:51:51 +00002699 sqlite3VdbeChangeP5(v, (u8)nFarg);
2700 if( nFarg ){
2701 sqlite3ReleaseTempRange(pParse, r1, nFarg);
drh2dcef112008-01-12 19:03:48 +00002702 }
drhcce7d172000-05-31 15:34:51 +00002703 break;
2704 }
drhfe2093d2005-01-20 22:48:47 +00002705#ifndef SQLITE_OMIT_SUBQUERY
2706 case TK_EXISTS:
drh19a775c2000-06-05 18:54:46 +00002707 case TK_SELECT: {
drhc5499be2008-04-01 15:06:33 +00002708 testcase( op==TK_EXISTS );
2709 testcase( op==TK_SELECT );
drh1450bc62009-10-30 13:25:56 +00002710 inReg = sqlite3CodeSubselect(pParse, pExpr, 0, 0);
drh19a775c2000-06-05 18:54:46 +00002711 break;
2712 }
drhfef52082000-06-06 01:50:43 +00002713 case TK_IN: {
drhe3365e62009-11-12 17:52:24 +00002714 int destIfFalse = sqlite3VdbeMakeLabel(v);
2715 int destIfNull = sqlite3VdbeMakeLabel(v);
2716 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
2717 sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
2718 sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
2719 sqlite3VdbeResolveLabel(v, destIfFalse);
2720 sqlite3VdbeAddOp2(v, OP_AddImm, target, 0);
2721 sqlite3VdbeResolveLabel(v, destIfNull);
drhfef52082000-06-06 01:50:43 +00002722 break;
2723 }
drhe3365e62009-11-12 17:52:24 +00002724#endif /* SQLITE_OMIT_SUBQUERY */
2725
2726
drh2dcef112008-01-12 19:03:48 +00002727 /*
2728 ** x BETWEEN y AND z
2729 **
2730 ** This is equivalent to
2731 **
2732 ** x>=y AND x<=z
2733 **
2734 ** X is stored in pExpr->pLeft.
2735 ** Y is stored in pExpr->pList->a[0].pExpr.
2736 ** Z is stored in pExpr->pList->a[1].pExpr.
2737 */
drhfef52082000-06-06 01:50:43 +00002738 case TK_BETWEEN: {
drhbe5c89a2004-07-26 00:31:09 +00002739 Expr *pLeft = pExpr->pLeft;
danielk19776ab3a2e2009-02-19 14:39:25 +00002740 struct ExprList_item *pLItem = pExpr->x.pList->a;
drhbe5c89a2004-07-26 00:31:09 +00002741 Expr *pRight = pLItem->pExpr;
drh35573352008-01-08 23:54:25 +00002742
drhb6da74e2009-12-24 16:00:28 +00002743 r1 = sqlite3ExprCodeTemp(pParse, pLeft, &regFree1);
2744 r2 = sqlite3ExprCodeTemp(pParse, pRight, &regFree2);
drhc5499be2008-04-01 15:06:33 +00002745 testcase( regFree1==0 );
2746 testcase( regFree2==0 );
drh2dcef112008-01-12 19:03:48 +00002747 r3 = sqlite3GetTempReg(pParse);
drh678ccce2008-03-31 18:19:54 +00002748 r4 = sqlite3GetTempReg(pParse);
drh35573352008-01-08 23:54:25 +00002749 codeCompare(pParse, pLeft, pRight, OP_Ge,
2750 r1, r2, r3, SQLITE_STOREP2);
drhbe5c89a2004-07-26 00:31:09 +00002751 pLItem++;
2752 pRight = pLItem->pExpr;
drh2dcef112008-01-12 19:03:48 +00002753 sqlite3ReleaseTempReg(pParse, regFree2);
2754 r2 = sqlite3ExprCodeTemp(pParse, pRight, &regFree2);
drhc5499be2008-04-01 15:06:33 +00002755 testcase( regFree2==0 );
drh678ccce2008-03-31 18:19:54 +00002756 codeCompare(pParse, pLeft, pRight, OP_Le, r1, r2, r4, SQLITE_STOREP2);
2757 sqlite3VdbeAddOp3(v, OP_And, r3, r4, target);
drh2dcef112008-01-12 19:03:48 +00002758 sqlite3ReleaseTempReg(pParse, r3);
drh678ccce2008-03-31 18:19:54 +00002759 sqlite3ReleaseTempReg(pParse, r4);
drhfef52082000-06-06 01:50:43 +00002760 break;
2761 }
drhae80dde2012-12-06 21:16:43 +00002762 case TK_COLLATE:
drh4f07e5f2007-05-14 11:34:46 +00002763 case TK_UPLUS: {
drh2dcef112008-01-12 19:03:48 +00002764 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
drha2e00042002-01-22 03:13:42 +00002765 break;
2766 }
drh2dcef112008-01-12 19:03:48 +00002767
dan165921a2009-08-28 18:53:45 +00002768 case TK_TRIGGER: {
dan65a7cd12009-09-01 12:16:01 +00002769 /* If the opcode is TK_TRIGGER, then the expression is a reference
2770 ** to a column in the new.* or old.* pseudo-tables available to
2771 ** trigger programs. In this case Expr.iTable is set to 1 for the
2772 ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
2773 ** is set to the column of the pseudo-table to read, or to -1 to
2774 ** read the rowid field.
2775 **
2776 ** The expression is implemented using an OP_Param opcode. The p1
2777 ** parameter is set to 0 for an old.rowid reference, or to (i+1)
2778 ** to reference another column of the old.* pseudo-table, where
2779 ** i is the index of the column. For a new.rowid reference, p1 is
2780 ** set to (n+1), where n is the number of columns in each pseudo-table.
2781 ** For a reference to any other column in the new.* pseudo-table, p1
2782 ** is set to (n+2+i), where n and i are as defined previously. For
2783 ** example, if the table on which triggers are being fired is
2784 ** declared as:
2785 **
2786 ** CREATE TABLE t1(a, b);
2787 **
2788 ** Then p1 is interpreted as follows:
2789 **
2790 ** p1==0 -> old.rowid p1==3 -> new.rowid
2791 ** p1==1 -> old.a p1==4 -> new.a
2792 ** p1==2 -> old.b p1==5 -> new.b
2793 */
dan2832ad42009-08-31 15:27:27 +00002794 Table *pTab = pExpr->pTab;
dan65a7cd12009-09-01 12:16:01 +00002795 int p1 = pExpr->iTable * (pTab->nCol+1) + 1 + pExpr->iColumn;
2796
2797 assert( pExpr->iTable==0 || pExpr->iTable==1 );
2798 assert( pExpr->iColumn>=-1 && pExpr->iColumn<pTab->nCol );
2799 assert( pTab->iPKey<0 || pExpr->iColumn!=pTab->iPKey );
2800 assert( p1>=0 && p1<(pTab->nCol*2+2) );
2801
2802 sqlite3VdbeAddOp2(v, OP_Param, p1, target);
dan2bd93512009-08-31 08:22:46 +00002803 VdbeComment((v, "%s.%s -> $%d",
2804 (pExpr->iTable ? "new" : "old"),
dan76d462e2009-08-30 11:42:51 +00002805 (pExpr->iColumn<0 ? "rowid" : pExpr->pTab->aCol[pExpr->iColumn].zName),
dan2bd93512009-08-31 08:22:46 +00002806 target
dan165921a2009-08-28 18:53:45 +00002807 ));
dan65a7cd12009-09-01 12:16:01 +00002808
drh44dbca82010-01-13 04:22:20 +00002809#ifndef SQLITE_OMIT_FLOATING_POINT
dan65a7cd12009-09-01 12:16:01 +00002810 /* If the column has REAL affinity, it may currently be stored as an
2811 ** integer. Use OP_RealAffinity to make sure it is really real. */
dan2832ad42009-08-31 15:27:27 +00002812 if( pExpr->iColumn>=0
2813 && pTab->aCol[pExpr->iColumn].affinity==SQLITE_AFF_REAL
2814 ){
2815 sqlite3VdbeAddOp1(v, OP_RealAffinity, target);
2816 }
drh44dbca82010-01-13 04:22:20 +00002817#endif
dan165921a2009-08-28 18:53:45 +00002818 break;
2819 }
2820
2821
drh2dcef112008-01-12 19:03:48 +00002822 /*
2823 ** Form A:
2824 ** CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
2825 **
2826 ** Form B:
2827 ** CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
2828 **
2829 ** Form A is can be transformed into the equivalent form B as follows:
2830 ** CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ...
2831 ** WHEN x=eN THEN rN ELSE y END
2832 **
2833 ** X (if it exists) is in pExpr->pLeft.
2834 ** Y is in pExpr->pRight. The Y is also optional. If there is no
2835 ** ELSE clause and no other term matches, then the result of the
2836 ** exprssion is NULL.
2837 ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1].
2838 **
2839 ** The result of the expression is the Ri for the first matching Ei,
2840 ** or if there is no matching Ei, the ELSE term Y, or if there is
2841 ** no ELSE term, NULL.
2842 */
drh33cd4902009-05-30 20:49:20 +00002843 default: assert( op==TK_CASE ); {
drh2dcef112008-01-12 19:03:48 +00002844 int endLabel; /* GOTO label for end of CASE stmt */
2845 int nextCase; /* GOTO label for next WHEN clause */
2846 int nExpr; /* 2x number of WHEN terms */
2847 int i; /* Loop counter */
2848 ExprList *pEList; /* List of WHEN terms */
2849 struct ExprList_item *aListelem; /* Array of WHEN terms */
2850 Expr opCompare; /* The X==Ei expression */
2851 Expr cacheX; /* Cached expression X */
2852 Expr *pX; /* The X expression */
drh1bd10f82008-12-10 21:19:56 +00002853 Expr *pTest = 0; /* X==Ei (form A) or just Ei (form B) */
drhceea3322009-04-23 13:22:42 +00002854 VVA_ONLY( int iCacheLevel = pParse->iCacheLevel; )
drh17a7f8d2002-03-24 13:13:27 +00002855
danielk19776ab3a2e2009-02-19 14:39:25 +00002856 assert( !ExprHasProperty(pExpr, EP_xIsSelect) && pExpr->x.pList );
2857 assert((pExpr->x.pList->nExpr % 2) == 0);
2858 assert(pExpr->x.pList->nExpr > 0);
2859 pEList = pExpr->x.pList;
drhbe5c89a2004-07-26 00:31:09 +00002860 aListelem = pEList->a;
2861 nExpr = pEList->nExpr;
drh2dcef112008-01-12 19:03:48 +00002862 endLabel = sqlite3VdbeMakeLabel(v);
2863 if( (pX = pExpr->pLeft)!=0 ){
2864 cacheX = *pX;
drh33cd4902009-05-30 20:49:20 +00002865 testcase( pX->op==TK_COLUMN );
2866 testcase( pX->op==TK_REGISTER );
drh2dcef112008-01-12 19:03:48 +00002867 cacheX.iTable = sqlite3ExprCodeTemp(pParse, pX, &regFree1);
drhc5499be2008-04-01 15:06:33 +00002868 testcase( regFree1==0 );
drh2dcef112008-01-12 19:03:48 +00002869 cacheX.op = TK_REGISTER;
2870 opCompare.op = TK_EQ;
2871 opCompare.pLeft = &cacheX;
2872 pTest = &opCompare;
drh8b1db072010-09-28 04:14:03 +00002873 /* Ticket b351d95f9cd5ef17e9d9dbae18f5ca8611190001:
2874 ** The value in regFree1 might get SCopy-ed into the file result.
2875 ** So make sure that the regFree1 register is not reused for other
2876 ** purposes and possibly overwritten. */
2877 regFree1 = 0;
drh17a7f8d2002-03-24 13:13:27 +00002878 }
drhf5905aa2002-05-26 20:54:33 +00002879 for(i=0; i<nExpr; i=i+2){
drhceea3322009-04-23 13:22:42 +00002880 sqlite3ExprCachePush(pParse);
drh2dcef112008-01-12 19:03:48 +00002881 if( pX ){
drh1bd10f82008-12-10 21:19:56 +00002882 assert( pTest!=0 );
drh2dcef112008-01-12 19:03:48 +00002883 opCompare.pRight = aListelem[i].pExpr;
drh17a7f8d2002-03-24 13:13:27 +00002884 }else{
drh2dcef112008-01-12 19:03:48 +00002885 pTest = aListelem[i].pExpr;
drh17a7f8d2002-03-24 13:13:27 +00002886 }
drh2dcef112008-01-12 19:03:48 +00002887 nextCase = sqlite3VdbeMakeLabel(v);
drh33cd4902009-05-30 20:49:20 +00002888 testcase( pTest->op==TK_COLUMN );
drh2dcef112008-01-12 19:03:48 +00002889 sqlite3ExprIfFalse(pParse, pTest, nextCase, SQLITE_JUMPIFNULL);
drhc5499be2008-04-01 15:06:33 +00002890 testcase( aListelem[i+1].pExpr->op==TK_COLUMN );
2891 testcase( aListelem[i+1].pExpr->op==TK_REGISTER );
drh9de221d2008-01-05 06:51:30 +00002892 sqlite3ExprCode(pParse, aListelem[i+1].pExpr, target);
drh2dcef112008-01-12 19:03:48 +00002893 sqlite3VdbeAddOp2(v, OP_Goto, 0, endLabel);
drhceea3322009-04-23 13:22:42 +00002894 sqlite3ExprCachePop(pParse, 1);
drh2dcef112008-01-12 19:03:48 +00002895 sqlite3VdbeResolveLabel(v, nextCase);
drhf570f012002-05-31 15:51:25 +00002896 }
drh17a7f8d2002-03-24 13:13:27 +00002897 if( pExpr->pRight ){
drhceea3322009-04-23 13:22:42 +00002898 sqlite3ExprCachePush(pParse);
drh9de221d2008-01-05 06:51:30 +00002899 sqlite3ExprCode(pParse, pExpr->pRight, target);
drhceea3322009-04-23 13:22:42 +00002900 sqlite3ExprCachePop(pParse, 1);
drh17a7f8d2002-03-24 13:13:27 +00002901 }else{
drh9de221d2008-01-05 06:51:30 +00002902 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
drh17a7f8d2002-03-24 13:13:27 +00002903 }
danielk1977c1f4a192009-04-28 12:08:15 +00002904 assert( db->mallocFailed || pParse->nErr>0
2905 || pParse->iCacheLevel==iCacheLevel );
drh2dcef112008-01-12 19:03:48 +00002906 sqlite3VdbeResolveLabel(v, endLabel);
danielk19776f349032002-06-11 02:25:40 +00002907 break;
2908 }
danielk19775338a5f2005-01-20 13:03:10 +00002909#ifndef SQLITE_OMIT_TRIGGER
danielk19776f349032002-06-11 02:25:40 +00002910 case TK_RAISE: {
dan165921a2009-08-28 18:53:45 +00002911 assert( pExpr->affinity==OE_Rollback
2912 || pExpr->affinity==OE_Abort
2913 || pExpr->affinity==OE_Fail
2914 || pExpr->affinity==OE_Ignore
2915 );
dane0af83a2009-09-08 19:15:01 +00002916 if( !pParse->pTriggerTab ){
2917 sqlite3ErrorMsg(pParse,
2918 "RAISE() may only be used within a trigger-program");
2919 return 0;
2920 }
2921 if( pExpr->affinity==OE_Abort ){
2922 sqlite3MayAbort(pParse);
2923 }
dan165921a2009-08-28 18:53:45 +00002924 assert( !ExprHasProperty(pExpr, EP_IntValue) );
dane0af83a2009-09-08 19:15:01 +00002925 if( pExpr->affinity==OE_Ignore ){
2926 sqlite3VdbeAddOp4(
2927 v, OP_Halt, SQLITE_OK, OE_Ignore, 0, pExpr->u.zToken,0);
2928 }else{
2929 sqlite3HaltConstraint(pParse, pExpr->affinity, pExpr->u.zToken, 0);
2930 }
2931
drhffe07b22005-11-03 00:41:17 +00002932 break;
drh17a7f8d2002-03-24 13:13:27 +00002933 }
danielk19775338a5f2005-01-20 13:03:10 +00002934#endif
drhffe07b22005-11-03 00:41:17 +00002935 }
drh2dcef112008-01-12 19:03:48 +00002936 sqlite3ReleaseTempReg(pParse, regFree1);
2937 sqlite3ReleaseTempReg(pParse, regFree2);
2938 return inReg;
2939}
2940
2941/*
2942** Generate code to evaluate an expression and store the results
2943** into a register. Return the register number where the results
2944** are stored.
2945**
2946** If the register is a temporary register that can be deallocated,
drh678ccce2008-03-31 18:19:54 +00002947** then write its number into *pReg. If the result register is not
drh2dcef112008-01-12 19:03:48 +00002948** a temporary, then set *pReg to zero.
2949*/
2950int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){
2951 int r1 = sqlite3GetTempReg(pParse);
2952 int r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
2953 if( r2==r1 ){
2954 *pReg = r1;
2955 }else{
2956 sqlite3ReleaseTempReg(pParse, r1);
2957 *pReg = 0;
2958 }
2959 return r2;
2960}
2961
2962/*
2963** Generate code that will evaluate expression pExpr and store the
2964** results in register target. The results are guaranteed to appear
2965** in register target.
2966*/
2967int sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){
drh9cbf3422008-01-17 16:22:13 +00002968 int inReg;
2969
2970 assert( target>0 && target<=pParse->nMem );
drhebc16712010-09-28 00:25:58 +00002971 if( pExpr && pExpr->op==TK_REGISTER ){
2972 sqlite3VdbeAddOp2(pParse->pVdbe, OP_Copy, pExpr->iTable, target);
2973 }else{
2974 inReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
2975 assert( pParse->pVdbe || pParse->db->mallocFailed );
2976 if( inReg!=target && pParse->pVdbe ){
2977 sqlite3VdbeAddOp2(pParse->pVdbe, OP_SCopy, inReg, target);
2978 }
drhcce7d172000-05-31 15:34:51 +00002979 }
drh389a1ad2008-01-03 23:44:53 +00002980 return target;
drhcce7d172000-05-31 15:34:51 +00002981}
2982
2983/*
drh2dcef112008-01-12 19:03:48 +00002984** Generate code that evalutes the given expression and puts the result
drhde4fcfd2008-01-19 23:50:26 +00002985** in register target.
drh25303782004-12-07 15:41:48 +00002986**
drh2dcef112008-01-12 19:03:48 +00002987** Also make a copy of the expression results into another "cache" register
2988** and modify the expression so that the next time it is evaluated,
2989** the result is a copy of the cache register.
2990**
2991** This routine is used for expressions that are used multiple
2992** times. They are evaluated once and the results of the expression
2993** are reused.
drh25303782004-12-07 15:41:48 +00002994*/
drh2dcef112008-01-12 19:03:48 +00002995int sqlite3ExprCodeAndCache(Parse *pParse, Expr *pExpr, int target){
drh25303782004-12-07 15:41:48 +00002996 Vdbe *v = pParse->pVdbe;
drh2dcef112008-01-12 19:03:48 +00002997 int inReg;
2998 inReg = sqlite3ExprCode(pParse, pExpr, target);
drhde4fcfd2008-01-19 23:50:26 +00002999 assert( target>0 );
drh20bc3932009-05-30 23:35:43 +00003000 /* This routine is called for terms to INSERT or UPDATE. And the only
3001 ** other place where expressions can be converted into TK_REGISTER is
3002 ** in WHERE clause processing. So as currently implemented, there is
3003 ** no way for a TK_REGISTER to exist here. But it seems prudent to
3004 ** keep the ALWAYS() in case the conditions above change with future
3005 ** modifications or enhancements. */
3006 if( ALWAYS(pExpr->op!=TK_REGISTER) ){
drh2dcef112008-01-12 19:03:48 +00003007 int iMem;
drhde4fcfd2008-01-19 23:50:26 +00003008 iMem = ++pParse->nMem;
3009 sqlite3VdbeAddOp2(v, OP_Copy, inReg, iMem);
drh2dcef112008-01-12 19:03:48 +00003010 pExpr->iTable = iMem;
dan937d0de2009-10-15 18:35:38 +00003011 pExpr->op2 = pExpr->op;
drh25303782004-12-07 15:41:48 +00003012 pExpr->op = TK_REGISTER;
3013 }
drh2dcef112008-01-12 19:03:48 +00003014 return inReg;
drh25303782004-12-07 15:41:48 +00003015}
drh2dcef112008-01-12 19:03:48 +00003016
drh678a9aa2011-12-10 15:55:01 +00003017#if defined(SQLITE_ENABLE_TREE_EXPLAIN)
drh7e02e5e2011-12-06 19:44:51 +00003018/*
3019** Generate a human-readable explanation of an expression tree.
3020*/
drha84203a2011-12-07 01:23:51 +00003021void sqlite3ExplainExpr(Vdbe *pOut, Expr *pExpr){
3022 int op; /* The opcode being coded */
3023 const char *zBinOp = 0; /* Binary operator */
3024 const char *zUniOp = 0; /* Unary operator */
3025 if( pExpr==0 ){
3026 op = TK_NULL;
drh7e02e5e2011-12-06 19:44:51 +00003027 }else{
drha84203a2011-12-07 01:23:51 +00003028 op = pExpr->op;
drh7e02e5e2011-12-06 19:44:51 +00003029 }
drha84203a2011-12-07 01:23:51 +00003030 switch( op ){
3031 case TK_AGG_COLUMN: {
drh04b83422011-12-07 15:33:14 +00003032 sqlite3ExplainPrintf(pOut, "AGG{%d:%d}",
3033 pExpr->iTable, pExpr->iColumn);
drha84203a2011-12-07 01:23:51 +00003034 break;
3035 }
3036 case TK_COLUMN: {
3037 if( pExpr->iTable<0 ){
3038 /* This only happens when coding check constraints */
3039 sqlite3ExplainPrintf(pOut, "COLUMN(%d)", pExpr->iColumn);
3040 }else{
drh04b83422011-12-07 15:33:14 +00003041 sqlite3ExplainPrintf(pOut, "{%d:%d}",
3042 pExpr->iTable, pExpr->iColumn);
drha84203a2011-12-07 01:23:51 +00003043 }
3044 break;
3045 }
3046 case TK_INTEGER: {
3047 if( pExpr->flags & EP_IntValue ){
drh04b83422011-12-07 15:33:14 +00003048 sqlite3ExplainPrintf(pOut, "%d", pExpr->u.iValue);
drha84203a2011-12-07 01:23:51 +00003049 }else{
drh04b83422011-12-07 15:33:14 +00003050 sqlite3ExplainPrintf(pOut, "%s", pExpr->u.zToken);
drha84203a2011-12-07 01:23:51 +00003051 }
3052 break;
3053 }
3054#ifndef SQLITE_OMIT_FLOATING_POINT
3055 case TK_FLOAT: {
drh04b83422011-12-07 15:33:14 +00003056 sqlite3ExplainPrintf(pOut,"%s", pExpr->u.zToken);
drha84203a2011-12-07 01:23:51 +00003057 break;
3058 }
3059#endif
3060 case TK_STRING: {
drh04b83422011-12-07 15:33:14 +00003061 sqlite3ExplainPrintf(pOut,"%Q", pExpr->u.zToken);
drha84203a2011-12-07 01:23:51 +00003062 break;
3063 }
3064 case TK_NULL: {
3065 sqlite3ExplainPrintf(pOut,"NULL");
3066 break;
3067 }
3068#ifndef SQLITE_OMIT_BLOB_LITERAL
3069 case TK_BLOB: {
drh04b83422011-12-07 15:33:14 +00003070 sqlite3ExplainPrintf(pOut,"%s", pExpr->u.zToken);
drha84203a2011-12-07 01:23:51 +00003071 break;
3072 }
3073#endif
3074 case TK_VARIABLE: {
3075 sqlite3ExplainPrintf(pOut,"VARIABLE(%s,%d)",
3076 pExpr->u.zToken, pExpr->iColumn);
3077 break;
3078 }
3079 case TK_REGISTER: {
3080 sqlite3ExplainPrintf(pOut,"REGISTER(%d)", pExpr->iTable);
3081 break;
3082 }
3083 case TK_AS: {
3084 sqlite3ExplainExpr(pOut, pExpr->pLeft);
3085 break;
3086 }
3087#ifndef SQLITE_OMIT_CAST
3088 case TK_CAST: {
3089 /* Expressions of the form: CAST(pLeft AS token) */
3090 const char *zAff = "unk";
3091 switch( sqlite3AffinityType(pExpr->u.zToken) ){
3092 case SQLITE_AFF_TEXT: zAff = "TEXT"; break;
3093 case SQLITE_AFF_NONE: zAff = "NONE"; break;
3094 case SQLITE_AFF_NUMERIC: zAff = "NUMERIC"; break;
3095 case SQLITE_AFF_INTEGER: zAff = "INTEGER"; break;
3096 case SQLITE_AFF_REAL: zAff = "REAL"; break;
3097 }
3098 sqlite3ExplainPrintf(pOut, "CAST-%s(", zAff);
3099 sqlite3ExplainExpr(pOut, pExpr->pLeft);
3100 sqlite3ExplainPrintf(pOut, ")");
3101 break;
3102 }
3103#endif /* SQLITE_OMIT_CAST */
3104 case TK_LT: zBinOp = "LT"; break;
3105 case TK_LE: zBinOp = "LE"; break;
3106 case TK_GT: zBinOp = "GT"; break;
3107 case TK_GE: zBinOp = "GE"; break;
3108 case TK_NE: zBinOp = "NE"; break;
3109 case TK_EQ: zBinOp = "EQ"; break;
3110 case TK_IS: zBinOp = "IS"; break;
3111 case TK_ISNOT: zBinOp = "ISNOT"; break;
3112 case TK_AND: zBinOp = "AND"; break;
3113 case TK_OR: zBinOp = "OR"; break;
3114 case TK_PLUS: zBinOp = "ADD"; break;
3115 case TK_STAR: zBinOp = "MUL"; break;
3116 case TK_MINUS: zBinOp = "SUB"; break;
3117 case TK_REM: zBinOp = "REM"; break;
3118 case TK_BITAND: zBinOp = "BITAND"; break;
3119 case TK_BITOR: zBinOp = "BITOR"; break;
3120 case TK_SLASH: zBinOp = "DIV"; break;
3121 case TK_LSHIFT: zBinOp = "LSHIFT"; break;
3122 case TK_RSHIFT: zBinOp = "RSHIFT"; break;
3123 case TK_CONCAT: zBinOp = "CONCAT"; break;
3124
3125 case TK_UMINUS: zUniOp = "UMINUS"; break;
3126 case TK_UPLUS: zUniOp = "UPLUS"; break;
3127 case TK_BITNOT: zUniOp = "BITNOT"; break;
3128 case TK_NOT: zUniOp = "NOT"; break;
3129 case TK_ISNULL: zUniOp = "ISNULL"; break;
3130 case TK_NOTNULL: zUniOp = "NOTNULL"; break;
3131
drh7a66da12012-12-07 20:31:11 +00003132 case TK_COLLATE: {
3133 sqlite3ExplainExpr(pOut, pExpr->pLeft);
3134 sqlite3ExplainPrintf(pOut,".COLLATE(%s)",pExpr->u.zToken);
3135 break;
3136 }
3137
drha84203a2011-12-07 01:23:51 +00003138 case TK_AGG_FUNCTION:
3139 case TK_CONST_FUNC:
3140 case TK_FUNCTION: {
3141 ExprList *pFarg; /* List of function arguments */
3142 if( ExprHasAnyProperty(pExpr, EP_TokenOnly) ){
3143 pFarg = 0;
3144 }else{
3145 pFarg = pExpr->x.pList;
3146 }
drhed551b92012-08-23 19:46:11 +00003147 if( op==TK_AGG_FUNCTION ){
3148 sqlite3ExplainPrintf(pOut, "AGG_FUNCTION%d:%s(",
3149 pExpr->op2, pExpr->u.zToken);
3150 }else{
3151 sqlite3ExplainPrintf(pOut, "FUNCTION:%s(", pExpr->u.zToken);
3152 }
drha84203a2011-12-07 01:23:51 +00003153 if( pFarg ){
3154 sqlite3ExplainExprList(pOut, pFarg);
3155 }
3156 sqlite3ExplainPrintf(pOut, ")");
3157 break;
3158 }
3159#ifndef SQLITE_OMIT_SUBQUERY
3160 case TK_EXISTS: {
3161 sqlite3ExplainPrintf(pOut, "EXISTS(");
3162 sqlite3ExplainSelect(pOut, pExpr->x.pSelect);
3163 sqlite3ExplainPrintf(pOut,")");
3164 break;
3165 }
3166 case TK_SELECT: {
3167 sqlite3ExplainPrintf(pOut, "(");
3168 sqlite3ExplainSelect(pOut, pExpr->x.pSelect);
3169 sqlite3ExplainPrintf(pOut, ")");
3170 break;
3171 }
3172 case TK_IN: {
3173 sqlite3ExplainPrintf(pOut, "IN(");
3174 sqlite3ExplainExpr(pOut, pExpr->pLeft);
3175 sqlite3ExplainPrintf(pOut, ",");
3176 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
3177 sqlite3ExplainSelect(pOut, pExpr->x.pSelect);
3178 }else{
3179 sqlite3ExplainExprList(pOut, pExpr->x.pList);
3180 }
3181 sqlite3ExplainPrintf(pOut, ")");
3182 break;
3183 }
3184#endif /* SQLITE_OMIT_SUBQUERY */
3185
3186 /*
3187 ** x BETWEEN y AND z
3188 **
3189 ** This is equivalent to
3190 **
3191 ** x>=y AND x<=z
3192 **
3193 ** X is stored in pExpr->pLeft.
3194 ** Y is stored in pExpr->pList->a[0].pExpr.
3195 ** Z is stored in pExpr->pList->a[1].pExpr.
3196 */
3197 case TK_BETWEEN: {
3198 Expr *pX = pExpr->pLeft;
3199 Expr *pY = pExpr->x.pList->a[0].pExpr;
3200 Expr *pZ = pExpr->x.pList->a[1].pExpr;
3201 sqlite3ExplainPrintf(pOut, "BETWEEN(");
3202 sqlite3ExplainExpr(pOut, pX);
3203 sqlite3ExplainPrintf(pOut, ",");
3204 sqlite3ExplainExpr(pOut, pY);
3205 sqlite3ExplainPrintf(pOut, ",");
3206 sqlite3ExplainExpr(pOut, pZ);
3207 sqlite3ExplainPrintf(pOut, ")");
3208 break;
3209 }
3210 case TK_TRIGGER: {
3211 /* If the opcode is TK_TRIGGER, then the expression is a reference
3212 ** to a column in the new.* or old.* pseudo-tables available to
3213 ** trigger programs. In this case Expr.iTable is set to 1 for the
3214 ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
3215 ** is set to the column of the pseudo-table to read, or to -1 to
3216 ** read the rowid field.
3217 */
3218 sqlite3ExplainPrintf(pOut, "%s(%d)",
3219 pExpr->iTable ? "NEW" : "OLD", pExpr->iColumn);
3220 break;
3221 }
3222 case TK_CASE: {
3223 sqlite3ExplainPrintf(pOut, "CASE(");
3224 sqlite3ExplainExpr(pOut, pExpr->pLeft);
3225 sqlite3ExplainPrintf(pOut, ",");
3226 sqlite3ExplainExprList(pOut, pExpr->x.pList);
3227 break;
3228 }
3229#ifndef SQLITE_OMIT_TRIGGER
3230 case TK_RAISE: {
3231 const char *zType = "unk";
3232 switch( pExpr->affinity ){
3233 case OE_Rollback: zType = "rollback"; break;
3234 case OE_Abort: zType = "abort"; break;
3235 case OE_Fail: zType = "fail"; break;
3236 case OE_Ignore: zType = "ignore"; break;
3237 }
3238 sqlite3ExplainPrintf(pOut, "RAISE-%s(%s)", zType, pExpr->u.zToken);
3239 break;
3240 }
3241#endif
drh7e02e5e2011-12-06 19:44:51 +00003242 }
drha84203a2011-12-07 01:23:51 +00003243 if( zBinOp ){
3244 sqlite3ExplainPrintf(pOut,"%s(", zBinOp);
3245 sqlite3ExplainExpr(pOut, pExpr->pLeft);
3246 sqlite3ExplainPrintf(pOut,",");
3247 sqlite3ExplainExpr(pOut, pExpr->pRight);
3248 sqlite3ExplainPrintf(pOut,")");
3249 }else if( zUniOp ){
3250 sqlite3ExplainPrintf(pOut,"%s(", zUniOp);
3251 sqlite3ExplainExpr(pOut, pExpr->pLeft);
3252 sqlite3ExplainPrintf(pOut,")");
drh7e02e5e2011-12-06 19:44:51 +00003253 }
drh7e02e5e2011-12-06 19:44:51 +00003254}
drh678a9aa2011-12-10 15:55:01 +00003255#endif /* defined(SQLITE_ENABLE_TREE_EXPLAIN) */
drh7e02e5e2011-12-06 19:44:51 +00003256
drh678a9aa2011-12-10 15:55:01 +00003257#if defined(SQLITE_ENABLE_TREE_EXPLAIN)
drh7e02e5e2011-12-06 19:44:51 +00003258/*
3259** Generate a human-readable explanation of an expression list.
3260*/
3261void sqlite3ExplainExprList(Vdbe *pOut, ExprList *pList){
3262 int i;
drha84203a2011-12-07 01:23:51 +00003263 if( pList==0 || pList->nExpr==0 ){
drh7e02e5e2011-12-06 19:44:51 +00003264 sqlite3ExplainPrintf(pOut, "(empty-list)");
3265 return;
drha84203a2011-12-07 01:23:51 +00003266 }else if( pList->nExpr==1 ){
3267 sqlite3ExplainExpr(pOut, pList->a[0].pExpr);
3268 }else{
drh7e02e5e2011-12-06 19:44:51 +00003269 sqlite3ExplainPush(pOut);
drha84203a2011-12-07 01:23:51 +00003270 for(i=0; i<pList->nExpr; i++){
3271 sqlite3ExplainPrintf(pOut, "item[%d] = ", i);
3272 sqlite3ExplainPush(pOut);
3273 sqlite3ExplainExpr(pOut, pList->a[i].pExpr);
3274 sqlite3ExplainPop(pOut);
3275 if( i<pList->nExpr-1 ){
3276 sqlite3ExplainNL(pOut);
3277 }
drh7e02e5e2011-12-06 19:44:51 +00003278 }
drha84203a2011-12-07 01:23:51 +00003279 sqlite3ExplainPop(pOut);
drh7e02e5e2011-12-06 19:44:51 +00003280 }
drh7e02e5e2011-12-06 19:44:51 +00003281}
3282#endif /* SQLITE_DEBUG */
3283
drh678ccce2008-03-31 18:19:54 +00003284/*
drh47de9552008-04-01 18:04:11 +00003285** Return TRUE if pExpr is an constant expression that is appropriate
3286** for factoring out of a loop. Appropriate expressions are:
3287**
3288** * Any expression that evaluates to two or more opcodes.
3289**
3290** * Any OP_Integer, OP_Real, OP_String, OP_Blob, OP_Null,
3291** or OP_Variable that does not need to be placed in a
3292** specific register.
3293**
3294** There is no point in factoring out single-instruction constant
3295** expressions that need to be placed in a particular register.
3296** We could factor them out, but then we would end up adding an
3297** OP_SCopy instruction to move the value into the correct register
3298** later. We might as well just use the original instruction and
3299** avoid the OP_SCopy.
3300*/
3301static int isAppropriateForFactoring(Expr *p){
3302 if( !sqlite3ExprIsConstantNotJoin(p) ){
3303 return 0; /* Only constant expressions are appropriate for factoring */
3304 }
3305 if( (p->flags & EP_FixedDest)==0 ){
3306 return 1; /* Any constant without a fixed destination is appropriate */
3307 }
3308 while( p->op==TK_UPLUS ) p = p->pLeft;
3309 switch( p->op ){
3310#ifndef SQLITE_OMIT_BLOB_LITERAL
3311 case TK_BLOB:
3312#endif
3313 case TK_VARIABLE:
3314 case TK_INTEGER:
3315 case TK_FLOAT:
3316 case TK_NULL:
3317 case TK_STRING: {
3318 testcase( p->op==TK_BLOB );
3319 testcase( p->op==TK_VARIABLE );
3320 testcase( p->op==TK_INTEGER );
3321 testcase( p->op==TK_FLOAT );
3322 testcase( p->op==TK_NULL );
3323 testcase( p->op==TK_STRING );
3324 /* Single-instruction constants with a fixed destination are
3325 ** better done in-line. If we factor them, they will just end
3326 ** up generating an OP_SCopy to move the value to the destination
3327 ** register. */
3328 return 0;
3329 }
3330 case TK_UMINUS: {
drh20bc3932009-05-30 23:35:43 +00003331 if( p->pLeft->op==TK_FLOAT || p->pLeft->op==TK_INTEGER ){
3332 return 0;
3333 }
3334 break;
drh47de9552008-04-01 18:04:11 +00003335 }
3336 default: {
3337 break;
3338 }
3339 }
3340 return 1;
3341}
3342
3343/*
3344** If pExpr is a constant expression that is appropriate for
3345** factoring out of a loop, then evaluate the expression
drh678ccce2008-03-31 18:19:54 +00003346** into a register and convert the expression into a TK_REGISTER
3347** expression.
3348*/
drh7d10d5a2008-08-20 16:35:10 +00003349static int evalConstExpr(Walker *pWalker, Expr *pExpr){
3350 Parse *pParse = pWalker->pParse;
drh47de9552008-04-01 18:04:11 +00003351 switch( pExpr->op ){
drhe05c9292009-10-29 13:48:10 +00003352 case TK_IN:
drh47de9552008-04-01 18:04:11 +00003353 case TK_REGISTER: {
drh33cd4902009-05-30 20:49:20 +00003354 return WRC_Prune;
drh47de9552008-04-01 18:04:11 +00003355 }
3356 case TK_FUNCTION:
3357 case TK_AGG_FUNCTION:
3358 case TK_CONST_FUNC: {
3359 /* The arguments to a function have a fixed destination.
3360 ** Mark them this way to avoid generated unneeded OP_SCopy
3361 ** instructions.
3362 */
danielk19776ab3a2e2009-02-19 14:39:25 +00003363 ExprList *pList = pExpr->x.pList;
3364 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
drh47de9552008-04-01 18:04:11 +00003365 if( pList ){
3366 int i = pList->nExpr;
3367 struct ExprList_item *pItem = pList->a;
3368 for(; i>0; i--, pItem++){
drh33cd4902009-05-30 20:49:20 +00003369 if( ALWAYS(pItem->pExpr) ) pItem->pExpr->flags |= EP_FixedDest;
drh47de9552008-04-01 18:04:11 +00003370 }
3371 }
3372 break;
3373 }
drh678ccce2008-03-31 18:19:54 +00003374 }
drh47de9552008-04-01 18:04:11 +00003375 if( isAppropriateForFactoring(pExpr) ){
drh678ccce2008-03-31 18:19:54 +00003376 int r1 = ++pParse->nMem;
3377 int r2;
3378 r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
drh4b17cf52012-12-07 14:02:14 +00003379 if( r1!=r2 ) sqlite3ReleaseTempReg(pParse, r1);
danfcd4a152009-08-19 17:17:00 +00003380 pExpr->op2 = pExpr->op;
drh678ccce2008-03-31 18:19:54 +00003381 pExpr->op = TK_REGISTER;
3382 pExpr->iTable = r2;
drh7d10d5a2008-08-20 16:35:10 +00003383 return WRC_Prune;
drh678ccce2008-03-31 18:19:54 +00003384 }
drh7d10d5a2008-08-20 16:35:10 +00003385 return WRC_Continue;
drh678ccce2008-03-31 18:19:54 +00003386}
3387
3388/*
3389** Preevaluate constant subexpressions within pExpr and store the
3390** results in registers. Modify pExpr so that the constant subexpresions
3391** are TK_REGISTER opcodes that refer to the precomputed values.
drhf58ee7f2010-12-06 21:06:09 +00003392**
3393** This routine is a no-op if the jump to the cookie-check code has
3394** already occur. Since the cookie-check jump is generated prior to
3395** any other serious processing, this check ensures that there is no
3396** way to accidently bypass the constant initializations.
3397**
3398** This routine is also a no-op if the SQLITE_FactorOutConst optimization
3399** is disabled via the sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS)
3400** interface. This allows test logic to verify that the same answer is
3401** obtained for queries regardless of whether or not constants are
3402** precomputed into registers or if they are inserted in-line.
drh678ccce2008-03-31 18:19:54 +00003403*/
3404void sqlite3ExprCodeConstants(Parse *pParse, Expr *pExpr){
drh7d10d5a2008-08-20 16:35:10 +00003405 Walker w;
drh48b5b042010-12-06 18:50:32 +00003406 if( pParse->cookieGoto ) return;
drh7e5418e2012-09-27 15:05:54 +00003407 if( OptimizationDisabled(pParse->db, SQLITE_FactorOutConst) ) return;
drh7d10d5a2008-08-20 16:35:10 +00003408 w.xExprCallback = evalConstExpr;
drhef4c0592010-12-06 18:59:13 +00003409 w.xSelectCallback = 0;
drh7d10d5a2008-08-20 16:35:10 +00003410 w.pParse = pParse;
3411 sqlite3WalkExpr(&w, pExpr);
drh678ccce2008-03-31 18:19:54 +00003412}
3413
drh25303782004-12-07 15:41:48 +00003414
3415/*
drh268380c2004-02-25 13:47:31 +00003416** Generate code that pushes the value of every element of the given
drh9cbf3422008-01-17 16:22:13 +00003417** expression list into a sequence of registers beginning at target.
drh268380c2004-02-25 13:47:31 +00003418**
drh892d3172008-01-10 03:46:36 +00003419** Return the number of elements evaluated.
drh268380c2004-02-25 13:47:31 +00003420*/
danielk19774adee202004-05-08 08:23:19 +00003421int sqlite3ExprCodeExprList(
drh268380c2004-02-25 13:47:31 +00003422 Parse *pParse, /* Parsing context */
drh389a1ad2008-01-03 23:44:53 +00003423 ExprList *pList, /* The expression list to be coded */
drh191b54c2008-04-15 12:14:21 +00003424 int target, /* Where to write results */
drhd1766112008-09-17 00:13:12 +00003425 int doHardCopy /* Make a hard copy of every element */
drh268380c2004-02-25 13:47:31 +00003426){
3427 struct ExprList_item *pItem;
drh9cbf3422008-01-17 16:22:13 +00003428 int i, n;
drh9d8b3072008-08-22 16:29:51 +00003429 assert( pList!=0 );
drh9cbf3422008-01-17 16:22:13 +00003430 assert( target>0 );
drhd81a1422010-09-28 07:11:24 +00003431 assert( pParse->pVdbe!=0 ); /* Never gets this far otherwise */
drh268380c2004-02-25 13:47:31 +00003432 n = pList->nExpr;
drh191b54c2008-04-15 12:14:21 +00003433 for(pItem=pList->a, i=0; i<n; i++, pItem++){
drh7445ffe2010-09-27 18:14:12 +00003434 Expr *pExpr = pItem->pExpr;
3435 int inReg = sqlite3ExprCodeTarget(pParse, pExpr, target+i);
drh746fd9c2010-09-28 06:00:47 +00003436 if( inReg!=target+i ){
drh7445ffe2010-09-27 18:14:12 +00003437 sqlite3VdbeAddOp2(pParse->pVdbe, doHardCopy ? OP_Copy : OP_SCopy,
3438 inReg, target+i);
drhd1766112008-09-17 00:13:12 +00003439 }
drh268380c2004-02-25 13:47:31 +00003440 }
drhf9b596e2004-05-26 16:54:42 +00003441 return n;
drh268380c2004-02-25 13:47:31 +00003442}
3443
3444/*
drh36c563a2009-11-12 13:32:22 +00003445** Generate code for a BETWEEN operator.
3446**
3447** x BETWEEN y AND z
3448**
3449** The above is equivalent to
3450**
3451** x>=y AND x<=z
3452**
3453** Code it as such, taking care to do the common subexpression
3454** elementation of x.
3455*/
3456static void exprCodeBetween(
3457 Parse *pParse, /* Parsing and code generating context */
3458 Expr *pExpr, /* The BETWEEN expression */
3459 int dest, /* Jump here if the jump is taken */
3460 int jumpIfTrue, /* Take the jump if the BETWEEN is true */
3461 int jumpIfNull /* Take the jump if the BETWEEN is NULL */
3462){
3463 Expr exprAnd; /* The AND operator in x>=y AND x<=z */
3464 Expr compLeft; /* The x>=y term */
3465 Expr compRight; /* The x<=z term */
3466 Expr exprX; /* The x subexpression */
3467 int regFree1 = 0; /* Temporary use register */
3468
3469 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
3470 exprX = *pExpr->pLeft;
3471 exprAnd.op = TK_AND;
3472 exprAnd.pLeft = &compLeft;
3473 exprAnd.pRight = &compRight;
3474 compLeft.op = TK_GE;
3475 compLeft.pLeft = &exprX;
3476 compLeft.pRight = pExpr->x.pList->a[0].pExpr;
3477 compRight.op = TK_LE;
3478 compRight.pLeft = &exprX;
3479 compRight.pRight = pExpr->x.pList->a[1].pExpr;
3480 exprX.iTable = sqlite3ExprCodeTemp(pParse, &exprX, &regFree1);
3481 exprX.op = TK_REGISTER;
3482 if( jumpIfTrue ){
3483 sqlite3ExprIfTrue(pParse, &exprAnd, dest, jumpIfNull);
3484 }else{
3485 sqlite3ExprIfFalse(pParse, &exprAnd, dest, jumpIfNull);
3486 }
3487 sqlite3ReleaseTempReg(pParse, regFree1);
3488
3489 /* Ensure adequate test coverage */
3490 testcase( jumpIfTrue==0 && jumpIfNull==0 && regFree1==0 );
3491 testcase( jumpIfTrue==0 && jumpIfNull==0 && regFree1!=0 );
3492 testcase( jumpIfTrue==0 && jumpIfNull!=0 && regFree1==0 );
3493 testcase( jumpIfTrue==0 && jumpIfNull!=0 && regFree1!=0 );
3494 testcase( jumpIfTrue!=0 && jumpIfNull==0 && regFree1==0 );
3495 testcase( jumpIfTrue!=0 && jumpIfNull==0 && regFree1!=0 );
3496 testcase( jumpIfTrue!=0 && jumpIfNull!=0 && regFree1==0 );
3497 testcase( jumpIfTrue!=0 && jumpIfNull!=0 && regFree1!=0 );
3498}
3499
3500/*
drhcce7d172000-05-31 15:34:51 +00003501** Generate code for a boolean expression such that a jump is made
3502** to the label "dest" if the expression is true but execution
3503** continues straight thru if the expression is false.
drhf5905aa2002-05-26 20:54:33 +00003504**
3505** If the expression evaluates to NULL (neither true nor false), then
drh35573352008-01-08 23:54:25 +00003506** take the jump if the jumpIfNull flag is SQLITE_JUMPIFNULL.
drhf2bc0132004-10-04 13:19:23 +00003507**
3508** This code depends on the fact that certain token values (ex: TK_EQ)
3509** are the same as opcode values (ex: OP_Eq) that implement the corresponding
3510** operation. Special comments in vdbe.c and the mkopcodeh.awk script in
3511** the make process cause these values to align. Assert()s in the code
3512** below verify that the numbers are aligned correctly.
drhcce7d172000-05-31 15:34:51 +00003513*/
danielk19774adee202004-05-08 08:23:19 +00003514void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
drhcce7d172000-05-31 15:34:51 +00003515 Vdbe *v = pParse->pVdbe;
3516 int op = 0;
drh2dcef112008-01-12 19:03:48 +00003517 int regFree1 = 0;
3518 int regFree2 = 0;
3519 int r1, r2;
3520
drh35573352008-01-08 23:54:25 +00003521 assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 );
drh33cd4902009-05-30 20:49:20 +00003522 if( NEVER(v==0) ) return; /* Existance of VDBE checked by caller */
3523 if( NEVER(pExpr==0) ) return; /* No way this can happen */
drhf2bc0132004-10-04 13:19:23 +00003524 op = pExpr->op;
3525 switch( op ){
drhcce7d172000-05-31 15:34:51 +00003526 case TK_AND: {
danielk19774adee202004-05-08 08:23:19 +00003527 int d2 = sqlite3VdbeMakeLabel(v);
drhc5499be2008-04-01 15:06:33 +00003528 testcase( jumpIfNull==0 );
drhceea3322009-04-23 13:22:42 +00003529 sqlite3ExprCachePush(pParse);
drh35573352008-01-08 23:54:25 +00003530 sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2,jumpIfNull^SQLITE_JUMPIFNULL);
danielk19774adee202004-05-08 08:23:19 +00003531 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
3532 sqlite3VdbeResolveLabel(v, d2);
drhceea3322009-04-23 13:22:42 +00003533 sqlite3ExprCachePop(pParse, 1);
drhcce7d172000-05-31 15:34:51 +00003534 break;
3535 }
3536 case TK_OR: {
drhc5499be2008-04-01 15:06:33 +00003537 testcase( jumpIfNull==0 );
danielk19774adee202004-05-08 08:23:19 +00003538 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
3539 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
drhcce7d172000-05-31 15:34:51 +00003540 break;
3541 }
3542 case TK_NOT: {
drhc5499be2008-04-01 15:06:33 +00003543 testcase( jumpIfNull==0 );
danielk19774adee202004-05-08 08:23:19 +00003544 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
drhcce7d172000-05-31 15:34:51 +00003545 break;
3546 }
3547 case TK_LT:
3548 case TK_LE:
3549 case TK_GT:
3550 case TK_GE:
3551 case TK_NE:
drh0ac65892002-04-20 14:24:41 +00003552 case TK_EQ: {
drhf2bc0132004-10-04 13:19:23 +00003553 assert( TK_LT==OP_Lt );
3554 assert( TK_LE==OP_Le );
3555 assert( TK_GT==OP_Gt );
3556 assert( TK_GE==OP_Ge );
3557 assert( TK_EQ==OP_Eq );
3558 assert( TK_NE==OP_Ne );
drhc5499be2008-04-01 15:06:33 +00003559 testcase( op==TK_LT );
3560 testcase( op==TK_LE );
3561 testcase( op==TK_GT );
3562 testcase( op==TK_GE );
3563 testcase( op==TK_EQ );
3564 testcase( op==TK_NE );
3565 testcase( jumpIfNull==0 );
drhb6da74e2009-12-24 16:00:28 +00003566 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
3567 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
drh35573352008-01-08 23:54:25 +00003568 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
drh2dcef112008-01-12 19:03:48 +00003569 r1, r2, dest, jumpIfNull);
drhc5499be2008-04-01 15:06:33 +00003570 testcase( regFree1==0 );
3571 testcase( regFree2==0 );
drhcce7d172000-05-31 15:34:51 +00003572 break;
3573 }
drh6a2fe092009-09-23 02:29:36 +00003574 case TK_IS:
3575 case TK_ISNOT: {
3576 testcase( op==TK_IS );
3577 testcase( op==TK_ISNOT );
drhb6da74e2009-12-24 16:00:28 +00003578 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
3579 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
drh6a2fe092009-09-23 02:29:36 +00003580 op = (op==TK_IS) ? TK_EQ : TK_NE;
3581 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
3582 r1, r2, dest, SQLITE_NULLEQ);
3583 testcase( regFree1==0 );
3584 testcase( regFree2==0 );
3585 break;
3586 }
drhcce7d172000-05-31 15:34:51 +00003587 case TK_ISNULL:
3588 case TK_NOTNULL: {
drhf2bc0132004-10-04 13:19:23 +00003589 assert( TK_ISNULL==OP_IsNull );
3590 assert( TK_NOTNULL==OP_NotNull );
drhc5499be2008-04-01 15:06:33 +00003591 testcase( op==TK_ISNULL );
3592 testcase( op==TK_NOTNULL );
drh2dcef112008-01-12 19:03:48 +00003593 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
3594 sqlite3VdbeAddOp2(v, op, r1, dest);
drhc5499be2008-04-01 15:06:33 +00003595 testcase( regFree1==0 );
drhcce7d172000-05-31 15:34:51 +00003596 break;
3597 }
drhfef52082000-06-06 01:50:43 +00003598 case TK_BETWEEN: {
drh5c03f302009-11-13 15:03:59 +00003599 testcase( jumpIfNull==0 );
drh36c563a2009-11-12 13:32:22 +00003600 exprCodeBetween(pParse, pExpr, dest, 1, jumpIfNull);
drhfef52082000-06-06 01:50:43 +00003601 break;
3602 }
drh84e30ca2011-02-10 17:46:14 +00003603#ifndef SQLITE_OMIT_SUBQUERY
drhe3365e62009-11-12 17:52:24 +00003604 case TK_IN: {
3605 int destIfFalse = sqlite3VdbeMakeLabel(v);
3606 int destIfNull = jumpIfNull ? dest : destIfFalse;
3607 sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
3608 sqlite3VdbeAddOp2(v, OP_Goto, 0, dest);
3609 sqlite3VdbeResolveLabel(v, destIfFalse);
3610 break;
3611 }
shanehbb201342011-02-09 19:55:20 +00003612#endif
drhcce7d172000-05-31 15:34:51 +00003613 default: {
drh2dcef112008-01-12 19:03:48 +00003614 r1 = sqlite3ExprCodeTemp(pParse, pExpr, &regFree1);
3615 sqlite3VdbeAddOp3(v, OP_If, r1, dest, jumpIfNull!=0);
drhc5499be2008-04-01 15:06:33 +00003616 testcase( regFree1==0 );
3617 testcase( jumpIfNull==0 );
drhcce7d172000-05-31 15:34:51 +00003618 break;
3619 }
3620 }
drh2dcef112008-01-12 19:03:48 +00003621 sqlite3ReleaseTempReg(pParse, regFree1);
3622 sqlite3ReleaseTempReg(pParse, regFree2);
drhcce7d172000-05-31 15:34:51 +00003623}
3624
3625/*
drh66b89c82000-11-28 20:47:17 +00003626** Generate code for a boolean expression such that a jump is made
drhcce7d172000-05-31 15:34:51 +00003627** to the label "dest" if the expression is false but execution
3628** continues straight thru if the expression is true.
drhf5905aa2002-05-26 20:54:33 +00003629**
3630** If the expression evaluates to NULL (neither true nor false) then
drh35573352008-01-08 23:54:25 +00003631** jump if jumpIfNull is SQLITE_JUMPIFNULL or fall through if jumpIfNull
3632** is 0.
drhcce7d172000-05-31 15:34:51 +00003633*/
danielk19774adee202004-05-08 08:23:19 +00003634void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
drhcce7d172000-05-31 15:34:51 +00003635 Vdbe *v = pParse->pVdbe;
3636 int op = 0;
drh2dcef112008-01-12 19:03:48 +00003637 int regFree1 = 0;
3638 int regFree2 = 0;
3639 int r1, r2;
3640
drh35573352008-01-08 23:54:25 +00003641 assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 );
drh33cd4902009-05-30 20:49:20 +00003642 if( NEVER(v==0) ) return; /* Existance of VDBE checked by caller */
3643 if( pExpr==0 ) return;
drhf2bc0132004-10-04 13:19:23 +00003644
3645 /* The value of pExpr->op and op are related as follows:
3646 **
3647 ** pExpr->op op
3648 ** --------- ----------
3649 ** TK_ISNULL OP_NotNull
3650 ** TK_NOTNULL OP_IsNull
3651 ** TK_NE OP_Eq
3652 ** TK_EQ OP_Ne
3653 ** TK_GT OP_Le
3654 ** TK_LE OP_Gt
3655 ** TK_GE OP_Lt
3656 ** TK_LT OP_Ge
3657 **
3658 ** For other values of pExpr->op, op is undefined and unused.
3659 ** The value of TK_ and OP_ constants are arranged such that we
3660 ** can compute the mapping above using the following expression.
3661 ** Assert()s verify that the computation is correct.
3662 */
3663 op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1);
3664
3665 /* Verify correct alignment of TK_ and OP_ constants
3666 */
3667 assert( pExpr->op!=TK_ISNULL || op==OP_NotNull );
3668 assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull );
3669 assert( pExpr->op!=TK_NE || op==OP_Eq );
3670 assert( pExpr->op!=TK_EQ || op==OP_Ne );
3671 assert( pExpr->op!=TK_LT || op==OP_Ge );
3672 assert( pExpr->op!=TK_LE || op==OP_Gt );
3673 assert( pExpr->op!=TK_GT || op==OP_Le );
3674 assert( pExpr->op!=TK_GE || op==OP_Lt );
3675
drhcce7d172000-05-31 15:34:51 +00003676 switch( pExpr->op ){
3677 case TK_AND: {
drhc5499be2008-04-01 15:06:33 +00003678 testcase( jumpIfNull==0 );
danielk19774adee202004-05-08 08:23:19 +00003679 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
3680 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
drhcce7d172000-05-31 15:34:51 +00003681 break;
3682 }
3683 case TK_OR: {
danielk19774adee202004-05-08 08:23:19 +00003684 int d2 = sqlite3VdbeMakeLabel(v);
drhc5499be2008-04-01 15:06:33 +00003685 testcase( jumpIfNull==0 );
drhceea3322009-04-23 13:22:42 +00003686 sqlite3ExprCachePush(pParse);
drh35573352008-01-08 23:54:25 +00003687 sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2, jumpIfNull^SQLITE_JUMPIFNULL);
danielk19774adee202004-05-08 08:23:19 +00003688 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
3689 sqlite3VdbeResolveLabel(v, d2);
drhceea3322009-04-23 13:22:42 +00003690 sqlite3ExprCachePop(pParse, 1);
drhcce7d172000-05-31 15:34:51 +00003691 break;
3692 }
3693 case TK_NOT: {
drh5c03f302009-11-13 15:03:59 +00003694 testcase( jumpIfNull==0 );
danielk19774adee202004-05-08 08:23:19 +00003695 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
drhcce7d172000-05-31 15:34:51 +00003696 break;
3697 }
3698 case TK_LT:
3699 case TK_LE:
3700 case TK_GT:
3701 case TK_GE:
3702 case TK_NE:
3703 case TK_EQ: {
drhc5499be2008-04-01 15:06:33 +00003704 testcase( op==TK_LT );
3705 testcase( op==TK_LE );
3706 testcase( op==TK_GT );
3707 testcase( op==TK_GE );
3708 testcase( op==TK_EQ );
3709 testcase( op==TK_NE );
3710 testcase( jumpIfNull==0 );
drhb6da74e2009-12-24 16:00:28 +00003711 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
3712 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
drh35573352008-01-08 23:54:25 +00003713 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
drh2dcef112008-01-12 19:03:48 +00003714 r1, r2, dest, jumpIfNull);
drhc5499be2008-04-01 15:06:33 +00003715 testcase( regFree1==0 );
3716 testcase( regFree2==0 );
drhcce7d172000-05-31 15:34:51 +00003717 break;
3718 }
drh6a2fe092009-09-23 02:29:36 +00003719 case TK_IS:
3720 case TK_ISNOT: {
drh6d4486a2009-09-23 14:45:05 +00003721 testcase( pExpr->op==TK_IS );
3722 testcase( pExpr->op==TK_ISNOT );
drhb6da74e2009-12-24 16:00:28 +00003723 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
3724 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
drh6a2fe092009-09-23 02:29:36 +00003725 op = (pExpr->op==TK_IS) ? TK_NE : TK_EQ;
3726 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
3727 r1, r2, dest, SQLITE_NULLEQ);
3728 testcase( regFree1==0 );
3729 testcase( regFree2==0 );
3730 break;
3731 }
drhcce7d172000-05-31 15:34:51 +00003732 case TK_ISNULL:
3733 case TK_NOTNULL: {
drhc5499be2008-04-01 15:06:33 +00003734 testcase( op==TK_ISNULL );
3735 testcase( op==TK_NOTNULL );
drh2dcef112008-01-12 19:03:48 +00003736 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
3737 sqlite3VdbeAddOp2(v, op, r1, dest);
drhc5499be2008-04-01 15:06:33 +00003738 testcase( regFree1==0 );
drhcce7d172000-05-31 15:34:51 +00003739 break;
3740 }
drhfef52082000-06-06 01:50:43 +00003741 case TK_BETWEEN: {
drh5c03f302009-11-13 15:03:59 +00003742 testcase( jumpIfNull==0 );
drh36c563a2009-11-12 13:32:22 +00003743 exprCodeBetween(pParse, pExpr, dest, 0, jumpIfNull);
drhfef52082000-06-06 01:50:43 +00003744 break;
3745 }
drh84e30ca2011-02-10 17:46:14 +00003746#ifndef SQLITE_OMIT_SUBQUERY
drhe3365e62009-11-12 17:52:24 +00003747 case TK_IN: {
3748 if( jumpIfNull ){
3749 sqlite3ExprCodeIN(pParse, pExpr, dest, dest);
3750 }else{
3751 int destIfNull = sqlite3VdbeMakeLabel(v);
3752 sqlite3ExprCodeIN(pParse, pExpr, dest, destIfNull);
3753 sqlite3VdbeResolveLabel(v, destIfNull);
3754 }
3755 break;
3756 }
shanehbb201342011-02-09 19:55:20 +00003757#endif
drhcce7d172000-05-31 15:34:51 +00003758 default: {
drh2dcef112008-01-12 19:03:48 +00003759 r1 = sqlite3ExprCodeTemp(pParse, pExpr, &regFree1);
3760 sqlite3VdbeAddOp3(v, OP_IfNot, r1, dest, jumpIfNull!=0);
drhc5499be2008-04-01 15:06:33 +00003761 testcase( regFree1==0 );
3762 testcase( jumpIfNull==0 );
drhcce7d172000-05-31 15:34:51 +00003763 break;
3764 }
3765 }
drh2dcef112008-01-12 19:03:48 +00003766 sqlite3ReleaseTempReg(pParse, regFree1);
3767 sqlite3ReleaseTempReg(pParse, regFree2);
drhcce7d172000-05-31 15:34:51 +00003768}
drh22827922000-06-06 17:27:05 +00003769
3770/*
drh1d9da702010-01-07 15:17:02 +00003771** Do a deep comparison of two expression trees. Return 0 if the two
3772** expressions are completely identical. Return 1 if they differ only
3773** by a COLLATE operator at the top level. Return 2 if there are differences
3774** other than the top-level COLLATE operator.
drhd40aab02007-02-24 15:29:03 +00003775**
drh1d9da702010-01-07 15:17:02 +00003776** Sometimes this routine will return 2 even if the two expressions
drhd40aab02007-02-24 15:29:03 +00003777** really are equivalent. If we cannot prove that the expressions are
drh1d9da702010-01-07 15:17:02 +00003778** identical, we return 2 just to be safe. So if this routine
3779** returns 2, then you do not really know for certain if the two
3780** expressions are the same. But if you get a 0 or 1 return, then you
drhd40aab02007-02-24 15:29:03 +00003781** can be sure the expressions are the same. In the places where
drh1d9da702010-01-07 15:17:02 +00003782** this routine is used, it does not hurt to get an extra 2 - that
drhd40aab02007-02-24 15:29:03 +00003783** just might result in some slightly slower code. But returning
drh1d9da702010-01-07 15:17:02 +00003784** an incorrect 0 or 1 could lead to a malfunction.
drh22827922000-06-06 17:27:05 +00003785*/
danielk19774adee202004-05-08 08:23:19 +00003786int sqlite3ExprCompare(Expr *pA, Expr *pB){
danielk19774b202ae2006-01-23 05:50:58 +00003787 if( pA==0||pB==0 ){
drh1d9da702010-01-07 15:17:02 +00003788 return pB==pA ? 0 : 2;
drh22827922000-06-06 17:27:05 +00003789 }
drh33e619f2009-05-28 01:00:55 +00003790 assert( !ExprHasAnyProperty(pA, EP_TokenOnly|EP_Reduced) );
3791 assert( !ExprHasAnyProperty(pB, EP_TokenOnly|EP_Reduced) );
danielk19776ab3a2e2009-02-19 14:39:25 +00003792 if( ExprHasProperty(pA, EP_xIsSelect) || ExprHasProperty(pB, EP_xIsSelect) ){
drh1d9da702010-01-07 15:17:02 +00003793 return 2;
drh22827922000-06-06 17:27:05 +00003794 }
drh1d9da702010-01-07 15:17:02 +00003795 if( (pA->flags & EP_Distinct)!=(pB->flags & EP_Distinct) ) return 2;
drhae80dde2012-12-06 21:16:43 +00003796 if( pA->op!=pB->op ){
3797 if( pA->op==TK_COLLATE && sqlite3ExprCompare(pA->pLeft, pB)<2 ){
3798 return 1;
3799 }
3800 if( pB->op==TK_COLLATE && sqlite3ExprCompare(pA, pB->pLeft)<2 ){
3801 return 1;
3802 }
3803 return 2;
3804 }
drh1d9da702010-01-07 15:17:02 +00003805 if( sqlite3ExprCompare(pA->pLeft, pB->pLeft) ) return 2;
3806 if( sqlite3ExprCompare(pA->pRight, pB->pRight) ) return 2;
drh8c6f6662010-04-26 19:17:26 +00003807 if( sqlite3ExprListCompare(pA->x.pList, pB->x.pList) ) return 2;
drh1d9da702010-01-07 15:17:02 +00003808 if( pA->iTable!=pB->iTable || pA->iColumn!=pB->iColumn ) return 2;
drh33e619f2009-05-28 01:00:55 +00003809 if( ExprHasProperty(pA, EP_IntValue) ){
3810 if( !ExprHasProperty(pB, EP_IntValue) || pA->u.iValue!=pB->u.iValue ){
drh1d9da702010-01-07 15:17:02 +00003811 return 2;
drh33e619f2009-05-28 01:00:55 +00003812 }
drhbbabe192012-05-21 21:20:57 +00003813 }else if( pA->op!=TK_COLUMN && ALWAYS(pA->op!=TK_AGG_COLUMN) && pA->u.zToken){
drh1d9da702010-01-07 15:17:02 +00003814 if( ExprHasProperty(pB, EP_IntValue) || NEVER(pB->u.zToken==0) ) return 2;
drh6b93c9a2011-10-13 15:35:52 +00003815 if( strcmp(pA->u.zToken,pB->u.zToken)!=0 ){
drhae80dde2012-12-06 21:16:43 +00003816 return pA->op==TK_COLLATE ? 1 : 2;
drh2646da72005-12-09 20:02:05 +00003817 }
drh22827922000-06-06 17:27:05 +00003818 }
drh4b17cf52012-12-07 14:02:14 +00003819 if( (pA->flags&EP_Collate)!=(pB->flags&EP_Collate) ) return 1;
drh1d9da702010-01-07 15:17:02 +00003820 return 0;
drh22827922000-06-06 17:27:05 +00003821}
3822
drh8c6f6662010-04-26 19:17:26 +00003823/*
3824** Compare two ExprList objects. Return 0 if they are identical and
3825** non-zero if they differ in any way.
3826**
3827** This routine might return non-zero for equivalent ExprLists. The
3828** only consequence will be disabled optimizations. But this routine
3829** must never return 0 if the two ExprList objects are different, or
3830** a malfunction will result.
3831**
3832** Two NULL pointers are considered to be the same. But a NULL pointer
3833** always differs from a non-NULL pointer.
3834*/
3835int sqlite3ExprListCompare(ExprList *pA, ExprList *pB){
3836 int i;
3837 if( pA==0 && pB==0 ) return 0;
3838 if( pA==0 || pB==0 ) return 1;
3839 if( pA->nExpr!=pB->nExpr ) return 1;
3840 for(i=0; i<pA->nExpr; i++){
3841 Expr *pExprA = pA->a[i].pExpr;
3842 Expr *pExprB = pB->a[i].pExpr;
3843 if( pA->a[i].sortOrder!=pB->a[i].sortOrder ) return 1;
3844 if( sqlite3ExprCompare(pExprA, pExprB) ) return 1;
3845 }
3846 return 0;
3847}
drh13449892005-09-07 21:22:45 +00003848
drh22827922000-06-06 17:27:05 +00003849/*
drh030796d2012-08-23 16:18:10 +00003850** An instance of the following structure is used by the tree walker
3851** to count references to table columns in the arguments of an
drhed551b92012-08-23 19:46:11 +00003852** aggregate function, in order to implement the
3853** sqlite3FunctionThisSrc() routine.
drh374fdce2012-04-17 16:38:53 +00003854*/
drh030796d2012-08-23 16:18:10 +00003855struct SrcCount {
3856 SrcList *pSrc; /* One particular FROM clause in a nested query */
3857 int nThis; /* Number of references to columns in pSrcList */
3858 int nOther; /* Number of references to columns in other FROM clauses */
3859};
3860
3861/*
3862** Count the number of references to columns.
3863*/
3864static int exprSrcCount(Walker *pWalker, Expr *pExpr){
drhfb0a6082012-08-24 01:07:52 +00003865 /* The NEVER() on the second term is because sqlite3FunctionUsesThisSrc()
3866 ** is always called before sqlite3ExprAnalyzeAggregates() and so the
3867 ** TK_COLUMNs have not yet been converted into TK_AGG_COLUMN. If
3868 ** sqlite3FunctionUsesThisSrc() is used differently in the future, the
3869 ** NEVER() will need to be removed. */
3870 if( pExpr->op==TK_COLUMN || NEVER(pExpr->op==TK_AGG_COLUMN) ){
drh374fdce2012-04-17 16:38:53 +00003871 int i;
drh030796d2012-08-23 16:18:10 +00003872 struct SrcCount *p = pWalker->u.pSrcCount;
3873 SrcList *pSrc = p->pSrc;
drh374fdce2012-04-17 16:38:53 +00003874 for(i=0; i<pSrc->nSrc; i++){
drh030796d2012-08-23 16:18:10 +00003875 if( pExpr->iTable==pSrc->a[i].iCursor ) break;
drh374fdce2012-04-17 16:38:53 +00003876 }
drh030796d2012-08-23 16:18:10 +00003877 if( i<pSrc->nSrc ){
3878 p->nThis++;
3879 }else{
3880 p->nOther++;
3881 }
drh374fdce2012-04-17 16:38:53 +00003882 }
drh030796d2012-08-23 16:18:10 +00003883 return WRC_Continue;
drh374fdce2012-04-17 16:38:53 +00003884}
3885
3886/*
drh030796d2012-08-23 16:18:10 +00003887** Determine if any of the arguments to the pExpr Function reference
3888** pSrcList. Return true if they do. Also return true if the function
3889** has no arguments or has only constant arguments. Return false if pExpr
3890** references columns but not columns of tables found in pSrcList.
drh374fdce2012-04-17 16:38:53 +00003891*/
drh030796d2012-08-23 16:18:10 +00003892int sqlite3FunctionUsesThisSrc(Expr *pExpr, SrcList *pSrcList){
drh374fdce2012-04-17 16:38:53 +00003893 Walker w;
drh030796d2012-08-23 16:18:10 +00003894 struct SrcCount cnt;
drh374fdce2012-04-17 16:38:53 +00003895 assert( pExpr->op==TK_AGG_FUNCTION );
3896 memset(&w, 0, sizeof(w));
drh030796d2012-08-23 16:18:10 +00003897 w.xExprCallback = exprSrcCount;
3898 w.u.pSrcCount = &cnt;
3899 cnt.pSrc = pSrcList;
3900 cnt.nThis = 0;
3901 cnt.nOther = 0;
3902 sqlite3WalkExprList(&w, pExpr->x.pList);
3903 return cnt.nThis>0 || cnt.nOther==0;
drh374fdce2012-04-17 16:38:53 +00003904}
3905
3906/*
drh13449892005-09-07 21:22:45 +00003907** Add a new element to the pAggInfo->aCol[] array. Return the index of
3908** the new element. Return a negative number if malloc fails.
drh22827922000-06-06 17:27:05 +00003909*/
drh17435752007-08-16 04:30:38 +00003910static int addAggInfoColumn(sqlite3 *db, AggInfo *pInfo){
drh13449892005-09-07 21:22:45 +00003911 int i;
drhcf643722007-03-27 13:36:37 +00003912 pInfo->aCol = sqlite3ArrayAllocate(
drh17435752007-08-16 04:30:38 +00003913 db,
drhcf643722007-03-27 13:36:37 +00003914 pInfo->aCol,
3915 sizeof(pInfo->aCol[0]),
drhcf643722007-03-27 13:36:37 +00003916 &pInfo->nColumn,
drhcf643722007-03-27 13:36:37 +00003917 &i
3918 );
drh13449892005-09-07 21:22:45 +00003919 return i;
3920}
3921
3922/*
3923** Add a new element to the pAggInfo->aFunc[] array. Return the index of
3924** the new element. Return a negative number if malloc fails.
3925*/
drh17435752007-08-16 04:30:38 +00003926static int addAggInfoFunc(sqlite3 *db, AggInfo *pInfo){
drh13449892005-09-07 21:22:45 +00003927 int i;
drhcf643722007-03-27 13:36:37 +00003928 pInfo->aFunc = sqlite3ArrayAllocate(
drh17435752007-08-16 04:30:38 +00003929 db,
drhcf643722007-03-27 13:36:37 +00003930 pInfo->aFunc,
3931 sizeof(pInfo->aFunc[0]),
drhcf643722007-03-27 13:36:37 +00003932 &pInfo->nFunc,
drhcf643722007-03-27 13:36:37 +00003933 &i
3934 );
drh13449892005-09-07 21:22:45 +00003935 return i;
3936}
drh22827922000-06-06 17:27:05 +00003937
3938/*
drh7d10d5a2008-08-20 16:35:10 +00003939** This is the xExprCallback for a tree walker. It is used to
3940** implement sqlite3ExprAnalyzeAggregates(). See sqlite3ExprAnalyzeAggregates
drh626a8792005-01-17 22:08:19 +00003941** for additional information.
drh22827922000-06-06 17:27:05 +00003942*/
drh7d10d5a2008-08-20 16:35:10 +00003943static int analyzeAggregate(Walker *pWalker, Expr *pExpr){
drh22827922000-06-06 17:27:05 +00003944 int i;
drh7d10d5a2008-08-20 16:35:10 +00003945 NameContext *pNC = pWalker->u.pNC;
danielk1977a58fdfb2005-02-08 07:50:40 +00003946 Parse *pParse = pNC->pParse;
3947 SrcList *pSrcList = pNC->pSrcList;
drh13449892005-09-07 21:22:45 +00003948 AggInfo *pAggInfo = pNC->pAggInfo;
drh22827922000-06-06 17:27:05 +00003949
drh22827922000-06-06 17:27:05 +00003950 switch( pExpr->op ){
drh89c69d02007-01-04 01:20:28 +00003951 case TK_AGG_COLUMN:
drh967e8b72000-06-21 13:59:10 +00003952 case TK_COLUMN: {
drh8b213892008-08-29 02:14:02 +00003953 testcase( pExpr->op==TK_AGG_COLUMN );
3954 testcase( pExpr->op==TK_COLUMN );
drh13449892005-09-07 21:22:45 +00003955 /* Check to see if the column is in one of the tables in the FROM
3956 ** clause of the aggregate query */
drh20bc3932009-05-30 23:35:43 +00003957 if( ALWAYS(pSrcList!=0) ){
drh13449892005-09-07 21:22:45 +00003958 struct SrcList_item *pItem = pSrcList->a;
3959 for(i=0; i<pSrcList->nSrc; i++, pItem++){
3960 struct AggInfo_col *pCol;
drh33e619f2009-05-28 01:00:55 +00003961 assert( !ExprHasAnyProperty(pExpr, EP_TokenOnly|EP_Reduced) );
drh13449892005-09-07 21:22:45 +00003962 if( pExpr->iTable==pItem->iCursor ){
3963 /* If we reach this point, it means that pExpr refers to a table
3964 ** that is in the FROM clause of the aggregate query.
3965 **
3966 ** Make an entry for the column in pAggInfo->aCol[] if there
3967 ** is not an entry there already.
3968 */
drh7f906d62007-03-12 23:48:52 +00003969 int k;
drh13449892005-09-07 21:22:45 +00003970 pCol = pAggInfo->aCol;
drh7f906d62007-03-12 23:48:52 +00003971 for(k=0; k<pAggInfo->nColumn; k++, pCol++){
drh13449892005-09-07 21:22:45 +00003972 if( pCol->iTable==pExpr->iTable &&
3973 pCol->iColumn==pExpr->iColumn ){
3974 break;
3975 }
danielk1977a58fdfb2005-02-08 07:50:40 +00003976 }
danielk19771e536952007-08-16 10:09:01 +00003977 if( (k>=pAggInfo->nColumn)
3978 && (k = addAggInfoColumn(pParse->db, pAggInfo))>=0
3979 ){
drh7f906d62007-03-12 23:48:52 +00003980 pCol = &pAggInfo->aCol[k];
danielk19770817d0d2007-02-14 09:19:36 +00003981 pCol->pTab = pExpr->pTab;
drh13449892005-09-07 21:22:45 +00003982 pCol->iTable = pExpr->iTable;
3983 pCol->iColumn = pExpr->iColumn;
drh0a07c102008-01-03 18:03:08 +00003984 pCol->iMem = ++pParse->nMem;
drh13449892005-09-07 21:22:45 +00003985 pCol->iSorterColumn = -1;
drh5774b802005-09-07 22:48:16 +00003986 pCol->pExpr = pExpr;
drh13449892005-09-07 21:22:45 +00003987 if( pAggInfo->pGroupBy ){
3988 int j, n;
3989 ExprList *pGB = pAggInfo->pGroupBy;
3990 struct ExprList_item *pTerm = pGB->a;
3991 n = pGB->nExpr;
3992 for(j=0; j<n; j++, pTerm++){
3993 Expr *pE = pTerm->pExpr;
3994 if( pE->op==TK_COLUMN && pE->iTable==pExpr->iTable &&
3995 pE->iColumn==pExpr->iColumn ){
3996 pCol->iSorterColumn = j;
3997 break;
3998 }
3999 }
4000 }
4001 if( pCol->iSorterColumn<0 ){
4002 pCol->iSorterColumn = pAggInfo->nSortingColumn++;
4003 }
4004 }
4005 /* There is now an entry for pExpr in pAggInfo->aCol[] (either
4006 ** because it was there before or because we just created it).
4007 ** Convert the pExpr to be a TK_AGG_COLUMN referring to that
4008 ** pAggInfo->aCol[] entry.
4009 */
drh33e619f2009-05-28 01:00:55 +00004010 ExprSetIrreducible(pExpr);
drh13449892005-09-07 21:22:45 +00004011 pExpr->pAggInfo = pAggInfo;
4012 pExpr->op = TK_AGG_COLUMN;
shanecf697392009-06-01 16:53:09 +00004013 pExpr->iAgg = (i16)k;
drh13449892005-09-07 21:22:45 +00004014 break;
4015 } /* endif pExpr->iTable==pItem->iCursor */
4016 } /* end loop over pSrcList */
drh22827922000-06-06 17:27:05 +00004017 }
drh7d10d5a2008-08-20 16:35:10 +00004018 return WRC_Prune;
drh22827922000-06-06 17:27:05 +00004019 }
4020 case TK_AGG_FUNCTION: {
drh3a8c4be2012-05-21 20:13:39 +00004021 if( (pNC->ncFlags & NC_InAggFunc)==0
drhed551b92012-08-23 19:46:11 +00004022 && pWalker->walkerDepth==pExpr->op2
drh3a8c4be2012-05-21 20:13:39 +00004023 ){
drh13449892005-09-07 21:22:45 +00004024 /* Check to see if pExpr is a duplicate of another aggregate
4025 ** function that is already in the pAggInfo structure
4026 */
4027 struct AggInfo_func *pItem = pAggInfo->aFunc;
4028 for(i=0; i<pAggInfo->nFunc; i++, pItem++){
drh1d9da702010-01-07 15:17:02 +00004029 if( sqlite3ExprCompare(pItem->pExpr, pExpr)==0 ){
danielk1977a58fdfb2005-02-08 07:50:40 +00004030 break;
4031 }
drh22827922000-06-06 17:27:05 +00004032 }
drh13449892005-09-07 21:22:45 +00004033 if( i>=pAggInfo->nFunc ){
4034 /* pExpr is original. Make a new entry in pAggInfo->aFunc[]
4035 */
danielk197714db2662006-01-09 16:12:04 +00004036 u8 enc = ENC(pParse->db);
danielk19771e536952007-08-16 10:09:01 +00004037 i = addAggInfoFunc(pParse->db, pAggInfo);
drh13449892005-09-07 21:22:45 +00004038 if( i>=0 ){
danielk19776ab3a2e2009-02-19 14:39:25 +00004039 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
drh13449892005-09-07 21:22:45 +00004040 pItem = &pAggInfo->aFunc[i];
4041 pItem->pExpr = pExpr;
drh0a07c102008-01-03 18:03:08 +00004042 pItem->iMem = ++pParse->nMem;
drh33e619f2009-05-28 01:00:55 +00004043 assert( !ExprHasProperty(pExpr, EP_IntValue) );
drh13449892005-09-07 21:22:45 +00004044 pItem->pFunc = sqlite3FindFunction(pParse->db,
drh33e619f2009-05-28 01:00:55 +00004045 pExpr->u.zToken, sqlite3Strlen30(pExpr->u.zToken),
danielk19776ab3a2e2009-02-19 14:39:25 +00004046 pExpr->x.pList ? pExpr->x.pList->nExpr : 0, enc, 0);
drhfd357972005-09-09 01:33:19 +00004047 if( pExpr->flags & EP_Distinct ){
4048 pItem->iDistinct = pParse->nTab++;
4049 }else{
4050 pItem->iDistinct = -1;
4051 }
drh13449892005-09-07 21:22:45 +00004052 }
danielk1977a58fdfb2005-02-08 07:50:40 +00004053 }
drh13449892005-09-07 21:22:45 +00004054 /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry
4055 */
drh33e619f2009-05-28 01:00:55 +00004056 assert( !ExprHasAnyProperty(pExpr, EP_TokenOnly|EP_Reduced) );
4057 ExprSetIrreducible(pExpr);
shanecf697392009-06-01 16:53:09 +00004058 pExpr->iAgg = (i16)i;
drh13449892005-09-07 21:22:45 +00004059 pExpr->pAggInfo = pAggInfo;
drh6e83a572012-11-02 18:48:49 +00004060 return WRC_Prune;
4061 }else{
4062 return WRC_Continue;
drh22827922000-06-06 17:27:05 +00004063 }
drh22827922000-06-06 17:27:05 +00004064 }
4065 }
drh7d10d5a2008-08-20 16:35:10 +00004066 return WRC_Continue;
4067}
4068static int analyzeAggregatesInSelect(Walker *pWalker, Select *pSelect){
drhd5a336e2012-04-19 15:49:19 +00004069 UNUSED_PARAMETER(pWalker);
4070 UNUSED_PARAMETER(pSelect);
drh374fdce2012-04-17 16:38:53 +00004071 return WRC_Continue;
drh626a8792005-01-17 22:08:19 +00004072}
4073
4074/*
drhe8abb4c2012-11-02 18:24:57 +00004075** Analyze the pExpr expression looking for aggregate functions and
4076** for variables that need to be added to AggInfo object that pNC->pAggInfo
4077** points to. Additional entries are made on the AggInfo object as
4078** necessary.
drh626a8792005-01-17 22:08:19 +00004079**
4080** This routine should only be called after the expression has been
drh7d10d5a2008-08-20 16:35:10 +00004081** analyzed by sqlite3ResolveExprNames().
drh626a8792005-01-17 22:08:19 +00004082*/
drhd2b3e232008-01-23 14:51:49 +00004083void sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){
drh7d10d5a2008-08-20 16:35:10 +00004084 Walker w;
drh374fdce2012-04-17 16:38:53 +00004085 memset(&w, 0, sizeof(w));
drh7d10d5a2008-08-20 16:35:10 +00004086 w.xExprCallback = analyzeAggregate;
4087 w.xSelectCallback = analyzeAggregatesInSelect;
4088 w.u.pNC = pNC;
drh20bc3932009-05-30 23:35:43 +00004089 assert( pNC->pSrcList!=0 );
drh7d10d5a2008-08-20 16:35:10 +00004090 sqlite3WalkExpr(&w, pExpr);
drh22827922000-06-06 17:27:05 +00004091}
drh5d9a4af2005-08-30 00:54:01 +00004092
4093/*
4094** Call sqlite3ExprAnalyzeAggregates() for every expression in an
4095** expression list. Return the number of errors.
4096**
4097** If an error is found, the analysis is cut short.
4098*/
drhd2b3e232008-01-23 14:51:49 +00004099void sqlite3ExprAnalyzeAggList(NameContext *pNC, ExprList *pList){
drh5d9a4af2005-08-30 00:54:01 +00004100 struct ExprList_item *pItem;
4101 int i;
drh5d9a4af2005-08-30 00:54:01 +00004102 if( pList ){
drhd2b3e232008-01-23 14:51:49 +00004103 for(pItem=pList->a, i=0; i<pList->nExpr; i++, pItem++){
4104 sqlite3ExprAnalyzeAggregates(pNC, pItem->pExpr);
drh5d9a4af2005-08-30 00:54:01 +00004105 }
4106 }
drh5d9a4af2005-08-30 00:54:01 +00004107}
drh892d3172008-01-10 03:46:36 +00004108
4109/*
drhceea3322009-04-23 13:22:42 +00004110** Allocate a single new register for use to hold some intermediate result.
drh892d3172008-01-10 03:46:36 +00004111*/
4112int sqlite3GetTempReg(Parse *pParse){
drhe55cbd72008-03-31 23:48:03 +00004113 if( pParse->nTempReg==0 ){
drh892d3172008-01-10 03:46:36 +00004114 return ++pParse->nMem;
4115 }
danielk19772f425f62008-07-04 09:41:39 +00004116 return pParse->aTempReg[--pParse->nTempReg];
drh892d3172008-01-10 03:46:36 +00004117}
drhceea3322009-04-23 13:22:42 +00004118
4119/*
4120** Deallocate a register, making available for reuse for some other
4121** purpose.
4122**
4123** If a register is currently being used by the column cache, then
4124** the dallocation is deferred until the column cache line that uses
4125** the register becomes stale.
4126*/
drh892d3172008-01-10 03:46:36 +00004127void sqlite3ReleaseTempReg(Parse *pParse, int iReg){
drh2dcef112008-01-12 19:03:48 +00004128 if( iReg && pParse->nTempReg<ArraySize(pParse->aTempReg) ){
drhceea3322009-04-23 13:22:42 +00004129 int i;
4130 struct yColCache *p;
4131 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
4132 if( p->iReg==iReg ){
4133 p->tempReg = 1;
4134 return;
4135 }
4136 }
drh892d3172008-01-10 03:46:36 +00004137 pParse->aTempReg[pParse->nTempReg++] = iReg;
4138 }
4139}
4140
4141/*
4142** Allocate or deallocate a block of nReg consecutive registers
4143*/
4144int sqlite3GetTempRange(Parse *pParse, int nReg){
drhe55cbd72008-03-31 23:48:03 +00004145 int i, n;
4146 i = pParse->iRangeReg;
4147 n = pParse->nRangeReg;
drhf49f3522009-12-30 14:12:38 +00004148 if( nReg<=n ){
4149 assert( !usedAsColumnCache(pParse, i, i+n-1) );
drh892d3172008-01-10 03:46:36 +00004150 pParse->iRangeReg += nReg;
4151 pParse->nRangeReg -= nReg;
4152 }else{
4153 i = pParse->nMem+1;
4154 pParse->nMem += nReg;
4155 }
4156 return i;
4157}
4158void sqlite3ReleaseTempRange(Parse *pParse, int iReg, int nReg){
drhf49f3522009-12-30 14:12:38 +00004159 sqlite3ExprCacheRemove(pParse, iReg, nReg);
drh892d3172008-01-10 03:46:36 +00004160 if( nReg>pParse->nRangeReg ){
4161 pParse->nRangeReg = nReg;
4162 pParse->iRangeReg = iReg;
4163 }
4164}
drhcdc69552011-12-06 13:24:59 +00004165
4166/*
4167** Mark all temporary registers as being unavailable for reuse.
4168*/
4169void sqlite3ClearTempRegCache(Parse *pParse){
4170 pParse->nTempReg = 0;
4171 pParse->nRangeReg = 0;
4172}