blob: becc82a49e4f95aa868c8f7f743f221da981f077 [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**
drhee76c612008-08-22 17:34:45 +000015** $Id: expr.c,v 1.391 2008/08/22 17:34:45 drh Exp $
drhcce7d172000-05-31 15:34:51 +000016*/
17#include "sqliteInt.h"
drh04738cb2002-06-02 18:19:00 +000018#include <ctype.h>
drha2e00042002-01-22 03:13:42 +000019
danielk1977e014a832004-05-17 10:48:57 +000020/*
21** Return the 'affinity' of the expression pExpr if any.
22**
23** If pExpr is a column, a reference to a column via an 'AS' alias,
24** or a sub-select with a column as the return value, then the
25** affinity of that column is returned. Otherwise, 0x00 is returned,
26** indicating no affinity for the expression.
27**
28** i.e. the WHERE clause expresssions in the following statements all
29** have an affinity:
30**
31** CREATE TABLE t1(a);
32** SELECT * FROM t1 WHERE a;
33** SELECT a AS b FROM t1 WHERE b;
34** SELECT * FROM t1 WHERE (select a from t1);
35*/
danielk1977bf3b7212004-05-18 10:06:24 +000036char sqlite3ExprAffinity(Expr *pExpr){
drh487e2622005-06-25 18:42:14 +000037 int op = pExpr->op;
drh487e2622005-06-25 18:42:14 +000038 if( op==TK_SELECT ){
danielk1977bf3b7212004-05-18 10:06:24 +000039 return sqlite3ExprAffinity(pExpr->pSelect->pEList->a[0].pExpr);
danielk1977a37cdde2004-05-16 11:15:36 +000040 }
drh487e2622005-06-25 18:42:14 +000041#ifndef SQLITE_OMIT_CAST
42 if( op==TK_CAST ){
drh8a512562005-11-14 22:29:05 +000043 return sqlite3AffinityType(&pExpr->token);
drh487e2622005-06-25 18:42:14 +000044 }
45#endif
drh7d10d5a2008-08-20 16:35:10 +000046 if( (op==TK_COLUMN || op==TK_REGISTER) && pExpr->pTab!=0 ){
47 /* op==TK_REGISTER && pExpr->pTab!=0 happens when pExpr was originally
48 ** a TK_COLUMN but was previously evaluated and cached in a register */
49 int j = pExpr->iColumn;
50 if( j<0 ) return SQLITE_AFF_INTEGER;
51 assert( pExpr->pTab && j<pExpr->pTab->nCol );
52 return pExpr->pTab->aCol[j].affinity;
53 }
danielk1977a37cdde2004-05-16 11:15:36 +000054 return pExpr->affinity;
55}
56
drh53db1452004-05-20 13:54:53 +000057/*
drh8b4c40d2007-02-01 23:02:45 +000058** Set the collating sequence for expression pExpr to be the collating
59** sequence named by pToken. Return a pointer to the revised expression.
drha34001c2007-02-02 12:44:37 +000060** The collating sequence is marked as "explicit" using the EP_ExpCollate
61** flag. An explicit collating sequence will override implicit
62** collating sequences.
drh8b4c40d2007-02-01 23:02:45 +000063*/
drh7d10d5a2008-08-20 16:35:10 +000064Expr *sqlite3ExprSetColl(Parse *pParse, Expr *pExpr, Token *pCollName){
danielk197739002502007-11-12 09:50:26 +000065 char *zColl = 0; /* Dequoted name of collation sequence */
drh8b4c40d2007-02-01 23:02:45 +000066 CollSeq *pColl;
drh633e6d52008-07-28 19:34:53 +000067 sqlite3 *db = pParse->db;
drh7d10d5a2008-08-20 16:35:10 +000068 zColl = sqlite3NameFromToken(db, pCollName);
danielk197739002502007-11-12 09:50:26 +000069 if( pExpr && zColl ){
70 pColl = sqlite3LocateCollSeq(pParse, zColl, -1);
71 if( pColl ){
72 pExpr->pColl = pColl;
73 pExpr->flags |= EP_ExpCollate;
74 }
drh8b4c40d2007-02-01 23:02:45 +000075 }
drh633e6d52008-07-28 19:34:53 +000076 sqlite3DbFree(db, zColl);
drh8b4c40d2007-02-01 23:02:45 +000077 return pExpr;
78}
79
80/*
danielk19770202b292004-06-09 09:55:16 +000081** Return the default collation sequence for the expression pExpr. If
82** there is no default collation type, return 0.
83*/
danielk19777cedc8d2004-06-10 10:50:08 +000084CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr){
85 CollSeq *pColl = 0;
drh7d10d5a2008-08-20 16:35:10 +000086 Expr *p = pExpr;
87 while( p ){
drh7e09fe02007-06-20 16:13:23 +000088 int op;
drh7d10d5a2008-08-20 16:35:10 +000089 pColl = p->pColl;
90 if( pColl ) break;
91 op = p->op;
92 if( (op==TK_COLUMN || op==TK_REGISTER) && p->pTab!=0 ){
93 /* op==TK_REGISTER && p->pTab!=0 happens when pExpr was originally
94 ** a TK_COLUMN but was previously evaluated and cached in a register */
95 const char *zColl;
96 int j = p->iColumn;
97 if( j>=0 ){
98 sqlite3 *db = pParse->db;
99 zColl = p->pTab->aCol[j].zColl;
100 pColl = sqlite3FindCollSeq(db, ENC(db), zColl, -1, 0);
101 pExpr->pColl = pColl;
102 }
103 break;
danielk19770202b292004-06-09 09:55:16 +0000104 }
drh7d10d5a2008-08-20 16:35:10 +0000105 if( op!=TK_CAST && op!=TK_UPLUS ){
106 break;
107 }
108 p = p->pLeft;
danielk19770202b292004-06-09 09:55:16 +0000109 }
danielk19777cedc8d2004-06-10 10:50:08 +0000110 if( sqlite3CheckCollSeq(pParse, pColl) ){
111 pColl = 0;
112 }
113 return pColl;
danielk19770202b292004-06-09 09:55:16 +0000114}
115
116/*
drh626a8792005-01-17 22:08:19 +0000117** pExpr is an operand of a comparison operator. aff2 is the
118** type affinity of the other operand. This routine returns the
drh53db1452004-05-20 13:54:53 +0000119** type affinity that should be used for the comparison operator.
120*/
danielk1977e014a832004-05-17 10:48:57 +0000121char sqlite3CompareAffinity(Expr *pExpr, char aff2){
danielk1977bf3b7212004-05-18 10:06:24 +0000122 char aff1 = sqlite3ExprAffinity(pExpr);
danielk1977e014a832004-05-17 10:48:57 +0000123 if( aff1 && aff2 ){
drh8df447f2005-11-01 15:48:24 +0000124 /* Both sides of the comparison are columns. If one has numeric
125 ** affinity, use that. Otherwise use no affinity.
danielk1977e014a832004-05-17 10:48:57 +0000126 */
drh8a512562005-11-14 22:29:05 +0000127 if( sqlite3IsNumericAffinity(aff1) || sqlite3IsNumericAffinity(aff2) ){
danielk1977e014a832004-05-17 10:48:57 +0000128 return SQLITE_AFF_NUMERIC;
129 }else{
130 return SQLITE_AFF_NONE;
131 }
132 }else if( !aff1 && !aff2 ){
drh5f6a87b2004-07-19 00:39:45 +0000133 /* Neither side of the comparison is a column. Compare the
134 ** results directly.
danielk1977e014a832004-05-17 10:48:57 +0000135 */
drh5f6a87b2004-07-19 00:39:45 +0000136 return SQLITE_AFF_NONE;
danielk1977e014a832004-05-17 10:48:57 +0000137 }else{
138 /* One side is a column, the other is not. Use the columns affinity. */
drhfe05af82005-07-21 03:14:59 +0000139 assert( aff1==0 || aff2==0 );
danielk1977e014a832004-05-17 10:48:57 +0000140 return (aff1 + aff2);
141 }
142}
143
drh53db1452004-05-20 13:54:53 +0000144/*
145** pExpr is a comparison operator. Return the type affinity that should
146** be applied to both operands prior to doing the comparison.
147*/
danielk1977e014a832004-05-17 10:48:57 +0000148static char comparisonAffinity(Expr *pExpr){
149 char aff;
150 assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT ||
151 pExpr->op==TK_GT || pExpr->op==TK_GE || pExpr->op==TK_LE ||
152 pExpr->op==TK_NE );
153 assert( pExpr->pLeft );
danielk1977bf3b7212004-05-18 10:06:24 +0000154 aff = sqlite3ExprAffinity(pExpr->pLeft);
danielk1977e014a832004-05-17 10:48:57 +0000155 if( pExpr->pRight ){
156 aff = sqlite3CompareAffinity(pExpr->pRight, aff);
157 }
158 else if( pExpr->pSelect ){
159 aff = sqlite3CompareAffinity(pExpr->pSelect->pEList->a[0].pExpr, aff);
160 }
161 else if( !aff ){
drhde087bd2007-02-23 03:00:44 +0000162 aff = SQLITE_AFF_NONE;
danielk1977e014a832004-05-17 10:48:57 +0000163 }
164 return aff;
165}
166
167/*
168** pExpr is a comparison expression, eg. '=', '<', IN(...) etc.
169** idx_affinity is the affinity of an indexed column. Return true
170** if the index with affinity idx_affinity may be used to implement
171** the comparison in pExpr.
172*/
173int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity){
174 char aff = comparisonAffinity(pExpr);
drh8a512562005-11-14 22:29:05 +0000175 switch( aff ){
176 case SQLITE_AFF_NONE:
177 return 1;
178 case SQLITE_AFF_TEXT:
179 return idx_affinity==SQLITE_AFF_TEXT;
180 default:
181 return sqlite3IsNumericAffinity(idx_affinity);
182 }
danielk1977e014a832004-05-17 10:48:57 +0000183}
184
danielk1977a37cdde2004-05-16 11:15:36 +0000185/*
drh35573352008-01-08 23:54:25 +0000186** Return the P5 value that should be used for a binary comparison
danielk1977a37cdde2004-05-16 11:15:36 +0000187** opcode (OP_Eq, OP_Ge etc.) used to compare pExpr1 and pExpr2.
danielk1977a37cdde2004-05-16 11:15:36 +0000188*/
drh35573352008-01-08 23:54:25 +0000189static u8 binaryCompareP5(Expr *pExpr1, Expr *pExpr2, int jumpIfNull){
190 u8 aff = (char)sqlite3ExprAffinity(pExpr2);
191 aff = sqlite3CompareAffinity(pExpr1, aff) | jumpIfNull;
192 return aff;
danielk1977a37cdde2004-05-16 11:15:36 +0000193}
194
drha2e00042002-01-22 03:13:42 +0000195/*
danielk19770202b292004-06-09 09:55:16 +0000196** Return a pointer to the collation sequence that should be used by
197** a binary comparison operator comparing pLeft and pRight.
198**
199** If the left hand expression has a collating sequence type, then it is
200** used. Otherwise the collation sequence for the right hand expression
201** is used, or the default (BINARY) if neither expression has a collating
202** type.
danielk1977bcbb04e2007-05-29 12:11:29 +0000203**
204** Argument pRight (but not pLeft) may be a null pointer. In this case,
205** it is not considered.
danielk19770202b292004-06-09 09:55:16 +0000206*/
drh0a0e1312007-08-07 17:04:59 +0000207CollSeq *sqlite3BinaryCompareCollSeq(
danielk1977bcbb04e2007-05-29 12:11:29 +0000208 Parse *pParse,
209 Expr *pLeft,
210 Expr *pRight
211){
drhec41dda2007-02-07 13:09:45 +0000212 CollSeq *pColl;
213 assert( pLeft );
drhec41dda2007-02-07 13:09:45 +0000214 if( pLeft->flags & EP_ExpCollate ){
215 assert( pLeft->pColl );
216 pColl = pLeft->pColl;
danielk1977bcbb04e2007-05-29 12:11:29 +0000217 }else if( pRight && pRight->flags & EP_ExpCollate ){
drhec41dda2007-02-07 13:09:45 +0000218 assert( pRight->pColl );
219 pColl = pRight->pColl;
220 }else{
221 pColl = sqlite3ExprCollSeq(pParse, pLeft);
222 if( !pColl ){
223 pColl = sqlite3ExprCollSeq(pParse, pRight);
224 }
danielk19770202b292004-06-09 09:55:16 +0000225 }
226 return pColl;
227}
228
229/*
drhda250ea2008-04-01 05:07:14 +0000230** Generate the operands for a comparison operation. Before
231** generating the code for each operand, set the EP_AnyAff
232** flag on the expression so that it will be able to used a
233** cached column value that has previously undergone an
234** affinity change.
235*/
236static void codeCompareOperands(
237 Parse *pParse, /* Parsing and code generating context */
238 Expr *pLeft, /* The left operand */
239 int *pRegLeft, /* Register where left operand is stored */
240 int *pFreeLeft, /* Free this register when done */
241 Expr *pRight, /* The right operand */
242 int *pRegRight, /* Register where right operand is stored */
243 int *pFreeRight /* Write temp register for right operand there */
244){
245 while( pLeft->op==TK_UPLUS ) pLeft = pLeft->pLeft;
246 pLeft->flags |= EP_AnyAff;
247 *pRegLeft = sqlite3ExprCodeTemp(pParse, pLeft, pFreeLeft);
248 while( pRight->op==TK_UPLUS ) pRight = pRight->pLeft;
249 pRight->flags |= EP_AnyAff;
250 *pRegRight = sqlite3ExprCodeTemp(pParse, pRight, pFreeRight);
251}
252
253/*
drhbe5c89a2004-07-26 00:31:09 +0000254** Generate code for a comparison operator.
255*/
256static int codeCompare(
257 Parse *pParse, /* The parsing (and code generating) context */
258 Expr *pLeft, /* The left operand */
259 Expr *pRight, /* The right operand */
260 int opcode, /* The comparison opcode */
drh35573352008-01-08 23:54:25 +0000261 int in1, int in2, /* Register holding operands */
drhbe5c89a2004-07-26 00:31:09 +0000262 int dest, /* Jump here if true. */
263 int jumpIfNull /* If true, jump if either operand is NULL */
264){
drh35573352008-01-08 23:54:25 +0000265 int p5;
266 int addr;
267 CollSeq *p4;
268
269 p4 = sqlite3BinaryCompareCollSeq(pParse, pLeft, pRight);
270 p5 = binaryCompareP5(pLeft, pRight, jumpIfNull);
271 addr = sqlite3VdbeAddOp4(pParse->pVdbe, opcode, in2, dest, in1,
272 (void*)p4, P4_COLLSEQ);
273 sqlite3VdbeChangeP5(pParse->pVdbe, p5);
drhe49b1462008-07-09 01:39:44 +0000274 if( (p5 & SQLITE_AFF_MASK)!=SQLITE_AFF_NONE ){
drhda250ea2008-04-01 05:07:14 +0000275 sqlite3ExprCacheAffinityChange(pParse, in1, 1);
276 sqlite3ExprCacheAffinityChange(pParse, in2, 1);
drh2f7794c2008-04-01 03:27:39 +0000277 }
drh35573352008-01-08 23:54:25 +0000278 return addr;
drhbe5c89a2004-07-26 00:31:09 +0000279}
280
danielk19774b5255a2008-06-05 16:47:39 +0000281#if SQLITE_MAX_EXPR_DEPTH>0
282/*
283** Check that argument nHeight is less than or equal to the maximum
284** expression depth allowed. If it is not, leave an error message in
285** pParse.
286*/
drh7d10d5a2008-08-20 16:35:10 +0000287int sqlite3ExprCheckHeight(Parse *pParse, int nHeight){
danielk19774b5255a2008-06-05 16:47:39 +0000288 int rc = SQLITE_OK;
289 int mxHeight = pParse->db->aLimit[SQLITE_LIMIT_EXPR_DEPTH];
290 if( nHeight>mxHeight ){
291 sqlite3ErrorMsg(pParse,
292 "Expression tree is too large (maximum depth %d)", mxHeight
293 );
294 rc = SQLITE_ERROR;
295 }
296 return rc;
297}
298
299/* The following three functions, heightOfExpr(), heightOfExprList()
300** and heightOfSelect(), are used to determine the maximum height
301** of any expression tree referenced by the structure passed as the
302** first argument.
303**
304** If this maximum height is greater than the current value pointed
305** to by pnHeight, the second parameter, then set *pnHeight to that
306** value.
307*/
308static void heightOfExpr(Expr *p, int *pnHeight){
309 if( p ){
310 if( p->nHeight>*pnHeight ){
311 *pnHeight = p->nHeight;
312 }
313 }
314}
315static void heightOfExprList(ExprList *p, int *pnHeight){
316 if( p ){
317 int i;
318 for(i=0; i<p->nExpr; i++){
319 heightOfExpr(p->a[i].pExpr, pnHeight);
320 }
321 }
322}
323static void heightOfSelect(Select *p, int *pnHeight){
324 if( p ){
325 heightOfExpr(p->pWhere, pnHeight);
326 heightOfExpr(p->pHaving, pnHeight);
327 heightOfExpr(p->pLimit, pnHeight);
328 heightOfExpr(p->pOffset, pnHeight);
329 heightOfExprList(p->pEList, pnHeight);
330 heightOfExprList(p->pGroupBy, pnHeight);
331 heightOfExprList(p->pOrderBy, pnHeight);
332 heightOfSelect(p->pPrior, pnHeight);
333 }
334}
335
336/*
337** Set the Expr.nHeight variable in the structure passed as an
338** argument. An expression with no children, Expr.pList or
339** Expr.pSelect member has a height of 1. Any other expression
340** has a height equal to the maximum height of any other
341** referenced Expr plus one.
342*/
343static void exprSetHeight(Expr *p){
344 int nHeight = 0;
345 heightOfExpr(p->pLeft, &nHeight);
346 heightOfExpr(p->pRight, &nHeight);
347 heightOfExprList(p->pList, &nHeight);
348 heightOfSelect(p->pSelect, &nHeight);
349 p->nHeight = nHeight + 1;
350}
351
352/*
353** Set the Expr.nHeight variable using the exprSetHeight() function. If
354** the height is greater than the maximum allowed expression depth,
355** leave an error in pParse.
356*/
357void sqlite3ExprSetHeight(Parse *pParse, Expr *p){
358 exprSetHeight(p);
drh7d10d5a2008-08-20 16:35:10 +0000359 sqlite3ExprCheckHeight(pParse, p->nHeight);
danielk19774b5255a2008-06-05 16:47:39 +0000360}
361
362/*
363** Return the maximum height of any expression tree referenced
364** by the select statement passed as an argument.
365*/
366int sqlite3SelectExprHeight(Select *p){
367 int nHeight = 0;
368 heightOfSelect(p, &nHeight);
369 return nHeight;
370}
371#else
danielk19774b5255a2008-06-05 16:47:39 +0000372 #define exprSetHeight(y)
373#endif /* SQLITE_MAX_EXPR_DEPTH>0 */
374
drhbe5c89a2004-07-26 00:31:09 +0000375/*
drha76b5df2002-02-23 02:32:10 +0000376** Construct a new expression node and return a pointer to it. Memory
drh17435752007-08-16 04:30:38 +0000377** for this node is obtained from sqlite3_malloc(). The calling function
drha76b5df2002-02-23 02:32:10 +0000378** is responsible for making sure the node eventually gets freed.
379*/
drh17435752007-08-16 04:30:38 +0000380Expr *sqlite3Expr(
danielk1977a1644fd2007-08-29 12:31:25 +0000381 sqlite3 *db, /* Handle for sqlite3DbMallocZero() (may be null) */
drh17435752007-08-16 04:30:38 +0000382 int op, /* Expression opcode */
383 Expr *pLeft, /* Left operand */
384 Expr *pRight, /* Right operand */
385 const Token *pToken /* Argument token */
386){
drha76b5df2002-02-23 02:32:10 +0000387 Expr *pNew;
drh26e4a8b2008-05-01 17:16:52 +0000388 pNew = sqlite3DbMallocZero(db, sizeof(Expr));
drha76b5df2002-02-23 02:32:10 +0000389 if( pNew==0 ){
danielk1977d5d56522005-03-16 12:15:20 +0000390 /* When malloc fails, delete pLeft and pRight. Expressions passed to
391 ** this function must always be allocated with sqlite3Expr() for this
392 ** reason.
393 */
drh633e6d52008-07-28 19:34:53 +0000394 sqlite3ExprDelete(db, pLeft);
395 sqlite3ExprDelete(db, pRight);
drha76b5df2002-02-23 02:32:10 +0000396 return 0;
397 }
398 pNew->op = op;
399 pNew->pLeft = pLeft;
400 pNew->pRight = pRight;
danielk1977a58fdfb2005-02-08 07:50:40 +0000401 pNew->iAgg = -1;
drhe49b1462008-07-09 01:39:44 +0000402 pNew->span.z = (u8*)"";
drha76b5df2002-02-23 02:32:10 +0000403 if( pToken ){
drh4b59ab52002-08-24 18:24:51 +0000404 assert( pToken->dyn==0 );
drh145716b2004-09-24 12:24:06 +0000405 pNew->span = pNew->token = *pToken;
drha34001c2007-02-02 12:44:37 +0000406 }else if( pLeft ){
407 if( pRight ){
drhe49b1462008-07-09 01:39:44 +0000408 if( pRight->span.dyn==0 && pLeft->span.dyn==0 ){
409 sqlite3ExprSpan(pNew, &pLeft->span, &pRight->span);
410 }
drh5ffb3ac2007-04-18 17:07:57 +0000411 if( pRight->flags & EP_ExpCollate ){
drha34001c2007-02-02 12:44:37 +0000412 pNew->flags |= EP_ExpCollate;
413 pNew->pColl = pRight->pColl;
414 }
415 }
drh5ffb3ac2007-04-18 17:07:57 +0000416 if( pLeft->flags & EP_ExpCollate ){
drha34001c2007-02-02 12:44:37 +0000417 pNew->flags |= EP_ExpCollate;
418 pNew->pColl = pLeft->pColl;
419 }
drha76b5df2002-02-23 02:32:10 +0000420 }
danielk1977fc976062007-05-10 10:46:56 +0000421
danielk19774b5255a2008-06-05 16:47:39 +0000422 exprSetHeight(pNew);
drha76b5df2002-02-23 02:32:10 +0000423 return pNew;
424}
425
426/*
drh17435752007-08-16 04:30:38 +0000427** Works like sqlite3Expr() except that it takes an extra Parse*
428** argument and notifies the associated connection object if malloc fails.
drh206f3d92006-07-11 13:15:08 +0000429*/
drh17435752007-08-16 04:30:38 +0000430Expr *sqlite3PExpr(
431 Parse *pParse, /* Parsing context */
432 int op, /* Expression opcode */
433 Expr *pLeft, /* Left operand */
434 Expr *pRight, /* Right operand */
435 const Token *pToken /* Argument token */
436){
danielk19774b5255a2008-06-05 16:47:39 +0000437 Expr *p = sqlite3Expr(pParse->db, op, pLeft, pRight, pToken);
438 if( p ){
drh7d10d5a2008-08-20 16:35:10 +0000439 sqlite3ExprCheckHeight(pParse, p->nHeight);
danielk19774b5255a2008-06-05 16:47:39 +0000440 }
441 return p;
drh206f3d92006-07-11 13:15:08 +0000442}
443
444/*
drh4e0cff62004-11-05 05:10:28 +0000445** When doing a nested parse, you can include terms in an expression
drhb7654112008-01-12 12:48:07 +0000446** that look like this: #1 #2 ... These terms refer to registers
447** in the virtual machine. #N is the N-th register.
drh4e0cff62004-11-05 05:10:28 +0000448**
449** This routine is called by the parser to deal with on of those terms.
450** It immediately generates code to store the value in a memory location.
451** The returns an expression that will code to extract the value from
452** that memory location as needed.
453*/
454Expr *sqlite3RegisterExpr(Parse *pParse, Token *pToken){
455 Vdbe *v = pParse->pVdbe;
456 Expr *p;
drh4e0cff62004-11-05 05:10:28 +0000457 if( pParse->nested==0 ){
458 sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", pToken);
danielk1977a1644fd2007-08-29 12:31:25 +0000459 return sqlite3PExpr(pParse, TK_NULL, 0, 0, 0);
drh4e0cff62004-11-05 05:10:28 +0000460 }
drhbb7ac002005-08-12 22:58:53 +0000461 if( v==0 ) return 0;
danielk1977a1644fd2007-08-29 12:31:25 +0000462 p = sqlite3PExpr(pParse, TK_REGISTER, 0, 0, pToken);
drh73c42a12004-11-20 18:13:10 +0000463 if( p==0 ){
464 return 0; /* Malloc failed */
465 }
drhb7654112008-01-12 12:48:07 +0000466 p->iTable = atoi((char*)&pToken->z[1]);
drh4e0cff62004-11-05 05:10:28 +0000467 return p;
468}
469
470/*
drh91bb0ee2004-09-01 03:06:34 +0000471** Join two expressions using an AND operator. If either expression is
472** NULL, then just return the other expression.
473*/
danielk19771e536952007-08-16 10:09:01 +0000474Expr *sqlite3ExprAnd(sqlite3 *db, Expr *pLeft, Expr *pRight){
drh91bb0ee2004-09-01 03:06:34 +0000475 if( pLeft==0 ){
476 return pRight;
477 }else if( pRight==0 ){
478 return pLeft;
479 }else{
danielk1977880c15b2007-09-01 18:24:55 +0000480 return sqlite3Expr(db, TK_AND, pLeft, pRight, 0);
drh91bb0ee2004-09-01 03:06:34 +0000481 }
482}
483
484/*
drh6977fea2002-10-22 23:38:04 +0000485** Set the Expr.span field of the given expression to span all
drhe49b1462008-07-09 01:39:44 +0000486** text between the two given tokens. Both tokens must be pointing
487** at the same string.
drha76b5df2002-02-23 02:32:10 +0000488*/
danielk19774adee202004-05-08 08:23:19 +0000489void sqlite3ExprSpan(Expr *pExpr, Token *pLeft, Token *pRight){
drh4efc4752004-01-16 15:55:37 +0000490 assert( pRight!=0 );
491 assert( pLeft!=0 );
drhe54a62a2008-07-18 17:03:52 +0000492 if( pExpr ){
drhe49b1462008-07-09 01:39:44 +0000493 pExpr->span.z = pLeft->z;
494 pExpr->span.n = pRight->n + (pRight->z - pLeft->z);
drha76b5df2002-02-23 02:32:10 +0000495 }
496}
497
498/*
499** Construct a new expression node for a function with multiple
500** arguments.
501*/
drh17435752007-08-16 04:30:38 +0000502Expr *sqlite3ExprFunction(Parse *pParse, ExprList *pList, Token *pToken){
drha76b5df2002-02-23 02:32:10 +0000503 Expr *pNew;
drh633e6d52008-07-28 19:34:53 +0000504 sqlite3 *db = pParse->db;
danielk19774b202ae2006-01-23 05:50:58 +0000505 assert( pToken );
drh633e6d52008-07-28 19:34:53 +0000506 pNew = sqlite3DbMallocZero(db, sizeof(Expr) );
drha76b5df2002-02-23 02:32:10 +0000507 if( pNew==0 ){
drh633e6d52008-07-28 19:34:53 +0000508 sqlite3ExprListDelete(db, pList); /* Avoid leaking memory when malloc fails */
drha76b5df2002-02-23 02:32:10 +0000509 return 0;
510 }
511 pNew->op = TK_FUNCTION;
512 pNew->pList = pList;
danielk19774b202ae2006-01-23 05:50:58 +0000513 assert( pToken->dyn==0 );
514 pNew->token = *pToken;
drh6977fea2002-10-22 23:38:04 +0000515 pNew->span = pNew->token;
danielk1977fc976062007-05-10 10:46:56 +0000516
danielk19774b5255a2008-06-05 16:47:39 +0000517 sqlite3ExprSetHeight(pParse, pNew);
drha76b5df2002-02-23 02:32:10 +0000518 return pNew;
519}
520
521/*
drhfa6bc002004-09-07 16:19:52 +0000522** Assign a variable number to an expression that encodes a wildcard
523** in the original SQL statement.
524**
525** Wildcards consisting of a single "?" are assigned the next sequential
526** variable number.
527**
528** Wildcards of the form "?nnn" are assigned the number "nnn". We make
529** sure "nnn" is not too be to avoid a denial of service attack when
530** the SQL statement comes from an external source.
531**
532** Wildcards of the form ":aaa" or "$aaa" are assigned the same number
533** as the previous instance of the same wildcard. Or if this is the first
534** instance of the wildcard, the next sequenial variable number is
535** assigned.
536*/
537void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr){
538 Token *pToken;
drh17435752007-08-16 04:30:38 +0000539 sqlite3 *db = pParse->db;
540
drhfa6bc002004-09-07 16:19:52 +0000541 if( pExpr==0 ) return;
542 pToken = &pExpr->token;
543 assert( pToken->n>=1 );
544 assert( pToken->z!=0 );
545 assert( pToken->z[0]!=0 );
546 if( pToken->n==1 ){
547 /* Wildcard of the form "?". Assign the next variable number */
548 pExpr->iTable = ++pParse->nVar;
549 }else if( pToken->z[0]=='?' ){
550 /* Wildcard of the form "?nnn". Convert "nnn" to an integer and
551 ** use it as the variable number */
552 int i;
drh2646da72005-12-09 20:02:05 +0000553 pExpr->iTable = i = atoi((char*)&pToken->z[1]);
drhc5499be2008-04-01 15:06:33 +0000554 testcase( i==0 );
555 testcase( i==1 );
556 testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]-1 );
557 testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] );
drhbb4957f2008-03-20 14:03:29 +0000558 if( i<1 || i>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){
drhfa6bc002004-09-07 16:19:52 +0000559 sqlite3ErrorMsg(pParse, "variable number must be between ?1 and ?%d",
drhbb4957f2008-03-20 14:03:29 +0000560 db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]);
drhfa6bc002004-09-07 16:19:52 +0000561 }
562 if( i>pParse->nVar ){
563 pParse->nVar = i;
564 }
565 }else{
566 /* Wildcards of the form ":aaa" or "$aaa". Reuse the same variable
567 ** number as the prior appearance of the same name, or if the name
568 ** has never appeared before, reuse the same variable number
569 */
570 int i, n;
571 n = pToken->n;
572 for(i=0; i<pParse->nVarExpr; i++){
573 Expr *pE;
574 if( (pE = pParse->apVarExpr[i])!=0
575 && pE->token.n==n
576 && memcmp(pE->token.z, pToken->z, n)==0 ){
577 pExpr->iTable = pE->iTable;
578 break;
579 }
580 }
581 if( i>=pParse->nVarExpr ){
582 pExpr->iTable = ++pParse->nVar;
583 if( pParse->nVarExpr>=pParse->nVarExprAlloc-1 ){
584 pParse->nVarExprAlloc += pParse->nVarExprAlloc + 10;
drh17435752007-08-16 04:30:38 +0000585 pParse->apVarExpr =
586 sqlite3DbReallocOrFree(
587 db,
588 pParse->apVarExpr,
589 pParse->nVarExprAlloc*sizeof(pParse->apVarExpr[0])
590 );
drhfa6bc002004-09-07 16:19:52 +0000591 }
drh17435752007-08-16 04:30:38 +0000592 if( !db->mallocFailed ){
drhfa6bc002004-09-07 16:19:52 +0000593 assert( pParse->apVarExpr!=0 );
594 pParse->apVarExpr[pParse->nVarExpr++] = pExpr;
595 }
596 }
597 }
drhbb4957f2008-03-20 14:03:29 +0000598 if( !pParse->nErr && pParse->nVar>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){
danielk1977832b2662007-05-09 11:37:22 +0000599 sqlite3ErrorMsg(pParse, "too many SQL variables");
600 }
drhfa6bc002004-09-07 16:19:52 +0000601}
602
603/*
drha2e00042002-01-22 03:13:42 +0000604** Recursively delete an expression tree.
605*/
drh633e6d52008-07-28 19:34:53 +0000606void sqlite3ExprDelete(sqlite3 *db, Expr *p){
drha2e00042002-01-22 03:13:42 +0000607 if( p==0 ) return;
drh633e6d52008-07-28 19:34:53 +0000608 if( p->span.dyn ) sqlite3DbFree(db, (char*)p->span.z);
609 if( p->token.dyn ) sqlite3DbFree(db, (char*)p->token.z);
610 sqlite3ExprDelete(db, p->pLeft);
611 sqlite3ExprDelete(db, p->pRight);
612 sqlite3ExprListDelete(db, p->pList);
613 sqlite3SelectDelete(db, p->pSelect);
614 sqlite3DbFree(db, p);
drha2e00042002-01-22 03:13:42 +0000615}
616
drhd2687b72005-08-12 22:56:09 +0000617/*
618** The Expr.token field might be a string literal that is quoted.
619** If so, remove the quotation marks.
620*/
drh17435752007-08-16 04:30:38 +0000621void sqlite3DequoteExpr(sqlite3 *db, Expr *p){
drhd2687b72005-08-12 22:56:09 +0000622 if( ExprHasAnyProperty(p, EP_Dequoted) ){
623 return;
624 }
625 ExprSetProperty(p, EP_Dequoted);
626 if( p->token.dyn==0 ){
drh17435752007-08-16 04:30:38 +0000627 sqlite3TokenCopy(db, &p->token, &p->token);
drhd2687b72005-08-12 22:56:09 +0000628 }
629 sqlite3Dequote((char*)p->token.z);
630}
631
drha76b5df2002-02-23 02:32:10 +0000632/*
drhff78bd22002-02-27 01:47:11 +0000633** The following group of routines make deep copies of expressions,
634** expression lists, ID lists, and select statements. The copies can
635** be deleted (by being passed to their respective ...Delete() routines)
636** without effecting the originals.
637**
danielk19774adee202004-05-08 08:23:19 +0000638** The expression list, ID, and source lists return by sqlite3ExprListDup(),
639** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded
drhad3cab52002-05-24 02:04:32 +0000640** by subsequent calls to sqlite*ListAppend() routines.
drhff78bd22002-02-27 01:47:11 +0000641**
drhad3cab52002-05-24 02:04:32 +0000642** Any tables that the SrcList might point to are not duplicated.
drhff78bd22002-02-27 01:47:11 +0000643*/
danielk19771e536952007-08-16 10:09:01 +0000644Expr *sqlite3ExprDup(sqlite3 *db, Expr *p){
drhff78bd22002-02-27 01:47:11 +0000645 Expr *pNew;
646 if( p==0 ) return 0;
drh17435752007-08-16 04:30:38 +0000647 pNew = sqlite3DbMallocRaw(db, sizeof(*p) );
drhff78bd22002-02-27 01:47:11 +0000648 if( pNew==0 ) return 0;
drh3b167c72002-06-28 12:18:47 +0000649 memcpy(pNew, p, sizeof(*pNew));
drh6977fea2002-10-22 23:38:04 +0000650 if( p->token.z!=0 ){
drh17435752007-08-16 04:30:38 +0000651 pNew->token.z = (u8*)sqlite3DbStrNDup(db, (char*)p->token.z, p->token.n);
drh4b59ab52002-08-24 18:24:51 +0000652 pNew->token.dyn = 1;
653 }else{
drh4efc4752004-01-16 15:55:37 +0000654 assert( pNew->token.z==0 );
drh4b59ab52002-08-24 18:24:51 +0000655 }
drh6977fea2002-10-22 23:38:04 +0000656 pNew->span.z = 0;
drh17435752007-08-16 04:30:38 +0000657 pNew->pLeft = sqlite3ExprDup(db, p->pLeft);
658 pNew->pRight = sqlite3ExprDup(db, p->pRight);
659 pNew->pList = sqlite3ExprListDup(db, p->pList);
660 pNew->pSelect = sqlite3SelectDup(db, p->pSelect);
drhff78bd22002-02-27 01:47:11 +0000661 return pNew;
662}
drh17435752007-08-16 04:30:38 +0000663void sqlite3TokenCopy(sqlite3 *db, Token *pTo, Token *pFrom){
drh633e6d52008-07-28 19:34:53 +0000664 if( pTo->dyn ) sqlite3DbFree(db, (char*)pTo->z);
drh4b59ab52002-08-24 18:24:51 +0000665 if( pFrom->z ){
666 pTo->n = pFrom->n;
drh17435752007-08-16 04:30:38 +0000667 pTo->z = (u8*)sqlite3DbStrNDup(db, (char*)pFrom->z, pFrom->n);
drh4b59ab52002-08-24 18:24:51 +0000668 pTo->dyn = 1;
669 }else{
drh4b59ab52002-08-24 18:24:51 +0000670 pTo->z = 0;
drh4b59ab52002-08-24 18:24:51 +0000671 }
672}
drh17435752007-08-16 04:30:38 +0000673ExprList *sqlite3ExprListDup(sqlite3 *db, ExprList *p){
drhff78bd22002-02-27 01:47:11 +0000674 ExprList *pNew;
drh145716b2004-09-24 12:24:06 +0000675 struct ExprList_item *pItem, *pOldItem;
drhff78bd22002-02-27 01:47:11 +0000676 int i;
677 if( p==0 ) return 0;
drh17435752007-08-16 04:30:38 +0000678 pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
drhff78bd22002-02-27 01:47:11 +0000679 if( pNew==0 ) return 0;
danielk197731dad9d2007-08-16 11:36:15 +0000680 pNew->iECursor = 0;
drh4305d102003-07-30 12:34:12 +0000681 pNew->nExpr = pNew->nAlloc = p->nExpr;
drh17435752007-08-16 04:30:38 +0000682 pNew->a = pItem = sqlite3DbMallocRaw(db, p->nExpr*sizeof(p->a[0]) );
danielk1977e0048402004-06-15 16:51:01 +0000683 if( pItem==0 ){
drh633e6d52008-07-28 19:34:53 +0000684 sqlite3DbFree(db, pNew);
danielk1977e0048402004-06-15 16:51:01 +0000685 return 0;
686 }
drh145716b2004-09-24 12:24:06 +0000687 pOldItem = p->a;
688 for(i=0; i<p->nExpr; i++, pItem++, pOldItem++){
drh4b59ab52002-08-24 18:24:51 +0000689 Expr *pNewExpr, *pOldExpr;
drh17435752007-08-16 04:30:38 +0000690 pItem->pExpr = pNewExpr = sqlite3ExprDup(db, pOldExpr = pOldItem->pExpr);
drh6977fea2002-10-22 23:38:04 +0000691 if( pOldExpr->span.z!=0 && pNewExpr ){
692 /* Always make a copy of the span for top-level expressions in the
drh4b59ab52002-08-24 18:24:51 +0000693 ** expression list. The logic in SELECT processing that determines
694 ** the names of columns in the result set needs this information */
drh17435752007-08-16 04:30:38 +0000695 sqlite3TokenCopy(db, &pNewExpr->span, &pOldExpr->span);
drh4b59ab52002-08-24 18:24:51 +0000696 }
drh1f3e9052002-10-31 00:09:39 +0000697 assert( pNewExpr==0 || pNewExpr->span.z!=0
drh6f7adc82006-01-11 21:41:20 +0000698 || pOldExpr->span.z==0
drh17435752007-08-16 04:30:38 +0000699 || db->mallocFailed );
700 pItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
drh145716b2004-09-24 12:24:06 +0000701 pItem->sortOrder = pOldItem->sortOrder;
drh3e7bc9c2004-02-21 19:17:17 +0000702 pItem->done = 0;
drh7d10d5a2008-08-20 16:35:10 +0000703 pItem->iCol = pOldItem->iCol;
drhff78bd22002-02-27 01:47:11 +0000704 }
705 return pNew;
706}
danielk197793758c82005-01-21 08:13:14 +0000707
708/*
709** If cursors, triggers, views and subqueries are all omitted from
710** the build, then none of the following routines, except for
711** sqlite3SelectDup(), can be called. sqlite3SelectDup() is sometimes
712** called with a NULL argument.
713*/
danielk19776a67fe82005-02-04 04:07:16 +0000714#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) \
715 || !defined(SQLITE_OMIT_SUBQUERY)
drh17435752007-08-16 04:30:38 +0000716SrcList *sqlite3SrcListDup(sqlite3 *db, SrcList *p){
drhad3cab52002-05-24 02:04:32 +0000717 SrcList *pNew;
718 int i;
drh113088e2003-03-20 01:16:58 +0000719 int nByte;
drhad3cab52002-05-24 02:04:32 +0000720 if( p==0 ) return 0;
drh113088e2003-03-20 01:16:58 +0000721 nByte = sizeof(*p) + (p->nSrc>0 ? sizeof(p->a[0]) * (p->nSrc-1) : 0);
drh17435752007-08-16 04:30:38 +0000722 pNew = sqlite3DbMallocRaw(db, nByte );
drhad3cab52002-05-24 02:04:32 +0000723 if( pNew==0 ) return 0;
drh4305d102003-07-30 12:34:12 +0000724 pNew->nSrc = pNew->nAlloc = p->nSrc;
drhad3cab52002-05-24 02:04:32 +0000725 for(i=0; i<p->nSrc; i++){
drh4efc4752004-01-16 15:55:37 +0000726 struct SrcList_item *pNewItem = &pNew->a[i];
727 struct SrcList_item *pOldItem = &p->a[i];
drhed8a3bb2005-06-06 21:19:56 +0000728 Table *pTab;
drh17435752007-08-16 04:30:38 +0000729 pNewItem->zDatabase = sqlite3DbStrDup(db, pOldItem->zDatabase);
730 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
731 pNewItem->zAlias = sqlite3DbStrDup(db, pOldItem->zAlias);
drh4efc4752004-01-16 15:55:37 +0000732 pNewItem->jointype = pOldItem->jointype;
733 pNewItem->iCursor = pOldItem->iCursor;
danielk19771787cca2006-02-10 07:07:14 +0000734 pNewItem->isPopulated = pOldItem->isPopulated;
drhed8a3bb2005-06-06 21:19:56 +0000735 pTab = pNewItem->pTab = pOldItem->pTab;
736 if( pTab ){
737 pTab->nRef++;
danielk1977a1cb1832005-02-12 08:59:55 +0000738 }
drh17435752007-08-16 04:30:38 +0000739 pNewItem->pSelect = sqlite3SelectDup(db, pOldItem->pSelect);
740 pNewItem->pOn = sqlite3ExprDup(db, pOldItem->pOn);
741 pNewItem->pUsing = sqlite3IdListDup(db, pOldItem->pUsing);
danielk19776c18b6e2005-01-30 09:17:58 +0000742 pNewItem->colUsed = pOldItem->colUsed;
drhad3cab52002-05-24 02:04:32 +0000743 }
744 return pNew;
745}
drh17435752007-08-16 04:30:38 +0000746IdList *sqlite3IdListDup(sqlite3 *db, IdList *p){
drhff78bd22002-02-27 01:47:11 +0000747 IdList *pNew;
748 int i;
749 if( p==0 ) return 0;
drh17435752007-08-16 04:30:38 +0000750 pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
drhff78bd22002-02-27 01:47:11 +0000751 if( pNew==0 ) return 0;
drh4305d102003-07-30 12:34:12 +0000752 pNew->nId = pNew->nAlloc = p->nId;
drh17435752007-08-16 04:30:38 +0000753 pNew->a = sqlite3DbMallocRaw(db, p->nId*sizeof(p->a[0]) );
danielk1977d5d56522005-03-16 12:15:20 +0000754 if( pNew->a==0 ){
drh633e6d52008-07-28 19:34:53 +0000755 sqlite3DbFree(db, pNew);
danielk1977d5d56522005-03-16 12:15:20 +0000756 return 0;
757 }
drhff78bd22002-02-27 01:47:11 +0000758 for(i=0; i<p->nId; i++){
drh4efc4752004-01-16 15:55:37 +0000759 struct IdList_item *pNewItem = &pNew->a[i];
760 struct IdList_item *pOldItem = &p->a[i];
drh17435752007-08-16 04:30:38 +0000761 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
drh4efc4752004-01-16 15:55:37 +0000762 pNewItem->idx = pOldItem->idx;
drhff78bd22002-02-27 01:47:11 +0000763 }
764 return pNew;
765}
drh17435752007-08-16 04:30:38 +0000766Select *sqlite3SelectDup(sqlite3 *db, Select *p){
drhff78bd22002-02-27 01:47:11 +0000767 Select *pNew;
768 if( p==0 ) return 0;
drh17435752007-08-16 04:30:38 +0000769 pNew = sqlite3DbMallocRaw(db, sizeof(*p) );
drhff78bd22002-02-27 01:47:11 +0000770 if( pNew==0 ) return 0;
drh17435752007-08-16 04:30:38 +0000771 pNew->pEList = sqlite3ExprListDup(db, p->pEList);
772 pNew->pSrc = sqlite3SrcListDup(db, p->pSrc);
773 pNew->pWhere = sqlite3ExprDup(db, p->pWhere);
774 pNew->pGroupBy = sqlite3ExprListDup(db, p->pGroupBy);
775 pNew->pHaving = sqlite3ExprDup(db, p->pHaving);
776 pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy);
drhff78bd22002-02-27 01:47:11 +0000777 pNew->op = p->op;
drh17435752007-08-16 04:30:38 +0000778 pNew->pPrior = sqlite3SelectDup(db, p->pPrior);
779 pNew->pLimit = sqlite3ExprDup(db, p->pLimit);
780 pNew->pOffset = sqlite3ExprDup(db, p->pOffset);
drh92b01d52008-06-24 00:32:35 +0000781 pNew->iLimit = 0;
782 pNew->iOffset = 0;
drh7d10d5a2008-08-20 16:35:10 +0000783 pNew->selFlags = p->selFlags & ~SF_UsesEphemeral;
drh0342b1f2005-09-01 03:07:44 +0000784 pNew->pRightmost = 0;
drhb9bb7c12006-06-11 23:41:55 +0000785 pNew->addrOpenEphm[0] = -1;
786 pNew->addrOpenEphm[1] = -1;
787 pNew->addrOpenEphm[2] = -1;
drhff78bd22002-02-27 01:47:11 +0000788 return pNew;
789}
danielk197793758c82005-01-21 08:13:14 +0000790#else
drh17435752007-08-16 04:30:38 +0000791Select *sqlite3SelectDup(sqlite3 *db, Select *p){
danielk197793758c82005-01-21 08:13:14 +0000792 assert( p==0 );
793 return 0;
794}
795#endif
drhff78bd22002-02-27 01:47:11 +0000796
797
798/*
drha76b5df2002-02-23 02:32:10 +0000799** Add a new element to the end of an expression list. If pList is
800** initially NULL, then create a new expression list.
801*/
drh17435752007-08-16 04:30:38 +0000802ExprList *sqlite3ExprListAppend(
803 Parse *pParse, /* Parsing context */
804 ExprList *pList, /* List to which to append. Might be NULL */
805 Expr *pExpr, /* Expression to be appended */
806 Token *pName /* AS keyword for the expression */
807){
808 sqlite3 *db = pParse->db;
drha76b5df2002-02-23 02:32:10 +0000809 if( pList==0 ){
drh17435752007-08-16 04:30:38 +0000810 pList = sqlite3DbMallocZero(db, sizeof(ExprList) );
drha76b5df2002-02-23 02:32:10 +0000811 if( pList==0 ){
danielk1977d5d56522005-03-16 12:15:20 +0000812 goto no_mem;
drha76b5df2002-02-23 02:32:10 +0000813 }
drh4efc4752004-01-16 15:55:37 +0000814 assert( pList->nAlloc==0 );
drha76b5df2002-02-23 02:32:10 +0000815 }
drh4305d102003-07-30 12:34:12 +0000816 if( pList->nAlloc<=pList->nExpr ){
danielk1977d5d56522005-03-16 12:15:20 +0000817 struct ExprList_item *a;
818 int n = pList->nAlloc*2 + 4;
danielk197726783a52007-08-29 14:06:22 +0000819 a = sqlite3DbRealloc(db, pList->a, n*sizeof(pList->a[0]));
danielk1977d5d56522005-03-16 12:15:20 +0000820 if( a==0 ){
821 goto no_mem;
drha76b5df2002-02-23 02:32:10 +0000822 }
danielk1977d5d56522005-03-16 12:15:20 +0000823 pList->a = a;
824 pList->nAlloc = n;
drha76b5df2002-02-23 02:32:10 +0000825 }
drh4efc4752004-01-16 15:55:37 +0000826 assert( pList->a!=0 );
827 if( pExpr || pName ){
828 struct ExprList_item *pItem = &pList->a[pList->nExpr++];
829 memset(pItem, 0, sizeof(*pItem));
drh17435752007-08-16 04:30:38 +0000830 pItem->zName = sqlite3NameFromToken(db, pName);
danielk1977e94ddc92005-03-21 03:53:38 +0000831 pItem->pExpr = pExpr;
drha76b5df2002-02-23 02:32:10 +0000832 }
833 return pList;
danielk1977d5d56522005-03-16 12:15:20 +0000834
835no_mem:
836 /* Avoid leaking memory if malloc has failed. */
drh633e6d52008-07-28 19:34:53 +0000837 sqlite3ExprDelete(db, pExpr);
838 sqlite3ExprListDelete(db, pList);
danielk1977d5d56522005-03-16 12:15:20 +0000839 return 0;
drha76b5df2002-02-23 02:32:10 +0000840}
841
842/*
danielk19777a15a4b2007-05-08 17:54:43 +0000843** If the expression list pEList contains more than iLimit elements,
844** leave an error message in pParse.
845*/
846void sqlite3ExprListCheckLength(
847 Parse *pParse,
848 ExprList *pEList,
danielk19777a15a4b2007-05-08 17:54:43 +0000849 const char *zObject
850){
drhb1a6c3c2008-03-20 16:30:17 +0000851 int mx = pParse->db->aLimit[SQLITE_LIMIT_COLUMN];
drhc5499be2008-04-01 15:06:33 +0000852 testcase( pEList && pEList->nExpr==mx );
853 testcase( pEList && pEList->nExpr==mx+1 );
drhb1a6c3c2008-03-20 16:30:17 +0000854 if( pEList && pEList->nExpr>mx ){
danielk19777a15a4b2007-05-08 17:54:43 +0000855 sqlite3ErrorMsg(pParse, "too many columns in %s", zObject);
856 }
857}
858
859/*
drha76b5df2002-02-23 02:32:10 +0000860** Delete an entire expression list.
861*/
drh633e6d52008-07-28 19:34:53 +0000862void sqlite3ExprListDelete(sqlite3 *db, ExprList *pList){
drha76b5df2002-02-23 02:32:10 +0000863 int i;
drhbe5c89a2004-07-26 00:31:09 +0000864 struct ExprList_item *pItem;
drha76b5df2002-02-23 02:32:10 +0000865 if( pList==0 ) return;
drh1bdd9b52004-04-23 17:04:44 +0000866 assert( pList->a!=0 || (pList->nExpr==0 && pList->nAlloc==0) );
867 assert( pList->nExpr<=pList->nAlloc );
drhbe5c89a2004-07-26 00:31:09 +0000868 for(pItem=pList->a, i=0; i<pList->nExpr; i++, pItem++){
drh633e6d52008-07-28 19:34:53 +0000869 sqlite3ExprDelete(db, pItem->pExpr);
870 sqlite3DbFree(db, pItem->zName);
drha76b5df2002-02-23 02:32:10 +0000871 }
drh633e6d52008-07-28 19:34:53 +0000872 sqlite3DbFree(db, pList->a);
873 sqlite3DbFree(db, pList);
drha76b5df2002-02-23 02:32:10 +0000874}
875
876/*
drh7d10d5a2008-08-20 16:35:10 +0000877** These routines are Walker callbacks. Walker.u.pi is a pointer
878** to an integer. These routines are checking an expression to see
879** if it is a constant. Set *Walker.u.pi to 0 if the expression is
880** not constant.
drh73b211a2005-01-18 04:00:42 +0000881**
drh7d10d5a2008-08-20 16:35:10 +0000882** These callback routines are used to implement the following:
drh626a8792005-01-17 22:08:19 +0000883**
drh7d10d5a2008-08-20 16:35:10 +0000884** sqlite3ExprIsConstant()
885** sqlite3ExprIsConstantNotJoin()
886** sqlite3ExprIsConstantOrFunction()
drh87abf5c2005-08-25 12:45:04 +0000887**
drh626a8792005-01-17 22:08:19 +0000888*/
drh7d10d5a2008-08-20 16:35:10 +0000889static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){
drh626a8792005-01-17 22:08:19 +0000890
drh7d10d5a2008-08-20 16:35:10 +0000891 /* If pWalker->u.i is 3 then any term of the expression that comes from
drh0a168372007-06-08 00:20:47 +0000892 ** the ON or USING clauses of a join disqualifies the expression
893 ** from being considered constant. */
drh7d10d5a2008-08-20 16:35:10 +0000894 if( pWalker->u.i==3 && ExprHasAnyProperty(pExpr, EP_FromJoin) ){
895 pWalker->u.i = 0;
896 return WRC_Abort;
drh0a168372007-06-08 00:20:47 +0000897 }
898
drh626a8792005-01-17 22:08:19 +0000899 switch( pExpr->op ){
drheb55bd22005-06-30 17:04:21 +0000900 /* Consider functions to be constant if all their arguments are constant
drh7d10d5a2008-08-20 16:35:10 +0000901 ** and pWalker->u.i==2 */
drheb55bd22005-06-30 17:04:21 +0000902 case TK_FUNCTION:
drh7d10d5a2008-08-20 16:35:10 +0000903 if( pWalker->u.i==2 ) return 0;
drheb55bd22005-06-30 17:04:21 +0000904 /* Fall through */
drh626a8792005-01-17 22:08:19 +0000905 case TK_ID:
906 case TK_COLUMN:
907 case TK_DOT:
908 case TK_AGG_FUNCTION:
drh13449892005-09-07 21:22:45 +0000909 case TK_AGG_COLUMN:
drhfe2093d2005-01-20 22:48:47 +0000910#ifndef SQLITE_OMIT_SUBQUERY
911 case TK_SELECT:
912 case TK_EXISTS:
drhc5499be2008-04-01 15:06:33 +0000913 testcase( pExpr->op==TK_SELECT );
914 testcase( pExpr->op==TK_EXISTS );
drhfe2093d2005-01-20 22:48:47 +0000915#endif
drhc5499be2008-04-01 15:06:33 +0000916 testcase( pExpr->op==TK_ID );
917 testcase( pExpr->op==TK_COLUMN );
918 testcase( pExpr->op==TK_DOT );
919 testcase( pExpr->op==TK_AGG_FUNCTION );
920 testcase( pExpr->op==TK_AGG_COLUMN );
drh7d10d5a2008-08-20 16:35:10 +0000921 pWalker->u.i = 0;
922 return WRC_Abort;
drh626a8792005-01-17 22:08:19 +0000923 default:
drh7d10d5a2008-08-20 16:35:10 +0000924 return WRC_Continue;
drh626a8792005-01-17 22:08:19 +0000925 }
926}
drh7d10d5a2008-08-20 16:35:10 +0000927static int selectNodeIsConstant(Walker *pWalker, Select *pSelect){
928 pWalker->u.i = 0;
929 return WRC_Abort;
930}
931static int exprIsConst(Expr *p, int initFlag){
932 Walker w;
933 w.u.i = initFlag;
934 w.xExprCallback = exprNodeIsConstant;
935 w.xSelectCallback = selectNodeIsConstant;
936 sqlite3WalkExpr(&w, p);
937 return w.u.i;
938}
drh626a8792005-01-17 22:08:19 +0000939
940/*
drhfef52082000-06-06 01:50:43 +0000941** Walk an expression tree. Return 1 if the expression is constant
drheb55bd22005-06-30 17:04:21 +0000942** and 0 if it involves variables or function calls.
drh23989372002-05-21 13:43:04 +0000943**
944** For the purposes of this function, a double-quoted string (ex: "abc")
945** is considered a variable but a single-quoted string (ex: 'abc') is
946** a constant.
drhfef52082000-06-06 01:50:43 +0000947*/
danielk19774adee202004-05-08 08:23:19 +0000948int sqlite3ExprIsConstant(Expr *p){
drh7d10d5a2008-08-20 16:35:10 +0000949 return exprIsConst(p, 1);
drhfef52082000-06-06 01:50:43 +0000950}
951
952/*
drheb55bd22005-06-30 17:04:21 +0000953** Walk an expression tree. Return 1 if the expression is constant
drh0a168372007-06-08 00:20:47 +0000954** that does no originate from the ON or USING clauses of a join.
955** Return 0 if it involves variables or function calls or terms from
956** an ON or USING clause.
957*/
958int sqlite3ExprIsConstantNotJoin(Expr *p){
drh7d10d5a2008-08-20 16:35:10 +0000959 return exprIsConst(p, 3);
drh0a168372007-06-08 00:20:47 +0000960}
961
962/*
963** Walk an expression tree. Return 1 if the expression is constant
drheb55bd22005-06-30 17:04:21 +0000964** or a function call with constant arguments. Return and 0 if there
965** are any variables.
966**
967** For the purposes of this function, a double-quoted string (ex: "abc")
968** is considered a variable but a single-quoted string (ex: 'abc') is
969** a constant.
970*/
971int sqlite3ExprIsConstantOrFunction(Expr *p){
drh7d10d5a2008-08-20 16:35:10 +0000972 return exprIsConst(p, 2);
drheb55bd22005-06-30 17:04:21 +0000973}
974
975/*
drh73b211a2005-01-18 04:00:42 +0000976** If the expression p codes a constant integer that is small enough
drh202b2df2004-01-06 01:13:46 +0000977** to fit in a 32-bit integer, return 1 and put the value of the integer
978** in *pValue. If the expression is not an integer or if it is too big
979** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
drhe4de1fe2002-06-02 16:09:01 +0000980*/
danielk19774adee202004-05-08 08:23:19 +0000981int sqlite3ExprIsInteger(Expr *p, int *pValue){
drh92b01d52008-06-24 00:32:35 +0000982 int rc = 0;
983 if( p->flags & EP_IntValue ){
984 *pValue = p->iTable;
985 return 1;
986 }
drhe4de1fe2002-06-02 16:09:01 +0000987 switch( p->op ){
988 case TK_INTEGER: {
drh92b01d52008-06-24 00:32:35 +0000989 rc = sqlite3GetInt32((char*)p->token.z, pValue);
drh202b2df2004-01-06 01:13:46 +0000990 break;
drhe4de1fe2002-06-02 16:09:01 +0000991 }
drh4b59ab52002-08-24 18:24:51 +0000992 case TK_UPLUS: {
drh92b01d52008-06-24 00:32:35 +0000993 rc = sqlite3ExprIsInteger(p->pLeft, pValue);
drhf6e369a2008-06-24 12:46:30 +0000994 break;
drh4b59ab52002-08-24 18:24:51 +0000995 }
drhe4de1fe2002-06-02 16:09:01 +0000996 case TK_UMINUS: {
997 int v;
danielk19774adee202004-05-08 08:23:19 +0000998 if( sqlite3ExprIsInteger(p->pLeft, &v) ){
drhe4de1fe2002-06-02 16:09:01 +0000999 *pValue = -v;
drh92b01d52008-06-24 00:32:35 +00001000 rc = 1;
drhe4de1fe2002-06-02 16:09:01 +00001001 }
1002 break;
1003 }
1004 default: break;
1005 }
drh92b01d52008-06-24 00:32:35 +00001006 if( rc ){
1007 p->op = TK_INTEGER;
1008 p->flags |= EP_IntValue;
1009 p->iTable = *pValue;
1010 }
1011 return rc;
drhe4de1fe2002-06-02 16:09:01 +00001012}
1013
1014/*
drhc4a3c772001-04-04 11:48:57 +00001015** Return TRUE if the given string is a row-id column name.
1016*/
danielk19774adee202004-05-08 08:23:19 +00001017int sqlite3IsRowid(const char *z){
1018 if( sqlite3StrICmp(z, "_ROWID_")==0 ) return 1;
1019 if( sqlite3StrICmp(z, "ROWID")==0 ) return 1;
1020 if( sqlite3StrICmp(z, "OID")==0 ) return 1;
drhc4a3c772001-04-04 11:48:57 +00001021 return 0;
1022}
1023
danielk19779a96b662007-11-29 17:05:18 +00001024#ifdef SQLITE_TEST
1025 int sqlite3_enable_in_opt = 1;
1026#else
1027 #define sqlite3_enable_in_opt 1
1028#endif
1029
1030/*
drhb287f4b2008-04-25 00:08:38 +00001031** Return true if the IN operator optimization is enabled and
1032** the SELECT statement p exists and is of the
1033** simple form:
1034**
1035** SELECT <column> FROM <table>
1036**
1037** If this is the case, it may be possible to use an existing table
1038** or index instead of generating an epheremal table.
1039*/
1040#ifndef SQLITE_OMIT_SUBQUERY
1041static int isCandidateForInOpt(Select *p){
1042 SrcList *pSrc;
1043 ExprList *pEList;
1044 Table *pTab;
1045 if( !sqlite3_enable_in_opt ) return 0; /* IN optimization must be enabled */
1046 if( p==0 ) return 0; /* right-hand side of IN is SELECT */
1047 if( p->pPrior ) return 0; /* Not a compound SELECT */
drh7d10d5a2008-08-20 16:35:10 +00001048 if( p->selFlags & (SF_Distinct|SF_Aggregate) ){
1049 return 0; /* No DISTINCT keyword and no aggregate functions */
1050 }
drhb287f4b2008-04-25 00:08:38 +00001051 if( p->pGroupBy ) return 0; /* Has no GROUP BY clause */
1052 if( p->pLimit ) return 0; /* Has no LIMIT clause */
1053 if( p->pOffset ) return 0;
1054 if( p->pWhere ) return 0; /* Has no WHERE clause */
1055 pSrc = p->pSrc;
1056 if( pSrc==0 ) return 0; /* A single table in the FROM clause */
1057 if( pSrc->nSrc!=1 ) return 0;
1058 if( pSrc->a[0].pSelect ) return 0; /* FROM clause is not a subquery */
1059 pTab = pSrc->a[0].pTab;
1060 if( pTab==0 ) return 0;
1061 if( pTab->pSelect ) return 0; /* FROM clause is not a view */
1062 if( IsVirtual(pTab) ) return 0; /* FROM clause not a virtual table */
1063 pEList = p->pEList;
1064 if( pEList->nExpr!=1 ) return 0; /* One column in the result set */
1065 if( pEList->a[0].pExpr->op!=TK_COLUMN ) return 0; /* Result is a column */
1066 return 1;
1067}
1068#endif /* SQLITE_OMIT_SUBQUERY */
1069
1070/*
danielk19779a96b662007-11-29 17:05:18 +00001071** This function is used by the implementation of the IN (...) operator.
1072** It's job is to find or create a b-tree structure that may be used
1073** either to test for membership of the (...) set or to iterate through
drh85b623f2007-12-13 21:54:09 +00001074** its members, skipping duplicates.
danielk19779a96b662007-11-29 17:05:18 +00001075**
1076** The cursor opened on the structure (database table, database index
1077** or ephermal table) is stored in pX->iTable before this function returns.
1078** The returned value indicates the structure type, as follows:
1079**
1080** IN_INDEX_ROWID - The cursor was opened on a database table.
drh2d401ab2008-01-10 23:50:11 +00001081** IN_INDEX_INDEX - The cursor was opened on a database index.
danielk19779a96b662007-11-29 17:05:18 +00001082** IN_INDEX_EPH - The cursor was opened on a specially created and
1083** populated epheremal table.
1084**
1085** An existing structure may only be used if the SELECT is of the simple
1086** form:
1087**
1088** SELECT <column> FROM <table>
1089**
danielk19770cdc0222008-06-26 18:04:03 +00001090** If prNotFound parameter is 0, then the structure will be used to iterate
danielk19779a96b662007-11-29 17:05:18 +00001091** through the set members, skipping any duplicates. In this case an
1092** epheremal table must be used unless the selected <column> is guaranteed
1093** to be unique - either because it is an INTEGER PRIMARY KEY or it
1094** is unique by virtue of a constraint or implicit index.
danielk19770cdc0222008-06-26 18:04:03 +00001095**
1096** If the prNotFound parameter is not 0, then the structure will be used
1097** for fast set membership tests. In this case an epheremal table must
1098** be used unless <column> is an INTEGER PRIMARY KEY or an index can
1099** be found with <column> as its left-most column.
1100**
1101** When the structure is being used for set membership tests, the user
1102** needs to know whether or not the structure contains an SQL NULL
1103** value in order to correctly evaluate expressions like "X IN (Y, Z)".
1104** If there is a chance that the structure may contain a NULL value at
1105** runtime, then a register is allocated and the register number written
1106** to *prNotFound. If there is no chance that the structure contains a
1107** NULL value, then *prNotFound is left unchanged.
1108**
1109** If a register is allocated and its location stored in *prNotFound, then
1110** its initial value is NULL. If the structure does not remain constant
1111** for the duration of the query (i.e. the set is a correlated sub-select),
1112** the value of the allocated register is reset to NULL each time the
1113** structure is repopulated. This allows the caller to use vdbe code
1114** equivalent to the following:
1115**
1116** if( register==NULL ){
1117** has_null = <test if data structure contains null>
1118** register = 1
1119** }
1120**
1121** in order to avoid running the <test if data structure contains null>
1122** test more often than is necessary.
danielk19779a96b662007-11-29 17:05:18 +00001123*/
danielk1977284f4ac2007-12-10 05:03:46 +00001124#ifndef SQLITE_OMIT_SUBQUERY
danielk19770cdc0222008-06-26 18:04:03 +00001125int sqlite3FindInIndex(Parse *pParse, Expr *pX, int *prNotFound){
danielk19779a96b662007-11-29 17:05:18 +00001126 Select *p;
1127 int eType = 0;
1128 int iTab = pParse->nTab++;
danielk19770cdc0222008-06-26 18:04:03 +00001129 int mustBeUnique = !prNotFound;
danielk19779a96b662007-11-29 17:05:18 +00001130
1131 /* The follwing if(...) expression is true if the SELECT is of the
1132 ** simple form:
1133 **
1134 ** SELECT <column> FROM <table>
1135 **
1136 ** If this is the case, it may be possible to use an existing table
1137 ** or index instead of generating an epheremal table.
1138 */
drhb287f4b2008-04-25 00:08:38 +00001139 p = pX->pSelect;
1140 if( isCandidateForInOpt(p) ){
danielk19779a96b662007-11-29 17:05:18 +00001141 sqlite3 *db = pParse->db;
1142 Index *pIdx;
1143 Expr *pExpr = p->pEList->a[0].pExpr;
1144 int iCol = pExpr->iColumn;
1145 Vdbe *v = sqlite3GetVdbe(pParse);
1146
1147 /* This function is only called from two places. In both cases the vdbe
1148 ** has already been allocated. So assume sqlite3GetVdbe() is always
1149 ** successful here.
1150 */
1151 assert(v);
1152 if( iCol<0 ){
drh0a07c102008-01-03 18:03:08 +00001153 int iMem = ++pParse->nMem;
danielk19779a96b662007-11-29 17:05:18 +00001154 int iAddr;
1155 Table *pTab = p->pSrc->a[0].pTab;
1156 int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
1157 sqlite3VdbeUsesBtree(v, iDb);
1158
drh892d3172008-01-10 03:46:36 +00001159 iAddr = sqlite3VdbeAddOp1(v, OP_If, iMem);
drh4c583122008-01-04 22:01:03 +00001160 sqlite3VdbeAddOp2(v, OP_Integer, 1, iMem);
danielk19779a96b662007-11-29 17:05:18 +00001161
1162 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
1163 eType = IN_INDEX_ROWID;
1164
1165 sqlite3VdbeJumpHere(v, iAddr);
1166 }else{
1167 /* The collation sequence used by the comparison. If an index is to
1168 ** be used in place of a temp-table, it must be ordered according
1169 ** to this collation sequence.
1170 */
1171 CollSeq *pReq = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pExpr);
1172
1173 /* Check that the affinity that will be used to perform the
1174 ** comparison is the same as the affinity of the column. If
1175 ** it is not, it is not possible to use any index.
1176 */
1177 Table *pTab = p->pSrc->a[0].pTab;
1178 char aff = comparisonAffinity(pX);
1179 int affinity_ok = (pTab->aCol[iCol].affinity==aff||aff==SQLITE_AFF_NONE);
1180
1181 for(pIdx=pTab->pIndex; pIdx && eType==0 && affinity_ok; pIdx=pIdx->pNext){
1182 if( (pIdx->aiColumn[0]==iCol)
1183 && (pReq==sqlite3FindCollSeq(db, ENC(db), pIdx->azColl[0], -1, 0))
1184 && (!mustBeUnique || (pIdx->nColumn==1 && pIdx->onError!=OE_None))
1185 ){
1186 int iDb;
drh0a07c102008-01-03 18:03:08 +00001187 int iMem = ++pParse->nMem;
danielk19779a96b662007-11-29 17:05:18 +00001188 int iAddr;
1189 char *pKey;
1190
1191 pKey = (char *)sqlite3IndexKeyinfo(pParse, pIdx);
1192 iDb = sqlite3SchemaToIndex(db, pIdx->pSchema);
1193 sqlite3VdbeUsesBtree(v, iDb);
1194
drh892d3172008-01-10 03:46:36 +00001195 iAddr = sqlite3VdbeAddOp1(v, OP_If, iMem);
drh4c583122008-01-04 22:01:03 +00001196 sqlite3VdbeAddOp2(v, OP_Integer, 1, iMem);
danielk19779a96b662007-11-29 17:05:18 +00001197
danielk1977cd3e8f72008-03-25 09:47:35 +00001198 sqlite3VdbeAddOp2(v, OP_SetNumColumns, 0, pIdx->nColumn);
danielk1977207872a2008-01-03 07:54:23 +00001199 sqlite3VdbeAddOp4(v, OP_OpenRead, iTab, pIdx->tnum, iDb,
drh66a51672008-01-03 00:01:23 +00001200 pKey,P4_KEYINFO_HANDOFF);
danielk1977207872a2008-01-03 07:54:23 +00001201 VdbeComment((v, "%s", pIdx->zName));
danielk19779a96b662007-11-29 17:05:18 +00001202 eType = IN_INDEX_INDEX;
danielk19779a96b662007-11-29 17:05:18 +00001203
1204 sqlite3VdbeJumpHere(v, iAddr);
danielk19770cdc0222008-06-26 18:04:03 +00001205 if( prNotFound && !pTab->aCol[iCol].notNull ){
1206 *prNotFound = ++pParse->nMem;
1207 }
danielk19779a96b662007-11-29 17:05:18 +00001208 }
1209 }
1210 }
1211 }
1212
1213 if( eType==0 ){
danielk19770cdc0222008-06-26 18:04:03 +00001214 int rMayHaveNull = 0;
1215 if( prNotFound ){
1216 *prNotFound = rMayHaveNull = ++pParse->nMem;
1217 }
1218 sqlite3CodeSubselect(pParse, pX, rMayHaveNull);
danielk19779a96b662007-11-29 17:05:18 +00001219 eType = IN_INDEX_EPH;
1220 }else{
1221 pX->iTable = iTab;
1222 }
1223 return eType;
1224}
danielk1977284f4ac2007-12-10 05:03:46 +00001225#endif
drh626a8792005-01-17 22:08:19 +00001226
1227/*
drh9cbe6352005-11-29 03:13:21 +00001228** Generate code for scalar subqueries used as an expression
1229** and IN operators. Examples:
drh626a8792005-01-17 22:08:19 +00001230**
drh9cbe6352005-11-29 03:13:21 +00001231** (SELECT a FROM b) -- subquery
1232** EXISTS (SELECT a FROM b) -- EXISTS subquery
1233** x IN (4,5,11) -- IN operator with list on right-hand side
1234** x IN (SELECT a FROM b) -- IN operator with subquery on the right
drhfef52082000-06-06 01:50:43 +00001235**
drh9cbe6352005-11-29 03:13:21 +00001236** The pExpr parameter describes the expression that contains the IN
1237** operator or subquery.
drhcce7d172000-05-31 15:34:51 +00001238*/
drh51522cd2005-01-20 13:36:19 +00001239#ifndef SQLITE_OMIT_SUBQUERY
danielk19770cdc0222008-06-26 18:04:03 +00001240void sqlite3CodeSubselect(Parse *pParse, Expr *pExpr, int rMayHaveNull){
drh57dbd7b2005-07-08 18:25:26 +00001241 int testAddr = 0; /* One-time test address */
danielk1977b3bce662005-01-29 08:32:43 +00001242 Vdbe *v = sqlite3GetVdbe(pParse);
1243 if( v==0 ) return;
1244
danielk1977fc976062007-05-10 10:46:56 +00001245
drh57dbd7b2005-07-08 18:25:26 +00001246 /* This code must be run in its entirety every time it is encountered
1247 ** if any of the following is true:
1248 **
1249 ** * The right-hand side is a correlated subquery
1250 ** * The right-hand side is an expression list containing variables
1251 ** * We are inside a trigger
1252 **
1253 ** If all of the above are false, then we can run this code just once
1254 ** save the results, and reuse the same result on subsequent invocations.
danielk1977b3bce662005-01-29 08:32:43 +00001255 */
1256 if( !ExprHasAnyProperty(pExpr, EP_VarSelect) && !pParse->trigStack ){
drh0a07c102008-01-03 18:03:08 +00001257 int mem = ++pParse->nMem;
drh892d3172008-01-10 03:46:36 +00001258 sqlite3VdbeAddOp1(v, OP_If, mem);
1259 testAddr = sqlite3VdbeAddOp2(v, OP_Integer, 1, mem);
drh17435752007-08-16 04:30:38 +00001260 assert( testAddr>0 || pParse->db->mallocFailed );
danielk1977b3bce662005-01-29 08:32:43 +00001261 }
1262
drhcce7d172000-05-31 15:34:51 +00001263 switch( pExpr->op ){
drhfef52082000-06-06 01:50:43 +00001264 case TK_IN: {
danielk1977e014a832004-05-17 10:48:57 +00001265 char affinity;
drhd3d39e92004-05-20 22:16:29 +00001266 KeyInfo keyInfo;
drhb9bb7c12006-06-11 23:41:55 +00001267 int addr; /* Address of OP_OpenEphemeral instruction */
drhd3d39e92004-05-20 22:16:29 +00001268
danielk19770cdc0222008-06-26 18:04:03 +00001269 if( rMayHaveNull ){
1270 sqlite3VdbeAddOp2(v, OP_Null, 0, rMayHaveNull);
1271 }
1272
danielk1977bf3b7212004-05-18 10:06:24 +00001273 affinity = sqlite3ExprAffinity(pExpr->pLeft);
danielk1977e014a832004-05-17 10:48:57 +00001274
1275 /* Whether this is an 'x IN(SELECT...)' or an 'x IN(<exprlist>)'
drh57dbd7b2005-07-08 18:25:26 +00001276 ** expression it is handled the same way. A virtual table is
danielk1977e014a832004-05-17 10:48:57 +00001277 ** filled with single-field index keys representing the results
1278 ** from the SELECT or the <exprlist>.
1279 **
1280 ** If the 'x' expression is a column value, or the SELECT...
1281 ** statement returns a column value, then the affinity of that
1282 ** column is used to build the index keys. If both 'x' and the
1283 ** SELECT... statement are columns, then numeric affinity is used
1284 ** if either column has NUMERIC or INTEGER affinity. If neither
1285 ** 'x' nor the SELECT... statement are columns, then numeric affinity
1286 ** is used.
1287 */
1288 pExpr->iTable = pParse->nTab++;
danielk1977cd3e8f72008-03-25 09:47:35 +00001289 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, 1);
drhd3d39e92004-05-20 22:16:29 +00001290 memset(&keyInfo, 0, sizeof(keyInfo));
1291 keyInfo.nField = 1;
danielk1977e014a832004-05-17 10:48:57 +00001292
drhfef52082000-06-06 01:50:43 +00001293 if( pExpr->pSelect ){
1294 /* Case 1: expr IN (SELECT ...)
1295 **
danielk1977e014a832004-05-17 10:48:57 +00001296 ** Generate code to write the results of the select into the temporary
1297 ** table allocated and opened above.
drhfef52082000-06-06 01:50:43 +00001298 */
drh1013c932008-01-06 00:25:21 +00001299 SelectDest dest;
drhbe5c89a2004-07-26 00:31:09 +00001300 ExprList *pEList;
drh1013c932008-01-06 00:25:21 +00001301
1302 sqlite3SelectDestInit(&dest, SRT_Set, pExpr->iTable);
1303 dest.affinity = (int)affinity;
danielk1977e014a832004-05-17 10:48:57 +00001304 assert( (pExpr->iTable&0x0000FFFF)==pExpr->iTable );
drh7d10d5a2008-08-20 16:35:10 +00001305 if( sqlite3Select(pParse, pExpr->pSelect, &dest) ){
drh94ccde52007-04-13 16:06:32 +00001306 return;
1307 }
drhbe5c89a2004-07-26 00:31:09 +00001308 pEList = pExpr->pSelect->pEList;
1309 if( pEList && pEList->nExpr>0 ){
danielk1977bcbb04e2007-05-29 12:11:29 +00001310 keyInfo.aColl[0] = sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft,
drhbe5c89a2004-07-26 00:31:09 +00001311 pEList->a[0].pExpr);
danielk19770202b292004-06-09 09:55:16 +00001312 }
drhfef52082000-06-06 01:50:43 +00001313 }else if( pExpr->pList ){
1314 /* Case 2: expr IN (exprlist)
1315 **
drhfd131da2007-08-07 17:13:03 +00001316 ** For each expression, build an index key from the evaluation and
danielk1977e014a832004-05-17 10:48:57 +00001317 ** store it in the temporary table. If <expr> is a column, then use
1318 ** that columns affinity when building index keys. If <expr> is not
1319 ** a column, use numeric affinity.
drhfef52082000-06-06 01:50:43 +00001320 */
danielk1977e014a832004-05-17 10:48:57 +00001321 int i;
drh57dbd7b2005-07-08 18:25:26 +00001322 ExprList *pList = pExpr->pList;
1323 struct ExprList_item *pItem;
drhecc31802008-06-26 20:06:06 +00001324 int r1, r2, r3;
drh57dbd7b2005-07-08 18:25:26 +00001325
danielk1977e014a832004-05-17 10:48:57 +00001326 if( !affinity ){
drh8159a352006-05-23 23:22:29 +00001327 affinity = SQLITE_AFF_NONE;
danielk1977e014a832004-05-17 10:48:57 +00001328 }
drh7d10d5a2008-08-20 16:35:10 +00001329 keyInfo.aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
danielk1977e014a832004-05-17 10:48:57 +00001330
1331 /* Loop through each expression in <exprlist>. */
drh2d401ab2008-01-10 23:50:11 +00001332 r1 = sqlite3GetTempReg(pParse);
1333 r2 = sqlite3GetTempReg(pParse);
drh57dbd7b2005-07-08 18:25:26 +00001334 for(i=pList->nExpr, pItem=pList->a; i>0; i--, pItem++){
1335 Expr *pE2 = pItem->pExpr;
danielk1977e014a832004-05-17 10:48:57 +00001336
drh57dbd7b2005-07-08 18:25:26 +00001337 /* If the expression is not constant then we will need to
1338 ** disable the test that was generated above that makes sure
1339 ** this code only executes once. Because for a non-constant
1340 ** expression we need to rerun this code each time.
1341 */
drh892d3172008-01-10 03:46:36 +00001342 if( testAddr && !sqlite3ExprIsConstant(pE2) ){
1343 sqlite3VdbeChangeToNoop(v, testAddr-1, 2);
drh57dbd7b2005-07-08 18:25:26 +00001344 testAddr = 0;
drh4794b982000-06-06 13:54:14 +00001345 }
danielk1977e014a832004-05-17 10:48:57 +00001346
1347 /* Evaluate the expression and insert it into the temp table */
drhe55cbd72008-03-31 23:48:03 +00001348 pParse->disableColCache++;
drhecc31802008-06-26 20:06:06 +00001349 r3 = sqlite3ExprCodeTarget(pParse, pE2, r1);
drhc5499be2008-04-01 15:06:33 +00001350 assert( pParse->disableColCache>0 );
drhe55cbd72008-03-31 23:48:03 +00001351 pParse->disableColCache--;
drhecc31802008-06-26 20:06:06 +00001352 sqlite3VdbeAddOp4(v, OP_MakeRecord, r3, 1, r2, &affinity, 1);
drh3c31fc22008-06-26 21:45:26 +00001353 sqlite3ExprCacheAffinityChange(pParse, r3, 1);
drh2d401ab2008-01-10 23:50:11 +00001354 sqlite3VdbeAddOp2(v, OP_IdxInsert, pExpr->iTable, r2);
drhfef52082000-06-06 01:50:43 +00001355 }
drh2d401ab2008-01-10 23:50:11 +00001356 sqlite3ReleaseTempReg(pParse, r1);
1357 sqlite3ReleaseTempReg(pParse, r2);
drhfef52082000-06-06 01:50:43 +00001358 }
drh66a51672008-01-03 00:01:23 +00001359 sqlite3VdbeChangeP4(v, addr, (void *)&keyInfo, P4_KEYINFO);
danielk1977b3bce662005-01-29 08:32:43 +00001360 break;
drhfef52082000-06-06 01:50:43 +00001361 }
1362
drh51522cd2005-01-20 13:36:19 +00001363 case TK_EXISTS:
drh19a775c2000-06-05 18:54:46 +00001364 case TK_SELECT: {
drhfef52082000-06-06 01:50:43 +00001365 /* This has to be a scalar SELECT. Generate code to put the
1366 ** value of this select in a memory cell and record the number
drh967e8b72000-06-21 13:59:10 +00001367 ** of the memory cell in iColumn.
drhfef52082000-06-06 01:50:43 +00001368 */
drh2646da72005-12-09 20:02:05 +00001369 static const Token one = { (u8*)"1", 0, 1 };
drh51522cd2005-01-20 13:36:19 +00001370 Select *pSel;
danielk19776c8c8ce2008-01-02 16:27:09 +00001371 SelectDest dest;
drh1398ad32005-01-19 23:24:50 +00001372
drh51522cd2005-01-20 13:36:19 +00001373 pSel = pExpr->pSelect;
drh1013c932008-01-06 00:25:21 +00001374 sqlite3SelectDestInit(&dest, 0, ++pParse->nMem);
drh51522cd2005-01-20 13:36:19 +00001375 if( pExpr->op==TK_SELECT ){
danielk19776c8c8ce2008-01-02 16:27:09 +00001376 dest.eDest = SRT_Mem;
drh4c583122008-01-04 22:01:03 +00001377 sqlite3VdbeAddOp2(v, OP_Null, 0, dest.iParm);
drhd4e70eb2008-01-02 00:34:36 +00001378 VdbeComment((v, "Init subquery result"));
drh51522cd2005-01-20 13:36:19 +00001379 }else{
danielk19776c8c8ce2008-01-02 16:27:09 +00001380 dest.eDest = SRT_Exists;
drh4c583122008-01-04 22:01:03 +00001381 sqlite3VdbeAddOp2(v, OP_Integer, 0, dest.iParm);
drhd4e70eb2008-01-02 00:34:36 +00001382 VdbeComment((v, "Init EXISTS result"));
drh51522cd2005-01-20 13:36:19 +00001383 }
drh633e6d52008-07-28 19:34:53 +00001384 sqlite3ExprDelete(pParse->db, pSel->pLimit);
danielk1977a1644fd2007-08-29 12:31:25 +00001385 pSel->pLimit = sqlite3PExpr(pParse, TK_INTEGER, 0, 0, &one);
drh7d10d5a2008-08-20 16:35:10 +00001386 if( sqlite3Select(pParse, pSel, &dest) ){
drh94ccde52007-04-13 16:06:32 +00001387 return;
1388 }
danielk19776c8c8ce2008-01-02 16:27:09 +00001389 pExpr->iColumn = dest.iParm;
danielk1977b3bce662005-01-29 08:32:43 +00001390 break;
drhcce7d172000-05-31 15:34:51 +00001391 }
1392 }
danielk1977b3bce662005-01-29 08:32:43 +00001393
drh57dbd7b2005-07-08 18:25:26 +00001394 if( testAddr ){
drh892d3172008-01-10 03:46:36 +00001395 sqlite3VdbeJumpHere(v, testAddr-1);
danielk1977b3bce662005-01-29 08:32:43 +00001396 }
danielk1977fc976062007-05-10 10:46:56 +00001397
danielk1977b3bce662005-01-29 08:32:43 +00001398 return;
drhcce7d172000-05-31 15:34:51 +00001399}
drh51522cd2005-01-20 13:36:19 +00001400#endif /* SQLITE_OMIT_SUBQUERY */
drhcce7d172000-05-31 15:34:51 +00001401
drhcce7d172000-05-31 15:34:51 +00001402/*
drh598f1342007-10-23 15:39:45 +00001403** Duplicate an 8-byte value
1404*/
1405static char *dup8bytes(Vdbe *v, const char *in){
1406 char *out = sqlite3DbMallocRaw(sqlite3VdbeDb(v), 8);
1407 if( out ){
1408 memcpy(out, in, 8);
1409 }
1410 return out;
1411}
1412
1413/*
1414** Generate an instruction that will put the floating point
drh9cbf3422008-01-17 16:22:13 +00001415** value described by z[0..n-1] into register iMem.
drh0cf19ed2007-10-23 18:55:48 +00001416**
1417** The z[] string will probably not be zero-terminated. But the
1418** z[n] character is guaranteed to be something that does not look
1419** like the continuation of the number.
drh598f1342007-10-23 15:39:45 +00001420*/
drh9de221d2008-01-05 06:51:30 +00001421static void codeReal(Vdbe *v, const char *z, int n, int negateFlag, int iMem){
drh598f1342007-10-23 15:39:45 +00001422 assert( z || v==0 || sqlite3VdbeDb(v)->mallocFailed );
1423 if( z ){
1424 double value;
1425 char *zV;
drh0cf19ed2007-10-23 18:55:48 +00001426 assert( !isdigit(z[n]) );
drh598f1342007-10-23 15:39:45 +00001427 sqlite3AtoF(z, &value);
drh2eaf93d2008-04-29 00:15:20 +00001428 if( sqlite3IsNaN(value) ){
1429 sqlite3VdbeAddOp2(v, OP_Null, 0, iMem);
1430 }else{
1431 if( negateFlag ) value = -value;
1432 zV = dup8bytes(v, (char*)&value);
1433 sqlite3VdbeAddOp4(v, OP_Real, 0, iMem, 0, zV, P4_REAL);
1434 }
drh598f1342007-10-23 15:39:45 +00001435 }
1436}
1437
1438
1439/*
drhfec19aa2004-05-19 20:41:03 +00001440** Generate an instruction that will put the integer describe by
drh9cbf3422008-01-17 16:22:13 +00001441** text z[0..n-1] into register iMem.
drh0cf19ed2007-10-23 18:55:48 +00001442**
1443** The z[] string will probably not be zero-terminated. But the
1444** z[n] character is guaranteed to be something that does not look
1445** like the continuation of the number.
drhfec19aa2004-05-19 20:41:03 +00001446*/
drh92b01d52008-06-24 00:32:35 +00001447static void codeInteger(Vdbe *v, Expr *pExpr, int negFlag, int iMem){
1448 const char *z;
1449 if( pExpr->flags & EP_IntValue ){
1450 int i = pExpr->iTable;
1451 if( negFlag ) i = -i;
1452 sqlite3VdbeAddOp2(v, OP_Integer, i, iMem);
1453 }else if( (z = (char*)pExpr->token.z)!=0 ){
danielk1977c9cf9012007-05-30 10:36:47 +00001454 int i;
drh92b01d52008-06-24 00:32:35 +00001455 int n = pExpr->token.n;
drh0cf19ed2007-10-23 18:55:48 +00001456 assert( !isdigit(z[n]) );
danielk1977c9cf9012007-05-30 10:36:47 +00001457 if( sqlite3GetInt32(z, &i) ){
drh9de221d2008-01-05 06:51:30 +00001458 if( negFlag ) i = -i;
1459 sqlite3VdbeAddOp2(v, OP_Integer, i, iMem);
1460 }else if( sqlite3FitsIn64Bits(z, negFlag) ){
drh598f1342007-10-23 15:39:45 +00001461 i64 value;
1462 char *zV;
1463 sqlite3Atoi64(z, &value);
drh9de221d2008-01-05 06:51:30 +00001464 if( negFlag ) value = -value;
drh598f1342007-10-23 15:39:45 +00001465 zV = dup8bytes(v, (char*)&value);
drh9de221d2008-01-05 06:51:30 +00001466 sqlite3VdbeAddOp4(v, OP_Int64, 0, iMem, 0, zV, P4_INT64);
danielk1977c9cf9012007-05-30 10:36:47 +00001467 }else{
drh9de221d2008-01-05 06:51:30 +00001468 codeReal(v, z, n, negFlag, iMem);
danielk1977c9cf9012007-05-30 10:36:47 +00001469 }
drhfec19aa2004-05-19 20:41:03 +00001470 }
1471}
1472
drh945498f2007-02-24 11:52:52 +00001473
1474/*
1475** Generate code that will extract the iColumn-th column from
drhe55cbd72008-03-31 23:48:03 +00001476** table pTab and store the column value in a register. An effort
1477** is made to store the column value in register iReg, but this is
1478** not guaranteed. The location of the column value is returned.
1479**
1480** There must be an open cursor to pTab in iTable when this routine
1481** is called. If iColumn<0 then code is generated that extracts the rowid.
drhda250ea2008-04-01 05:07:14 +00001482**
1483** This routine might attempt to reuse the value of the column that
1484** has already been loaded into a register. The value will always
1485** be used if it has not undergone any affinity changes. But if
1486** an affinity change has occurred, then the cached value will only be
1487** used if allowAffChng is true.
drh945498f2007-02-24 11:52:52 +00001488*/
drhe55cbd72008-03-31 23:48:03 +00001489int sqlite3ExprCodeGetColumn(
1490 Parse *pParse, /* Parsing and code generating context */
drh2133d822008-01-03 18:44:59 +00001491 Table *pTab, /* Description of the table we are reading from */
1492 int iColumn, /* Index of the table column */
1493 int iTable, /* The cursor pointing to the table */
drhda250ea2008-04-01 05:07:14 +00001494 int iReg, /* Store results here */
1495 int allowAffChng /* True if prior affinity changes are OK */
drh2133d822008-01-03 18:44:59 +00001496){
drhe55cbd72008-03-31 23:48:03 +00001497 Vdbe *v = pParse->pVdbe;
1498 int i;
drhda250ea2008-04-01 05:07:14 +00001499 struct yColCache *p;
drhe55cbd72008-03-31 23:48:03 +00001500
drhda250ea2008-04-01 05:07:14 +00001501 for(i=0, p=pParse->aColCache; i<pParse->nColCache; i++, p++){
1502 if( p->iTable==iTable && p->iColumn==iColumn
1503 && (!p->affChange || allowAffChng) ){
drhe55cbd72008-03-31 23:48:03 +00001504#if 0
1505 sqlite3VdbeAddOp0(v, OP_Noop);
drhda250ea2008-04-01 05:07:14 +00001506 VdbeComment((v, "OPT: tab%d.col%d -> r%d", iTable, iColumn, p->iReg));
drhe55cbd72008-03-31 23:48:03 +00001507#endif
drhda250ea2008-04-01 05:07:14 +00001508 return p->iReg;
drhe55cbd72008-03-31 23:48:03 +00001509 }
1510 }
1511 assert( v!=0 );
drh945498f2007-02-24 11:52:52 +00001512 if( iColumn<0 ){
1513 int op = (pTab && IsVirtual(pTab)) ? OP_VRowid : OP_Rowid;
drh2133d822008-01-03 18:44:59 +00001514 sqlite3VdbeAddOp2(v, op, iTable, iReg);
drh945498f2007-02-24 11:52:52 +00001515 }else if( pTab==0 ){
drh2133d822008-01-03 18:44:59 +00001516 sqlite3VdbeAddOp3(v, OP_Column, iTable, iColumn, iReg);
drh945498f2007-02-24 11:52:52 +00001517 }else{
1518 int op = IsVirtual(pTab) ? OP_VColumn : OP_Column;
drh2133d822008-01-03 18:44:59 +00001519 sqlite3VdbeAddOp3(v, op, iTable, iColumn, iReg);
drh945498f2007-02-24 11:52:52 +00001520 sqlite3ColumnDefault(v, pTab, iColumn);
1521#ifndef SQLITE_OMIT_FLOATING_POINT
1522 if( pTab->aCol[iColumn].affinity==SQLITE_AFF_REAL ){
drh2133d822008-01-03 18:44:59 +00001523 sqlite3VdbeAddOp1(v, OP_RealAffinity, iReg);
drh945498f2007-02-24 11:52:52 +00001524 }
1525#endif
1526 }
drhe55cbd72008-03-31 23:48:03 +00001527 if( pParse->disableColCache==0 ){
1528 i = pParse->iColCache;
drhda250ea2008-04-01 05:07:14 +00001529 p = &pParse->aColCache[i];
1530 p->iTable = iTable;
1531 p->iColumn = iColumn;
1532 p->iReg = iReg;
drhc5499be2008-04-01 15:06:33 +00001533 p->affChange = 0;
drhe55cbd72008-03-31 23:48:03 +00001534 i++;
drh2f7794c2008-04-01 03:27:39 +00001535 if( i>=ArraySize(pParse->aColCache) ) i = 0;
drhe55cbd72008-03-31 23:48:03 +00001536 if( i>pParse->nColCache ) pParse->nColCache = i;
drh2f7794c2008-04-01 03:27:39 +00001537 pParse->iColCache = i;
drhe55cbd72008-03-31 23:48:03 +00001538 }
1539 return iReg;
1540}
1541
1542/*
drhe55cbd72008-03-31 23:48:03 +00001543** Clear all column cache entries associated with the vdbe
1544** cursor with cursor number iTable.
1545*/
1546void sqlite3ExprClearColumnCache(Parse *pParse, int iTable){
1547 if( iTable<0 ){
1548 pParse->nColCache = 0;
1549 pParse->iColCache = 0;
1550 }else{
1551 int i;
1552 for(i=0; i<pParse->nColCache; i++){
1553 if( pParse->aColCache[i].iTable==iTable ){
drhc5499be2008-04-01 15:06:33 +00001554 testcase( i==pParse->nColCache-1 );
drhe55cbd72008-03-31 23:48:03 +00001555 pParse->aColCache[i] = pParse->aColCache[--pParse->nColCache];
drhda250ea2008-04-01 05:07:14 +00001556 pParse->iColCache = pParse->nColCache;
drhe55cbd72008-03-31 23:48:03 +00001557 }
1558 }
drhe55cbd72008-03-31 23:48:03 +00001559 }
1560}
1561
1562/*
drhda250ea2008-04-01 05:07:14 +00001563** Record the fact that an affinity change has occurred on iCount
1564** registers starting with iStart.
drhe55cbd72008-03-31 23:48:03 +00001565*/
drhda250ea2008-04-01 05:07:14 +00001566void sqlite3ExprCacheAffinityChange(Parse *pParse, int iStart, int iCount){
1567 int iEnd = iStart + iCount - 1;
drhe55cbd72008-03-31 23:48:03 +00001568 int i;
1569 for(i=0; i<pParse->nColCache; i++){
1570 int r = pParse->aColCache[i].iReg;
drhda250ea2008-04-01 05:07:14 +00001571 if( r>=iStart && r<=iEnd ){
1572 pParse->aColCache[i].affChange = 1;
drhe55cbd72008-03-31 23:48:03 +00001573 }
1574 }
drhe55cbd72008-03-31 23:48:03 +00001575}
1576
1577/*
drhb21e7c72008-06-22 12:37:57 +00001578** Generate code to move content from registers iFrom...iFrom+nReg-1
1579** over to iTo..iTo+nReg-1. Keep the column cache up-to-date.
drhe55cbd72008-03-31 23:48:03 +00001580*/
drhb21e7c72008-06-22 12:37:57 +00001581void sqlite3ExprCodeMove(Parse *pParse, int iFrom, int iTo, int nReg){
drhe55cbd72008-03-31 23:48:03 +00001582 int i;
1583 if( iFrom==iTo ) return;
drhb21e7c72008-06-22 12:37:57 +00001584 sqlite3VdbeAddOp3(pParse->pVdbe, OP_Move, iFrom, iTo, nReg);
drhe55cbd72008-03-31 23:48:03 +00001585 for(i=0; i<pParse->nColCache; i++){
drhb21e7c72008-06-22 12:37:57 +00001586 int x = pParse->aColCache[i].iReg;
1587 if( x>=iFrom && x<iFrom+nReg ){
1588 pParse->aColCache[i].iReg += iTo-iFrom;
drhe55cbd72008-03-31 23:48:03 +00001589 }
1590 }
drh945498f2007-02-24 11:52:52 +00001591}
1592
drhfec19aa2004-05-19 20:41:03 +00001593/*
drh92b01d52008-06-24 00:32:35 +00001594** Generate code to copy content from registers iFrom...iFrom+nReg-1
1595** over to iTo..iTo+nReg-1.
1596*/
1597void sqlite3ExprCodeCopy(Parse *pParse, int iFrom, int iTo, int nReg){
1598 int i;
1599 if( iFrom==iTo ) return;
1600 for(i=0; i<nReg; i++){
1601 sqlite3VdbeAddOp2(pParse->pVdbe, OP_Copy, iFrom+i, iTo+i);
1602 }
1603}
1604
1605/*
drh652fbf52008-04-01 01:42:41 +00001606** Return true if any register in the range iFrom..iTo (inclusive)
1607** is used as part of the column cache.
1608*/
1609static int usedAsColumnCache(Parse *pParse, int iFrom, int iTo){
1610 int i;
1611 for(i=0; i<pParse->nColCache; i++){
1612 int r = pParse->aColCache[i].iReg;
1613 if( r>=iFrom && r<=iTo ) return 1;
1614 }
1615 return 0;
1616}
1617
1618/*
1619** Theres is a value in register iCurrent. We ultimately want
1620** the value to be in register iTarget. It might be that
1621** iCurrent and iTarget are the same register.
1622**
1623** We are going to modify the value, so we need to make sure it
1624** is not a cached register. If iCurrent is a cached register,
1625** then try to move the value over to iTarget. If iTarget is a
1626** cached register, then clear the corresponding cache line.
1627**
1628** Return the register that the value ends up in.
1629*/
1630int sqlite3ExprWritableRegister(Parse *pParse, int iCurrent, int iTarget){
drhda250ea2008-04-01 05:07:14 +00001631 int i;
drh652fbf52008-04-01 01:42:41 +00001632 assert( pParse->pVdbe!=0 );
1633 if( !usedAsColumnCache(pParse, iCurrent, iCurrent) ){
1634 return iCurrent;
1635 }
drh2f7794c2008-04-01 03:27:39 +00001636 if( iCurrent!=iTarget ){
1637 sqlite3VdbeAddOp2(pParse->pVdbe, OP_SCopy, iCurrent, iTarget);
1638 }
drhda250ea2008-04-01 05:07:14 +00001639 for(i=0; i<pParse->nColCache; i++){
1640 if( pParse->aColCache[i].iReg==iTarget ){
1641 pParse->aColCache[i] = pParse->aColCache[--pParse->nColCache];
1642 pParse->iColCache = pParse->nColCache;
1643 }
1644 }
drh652fbf52008-04-01 01:42:41 +00001645 return iTarget;
1646}
1647
1648/*
drh191b54c2008-04-15 12:14:21 +00001649** If the last instruction coded is an ephemeral copy of any of
1650** the registers in the nReg registers beginning with iReg, then
1651** convert the last instruction from OP_SCopy to OP_Copy.
1652*/
1653void sqlite3ExprHardCopy(Parse *pParse, int iReg, int nReg){
1654 int addr;
1655 VdbeOp *pOp;
1656 Vdbe *v;
1657
1658 v = pParse->pVdbe;
1659 addr = sqlite3VdbeCurrentAddr(v);
1660 pOp = sqlite3VdbeGetOp(v, addr-1);
danielk1977d7eb2ed2008-04-24 12:36:35 +00001661 assert( pOp || pParse->db->mallocFailed );
1662 if( pOp && pOp->opcode==OP_SCopy && pOp->p1>=iReg && pOp->p1<iReg+nReg ){
drh191b54c2008-04-15 12:14:21 +00001663 pOp->opcode = OP_Copy;
1664 }
1665}
1666
1667/*
drhcce7d172000-05-31 15:34:51 +00001668** Generate code into the current Vdbe to evaluate the given
drh2dcef112008-01-12 19:03:48 +00001669** expression. Attempt to store the results in register "target".
1670** Return the register where results are stored.
drh389a1ad2008-01-03 23:44:53 +00001671**
drh2dcef112008-01-12 19:03:48 +00001672** With this routine, there is no guaranteed that results will
1673** be stored in target. The result might be stored in some other
1674** register if it is convenient to do so. The calling function
1675** must check the return code and move the results to the desired
1676** register.
drhcce7d172000-05-31 15:34:51 +00001677*/
drh678ccce2008-03-31 18:19:54 +00001678int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){
drh2dcef112008-01-12 19:03:48 +00001679 Vdbe *v = pParse->pVdbe; /* The VM under construction */
1680 int op; /* The opcode being coded */
1681 int inReg = target; /* Results stored in register inReg */
1682 int regFree1 = 0; /* If non-zero free this temporary register */
1683 int regFree2 = 0; /* If non-zero free this temporary register */
drh678ccce2008-03-31 18:19:54 +00001684 int r1, r2, r3, r4; /* Various register numbers */
drhffe07b22005-11-03 00:41:17 +00001685
drh389a1ad2008-01-03 23:44:53 +00001686 assert( v!=0 || pParse->db->mallocFailed );
drh9cbf3422008-01-17 16:22:13 +00001687 assert( target>0 && target<=pParse->nMem );
drh389a1ad2008-01-03 23:44:53 +00001688 if( v==0 ) return 0;
drh389a1ad2008-01-03 23:44:53 +00001689
1690 if( pExpr==0 ){
1691 op = TK_NULL;
1692 }else{
1693 op = pExpr->op;
1694 }
drhf2bc0132004-10-04 13:19:23 +00001695 switch( op ){
drh13449892005-09-07 21:22:45 +00001696 case TK_AGG_COLUMN: {
1697 AggInfo *pAggInfo = pExpr->pAggInfo;
1698 struct AggInfo_col *pCol = &pAggInfo->aCol[pExpr->iAgg];
1699 if( !pAggInfo->directMode ){
drh9de221d2008-01-05 06:51:30 +00001700 assert( pCol->iMem>0 );
1701 inReg = pCol->iMem;
drh13449892005-09-07 21:22:45 +00001702 break;
1703 }else if( pAggInfo->useSortingIdx ){
drh389a1ad2008-01-03 23:44:53 +00001704 sqlite3VdbeAddOp3(v, OP_Column, pAggInfo->sortingIdx,
1705 pCol->iSorterColumn, target);
drh13449892005-09-07 21:22:45 +00001706 break;
1707 }
1708 /* Otherwise, fall thru into the TK_COLUMN case */
1709 }
drh967e8b72000-06-21 13:59:10 +00001710 case TK_COLUMN: {
drhffe07b22005-11-03 00:41:17 +00001711 if( pExpr->iTable<0 ){
1712 /* This only happens when coding check constraints */
drhaa9b8962008-01-08 02:57:55 +00001713 assert( pParse->ckBase>0 );
1714 inReg = pExpr->iColumn + pParse->ckBase;
drhc4a3c772001-04-04 11:48:57 +00001715 }else{
drhc5499be2008-04-01 15:06:33 +00001716 testcase( (pExpr->flags & EP_AnyAff)!=0 );
drhe55cbd72008-03-31 23:48:03 +00001717 inReg = sqlite3ExprCodeGetColumn(pParse, pExpr->pTab,
drhda250ea2008-04-01 05:07:14 +00001718 pExpr->iColumn, pExpr->iTable, target,
1719 pExpr->flags & EP_AnyAff);
drh22827922000-06-06 17:27:05 +00001720 }
drhcce7d172000-05-31 15:34:51 +00001721 break;
1722 }
1723 case TK_INTEGER: {
drh92b01d52008-06-24 00:32:35 +00001724 codeInteger(v, pExpr, 0, target);
drhfec19aa2004-05-19 20:41:03 +00001725 break;
1726 }
drh598f1342007-10-23 15:39:45 +00001727 case TK_FLOAT: {
drh9de221d2008-01-05 06:51:30 +00001728 codeReal(v, (char*)pExpr->token.z, pExpr->token.n, 0, target);
drh598f1342007-10-23 15:39:45 +00001729 break;
1730 }
drhfec19aa2004-05-19 20:41:03 +00001731 case TK_STRING: {
danielk19771e536952007-08-16 10:09:01 +00001732 sqlite3DequoteExpr(pParse->db, pExpr);
drh9de221d2008-01-05 06:51:30 +00001733 sqlite3VdbeAddOp4(v,OP_String8, 0, target, 0,
drh66a51672008-01-03 00:01:23 +00001734 (char*)pExpr->token.z, pExpr->token.n);
drhcce7d172000-05-31 15:34:51 +00001735 break;
1736 }
drhf0863fe2005-06-12 21:35:51 +00001737 case TK_NULL: {
drh9de221d2008-01-05 06:51:30 +00001738 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
drhf0863fe2005-06-12 21:35:51 +00001739 break;
1740 }
danielk19775338a5f2005-01-20 13:03:10 +00001741#ifndef SQLITE_OMIT_BLOB_LITERAL
danielk1977c572ef72004-05-27 09:28:41 +00001742 case TK_BLOB: {
drh6c8c6ce2005-08-23 11:17:58 +00001743 int n;
1744 const char *z;
drhca48c902008-01-18 14:08:24 +00001745 char *zBlob;
1746 assert( pExpr->token.n>=3 );
1747 assert( pExpr->token.z[0]=='x' || pExpr->token.z[0]=='X' );
1748 assert( pExpr->token.z[1]=='\'' );
1749 assert( pExpr->token.z[pExpr->token.n-1]=='\'' );
drh6c8c6ce2005-08-23 11:17:58 +00001750 n = pExpr->token.n - 3;
drh2646da72005-12-09 20:02:05 +00001751 z = (char*)pExpr->token.z + 2;
drhca48c902008-01-18 14:08:24 +00001752 zBlob = sqlite3HexToBlob(sqlite3VdbeDb(v), z, n);
1753 sqlite3VdbeAddOp4(v, OP_Blob, n/2, target, 0, zBlob, P4_DYNAMIC);
danielk1977c572ef72004-05-27 09:28:41 +00001754 break;
1755 }
danielk19775338a5f2005-01-20 13:03:10 +00001756#endif
drh50457892003-09-06 01:10:47 +00001757 case TK_VARIABLE: {
drh9de221d2008-01-05 06:51:30 +00001758 sqlite3VdbeAddOp2(v, OP_Variable, pExpr->iTable, target);
drh895d7472004-08-20 16:02:39 +00001759 if( pExpr->token.n>1 ){
drh66a51672008-01-03 00:01:23 +00001760 sqlite3VdbeChangeP4(v, -1, (char*)pExpr->token.z, pExpr->token.n);
drh895d7472004-08-20 16:02:39 +00001761 }
drh50457892003-09-06 01:10:47 +00001762 break;
1763 }
drh4e0cff62004-11-05 05:10:28 +00001764 case TK_REGISTER: {
drh9de221d2008-01-05 06:51:30 +00001765 inReg = pExpr->iTable;
drh4e0cff62004-11-05 05:10:28 +00001766 break;
1767 }
drh487e2622005-06-25 18:42:14 +00001768#ifndef SQLITE_OMIT_CAST
1769 case TK_CAST: {
1770 /* Expressions of the form: CAST(pLeft AS token) */
danielk1977f0113002006-01-24 12:09:17 +00001771 int aff, to_op;
drh2dcef112008-01-12 19:03:48 +00001772 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
drh8a512562005-11-14 22:29:05 +00001773 aff = sqlite3AffinityType(&pExpr->token);
danielk1977f0113002006-01-24 12:09:17 +00001774 to_op = aff - SQLITE_AFF_TEXT + OP_ToText;
1775 assert( to_op==OP_ToText || aff!=SQLITE_AFF_TEXT );
1776 assert( to_op==OP_ToBlob || aff!=SQLITE_AFF_NONE );
1777 assert( to_op==OP_ToNumeric || aff!=SQLITE_AFF_NUMERIC );
1778 assert( to_op==OP_ToInt || aff!=SQLITE_AFF_INTEGER );
1779 assert( to_op==OP_ToReal || aff!=SQLITE_AFF_REAL );
drhc5499be2008-04-01 15:06:33 +00001780 testcase( to_op==OP_ToText );
1781 testcase( to_op==OP_ToBlob );
1782 testcase( to_op==OP_ToNumeric );
1783 testcase( to_op==OP_ToInt );
1784 testcase( to_op==OP_ToReal );
drh2dcef112008-01-12 19:03:48 +00001785 sqlite3VdbeAddOp1(v, to_op, inReg);
drhc5499be2008-04-01 15:06:33 +00001786 testcase( usedAsColumnCache(pParse, inReg, inReg) );
drhb3843a82008-04-01 12:24:11 +00001787 sqlite3ExprCacheAffinityChange(pParse, inReg, 1);
drh487e2622005-06-25 18:42:14 +00001788 break;
1789 }
1790#endif /* SQLITE_OMIT_CAST */
drhc9b84a12002-06-20 11:36:48 +00001791 case TK_LT:
1792 case TK_LE:
1793 case TK_GT:
1794 case TK_GE:
1795 case TK_NE:
1796 case TK_EQ: {
drhf2bc0132004-10-04 13:19:23 +00001797 assert( TK_LT==OP_Lt );
1798 assert( TK_LE==OP_Le );
1799 assert( TK_GT==OP_Gt );
1800 assert( TK_GE==OP_Ge );
1801 assert( TK_EQ==OP_Eq );
1802 assert( TK_NE==OP_Ne );
drhc5499be2008-04-01 15:06:33 +00001803 testcase( op==TK_LT );
1804 testcase( op==TK_LE );
1805 testcase( op==TK_GT );
1806 testcase( op==TK_GE );
1807 testcase( op==TK_EQ );
1808 testcase( op==TK_NE );
drhda250ea2008-04-01 05:07:14 +00001809 codeCompareOperands(pParse, pExpr->pLeft, &r1, &regFree1,
1810 pExpr->pRight, &r2, &regFree2);
drh35573352008-01-08 23:54:25 +00001811 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
1812 r1, r2, inReg, SQLITE_STOREP2);
drhc5499be2008-04-01 15:06:33 +00001813 testcase( regFree1==0 );
1814 testcase( regFree2==0 );
danielk1977a37cdde2004-05-16 11:15:36 +00001815 break;
drhc9b84a12002-06-20 11:36:48 +00001816 }
drhcce7d172000-05-31 15:34:51 +00001817 case TK_AND:
1818 case TK_OR:
1819 case TK_PLUS:
1820 case TK_STAR:
1821 case TK_MINUS:
drhbf4133c2001-10-13 02:59:08 +00001822 case TK_REM:
1823 case TK_BITAND:
1824 case TK_BITOR:
drh17c40292004-07-21 02:53:29 +00001825 case TK_SLASH:
drhbf4133c2001-10-13 02:59:08 +00001826 case TK_LSHIFT:
drh855eb1c2004-08-31 13:45:11 +00001827 case TK_RSHIFT:
drh00400772000-06-16 20:51:26 +00001828 case TK_CONCAT: {
drhf2bc0132004-10-04 13:19:23 +00001829 assert( TK_AND==OP_And );
1830 assert( TK_OR==OP_Or );
1831 assert( TK_PLUS==OP_Add );
1832 assert( TK_MINUS==OP_Subtract );
1833 assert( TK_REM==OP_Remainder );
1834 assert( TK_BITAND==OP_BitAnd );
1835 assert( TK_BITOR==OP_BitOr );
1836 assert( TK_SLASH==OP_Divide );
1837 assert( TK_LSHIFT==OP_ShiftLeft );
1838 assert( TK_RSHIFT==OP_ShiftRight );
1839 assert( TK_CONCAT==OP_Concat );
drhc5499be2008-04-01 15:06:33 +00001840 testcase( op==TK_AND );
1841 testcase( op==TK_OR );
1842 testcase( op==TK_PLUS );
1843 testcase( op==TK_MINUS );
1844 testcase( op==TK_REM );
1845 testcase( op==TK_BITAND );
1846 testcase( op==TK_BITOR );
1847 testcase( op==TK_SLASH );
1848 testcase( op==TK_LSHIFT );
1849 testcase( op==TK_RSHIFT );
1850 testcase( op==TK_CONCAT );
drh2dcef112008-01-12 19:03:48 +00001851 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
1852 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
drh5b6afba2008-01-05 16:29:28 +00001853 sqlite3VdbeAddOp3(v, op, r2, r1, target);
drhc5499be2008-04-01 15:06:33 +00001854 testcase( regFree1==0 );
1855 testcase( regFree2==0 );
drh00400772000-06-16 20:51:26 +00001856 break;
1857 }
drhcce7d172000-05-31 15:34:51 +00001858 case TK_UMINUS: {
drhfec19aa2004-05-19 20:41:03 +00001859 Expr *pLeft = pExpr->pLeft;
1860 assert( pLeft );
1861 if( pLeft->op==TK_FLOAT || pLeft->op==TK_INTEGER ){
drhfec19aa2004-05-19 20:41:03 +00001862 if( pLeft->op==TK_FLOAT ){
drh92b01d52008-06-24 00:32:35 +00001863 codeReal(v, (char*)pLeft->token.z, pLeft->token.n, 1, target);
drhe6840902002-03-06 03:08:25 +00001864 }else{
drh92b01d52008-06-24 00:32:35 +00001865 codeInteger(v, pLeft, 1, target);
drhe6840902002-03-06 03:08:25 +00001866 }
drh3c84ddf2008-01-09 02:15:38 +00001867 }else{
drh2dcef112008-01-12 19:03:48 +00001868 regFree1 = r1 = sqlite3GetTempReg(pParse);
drh3c84ddf2008-01-09 02:15:38 +00001869 sqlite3VdbeAddOp2(v, OP_Integer, 0, r1);
drhe55cbd72008-03-31 23:48:03 +00001870 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree2);
drh2dcef112008-01-12 19:03:48 +00001871 sqlite3VdbeAddOp3(v, OP_Subtract, r2, r1, target);
drhc5499be2008-04-01 15:06:33 +00001872 testcase( regFree2==0 );
drh6e142f52000-06-08 13:36:40 +00001873 }
drh3c84ddf2008-01-09 02:15:38 +00001874 inReg = target;
1875 break;
drh6e142f52000-06-08 13:36:40 +00001876 }
drhbf4133c2001-10-13 02:59:08 +00001877 case TK_BITNOT:
drh6e142f52000-06-08 13:36:40 +00001878 case TK_NOT: {
drhf2bc0132004-10-04 13:19:23 +00001879 assert( TK_BITNOT==OP_BitNot );
1880 assert( TK_NOT==OP_Not );
drhc5499be2008-04-01 15:06:33 +00001881 testcase( op==TK_BITNOT );
1882 testcase( op==TK_NOT );
drh2dcef112008-01-12 19:03:48 +00001883 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
drhc5499be2008-04-01 15:06:33 +00001884 testcase( inReg==target );
1885 testcase( usedAsColumnCache(pParse, inReg, inReg) );
drh652fbf52008-04-01 01:42:41 +00001886 inReg = sqlite3ExprWritableRegister(pParse, inReg, target);
drh2dcef112008-01-12 19:03:48 +00001887 sqlite3VdbeAddOp1(v, op, inReg);
drhcce7d172000-05-31 15:34:51 +00001888 break;
1889 }
1890 case TK_ISNULL:
1891 case TK_NOTNULL: {
drh6a288a32008-01-07 19:20:24 +00001892 int addr;
drhf2bc0132004-10-04 13:19:23 +00001893 assert( TK_ISNULL==OP_IsNull );
1894 assert( TK_NOTNULL==OP_NotNull );
drhc5499be2008-04-01 15:06:33 +00001895 testcase( op==TK_ISNULL );
1896 testcase( op==TK_NOTNULL );
drh9de221d2008-01-05 06:51:30 +00001897 sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
drh2dcef112008-01-12 19:03:48 +00001898 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
drhc5499be2008-04-01 15:06:33 +00001899 testcase( regFree1==0 );
drh2dcef112008-01-12 19:03:48 +00001900 addr = sqlite3VdbeAddOp1(v, op, r1);
drh9de221d2008-01-05 06:51:30 +00001901 sqlite3VdbeAddOp2(v, OP_AddImm, target, -1);
drh6a288a32008-01-07 19:20:24 +00001902 sqlite3VdbeJumpHere(v, addr);
drhf2bc0132004-10-04 13:19:23 +00001903 break;
drhcce7d172000-05-31 15:34:51 +00001904 }
drh22827922000-06-06 17:27:05 +00001905 case TK_AGG_FUNCTION: {
drh13449892005-09-07 21:22:45 +00001906 AggInfo *pInfo = pExpr->pAggInfo;
drh7e56e712005-11-16 12:53:15 +00001907 if( pInfo==0 ){
1908 sqlite3ErrorMsg(pParse, "misuse of aggregate: %T",
1909 &pExpr->span);
1910 }else{
drh9de221d2008-01-05 06:51:30 +00001911 inReg = pInfo->aFunc[pExpr->iAgg].iMem;
drh7e56e712005-11-16 12:53:15 +00001912 }
drh22827922000-06-06 17:27:05 +00001913 break;
1914 }
drhb71090f2005-05-23 17:26:51 +00001915 case TK_CONST_FUNC:
drhcce7d172000-05-31 15:34:51 +00001916 case TK_FUNCTION: {
drhcce7d172000-05-31 15:34:51 +00001917 ExprList *pList = pExpr->pList;
drh89425d52002-02-28 03:04:48 +00001918 int nExpr = pList ? pList->nExpr : 0;
drh0bce8352002-02-28 00:41:10 +00001919 FuncDef *pDef;
drh4b59ab52002-08-24 18:24:51 +00001920 int nId;
1921 const char *zId;
drh13449892005-09-07 21:22:45 +00001922 int constMask = 0;
danielk1977682f68b2004-06-05 10:22:17 +00001923 int i;
drh17435752007-08-16 04:30:38 +00001924 sqlite3 *db = pParse->db;
1925 u8 enc = ENC(db);
danielk1977dc1bdc42004-06-11 10:51:27 +00001926 CollSeq *pColl = 0;
drh17435752007-08-16 04:30:38 +00001927
drhc5499be2008-04-01 15:06:33 +00001928 testcase( op==TK_CONST_FUNC );
1929 testcase( op==TK_FUNCTION );
drh2646da72005-12-09 20:02:05 +00001930 zId = (char*)pExpr->token.z;
drhb71090f2005-05-23 17:26:51 +00001931 nId = pExpr->token.n;
danielk1977d8123362004-06-12 09:25:12 +00001932 pDef = sqlite3FindFunction(pParse->db, zId, nId, nExpr, enc, 0);
drh0bce8352002-02-28 00:41:10 +00001933 assert( pDef!=0 );
drh892d3172008-01-10 03:46:36 +00001934 if( pList ){
1935 nExpr = pList->nExpr;
drh2dcef112008-01-12 19:03:48 +00001936 r1 = sqlite3GetTempRange(pParse, nExpr);
drh191b54c2008-04-15 12:14:21 +00001937 sqlite3ExprCodeExprList(pParse, pList, r1, 1);
drh892d3172008-01-10 03:46:36 +00001938 }else{
drhd847eaa2008-01-17 17:15:56 +00001939 nExpr = r1 = 0;
drh892d3172008-01-10 03:46:36 +00001940 }
drhb7f6f682006-07-08 17:06:43 +00001941#ifndef SQLITE_OMIT_VIRTUALTABLE
drha43fa222006-07-08 18:41:37 +00001942 /* Possibly overload the function if the first argument is
1943 ** a virtual table column.
1944 **
1945 ** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the
1946 ** second argument, not the first, as the argument to test to
1947 ** see if it is a column in a virtual table. This is done because
1948 ** the left operand of infix functions (the operand we want to
1949 ** control overloading) ends up as the second argument to the
1950 ** function. The expression "A glob B" is equivalent to
1951 ** "glob(B,A). We want to use the A in "A glob B" to test
1952 ** for function overloading. But we use the B term in "glob(B,A)".
1953 */
drh6a03a1c2006-07-08 18:34:59 +00001954 if( nExpr>=2 && (pExpr->flags & EP_InfixFunc) ){
drh17435752007-08-16 04:30:38 +00001955 pDef = sqlite3VtabOverloadFunction(db, pDef, nExpr, pList->a[1].pExpr);
drh6a03a1c2006-07-08 18:34:59 +00001956 }else if( nExpr>0 ){
drh17435752007-08-16 04:30:38 +00001957 pDef = sqlite3VtabOverloadFunction(db, pDef, nExpr, pList->a[0].pExpr);
drhb7f6f682006-07-08 17:06:43 +00001958 }
1959#endif
danielk1977682f68b2004-06-05 10:22:17 +00001960 for(i=0; i<nExpr && i<32; i++){
danielk1977d02eb1f2004-06-06 09:44:03 +00001961 if( sqlite3ExprIsConstant(pList->a[i].pExpr) ){
drh13449892005-09-07 21:22:45 +00001962 constMask |= (1<<i);
danielk1977d02eb1f2004-06-06 09:44:03 +00001963 }
danielk1977dc1bdc42004-06-11 10:51:27 +00001964 if( pDef->needCollSeq && !pColl ){
1965 pColl = sqlite3ExprCollSeq(pParse, pList->a[i].pExpr);
1966 }
1967 }
1968 if( pDef->needCollSeq ){
1969 if( !pColl ) pColl = pParse->db->pDfltColl;
drh66a51672008-01-03 00:01:23 +00001970 sqlite3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ);
danielk1977682f68b2004-06-05 10:22:17 +00001971 }
drh2dcef112008-01-12 19:03:48 +00001972 sqlite3VdbeAddOp4(v, OP_Function, constMask, r1, target,
drh66a51672008-01-03 00:01:23 +00001973 (char*)pDef, P4_FUNCDEF);
drh98757152008-01-09 23:04:12 +00001974 sqlite3VdbeChangeP5(v, nExpr);
drh2dcef112008-01-12 19:03:48 +00001975 if( nExpr ){
1976 sqlite3ReleaseTempRange(pParse, r1, nExpr);
1977 }
drhda250ea2008-04-01 05:07:14 +00001978 sqlite3ExprCacheAffinityChange(pParse, r1, nExpr);
drhcce7d172000-05-31 15:34:51 +00001979 break;
1980 }
drhfe2093d2005-01-20 22:48:47 +00001981#ifndef SQLITE_OMIT_SUBQUERY
1982 case TK_EXISTS:
drh19a775c2000-06-05 18:54:46 +00001983 case TK_SELECT: {
drhc5499be2008-04-01 15:06:33 +00001984 testcase( op==TK_EXISTS );
1985 testcase( op==TK_SELECT );
drh41714d62006-03-02 04:44:23 +00001986 if( pExpr->iColumn==0 ){
danielk19770cdc0222008-06-26 18:04:03 +00001987 sqlite3CodeSubselect(pParse, pExpr, 0);
drh41714d62006-03-02 04:44:23 +00001988 }
drh9de221d2008-01-05 06:51:30 +00001989 inReg = pExpr->iColumn;
drh19a775c2000-06-05 18:54:46 +00001990 break;
1991 }
drhfef52082000-06-06 01:50:43 +00001992 case TK_IN: {
danielk19770cdc0222008-06-26 18:04:03 +00001993 int rNotFound = 0;
1994 int rMayHaveNull = 0;
drh6fccc352008-06-27 00:52:45 +00001995 int j2, j3, j4, j5;
drh94a11212004-09-25 13:12:14 +00001996 char affinity;
danielk19779a96b662007-11-29 17:05:18 +00001997 int eType;
danielk19779a96b662007-11-29 17:05:18 +00001998
drh3c31fc22008-06-26 21:45:26 +00001999 VdbeNoopComment((v, "begin IN expr r%d", target));
danielk19770cdc0222008-06-26 18:04:03 +00002000 eType = sqlite3FindInIndex(pParse, pExpr, &rMayHaveNull);
2001 if( rMayHaveNull ){
2002 rNotFound = ++pParse->nMem;
2003 }
danielk1977e014a832004-05-17 10:48:57 +00002004
2005 /* Figure out the affinity to use to create a key from the results
2006 ** of the expression. affinityStr stores a static string suitable for
drh66a51672008-01-03 00:01:23 +00002007 ** P4 of OP_MakeRecord.
danielk1977e014a832004-05-17 10:48:57 +00002008 */
drh94a11212004-09-25 13:12:14 +00002009 affinity = comparisonAffinity(pExpr);
danielk1977e014a832004-05-17 10:48:57 +00002010
danielk1977e014a832004-05-17 10:48:57 +00002011
2012 /* Code the <expr> from "<expr> IN (...)". The temporary table
2013 ** pExpr->iTable contains the values that make up the (...) set.
2014 */
drh66ba23c2008-06-27 00:47:28 +00002015 pParse->disableColCache++;
2016 sqlite3ExprCode(pParse, pExpr->pLeft, target);
2017 pParse->disableColCache--;
2018 j2 = sqlite3VdbeAddOp1(v, OP_IsNull, target);
danielk19779a96b662007-11-29 17:05:18 +00002019 if( eType==IN_INDEX_ROWID ){
drh66ba23c2008-06-27 00:47:28 +00002020 j3 = sqlite3VdbeAddOp1(v, OP_MustBeInt, target);
2021 j4 = sqlite3VdbeAddOp3(v, OP_NotExists, pExpr->iTable, 0, target);
2022 sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
drh6a288a32008-01-07 19:20:24 +00002023 j5 = sqlite3VdbeAddOp0(v, OP_Goto);
2024 sqlite3VdbeJumpHere(v, j3);
2025 sqlite3VdbeJumpHere(v, j4);
danielk19770cdc0222008-06-26 18:04:03 +00002026 sqlite3VdbeAddOp2(v, OP_Integer, 0, target);
danielk19779a96b662007-11-29 17:05:18 +00002027 }else{
drh2dcef112008-01-12 19:03:48 +00002028 r2 = regFree2 = sqlite3GetTempReg(pParse);
danielk19770cdc0222008-06-26 18:04:03 +00002029
2030 /* Create a record and test for set membership. If the set contains
2031 ** the value, then jump to the end of the test code. The target
2032 ** register still contains the true (1) value written to it earlier.
2033 */
drh66ba23c2008-06-27 00:47:28 +00002034 sqlite3VdbeAddOp4(v, OP_MakeRecord, target, 1, r2, &affinity, 1);
2035 sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
drh2dcef112008-01-12 19:03:48 +00002036 j5 = sqlite3VdbeAddOp3(v, OP_Found, pExpr->iTable, 0, r2);
danielk19770cdc0222008-06-26 18:04:03 +00002037
2038 /* If the set membership test fails, then the result of the
2039 ** "x IN (...)" expression must be either 0 or NULL. If the set
2040 ** contains no NULL values, then the result is 0. If the set
2041 ** contains one or more NULL values, then the result of the
2042 ** expression is also NULL.
2043 */
2044 if( rNotFound==0 ){
2045 /* This branch runs if it is known at compile time (now) that
2046 ** the set contains no NULL values. This happens as the result
2047 ** of a "NOT NULL" constraint in the database schema. No need
2048 ** to test the data structure at runtime in this case.
2049 */
2050 sqlite3VdbeAddOp2(v, OP_Integer, 0, target);
2051 }else{
2052 /* This block populates the rNotFound register with either NULL
2053 ** or 0 (an integer value). If the data structure contains one
2054 ** or more NULLs, then set rNotFound to NULL. Otherwise, set it
2055 ** to 0. If register rMayHaveNull is already set to some value
2056 ** other than NULL, then the test has already been run and
2057 ** rNotFound is already populated.
2058 */
drh66ba23c2008-06-27 00:47:28 +00002059 static const char nullRecord[] = { 0x02, 0x00 };
danielk19770cdc0222008-06-26 18:04:03 +00002060 j3 = sqlite3VdbeAddOp1(v, OP_NotNull, rMayHaveNull);
2061 sqlite3VdbeAddOp2(v, OP_Null, 0, rNotFound);
drh66ba23c2008-06-27 00:47:28 +00002062 sqlite3VdbeAddOp4(v, OP_Blob, 2, rMayHaveNull, 0,
2063 nullRecord, P4_STATIC);
2064 j4 = sqlite3VdbeAddOp3(v, OP_Found, pExpr->iTable, 0, rMayHaveNull);
danielk19770cdc0222008-06-26 18:04:03 +00002065 sqlite3VdbeAddOp2(v, OP_Integer, 0, rNotFound);
2066 sqlite3VdbeJumpHere(v, j4);
2067 sqlite3VdbeJumpHere(v, j3);
2068
2069 /* Copy the value of register rNotFound (which is either NULL or 0)
2070 ** into the target register. This will be the result of the
2071 ** expression.
2072 */
2073 sqlite3VdbeAddOp2(v, OP_Copy, rNotFound, target);
2074 }
danielk19779a96b662007-11-29 17:05:18 +00002075 }
drh6a288a32008-01-07 19:20:24 +00002076 sqlite3VdbeJumpHere(v, j2);
2077 sqlite3VdbeJumpHere(v, j5);
drh3c31fc22008-06-26 21:45:26 +00002078 VdbeComment((v, "end IN expr r%d", target));
drhfef52082000-06-06 01:50:43 +00002079 break;
2080 }
danielk197793758c82005-01-21 08:13:14 +00002081#endif
drh2dcef112008-01-12 19:03:48 +00002082 /*
2083 ** x BETWEEN y AND z
2084 **
2085 ** This is equivalent to
2086 **
2087 ** x>=y AND x<=z
2088 **
2089 ** X is stored in pExpr->pLeft.
2090 ** Y is stored in pExpr->pList->a[0].pExpr.
2091 ** Z is stored in pExpr->pList->a[1].pExpr.
2092 */
drhfef52082000-06-06 01:50:43 +00002093 case TK_BETWEEN: {
drhbe5c89a2004-07-26 00:31:09 +00002094 Expr *pLeft = pExpr->pLeft;
2095 struct ExprList_item *pLItem = pExpr->pList->a;
2096 Expr *pRight = pLItem->pExpr;
drh35573352008-01-08 23:54:25 +00002097
drhda250ea2008-04-01 05:07:14 +00002098 codeCompareOperands(pParse, pLeft, &r1, &regFree1,
2099 pRight, &r2, &regFree2);
drhc5499be2008-04-01 15:06:33 +00002100 testcase( regFree1==0 );
2101 testcase( regFree2==0 );
drh2dcef112008-01-12 19:03:48 +00002102 r3 = sqlite3GetTempReg(pParse);
drh678ccce2008-03-31 18:19:54 +00002103 r4 = sqlite3GetTempReg(pParse);
drh35573352008-01-08 23:54:25 +00002104 codeCompare(pParse, pLeft, pRight, OP_Ge,
2105 r1, r2, r3, SQLITE_STOREP2);
drhbe5c89a2004-07-26 00:31:09 +00002106 pLItem++;
2107 pRight = pLItem->pExpr;
drh2dcef112008-01-12 19:03:48 +00002108 sqlite3ReleaseTempReg(pParse, regFree2);
2109 r2 = sqlite3ExprCodeTemp(pParse, pRight, &regFree2);
drhc5499be2008-04-01 15:06:33 +00002110 testcase( regFree2==0 );
drh678ccce2008-03-31 18:19:54 +00002111 codeCompare(pParse, pLeft, pRight, OP_Le, r1, r2, r4, SQLITE_STOREP2);
2112 sqlite3VdbeAddOp3(v, OP_And, r3, r4, target);
drh2dcef112008-01-12 19:03:48 +00002113 sqlite3ReleaseTempReg(pParse, r3);
drh678ccce2008-03-31 18:19:54 +00002114 sqlite3ReleaseTempReg(pParse, r4);
drhfef52082000-06-06 01:50:43 +00002115 break;
2116 }
drh4f07e5f2007-05-14 11:34:46 +00002117 case TK_UPLUS: {
drh2dcef112008-01-12 19:03:48 +00002118 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
drha2e00042002-01-22 03:13:42 +00002119 break;
2120 }
drh2dcef112008-01-12 19:03:48 +00002121
2122 /*
2123 ** Form A:
2124 ** CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
2125 **
2126 ** Form B:
2127 ** CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
2128 **
2129 ** Form A is can be transformed into the equivalent form B as follows:
2130 ** CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ...
2131 ** WHEN x=eN THEN rN ELSE y END
2132 **
2133 ** X (if it exists) is in pExpr->pLeft.
2134 ** Y is in pExpr->pRight. The Y is also optional. If there is no
2135 ** ELSE clause and no other term matches, then the result of the
2136 ** exprssion is NULL.
2137 ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1].
2138 **
2139 ** The result of the expression is the Ri for the first matching Ei,
2140 ** or if there is no matching Ei, the ELSE term Y, or if there is
2141 ** no ELSE term, NULL.
2142 */
drh17a7f8d2002-03-24 13:13:27 +00002143 case TK_CASE: {
drh2dcef112008-01-12 19:03:48 +00002144 int endLabel; /* GOTO label for end of CASE stmt */
2145 int nextCase; /* GOTO label for next WHEN clause */
2146 int nExpr; /* 2x number of WHEN terms */
2147 int i; /* Loop counter */
2148 ExprList *pEList; /* List of WHEN terms */
2149 struct ExprList_item *aListelem; /* Array of WHEN terms */
2150 Expr opCompare; /* The X==Ei expression */
2151 Expr cacheX; /* Cached expression X */
2152 Expr *pX; /* The X expression */
2153 Expr *pTest; /* X==Ei (form A) or just Ei (form B) */
drh17a7f8d2002-03-24 13:13:27 +00002154
2155 assert(pExpr->pList);
2156 assert((pExpr->pList->nExpr % 2) == 0);
2157 assert(pExpr->pList->nExpr > 0);
drhbe5c89a2004-07-26 00:31:09 +00002158 pEList = pExpr->pList;
2159 aListelem = pEList->a;
2160 nExpr = pEList->nExpr;
drh2dcef112008-01-12 19:03:48 +00002161 endLabel = sqlite3VdbeMakeLabel(v);
2162 if( (pX = pExpr->pLeft)!=0 ){
2163 cacheX = *pX;
drhc5499be2008-04-01 15:06:33 +00002164 testcase( pX->op==TK_COLUMN || pX->op==TK_REGISTER );
drh2dcef112008-01-12 19:03:48 +00002165 cacheX.iTable = sqlite3ExprCodeTemp(pParse, pX, &regFree1);
drhc5499be2008-04-01 15:06:33 +00002166 testcase( regFree1==0 );
drh2dcef112008-01-12 19:03:48 +00002167 cacheX.op = TK_REGISTER;
2168 opCompare.op = TK_EQ;
2169 opCompare.pLeft = &cacheX;
2170 pTest = &opCompare;
drh17a7f8d2002-03-24 13:13:27 +00002171 }
drhc5499be2008-04-01 15:06:33 +00002172 pParse->disableColCache++;
drhf5905aa2002-05-26 20:54:33 +00002173 for(i=0; i<nExpr; i=i+2){
drh2dcef112008-01-12 19:03:48 +00002174 if( pX ){
2175 opCompare.pRight = aListelem[i].pExpr;
drh17a7f8d2002-03-24 13:13:27 +00002176 }else{
drh2dcef112008-01-12 19:03:48 +00002177 pTest = aListelem[i].pExpr;
drh17a7f8d2002-03-24 13:13:27 +00002178 }
drh2dcef112008-01-12 19:03:48 +00002179 nextCase = sqlite3VdbeMakeLabel(v);
drhc5499be2008-04-01 15:06:33 +00002180 testcase( pTest->op==TK_COLUMN || pTest->op==TK_REGISTER );
drh2dcef112008-01-12 19:03:48 +00002181 sqlite3ExprIfFalse(pParse, pTest, nextCase, SQLITE_JUMPIFNULL);
drhc5499be2008-04-01 15:06:33 +00002182 testcase( aListelem[i+1].pExpr->op==TK_COLUMN );
2183 testcase( aListelem[i+1].pExpr->op==TK_REGISTER );
drh9de221d2008-01-05 06:51:30 +00002184 sqlite3ExprCode(pParse, aListelem[i+1].pExpr, target);
drh2dcef112008-01-12 19:03:48 +00002185 sqlite3VdbeAddOp2(v, OP_Goto, 0, endLabel);
2186 sqlite3VdbeResolveLabel(v, nextCase);
drhf570f012002-05-31 15:51:25 +00002187 }
drh17a7f8d2002-03-24 13:13:27 +00002188 if( pExpr->pRight ){
drh9de221d2008-01-05 06:51:30 +00002189 sqlite3ExprCode(pParse, pExpr->pRight, target);
drh17a7f8d2002-03-24 13:13:27 +00002190 }else{
drh9de221d2008-01-05 06:51:30 +00002191 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
drh17a7f8d2002-03-24 13:13:27 +00002192 }
drh2dcef112008-01-12 19:03:48 +00002193 sqlite3VdbeResolveLabel(v, endLabel);
drhc5499be2008-04-01 15:06:33 +00002194 assert( pParse->disableColCache>0 );
2195 pParse->disableColCache--;
danielk19776f349032002-06-11 02:25:40 +00002196 break;
2197 }
danielk19775338a5f2005-01-20 13:03:10 +00002198#ifndef SQLITE_OMIT_TRIGGER
danielk19776f349032002-06-11 02:25:40 +00002199 case TK_RAISE: {
2200 if( !pParse->trigStack ){
danielk19774adee202004-05-08 08:23:19 +00002201 sqlite3ErrorMsg(pParse,
drhda93d232003-03-31 02:12:46 +00002202 "RAISE() may only be used within a trigger-program");
drh389a1ad2008-01-03 23:44:53 +00002203 return 0;
danielk19776f349032002-06-11 02:25:40 +00002204 }
drhad6d9462004-09-19 02:15:24 +00002205 if( pExpr->iColumn!=OE_Ignore ){
2206 assert( pExpr->iColumn==OE_Rollback ||
2207 pExpr->iColumn == OE_Abort ||
2208 pExpr->iColumn == OE_Fail );
danielk19771e536952007-08-16 10:09:01 +00002209 sqlite3DequoteExpr(pParse->db, pExpr);
drh66a51672008-01-03 00:01:23 +00002210 sqlite3VdbeAddOp4(v, OP_Halt, SQLITE_CONSTRAINT, pExpr->iColumn, 0,
drh2646da72005-12-09 20:02:05 +00002211 (char*)pExpr->token.z, pExpr->token.n);
danielk19776f349032002-06-11 02:25:40 +00002212 } else {
drhad6d9462004-09-19 02:15:24 +00002213 assert( pExpr->iColumn == OE_Ignore );
drh66a51672008-01-03 00:01:23 +00002214 sqlite3VdbeAddOp2(v, OP_ContextPop, 0, 0);
2215 sqlite3VdbeAddOp2(v, OP_Goto, 0, pParse->trigStack->ignoreJump);
drhd4e70eb2008-01-02 00:34:36 +00002216 VdbeComment((v, "raise(IGNORE)"));
danielk19776f349032002-06-11 02:25:40 +00002217 }
drhffe07b22005-11-03 00:41:17 +00002218 break;
drh17a7f8d2002-03-24 13:13:27 +00002219 }
danielk19775338a5f2005-01-20 13:03:10 +00002220#endif
drhffe07b22005-11-03 00:41:17 +00002221 }
drh2dcef112008-01-12 19:03:48 +00002222 sqlite3ReleaseTempReg(pParse, regFree1);
2223 sqlite3ReleaseTempReg(pParse, regFree2);
2224 return inReg;
2225}
2226
2227/*
2228** Generate code to evaluate an expression and store the results
2229** into a register. Return the register number where the results
2230** are stored.
2231**
2232** If the register is a temporary register that can be deallocated,
drh678ccce2008-03-31 18:19:54 +00002233** then write its number into *pReg. If the result register is not
drh2dcef112008-01-12 19:03:48 +00002234** a temporary, then set *pReg to zero.
2235*/
2236int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){
2237 int r1 = sqlite3GetTempReg(pParse);
2238 int r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
2239 if( r2==r1 ){
2240 *pReg = r1;
2241 }else{
2242 sqlite3ReleaseTempReg(pParse, r1);
2243 *pReg = 0;
2244 }
2245 return r2;
2246}
2247
2248/*
2249** Generate code that will evaluate expression pExpr and store the
2250** results in register target. The results are guaranteed to appear
2251** in register target.
2252*/
2253int sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){
drh9cbf3422008-01-17 16:22:13 +00002254 int inReg;
2255
2256 assert( target>0 && target<=pParse->nMem );
2257 inReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
drh0e359b32008-01-13 19:02:11 +00002258 assert( pParse->pVdbe || pParse->db->mallocFailed );
2259 if( inReg!=target && pParse->pVdbe ){
drh9cbf3422008-01-17 16:22:13 +00002260 sqlite3VdbeAddOp2(pParse->pVdbe, OP_SCopy, inReg, target);
drhcce7d172000-05-31 15:34:51 +00002261 }
drh389a1ad2008-01-03 23:44:53 +00002262 return target;
drhcce7d172000-05-31 15:34:51 +00002263}
2264
2265/*
drh2dcef112008-01-12 19:03:48 +00002266** Generate code that evalutes the given expression and puts the result
drhde4fcfd2008-01-19 23:50:26 +00002267** in register target.
drh25303782004-12-07 15:41:48 +00002268**
drh2dcef112008-01-12 19:03:48 +00002269** Also make a copy of the expression results into another "cache" register
2270** and modify the expression so that the next time it is evaluated,
2271** the result is a copy of the cache register.
2272**
2273** This routine is used for expressions that are used multiple
2274** times. They are evaluated once and the results of the expression
2275** are reused.
drh25303782004-12-07 15:41:48 +00002276*/
drh2dcef112008-01-12 19:03:48 +00002277int sqlite3ExprCodeAndCache(Parse *pParse, Expr *pExpr, int target){
drh25303782004-12-07 15:41:48 +00002278 Vdbe *v = pParse->pVdbe;
drh2dcef112008-01-12 19:03:48 +00002279 int inReg;
2280 inReg = sqlite3ExprCode(pParse, pExpr, target);
drhde4fcfd2008-01-19 23:50:26 +00002281 assert( target>0 );
drh2dcef112008-01-12 19:03:48 +00002282 if( pExpr->op!=TK_REGISTER ){
2283 int iMem;
drhde4fcfd2008-01-19 23:50:26 +00002284 iMem = ++pParse->nMem;
2285 sqlite3VdbeAddOp2(v, OP_Copy, inReg, iMem);
drh2dcef112008-01-12 19:03:48 +00002286 pExpr->iTable = iMem;
drh25303782004-12-07 15:41:48 +00002287 pExpr->op = TK_REGISTER;
2288 }
drh2dcef112008-01-12 19:03:48 +00002289 return inReg;
drh25303782004-12-07 15:41:48 +00002290}
drh2dcef112008-01-12 19:03:48 +00002291
drh678ccce2008-03-31 18:19:54 +00002292/*
drh47de9552008-04-01 18:04:11 +00002293** Return TRUE if pExpr is an constant expression that is appropriate
2294** for factoring out of a loop. Appropriate expressions are:
2295**
2296** * Any expression that evaluates to two or more opcodes.
2297**
2298** * Any OP_Integer, OP_Real, OP_String, OP_Blob, OP_Null,
2299** or OP_Variable that does not need to be placed in a
2300** specific register.
2301**
2302** There is no point in factoring out single-instruction constant
2303** expressions that need to be placed in a particular register.
2304** We could factor them out, but then we would end up adding an
2305** OP_SCopy instruction to move the value into the correct register
2306** later. We might as well just use the original instruction and
2307** avoid the OP_SCopy.
2308*/
2309static int isAppropriateForFactoring(Expr *p){
2310 if( !sqlite3ExprIsConstantNotJoin(p) ){
2311 return 0; /* Only constant expressions are appropriate for factoring */
2312 }
2313 if( (p->flags & EP_FixedDest)==0 ){
2314 return 1; /* Any constant without a fixed destination is appropriate */
2315 }
2316 while( p->op==TK_UPLUS ) p = p->pLeft;
2317 switch( p->op ){
2318#ifndef SQLITE_OMIT_BLOB_LITERAL
2319 case TK_BLOB:
2320#endif
2321 case TK_VARIABLE:
2322 case TK_INTEGER:
2323 case TK_FLOAT:
2324 case TK_NULL:
2325 case TK_STRING: {
2326 testcase( p->op==TK_BLOB );
2327 testcase( p->op==TK_VARIABLE );
2328 testcase( p->op==TK_INTEGER );
2329 testcase( p->op==TK_FLOAT );
2330 testcase( p->op==TK_NULL );
2331 testcase( p->op==TK_STRING );
2332 /* Single-instruction constants with a fixed destination are
2333 ** better done in-line. If we factor them, they will just end
2334 ** up generating an OP_SCopy to move the value to the destination
2335 ** register. */
2336 return 0;
2337 }
2338 case TK_UMINUS: {
2339 if( p->pLeft->op==TK_FLOAT || p->pLeft->op==TK_INTEGER ){
2340 return 0;
2341 }
2342 break;
2343 }
2344 default: {
2345 break;
2346 }
2347 }
2348 return 1;
2349}
2350
2351/*
2352** If pExpr is a constant expression that is appropriate for
2353** factoring out of a loop, then evaluate the expression
drh678ccce2008-03-31 18:19:54 +00002354** into a register and convert the expression into a TK_REGISTER
2355** expression.
2356*/
drh7d10d5a2008-08-20 16:35:10 +00002357static int evalConstExpr(Walker *pWalker, Expr *pExpr){
2358 Parse *pParse = pWalker->pParse;
drh47de9552008-04-01 18:04:11 +00002359 switch( pExpr->op ){
2360 case TK_REGISTER: {
2361 return 1;
2362 }
2363 case TK_FUNCTION:
2364 case TK_AGG_FUNCTION:
2365 case TK_CONST_FUNC: {
2366 /* The arguments to a function have a fixed destination.
2367 ** Mark them this way to avoid generated unneeded OP_SCopy
2368 ** instructions.
2369 */
2370 ExprList *pList = pExpr->pList;
2371 if( pList ){
2372 int i = pList->nExpr;
2373 struct ExprList_item *pItem = pList->a;
2374 for(; i>0; i--, pItem++){
2375 if( pItem->pExpr ) pItem->pExpr->flags |= EP_FixedDest;
2376 }
2377 }
2378 break;
2379 }
drh678ccce2008-03-31 18:19:54 +00002380 }
drh47de9552008-04-01 18:04:11 +00002381 if( isAppropriateForFactoring(pExpr) ){
drh678ccce2008-03-31 18:19:54 +00002382 int r1 = ++pParse->nMem;
2383 int r2;
2384 r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
drhc5499be2008-04-01 15:06:33 +00002385 if( r1!=r2 ) sqlite3ReleaseTempReg(pParse, r1);
drh678ccce2008-03-31 18:19:54 +00002386 pExpr->op = TK_REGISTER;
2387 pExpr->iTable = r2;
drh7d10d5a2008-08-20 16:35:10 +00002388 return WRC_Prune;
drh678ccce2008-03-31 18:19:54 +00002389 }
drh7d10d5a2008-08-20 16:35:10 +00002390 return WRC_Continue;
drh678ccce2008-03-31 18:19:54 +00002391}
2392
2393/*
2394** Preevaluate constant subexpressions within pExpr and store the
2395** results in registers. Modify pExpr so that the constant subexpresions
2396** are TK_REGISTER opcodes that refer to the precomputed values.
2397*/
2398void sqlite3ExprCodeConstants(Parse *pParse, Expr *pExpr){
drh7d10d5a2008-08-20 16:35:10 +00002399 Walker w;
2400 w.xExprCallback = evalConstExpr;
2401 w.xSelectCallback = 0;
2402 w.pParse = pParse;
2403 sqlite3WalkExpr(&w, pExpr);
drh678ccce2008-03-31 18:19:54 +00002404}
2405
drh25303782004-12-07 15:41:48 +00002406
2407/*
drh268380c2004-02-25 13:47:31 +00002408** Generate code that pushes the value of every element of the given
drh9cbf3422008-01-17 16:22:13 +00002409** expression list into a sequence of registers beginning at target.
drh268380c2004-02-25 13:47:31 +00002410**
drh892d3172008-01-10 03:46:36 +00002411** Return the number of elements evaluated.
drh268380c2004-02-25 13:47:31 +00002412*/
danielk19774adee202004-05-08 08:23:19 +00002413int sqlite3ExprCodeExprList(
drh268380c2004-02-25 13:47:31 +00002414 Parse *pParse, /* Parsing context */
drh389a1ad2008-01-03 23:44:53 +00002415 ExprList *pList, /* The expression list to be coded */
drh191b54c2008-04-15 12:14:21 +00002416 int target, /* Where to write results */
2417 int doHardCopy /* Call sqlite3ExprHardCopy on each element if true */
drh268380c2004-02-25 13:47:31 +00002418){
2419 struct ExprList_item *pItem;
drh9cbf3422008-01-17 16:22:13 +00002420 int i, n;
drh9d8b3072008-08-22 16:29:51 +00002421 assert( pList!=0 );
drh9cbf3422008-01-17 16:22:13 +00002422 assert( target>0 );
drh268380c2004-02-25 13:47:31 +00002423 n = pList->nExpr;
drh191b54c2008-04-15 12:14:21 +00002424 for(pItem=pList->a, i=0; i<n; i++, pItem++){
2425 sqlite3ExprCode(pParse, pItem->pExpr, target+i);
2426 if( doHardCopy ) sqlite3ExprHardCopy(pParse, target, n);
drh268380c2004-02-25 13:47:31 +00002427 }
drhf9b596e2004-05-26 16:54:42 +00002428 return n;
drh268380c2004-02-25 13:47:31 +00002429}
2430
2431/*
drhcce7d172000-05-31 15:34:51 +00002432** Generate code for a boolean expression such that a jump is made
2433** to the label "dest" if the expression is true but execution
2434** continues straight thru if the expression is false.
drhf5905aa2002-05-26 20:54:33 +00002435**
2436** If the expression evaluates to NULL (neither true nor false), then
drh35573352008-01-08 23:54:25 +00002437** take the jump if the jumpIfNull flag is SQLITE_JUMPIFNULL.
drhf2bc0132004-10-04 13:19:23 +00002438**
2439** This code depends on the fact that certain token values (ex: TK_EQ)
2440** are the same as opcode values (ex: OP_Eq) that implement the corresponding
2441** operation. Special comments in vdbe.c and the mkopcodeh.awk script in
2442** the make process cause these values to align. Assert()s in the code
2443** below verify that the numbers are aligned correctly.
drhcce7d172000-05-31 15:34:51 +00002444*/
danielk19774adee202004-05-08 08:23:19 +00002445void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
drhcce7d172000-05-31 15:34:51 +00002446 Vdbe *v = pParse->pVdbe;
2447 int op = 0;
drh2dcef112008-01-12 19:03:48 +00002448 int regFree1 = 0;
2449 int regFree2 = 0;
2450 int r1, r2;
2451
drh35573352008-01-08 23:54:25 +00002452 assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 );
drhdaffd0e2001-04-11 14:28:42 +00002453 if( v==0 || pExpr==0 ) return;
drhf2bc0132004-10-04 13:19:23 +00002454 op = pExpr->op;
2455 switch( op ){
drhcce7d172000-05-31 15:34:51 +00002456 case TK_AND: {
danielk19774adee202004-05-08 08:23:19 +00002457 int d2 = sqlite3VdbeMakeLabel(v);
drhc5499be2008-04-01 15:06:33 +00002458 testcase( jumpIfNull==0 );
2459 testcase( pParse->disableColCache==0 );
drh35573352008-01-08 23:54:25 +00002460 sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2,jumpIfNull^SQLITE_JUMPIFNULL);
drhe55cbd72008-03-31 23:48:03 +00002461 pParse->disableColCache++;
danielk19774adee202004-05-08 08:23:19 +00002462 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
drhc5499be2008-04-01 15:06:33 +00002463 assert( pParse->disableColCache>0 );
drhe55cbd72008-03-31 23:48:03 +00002464 pParse->disableColCache--;
danielk19774adee202004-05-08 08:23:19 +00002465 sqlite3VdbeResolveLabel(v, d2);
drhcce7d172000-05-31 15:34:51 +00002466 break;
2467 }
2468 case TK_OR: {
drhc5499be2008-04-01 15:06:33 +00002469 testcase( jumpIfNull==0 );
2470 testcase( pParse->disableColCache==0 );
danielk19774adee202004-05-08 08:23:19 +00002471 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
drhe55cbd72008-03-31 23:48:03 +00002472 pParse->disableColCache++;
danielk19774adee202004-05-08 08:23:19 +00002473 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
drhc5499be2008-04-01 15:06:33 +00002474 assert( pParse->disableColCache>0 );
drhe55cbd72008-03-31 23:48:03 +00002475 pParse->disableColCache--;
drhcce7d172000-05-31 15:34:51 +00002476 break;
2477 }
2478 case TK_NOT: {
drhc5499be2008-04-01 15:06:33 +00002479 testcase( jumpIfNull==0 );
danielk19774adee202004-05-08 08:23:19 +00002480 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
drhcce7d172000-05-31 15:34:51 +00002481 break;
2482 }
2483 case TK_LT:
2484 case TK_LE:
2485 case TK_GT:
2486 case TK_GE:
2487 case TK_NE:
drh0ac65892002-04-20 14:24:41 +00002488 case TK_EQ: {
drhf2bc0132004-10-04 13:19:23 +00002489 assert( TK_LT==OP_Lt );
2490 assert( TK_LE==OP_Le );
2491 assert( TK_GT==OP_Gt );
2492 assert( TK_GE==OP_Ge );
2493 assert( TK_EQ==OP_Eq );
2494 assert( TK_NE==OP_Ne );
drhc5499be2008-04-01 15:06:33 +00002495 testcase( op==TK_LT );
2496 testcase( op==TK_LE );
2497 testcase( op==TK_GT );
2498 testcase( op==TK_GE );
2499 testcase( op==TK_EQ );
2500 testcase( op==TK_NE );
2501 testcase( jumpIfNull==0 );
drhda250ea2008-04-01 05:07:14 +00002502 codeCompareOperands(pParse, pExpr->pLeft, &r1, &regFree1,
2503 pExpr->pRight, &r2, &regFree2);
drh35573352008-01-08 23:54:25 +00002504 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
drh2dcef112008-01-12 19:03:48 +00002505 r1, r2, dest, jumpIfNull);
drhc5499be2008-04-01 15:06:33 +00002506 testcase( regFree1==0 );
2507 testcase( regFree2==0 );
drhcce7d172000-05-31 15:34:51 +00002508 break;
2509 }
2510 case TK_ISNULL:
2511 case TK_NOTNULL: {
drhf2bc0132004-10-04 13:19:23 +00002512 assert( TK_ISNULL==OP_IsNull );
2513 assert( TK_NOTNULL==OP_NotNull );
drhc5499be2008-04-01 15:06:33 +00002514 testcase( op==TK_ISNULL );
2515 testcase( op==TK_NOTNULL );
drh2dcef112008-01-12 19:03:48 +00002516 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
2517 sqlite3VdbeAddOp2(v, op, r1, dest);
drhc5499be2008-04-01 15:06:33 +00002518 testcase( regFree1==0 );
drhcce7d172000-05-31 15:34:51 +00002519 break;
2520 }
drhfef52082000-06-06 01:50:43 +00002521 case TK_BETWEEN: {
drh2dcef112008-01-12 19:03:48 +00002522 /* x BETWEEN y AND z
danielk19770202b292004-06-09 09:55:16 +00002523 **
drh2dcef112008-01-12 19:03:48 +00002524 ** Is equivalent to
2525 **
2526 ** x>=y AND x<=z
2527 **
2528 ** Code it as such, taking care to do the common subexpression
2529 ** elementation of x.
danielk19770202b292004-06-09 09:55:16 +00002530 */
drh2dcef112008-01-12 19:03:48 +00002531 Expr exprAnd;
2532 Expr compLeft;
2533 Expr compRight;
2534 Expr exprX;
danielk19770202b292004-06-09 09:55:16 +00002535
drh2dcef112008-01-12 19:03:48 +00002536 exprX = *pExpr->pLeft;
2537 exprAnd.op = TK_AND;
2538 exprAnd.pLeft = &compLeft;
2539 exprAnd.pRight = &compRight;
2540 compLeft.op = TK_GE;
2541 compLeft.pLeft = &exprX;
2542 compLeft.pRight = pExpr->pList->a[0].pExpr;
2543 compRight.op = TK_LE;
2544 compRight.pLeft = &exprX;
2545 compRight.pRight = pExpr->pList->a[1].pExpr;
2546 exprX.iTable = sqlite3ExprCodeTemp(pParse, &exprX, &regFree1);
drhc5499be2008-04-01 15:06:33 +00002547 testcase( regFree1==0 );
drh2dcef112008-01-12 19:03:48 +00002548 exprX.op = TK_REGISTER;
drhc5499be2008-04-01 15:06:33 +00002549 testcase( jumpIfNull==0 );
drh2dcef112008-01-12 19:03:48 +00002550 sqlite3ExprIfTrue(pParse, &exprAnd, dest, jumpIfNull);
drhfef52082000-06-06 01:50:43 +00002551 break;
2552 }
drhcce7d172000-05-31 15:34:51 +00002553 default: {
drh2dcef112008-01-12 19:03:48 +00002554 r1 = sqlite3ExprCodeTemp(pParse, pExpr, &regFree1);
2555 sqlite3VdbeAddOp3(v, OP_If, r1, dest, jumpIfNull!=0);
drhc5499be2008-04-01 15:06:33 +00002556 testcase( regFree1==0 );
2557 testcase( jumpIfNull==0 );
drhcce7d172000-05-31 15:34:51 +00002558 break;
2559 }
2560 }
drh2dcef112008-01-12 19:03:48 +00002561 sqlite3ReleaseTempReg(pParse, regFree1);
2562 sqlite3ReleaseTempReg(pParse, regFree2);
drhcce7d172000-05-31 15:34:51 +00002563}
2564
2565/*
drh66b89c82000-11-28 20:47:17 +00002566** Generate code for a boolean expression such that a jump is made
drhcce7d172000-05-31 15:34:51 +00002567** to the label "dest" if the expression is false but execution
2568** continues straight thru if the expression is true.
drhf5905aa2002-05-26 20:54:33 +00002569**
2570** If the expression evaluates to NULL (neither true nor false) then
drh35573352008-01-08 23:54:25 +00002571** jump if jumpIfNull is SQLITE_JUMPIFNULL or fall through if jumpIfNull
2572** is 0.
drhcce7d172000-05-31 15:34:51 +00002573*/
danielk19774adee202004-05-08 08:23:19 +00002574void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
drhcce7d172000-05-31 15:34:51 +00002575 Vdbe *v = pParse->pVdbe;
2576 int op = 0;
drh2dcef112008-01-12 19:03:48 +00002577 int regFree1 = 0;
2578 int regFree2 = 0;
2579 int r1, r2;
2580
drh35573352008-01-08 23:54:25 +00002581 assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 );
drhdaffd0e2001-04-11 14:28:42 +00002582 if( v==0 || pExpr==0 ) return;
drhf2bc0132004-10-04 13:19:23 +00002583
2584 /* The value of pExpr->op and op are related as follows:
2585 **
2586 ** pExpr->op op
2587 ** --------- ----------
2588 ** TK_ISNULL OP_NotNull
2589 ** TK_NOTNULL OP_IsNull
2590 ** TK_NE OP_Eq
2591 ** TK_EQ OP_Ne
2592 ** TK_GT OP_Le
2593 ** TK_LE OP_Gt
2594 ** TK_GE OP_Lt
2595 ** TK_LT OP_Ge
2596 **
2597 ** For other values of pExpr->op, op is undefined and unused.
2598 ** The value of TK_ and OP_ constants are arranged such that we
2599 ** can compute the mapping above using the following expression.
2600 ** Assert()s verify that the computation is correct.
2601 */
2602 op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1);
2603
2604 /* Verify correct alignment of TK_ and OP_ constants
2605 */
2606 assert( pExpr->op!=TK_ISNULL || op==OP_NotNull );
2607 assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull );
2608 assert( pExpr->op!=TK_NE || op==OP_Eq );
2609 assert( pExpr->op!=TK_EQ || op==OP_Ne );
2610 assert( pExpr->op!=TK_LT || op==OP_Ge );
2611 assert( pExpr->op!=TK_LE || op==OP_Gt );
2612 assert( pExpr->op!=TK_GT || op==OP_Le );
2613 assert( pExpr->op!=TK_GE || op==OP_Lt );
2614
drhcce7d172000-05-31 15:34:51 +00002615 switch( pExpr->op ){
2616 case TK_AND: {
drhc5499be2008-04-01 15:06:33 +00002617 testcase( jumpIfNull==0 );
2618 testcase( pParse->disableColCache==0 );
danielk19774adee202004-05-08 08:23:19 +00002619 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
drhe55cbd72008-03-31 23:48:03 +00002620 pParse->disableColCache++;
danielk19774adee202004-05-08 08:23:19 +00002621 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
drhc5499be2008-04-01 15:06:33 +00002622 assert( pParse->disableColCache>0 );
drhe55cbd72008-03-31 23:48:03 +00002623 pParse->disableColCache--;
drhcce7d172000-05-31 15:34:51 +00002624 break;
2625 }
2626 case TK_OR: {
danielk19774adee202004-05-08 08:23:19 +00002627 int d2 = sqlite3VdbeMakeLabel(v);
drhc5499be2008-04-01 15:06:33 +00002628 testcase( jumpIfNull==0 );
2629 testcase( pParse->disableColCache==0 );
drh35573352008-01-08 23:54:25 +00002630 sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2, jumpIfNull^SQLITE_JUMPIFNULL);
drhe55cbd72008-03-31 23:48:03 +00002631 pParse->disableColCache++;
danielk19774adee202004-05-08 08:23:19 +00002632 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
drhc5499be2008-04-01 15:06:33 +00002633 assert( pParse->disableColCache>0 );
drhe55cbd72008-03-31 23:48:03 +00002634 pParse->disableColCache--;
danielk19774adee202004-05-08 08:23:19 +00002635 sqlite3VdbeResolveLabel(v, d2);
drhcce7d172000-05-31 15:34:51 +00002636 break;
2637 }
2638 case TK_NOT: {
danielk19774adee202004-05-08 08:23:19 +00002639 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
drhcce7d172000-05-31 15:34:51 +00002640 break;
2641 }
2642 case TK_LT:
2643 case TK_LE:
2644 case TK_GT:
2645 case TK_GE:
2646 case TK_NE:
2647 case TK_EQ: {
drhc5499be2008-04-01 15:06:33 +00002648 testcase( op==TK_LT );
2649 testcase( op==TK_LE );
2650 testcase( op==TK_GT );
2651 testcase( op==TK_GE );
2652 testcase( op==TK_EQ );
2653 testcase( op==TK_NE );
2654 testcase( jumpIfNull==0 );
drhda250ea2008-04-01 05:07:14 +00002655 codeCompareOperands(pParse, pExpr->pLeft, &r1, &regFree1,
2656 pExpr->pRight, &r2, &regFree2);
drh35573352008-01-08 23:54:25 +00002657 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
drh2dcef112008-01-12 19:03:48 +00002658 r1, r2, dest, jumpIfNull);
drhc5499be2008-04-01 15:06:33 +00002659 testcase( regFree1==0 );
2660 testcase( regFree2==0 );
drhcce7d172000-05-31 15:34:51 +00002661 break;
2662 }
drhcce7d172000-05-31 15:34:51 +00002663 case TK_ISNULL:
2664 case TK_NOTNULL: {
drhc5499be2008-04-01 15:06:33 +00002665 testcase( op==TK_ISNULL );
2666 testcase( op==TK_NOTNULL );
drh2dcef112008-01-12 19:03:48 +00002667 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
2668 sqlite3VdbeAddOp2(v, op, r1, dest);
drhc5499be2008-04-01 15:06:33 +00002669 testcase( regFree1==0 );
drhcce7d172000-05-31 15:34:51 +00002670 break;
2671 }
drhfef52082000-06-06 01:50:43 +00002672 case TK_BETWEEN: {
drh2dcef112008-01-12 19:03:48 +00002673 /* x BETWEEN y AND z
danielk19770202b292004-06-09 09:55:16 +00002674 **
drh2dcef112008-01-12 19:03:48 +00002675 ** Is equivalent to
2676 **
2677 ** x>=y AND x<=z
2678 **
2679 ** Code it as such, taking care to do the common subexpression
2680 ** elementation of x.
danielk19770202b292004-06-09 09:55:16 +00002681 */
drh2dcef112008-01-12 19:03:48 +00002682 Expr exprAnd;
2683 Expr compLeft;
2684 Expr compRight;
2685 Expr exprX;
drhbe5c89a2004-07-26 00:31:09 +00002686
drh2dcef112008-01-12 19:03:48 +00002687 exprX = *pExpr->pLeft;
2688 exprAnd.op = TK_AND;
2689 exprAnd.pLeft = &compLeft;
2690 exprAnd.pRight = &compRight;
2691 compLeft.op = TK_GE;
2692 compLeft.pLeft = &exprX;
2693 compLeft.pRight = pExpr->pList->a[0].pExpr;
2694 compRight.op = TK_LE;
2695 compRight.pLeft = &exprX;
2696 compRight.pRight = pExpr->pList->a[1].pExpr;
2697 exprX.iTable = sqlite3ExprCodeTemp(pParse, &exprX, &regFree1);
drhc5499be2008-04-01 15:06:33 +00002698 testcase( regFree1==0 );
drh2dcef112008-01-12 19:03:48 +00002699 exprX.op = TK_REGISTER;
drhc5499be2008-04-01 15:06:33 +00002700 testcase( jumpIfNull==0 );
drh2dcef112008-01-12 19:03:48 +00002701 sqlite3ExprIfFalse(pParse, &exprAnd, dest, jumpIfNull);
drhfef52082000-06-06 01:50:43 +00002702 break;
2703 }
drhcce7d172000-05-31 15:34:51 +00002704 default: {
drh2dcef112008-01-12 19:03:48 +00002705 r1 = sqlite3ExprCodeTemp(pParse, pExpr, &regFree1);
2706 sqlite3VdbeAddOp3(v, OP_IfNot, r1, dest, jumpIfNull!=0);
drhc5499be2008-04-01 15:06:33 +00002707 testcase( regFree1==0 );
2708 testcase( jumpIfNull==0 );
drhcce7d172000-05-31 15:34:51 +00002709 break;
2710 }
2711 }
drh2dcef112008-01-12 19:03:48 +00002712 sqlite3ReleaseTempReg(pParse, regFree1);
2713 sqlite3ReleaseTempReg(pParse, regFree2);
drhcce7d172000-05-31 15:34:51 +00002714}
drh22827922000-06-06 17:27:05 +00002715
2716/*
2717** Do a deep comparison of two expression trees. Return TRUE (non-zero)
2718** if they are identical and return FALSE if they differ in any way.
drhd40aab02007-02-24 15:29:03 +00002719**
2720** Sometimes this routine will return FALSE even if the two expressions
2721** really are equivalent. If we cannot prove that the expressions are
2722** identical, we return FALSE just to be safe. So if this routine
2723** returns false, then you do not really know for certain if the two
2724** expressions are the same. But if you get a TRUE return, then you
2725** can be sure the expressions are the same. In the places where
2726** this routine is used, it does not hurt to get an extra FALSE - that
2727** just might result in some slightly slower code. But returning
2728** an incorrect TRUE could lead to a malfunction.
drh22827922000-06-06 17:27:05 +00002729*/
danielk19774adee202004-05-08 08:23:19 +00002730int sqlite3ExprCompare(Expr *pA, Expr *pB){
drh22827922000-06-06 17:27:05 +00002731 int i;
danielk19774b202ae2006-01-23 05:50:58 +00002732 if( pA==0||pB==0 ){
2733 return pB==pA;
drh22827922000-06-06 17:27:05 +00002734 }
2735 if( pA->op!=pB->op ) return 0;
drhfd357972005-09-09 01:33:19 +00002736 if( (pA->flags & EP_Distinct)!=(pB->flags & EP_Distinct) ) return 0;
danielk19774adee202004-05-08 08:23:19 +00002737 if( !sqlite3ExprCompare(pA->pLeft, pB->pLeft) ) return 0;
2738 if( !sqlite3ExprCompare(pA->pRight, pB->pRight) ) return 0;
drh22827922000-06-06 17:27:05 +00002739 if( pA->pList ){
2740 if( pB->pList==0 ) return 0;
2741 if( pA->pList->nExpr!=pB->pList->nExpr ) return 0;
2742 for(i=0; i<pA->pList->nExpr; i++){
danielk19774adee202004-05-08 08:23:19 +00002743 if( !sqlite3ExprCompare(pA->pList->a[i].pExpr, pB->pList->a[i].pExpr) ){
drh22827922000-06-06 17:27:05 +00002744 return 0;
2745 }
2746 }
2747 }else if( pB->pList ){
2748 return 0;
2749 }
2750 if( pA->pSelect || pB->pSelect ) return 0;
drh2f2c01e2002-07-02 13:05:04 +00002751 if( pA->iTable!=pB->iTable || pA->iColumn!=pB->iColumn ) return 0;
drhdd735212007-02-24 13:53:05 +00002752 if( pA->op!=TK_COLUMN && pA->token.z ){
drh22827922000-06-06 17:27:05 +00002753 if( pB->token.z==0 ) return 0;
drh6977fea2002-10-22 23:38:04 +00002754 if( pB->token.n!=pA->token.n ) return 0;
drh2646da72005-12-09 20:02:05 +00002755 if( sqlite3StrNICmp((char*)pA->token.z,(char*)pB->token.z,pB->token.n)!=0 ){
2756 return 0;
2757 }
drh22827922000-06-06 17:27:05 +00002758 }
2759 return 1;
2760}
2761
drh13449892005-09-07 21:22:45 +00002762
drh22827922000-06-06 17:27:05 +00002763/*
drh13449892005-09-07 21:22:45 +00002764** Add a new element to the pAggInfo->aCol[] array. Return the index of
2765** the new element. Return a negative number if malloc fails.
drh22827922000-06-06 17:27:05 +00002766*/
drh17435752007-08-16 04:30:38 +00002767static int addAggInfoColumn(sqlite3 *db, AggInfo *pInfo){
drh13449892005-09-07 21:22:45 +00002768 int i;
drhcf643722007-03-27 13:36:37 +00002769 pInfo->aCol = sqlite3ArrayAllocate(
drh17435752007-08-16 04:30:38 +00002770 db,
drhcf643722007-03-27 13:36:37 +00002771 pInfo->aCol,
2772 sizeof(pInfo->aCol[0]),
2773 3,
2774 &pInfo->nColumn,
2775 &pInfo->nColumnAlloc,
2776 &i
2777 );
drh13449892005-09-07 21:22:45 +00002778 return i;
2779}
2780
2781/*
2782** Add a new element to the pAggInfo->aFunc[] array. Return the index of
2783** the new element. Return a negative number if malloc fails.
2784*/
drh17435752007-08-16 04:30:38 +00002785static int addAggInfoFunc(sqlite3 *db, AggInfo *pInfo){
drh13449892005-09-07 21:22:45 +00002786 int i;
drhcf643722007-03-27 13:36:37 +00002787 pInfo->aFunc = sqlite3ArrayAllocate(
drh17435752007-08-16 04:30:38 +00002788 db,
drhcf643722007-03-27 13:36:37 +00002789 pInfo->aFunc,
2790 sizeof(pInfo->aFunc[0]),
2791 3,
2792 &pInfo->nFunc,
2793 &pInfo->nFuncAlloc,
2794 &i
2795 );
drh13449892005-09-07 21:22:45 +00002796 return i;
2797}
drh22827922000-06-06 17:27:05 +00002798
2799/*
drh7d10d5a2008-08-20 16:35:10 +00002800** This is the xExprCallback for a tree walker. It is used to
2801** implement sqlite3ExprAnalyzeAggregates(). See sqlite3ExprAnalyzeAggregates
drh626a8792005-01-17 22:08:19 +00002802** for additional information.
drh22827922000-06-06 17:27:05 +00002803*/
drh7d10d5a2008-08-20 16:35:10 +00002804static int analyzeAggregate(Walker *pWalker, Expr *pExpr){
drh22827922000-06-06 17:27:05 +00002805 int i;
drh7d10d5a2008-08-20 16:35:10 +00002806 NameContext *pNC = pWalker->u.pNC;
danielk1977a58fdfb2005-02-08 07:50:40 +00002807 Parse *pParse = pNC->pParse;
2808 SrcList *pSrcList = pNC->pSrcList;
drh13449892005-09-07 21:22:45 +00002809 AggInfo *pAggInfo = pNC->pAggInfo;
drh22827922000-06-06 17:27:05 +00002810
drh22827922000-06-06 17:27:05 +00002811 switch( pExpr->op ){
drh89c69d02007-01-04 01:20:28 +00002812 case TK_AGG_COLUMN:
drh967e8b72000-06-21 13:59:10 +00002813 case TK_COLUMN: {
drh13449892005-09-07 21:22:45 +00002814 /* Check to see if the column is in one of the tables in the FROM
2815 ** clause of the aggregate query */
2816 if( pSrcList ){
2817 struct SrcList_item *pItem = pSrcList->a;
2818 for(i=0; i<pSrcList->nSrc; i++, pItem++){
2819 struct AggInfo_col *pCol;
2820 if( pExpr->iTable==pItem->iCursor ){
2821 /* If we reach this point, it means that pExpr refers to a table
2822 ** that is in the FROM clause of the aggregate query.
2823 **
2824 ** Make an entry for the column in pAggInfo->aCol[] if there
2825 ** is not an entry there already.
2826 */
drh7f906d62007-03-12 23:48:52 +00002827 int k;
drh13449892005-09-07 21:22:45 +00002828 pCol = pAggInfo->aCol;
drh7f906d62007-03-12 23:48:52 +00002829 for(k=0; k<pAggInfo->nColumn; k++, pCol++){
drh13449892005-09-07 21:22:45 +00002830 if( pCol->iTable==pExpr->iTable &&
2831 pCol->iColumn==pExpr->iColumn ){
2832 break;
2833 }
danielk1977a58fdfb2005-02-08 07:50:40 +00002834 }
danielk19771e536952007-08-16 10:09:01 +00002835 if( (k>=pAggInfo->nColumn)
2836 && (k = addAggInfoColumn(pParse->db, pAggInfo))>=0
2837 ){
drh7f906d62007-03-12 23:48:52 +00002838 pCol = &pAggInfo->aCol[k];
danielk19770817d0d2007-02-14 09:19:36 +00002839 pCol->pTab = pExpr->pTab;
drh13449892005-09-07 21:22:45 +00002840 pCol->iTable = pExpr->iTable;
2841 pCol->iColumn = pExpr->iColumn;
drh0a07c102008-01-03 18:03:08 +00002842 pCol->iMem = ++pParse->nMem;
drh13449892005-09-07 21:22:45 +00002843 pCol->iSorterColumn = -1;
drh5774b802005-09-07 22:48:16 +00002844 pCol->pExpr = pExpr;
drh13449892005-09-07 21:22:45 +00002845 if( pAggInfo->pGroupBy ){
2846 int j, n;
2847 ExprList *pGB = pAggInfo->pGroupBy;
2848 struct ExprList_item *pTerm = pGB->a;
2849 n = pGB->nExpr;
2850 for(j=0; j<n; j++, pTerm++){
2851 Expr *pE = pTerm->pExpr;
2852 if( pE->op==TK_COLUMN && pE->iTable==pExpr->iTable &&
2853 pE->iColumn==pExpr->iColumn ){
2854 pCol->iSorterColumn = j;
2855 break;
2856 }
2857 }
2858 }
2859 if( pCol->iSorterColumn<0 ){
2860 pCol->iSorterColumn = pAggInfo->nSortingColumn++;
2861 }
2862 }
2863 /* There is now an entry for pExpr in pAggInfo->aCol[] (either
2864 ** because it was there before or because we just created it).
2865 ** Convert the pExpr to be a TK_AGG_COLUMN referring to that
2866 ** pAggInfo->aCol[] entry.
2867 */
2868 pExpr->pAggInfo = pAggInfo;
2869 pExpr->op = TK_AGG_COLUMN;
drh7f906d62007-03-12 23:48:52 +00002870 pExpr->iAgg = k;
drh13449892005-09-07 21:22:45 +00002871 break;
2872 } /* endif pExpr->iTable==pItem->iCursor */
2873 } /* end loop over pSrcList */
drh22827922000-06-06 17:27:05 +00002874 }
drh7d10d5a2008-08-20 16:35:10 +00002875 return WRC_Prune;
drh22827922000-06-06 17:27:05 +00002876 }
2877 case TK_AGG_FUNCTION: {
drh13449892005-09-07 21:22:45 +00002878 /* The pNC->nDepth==0 test causes aggregate functions in subqueries
2879 ** to be ignored */
danielk1977a58fdfb2005-02-08 07:50:40 +00002880 if( pNC->nDepth==0 ){
drh13449892005-09-07 21:22:45 +00002881 /* Check to see if pExpr is a duplicate of another aggregate
2882 ** function that is already in the pAggInfo structure
2883 */
2884 struct AggInfo_func *pItem = pAggInfo->aFunc;
2885 for(i=0; i<pAggInfo->nFunc; i++, pItem++){
2886 if( sqlite3ExprCompare(pItem->pExpr, pExpr) ){
danielk1977a58fdfb2005-02-08 07:50:40 +00002887 break;
2888 }
drh22827922000-06-06 17:27:05 +00002889 }
drh13449892005-09-07 21:22:45 +00002890 if( i>=pAggInfo->nFunc ){
2891 /* pExpr is original. Make a new entry in pAggInfo->aFunc[]
2892 */
danielk197714db2662006-01-09 16:12:04 +00002893 u8 enc = ENC(pParse->db);
danielk19771e536952007-08-16 10:09:01 +00002894 i = addAggInfoFunc(pParse->db, pAggInfo);
drh13449892005-09-07 21:22:45 +00002895 if( i>=0 ){
2896 pItem = &pAggInfo->aFunc[i];
2897 pItem->pExpr = pExpr;
drh0a07c102008-01-03 18:03:08 +00002898 pItem->iMem = ++pParse->nMem;
drh13449892005-09-07 21:22:45 +00002899 pItem->pFunc = sqlite3FindFunction(pParse->db,
drh2646da72005-12-09 20:02:05 +00002900 (char*)pExpr->token.z, pExpr->token.n,
drh13449892005-09-07 21:22:45 +00002901 pExpr->pList ? pExpr->pList->nExpr : 0, enc, 0);
drhfd357972005-09-09 01:33:19 +00002902 if( pExpr->flags & EP_Distinct ){
2903 pItem->iDistinct = pParse->nTab++;
2904 }else{
2905 pItem->iDistinct = -1;
2906 }
drh13449892005-09-07 21:22:45 +00002907 }
danielk1977a58fdfb2005-02-08 07:50:40 +00002908 }
drh13449892005-09-07 21:22:45 +00002909 /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry
2910 */
danielk1977a58fdfb2005-02-08 07:50:40 +00002911 pExpr->iAgg = i;
drh13449892005-09-07 21:22:45 +00002912 pExpr->pAggInfo = pAggInfo;
drh7d10d5a2008-08-20 16:35:10 +00002913 return WRC_Prune;
drh22827922000-06-06 17:27:05 +00002914 }
drh22827922000-06-06 17:27:05 +00002915 }
2916 }
drh7d10d5a2008-08-20 16:35:10 +00002917 return WRC_Continue;
2918}
2919static int analyzeAggregatesInSelect(Walker *pWalker, Select *pSelect){
2920 NameContext *pNC = pWalker->u.pNC;
2921 if( pNC->nDepth==0 ){
danielk1977a58fdfb2005-02-08 07:50:40 +00002922 pNC->nDepth++;
drh7d10d5a2008-08-20 16:35:10 +00002923 sqlite3WalkSelect(pWalker, pSelect);
danielk1977a58fdfb2005-02-08 07:50:40 +00002924 pNC->nDepth--;
drh7d10d5a2008-08-20 16:35:10 +00002925 return WRC_Prune;
2926 }else{
2927 return WRC_Continue;
danielk1977a58fdfb2005-02-08 07:50:40 +00002928 }
drh626a8792005-01-17 22:08:19 +00002929}
2930
2931/*
2932** Analyze the given expression looking for aggregate functions and
2933** for variables that need to be added to the pParse->aAgg[] array.
2934** Make additional entries to the pParse->aAgg[] array as necessary.
2935**
2936** This routine should only be called after the expression has been
drh7d10d5a2008-08-20 16:35:10 +00002937** analyzed by sqlite3ResolveExprNames().
drh626a8792005-01-17 22:08:19 +00002938*/
drhd2b3e232008-01-23 14:51:49 +00002939void sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){
drh7d10d5a2008-08-20 16:35:10 +00002940 Walker w;
2941 w.xExprCallback = analyzeAggregate;
2942 w.xSelectCallback = analyzeAggregatesInSelect;
2943 w.u.pNC = pNC;
2944 sqlite3WalkExpr(&w, pExpr);
drh22827922000-06-06 17:27:05 +00002945}
drh5d9a4af2005-08-30 00:54:01 +00002946
2947/*
2948** Call sqlite3ExprAnalyzeAggregates() for every expression in an
2949** expression list. Return the number of errors.
2950**
2951** If an error is found, the analysis is cut short.
2952*/
drhd2b3e232008-01-23 14:51:49 +00002953void sqlite3ExprAnalyzeAggList(NameContext *pNC, ExprList *pList){
drh5d9a4af2005-08-30 00:54:01 +00002954 struct ExprList_item *pItem;
2955 int i;
drh5d9a4af2005-08-30 00:54:01 +00002956 if( pList ){
drhd2b3e232008-01-23 14:51:49 +00002957 for(pItem=pList->a, i=0; i<pList->nExpr; i++, pItem++){
2958 sqlite3ExprAnalyzeAggregates(pNC, pItem->pExpr);
drh5d9a4af2005-08-30 00:54:01 +00002959 }
2960 }
drh5d9a4af2005-08-30 00:54:01 +00002961}
drh892d3172008-01-10 03:46:36 +00002962
2963/*
2964** Allocate or deallocate temporary use registers during code generation.
2965*/
2966int sqlite3GetTempReg(Parse *pParse){
drhe55cbd72008-03-31 23:48:03 +00002967 if( pParse->nTempReg==0 ){
drh892d3172008-01-10 03:46:36 +00002968 return ++pParse->nMem;
2969 }
danielk19772f425f62008-07-04 09:41:39 +00002970 return pParse->aTempReg[--pParse->nTempReg];
drh892d3172008-01-10 03:46:36 +00002971}
2972void sqlite3ReleaseTempReg(Parse *pParse, int iReg){
drh2dcef112008-01-12 19:03:48 +00002973 if( iReg && pParse->nTempReg<ArraySize(pParse->aTempReg) ){
danielk1977a7d8b852008-07-04 09:15:11 +00002974 sqlite3ExprWritableRegister(pParse, iReg, iReg);
drh892d3172008-01-10 03:46:36 +00002975 pParse->aTempReg[pParse->nTempReg++] = iReg;
2976 }
2977}
2978
2979/*
2980** Allocate or deallocate a block of nReg consecutive registers
2981*/
2982int sqlite3GetTempRange(Parse *pParse, int nReg){
drhe55cbd72008-03-31 23:48:03 +00002983 int i, n;
2984 i = pParse->iRangeReg;
2985 n = pParse->nRangeReg;
2986 if( nReg<=n && !usedAsColumnCache(pParse, i, i+n-1) ){
drh892d3172008-01-10 03:46:36 +00002987 pParse->iRangeReg += nReg;
2988 pParse->nRangeReg -= nReg;
2989 }else{
2990 i = pParse->nMem+1;
2991 pParse->nMem += nReg;
2992 }
2993 return i;
2994}
2995void sqlite3ReleaseTempRange(Parse *pParse, int iReg, int nReg){
2996 if( nReg>pParse->nRangeReg ){
2997 pParse->nRangeReg = nReg;
2998 pParse->iRangeReg = iReg;
2999 }
3000}