blob: b650035222de2dbc9517c6281482c747ed08464a [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**
drh7d10d5a2008-08-20 16:35:10 +000015** $Id: expr.c,v 1.389 2008/08/20 16:35:10 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;
drh87abf5c2005-08-25 12:45:04 +0000923 case TK_IN:
924 if( pExpr->pSelect ){
drh7d10d5a2008-08-20 16:35:10 +0000925 pWalker->u.i = 0;
926 return WRC_Abort;
drh87abf5c2005-08-25 12:45:04 +0000927 }
drh626a8792005-01-17 22:08:19 +0000928 default:
drh7d10d5a2008-08-20 16:35:10 +0000929 return WRC_Continue;
drh626a8792005-01-17 22:08:19 +0000930 }
931}
drh7d10d5a2008-08-20 16:35:10 +0000932static int selectNodeIsConstant(Walker *pWalker, Select *pSelect){
933 pWalker->u.i = 0;
934 return WRC_Abort;
935}
936static int exprIsConst(Expr *p, int initFlag){
937 Walker w;
938 w.u.i = initFlag;
939 w.xExprCallback = exprNodeIsConstant;
940 w.xSelectCallback = selectNodeIsConstant;
941 sqlite3WalkExpr(&w, p);
942 return w.u.i;
943}
drh626a8792005-01-17 22:08:19 +0000944
945/*
drhfef52082000-06-06 01:50:43 +0000946** Walk an expression tree. Return 1 if the expression is constant
drheb55bd22005-06-30 17:04:21 +0000947** and 0 if it involves variables or function calls.
drh23989372002-05-21 13:43:04 +0000948**
949** For the purposes of this function, a double-quoted string (ex: "abc")
950** is considered a variable but a single-quoted string (ex: 'abc') is
951** a constant.
drhfef52082000-06-06 01:50:43 +0000952*/
danielk19774adee202004-05-08 08:23:19 +0000953int sqlite3ExprIsConstant(Expr *p){
drh7d10d5a2008-08-20 16:35:10 +0000954 return exprIsConst(p, 1);
drhfef52082000-06-06 01:50:43 +0000955}
956
957/*
drheb55bd22005-06-30 17:04:21 +0000958** Walk an expression tree. Return 1 if the expression is constant
drh0a168372007-06-08 00:20:47 +0000959** that does no originate from the ON or USING clauses of a join.
960** Return 0 if it involves variables or function calls or terms from
961** an ON or USING clause.
962*/
963int sqlite3ExprIsConstantNotJoin(Expr *p){
drh7d10d5a2008-08-20 16:35:10 +0000964 return exprIsConst(p, 3);
drh0a168372007-06-08 00:20:47 +0000965}
966
967/*
968** Walk an expression tree. Return 1 if the expression is constant
drheb55bd22005-06-30 17:04:21 +0000969** or a function call with constant arguments. Return and 0 if there
970** are any variables.
971**
972** For the purposes of this function, a double-quoted string (ex: "abc")
973** is considered a variable but a single-quoted string (ex: 'abc') is
974** a constant.
975*/
976int sqlite3ExprIsConstantOrFunction(Expr *p){
drh7d10d5a2008-08-20 16:35:10 +0000977 return exprIsConst(p, 2);
drheb55bd22005-06-30 17:04:21 +0000978}
979
980/*
drh73b211a2005-01-18 04:00:42 +0000981** If the expression p codes a constant integer that is small enough
drh202b2df2004-01-06 01:13:46 +0000982** to fit in a 32-bit integer, return 1 and put the value of the integer
983** in *pValue. If the expression is not an integer or if it is too big
984** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
drhe4de1fe2002-06-02 16:09:01 +0000985*/
danielk19774adee202004-05-08 08:23:19 +0000986int sqlite3ExprIsInteger(Expr *p, int *pValue){
drh92b01d52008-06-24 00:32:35 +0000987 int rc = 0;
988 if( p->flags & EP_IntValue ){
989 *pValue = p->iTable;
990 return 1;
991 }
drhe4de1fe2002-06-02 16:09:01 +0000992 switch( p->op ){
993 case TK_INTEGER: {
drh92b01d52008-06-24 00:32:35 +0000994 rc = sqlite3GetInt32((char*)p->token.z, pValue);
drh202b2df2004-01-06 01:13:46 +0000995 break;
drhe4de1fe2002-06-02 16:09:01 +0000996 }
drh4b59ab52002-08-24 18:24:51 +0000997 case TK_UPLUS: {
drh92b01d52008-06-24 00:32:35 +0000998 rc = sqlite3ExprIsInteger(p->pLeft, pValue);
drhf6e369a2008-06-24 12:46:30 +0000999 break;
drh4b59ab52002-08-24 18:24:51 +00001000 }
drhe4de1fe2002-06-02 16:09:01 +00001001 case TK_UMINUS: {
1002 int v;
danielk19774adee202004-05-08 08:23:19 +00001003 if( sqlite3ExprIsInteger(p->pLeft, &v) ){
drhe4de1fe2002-06-02 16:09:01 +00001004 *pValue = -v;
drh92b01d52008-06-24 00:32:35 +00001005 rc = 1;
drhe4de1fe2002-06-02 16:09:01 +00001006 }
1007 break;
1008 }
1009 default: break;
1010 }
drh92b01d52008-06-24 00:32:35 +00001011 if( rc ){
1012 p->op = TK_INTEGER;
1013 p->flags |= EP_IntValue;
1014 p->iTable = *pValue;
1015 }
1016 return rc;
drhe4de1fe2002-06-02 16:09:01 +00001017}
1018
1019/*
drhc4a3c772001-04-04 11:48:57 +00001020** Return TRUE if the given string is a row-id column name.
1021*/
danielk19774adee202004-05-08 08:23:19 +00001022int sqlite3IsRowid(const char *z){
1023 if( sqlite3StrICmp(z, "_ROWID_")==0 ) return 1;
1024 if( sqlite3StrICmp(z, "ROWID")==0 ) return 1;
1025 if( sqlite3StrICmp(z, "OID")==0 ) return 1;
drhc4a3c772001-04-04 11:48:57 +00001026 return 0;
1027}
1028
danielk19779a96b662007-11-29 17:05:18 +00001029#ifdef SQLITE_TEST
1030 int sqlite3_enable_in_opt = 1;
1031#else
1032 #define sqlite3_enable_in_opt 1
1033#endif
1034
1035/*
drhb287f4b2008-04-25 00:08:38 +00001036** Return true if the IN operator optimization is enabled and
1037** the SELECT statement p exists and is of the
1038** simple form:
1039**
1040** SELECT <column> FROM <table>
1041**
1042** If this is the case, it may be possible to use an existing table
1043** or index instead of generating an epheremal table.
1044*/
1045#ifndef SQLITE_OMIT_SUBQUERY
1046static int isCandidateForInOpt(Select *p){
1047 SrcList *pSrc;
1048 ExprList *pEList;
1049 Table *pTab;
1050 if( !sqlite3_enable_in_opt ) return 0; /* IN optimization must be enabled */
1051 if( p==0 ) return 0; /* right-hand side of IN is SELECT */
1052 if( p->pPrior ) return 0; /* Not a compound SELECT */
drh7d10d5a2008-08-20 16:35:10 +00001053 if( p->selFlags & (SF_Distinct|SF_Aggregate) ){
1054 return 0; /* No DISTINCT keyword and no aggregate functions */
1055 }
drhb287f4b2008-04-25 00:08:38 +00001056 if( p->pGroupBy ) return 0; /* Has no GROUP BY clause */
1057 if( p->pLimit ) return 0; /* Has no LIMIT clause */
1058 if( p->pOffset ) return 0;
1059 if( p->pWhere ) return 0; /* Has no WHERE clause */
1060 pSrc = p->pSrc;
1061 if( pSrc==0 ) return 0; /* A single table in the FROM clause */
1062 if( pSrc->nSrc!=1 ) return 0;
1063 if( pSrc->a[0].pSelect ) return 0; /* FROM clause is not a subquery */
1064 pTab = pSrc->a[0].pTab;
1065 if( pTab==0 ) return 0;
1066 if( pTab->pSelect ) return 0; /* FROM clause is not a view */
1067 if( IsVirtual(pTab) ) return 0; /* FROM clause not a virtual table */
1068 pEList = p->pEList;
1069 if( pEList->nExpr!=1 ) return 0; /* One column in the result set */
1070 if( pEList->a[0].pExpr->op!=TK_COLUMN ) return 0; /* Result is a column */
1071 return 1;
1072}
1073#endif /* SQLITE_OMIT_SUBQUERY */
1074
1075/*
danielk19779a96b662007-11-29 17:05:18 +00001076** This function is used by the implementation of the IN (...) operator.
1077** It's job is to find or create a b-tree structure that may be used
1078** either to test for membership of the (...) set or to iterate through
drh85b623f2007-12-13 21:54:09 +00001079** its members, skipping duplicates.
danielk19779a96b662007-11-29 17:05:18 +00001080**
1081** The cursor opened on the structure (database table, database index
1082** or ephermal table) is stored in pX->iTable before this function returns.
1083** The returned value indicates the structure type, as follows:
1084**
1085** IN_INDEX_ROWID - The cursor was opened on a database table.
drh2d401ab2008-01-10 23:50:11 +00001086** IN_INDEX_INDEX - The cursor was opened on a database index.
danielk19779a96b662007-11-29 17:05:18 +00001087** IN_INDEX_EPH - The cursor was opened on a specially created and
1088** populated epheremal table.
1089**
1090** An existing structure may only be used if the SELECT is of the simple
1091** form:
1092**
1093** SELECT <column> FROM <table>
1094**
danielk19770cdc0222008-06-26 18:04:03 +00001095** If prNotFound parameter is 0, then the structure will be used to iterate
danielk19779a96b662007-11-29 17:05:18 +00001096** through the set members, skipping any duplicates. In this case an
1097** epheremal table must be used unless the selected <column> is guaranteed
1098** to be unique - either because it is an INTEGER PRIMARY KEY or it
1099** is unique by virtue of a constraint or implicit index.
danielk19770cdc0222008-06-26 18:04:03 +00001100**
1101** If the prNotFound parameter is not 0, then the structure will be used
1102** for fast set membership tests. In this case an epheremal table must
1103** be used unless <column> is an INTEGER PRIMARY KEY or an index can
1104** be found with <column> as its left-most column.
1105**
1106** When the structure is being used for set membership tests, the user
1107** needs to know whether or not the structure contains an SQL NULL
1108** value in order to correctly evaluate expressions like "X IN (Y, Z)".
1109** If there is a chance that the structure may contain a NULL value at
1110** runtime, then a register is allocated and the register number written
1111** to *prNotFound. If there is no chance that the structure contains a
1112** NULL value, then *prNotFound is left unchanged.
1113**
1114** If a register is allocated and its location stored in *prNotFound, then
1115** its initial value is NULL. If the structure does not remain constant
1116** for the duration of the query (i.e. the set is a correlated sub-select),
1117** the value of the allocated register is reset to NULL each time the
1118** structure is repopulated. This allows the caller to use vdbe code
1119** equivalent to the following:
1120**
1121** if( register==NULL ){
1122** has_null = <test if data structure contains null>
1123** register = 1
1124** }
1125**
1126** in order to avoid running the <test if data structure contains null>
1127** test more often than is necessary.
danielk19779a96b662007-11-29 17:05:18 +00001128*/
danielk1977284f4ac2007-12-10 05:03:46 +00001129#ifndef SQLITE_OMIT_SUBQUERY
danielk19770cdc0222008-06-26 18:04:03 +00001130int sqlite3FindInIndex(Parse *pParse, Expr *pX, int *prNotFound){
danielk19779a96b662007-11-29 17:05:18 +00001131 Select *p;
1132 int eType = 0;
1133 int iTab = pParse->nTab++;
danielk19770cdc0222008-06-26 18:04:03 +00001134 int mustBeUnique = !prNotFound;
danielk19779a96b662007-11-29 17:05:18 +00001135
1136 /* The follwing if(...) expression is true if the SELECT is of the
1137 ** simple form:
1138 **
1139 ** SELECT <column> FROM <table>
1140 **
1141 ** If this is the case, it may be possible to use an existing table
1142 ** or index instead of generating an epheremal table.
1143 */
drhb287f4b2008-04-25 00:08:38 +00001144 p = pX->pSelect;
1145 if( isCandidateForInOpt(p) ){
danielk19779a96b662007-11-29 17:05:18 +00001146 sqlite3 *db = pParse->db;
1147 Index *pIdx;
1148 Expr *pExpr = p->pEList->a[0].pExpr;
1149 int iCol = pExpr->iColumn;
1150 Vdbe *v = sqlite3GetVdbe(pParse);
1151
1152 /* This function is only called from two places. In both cases the vdbe
1153 ** has already been allocated. So assume sqlite3GetVdbe() is always
1154 ** successful here.
1155 */
1156 assert(v);
1157 if( iCol<0 ){
drh0a07c102008-01-03 18:03:08 +00001158 int iMem = ++pParse->nMem;
danielk19779a96b662007-11-29 17:05:18 +00001159 int iAddr;
1160 Table *pTab = p->pSrc->a[0].pTab;
1161 int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
1162 sqlite3VdbeUsesBtree(v, iDb);
1163
drh892d3172008-01-10 03:46:36 +00001164 iAddr = sqlite3VdbeAddOp1(v, OP_If, iMem);
drh4c583122008-01-04 22:01:03 +00001165 sqlite3VdbeAddOp2(v, OP_Integer, 1, iMem);
danielk19779a96b662007-11-29 17:05:18 +00001166
1167 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
1168 eType = IN_INDEX_ROWID;
1169
1170 sqlite3VdbeJumpHere(v, iAddr);
1171 }else{
1172 /* The collation sequence used by the comparison. If an index is to
1173 ** be used in place of a temp-table, it must be ordered according
1174 ** to this collation sequence.
1175 */
1176 CollSeq *pReq = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pExpr);
1177
1178 /* Check that the affinity that will be used to perform the
1179 ** comparison is the same as the affinity of the column. If
1180 ** it is not, it is not possible to use any index.
1181 */
1182 Table *pTab = p->pSrc->a[0].pTab;
1183 char aff = comparisonAffinity(pX);
1184 int affinity_ok = (pTab->aCol[iCol].affinity==aff||aff==SQLITE_AFF_NONE);
1185
1186 for(pIdx=pTab->pIndex; pIdx && eType==0 && affinity_ok; pIdx=pIdx->pNext){
1187 if( (pIdx->aiColumn[0]==iCol)
1188 && (pReq==sqlite3FindCollSeq(db, ENC(db), pIdx->azColl[0], -1, 0))
1189 && (!mustBeUnique || (pIdx->nColumn==1 && pIdx->onError!=OE_None))
1190 ){
1191 int iDb;
drh0a07c102008-01-03 18:03:08 +00001192 int iMem = ++pParse->nMem;
danielk19779a96b662007-11-29 17:05:18 +00001193 int iAddr;
1194 char *pKey;
1195
1196 pKey = (char *)sqlite3IndexKeyinfo(pParse, pIdx);
1197 iDb = sqlite3SchemaToIndex(db, pIdx->pSchema);
1198 sqlite3VdbeUsesBtree(v, iDb);
1199
drh892d3172008-01-10 03:46:36 +00001200 iAddr = sqlite3VdbeAddOp1(v, OP_If, iMem);
drh4c583122008-01-04 22:01:03 +00001201 sqlite3VdbeAddOp2(v, OP_Integer, 1, iMem);
danielk19779a96b662007-11-29 17:05:18 +00001202
danielk1977cd3e8f72008-03-25 09:47:35 +00001203 sqlite3VdbeAddOp2(v, OP_SetNumColumns, 0, pIdx->nColumn);
danielk1977207872a2008-01-03 07:54:23 +00001204 sqlite3VdbeAddOp4(v, OP_OpenRead, iTab, pIdx->tnum, iDb,
drh66a51672008-01-03 00:01:23 +00001205 pKey,P4_KEYINFO_HANDOFF);
danielk1977207872a2008-01-03 07:54:23 +00001206 VdbeComment((v, "%s", pIdx->zName));
danielk19779a96b662007-11-29 17:05:18 +00001207 eType = IN_INDEX_INDEX;
danielk19779a96b662007-11-29 17:05:18 +00001208
1209 sqlite3VdbeJumpHere(v, iAddr);
danielk19770cdc0222008-06-26 18:04:03 +00001210 if( prNotFound && !pTab->aCol[iCol].notNull ){
1211 *prNotFound = ++pParse->nMem;
1212 }
danielk19779a96b662007-11-29 17:05:18 +00001213 }
1214 }
1215 }
1216 }
1217
1218 if( eType==0 ){
danielk19770cdc0222008-06-26 18:04:03 +00001219 int rMayHaveNull = 0;
1220 if( prNotFound ){
1221 *prNotFound = rMayHaveNull = ++pParse->nMem;
1222 }
1223 sqlite3CodeSubselect(pParse, pX, rMayHaveNull);
danielk19779a96b662007-11-29 17:05:18 +00001224 eType = IN_INDEX_EPH;
1225 }else{
1226 pX->iTable = iTab;
1227 }
1228 return eType;
1229}
danielk1977284f4ac2007-12-10 05:03:46 +00001230#endif
drh626a8792005-01-17 22:08:19 +00001231
1232/*
drh9cbe6352005-11-29 03:13:21 +00001233** Generate code for scalar subqueries used as an expression
1234** and IN operators. Examples:
drh626a8792005-01-17 22:08:19 +00001235**
drh9cbe6352005-11-29 03:13:21 +00001236** (SELECT a FROM b) -- subquery
1237** EXISTS (SELECT a FROM b) -- EXISTS subquery
1238** x IN (4,5,11) -- IN operator with list on right-hand side
1239** x IN (SELECT a FROM b) -- IN operator with subquery on the right
drhfef52082000-06-06 01:50:43 +00001240**
drh9cbe6352005-11-29 03:13:21 +00001241** The pExpr parameter describes the expression that contains the IN
1242** operator or subquery.
drhcce7d172000-05-31 15:34:51 +00001243*/
drh51522cd2005-01-20 13:36:19 +00001244#ifndef SQLITE_OMIT_SUBQUERY
danielk19770cdc0222008-06-26 18:04:03 +00001245void sqlite3CodeSubselect(Parse *pParse, Expr *pExpr, int rMayHaveNull){
drh57dbd7b2005-07-08 18:25:26 +00001246 int testAddr = 0; /* One-time test address */
danielk1977b3bce662005-01-29 08:32:43 +00001247 Vdbe *v = sqlite3GetVdbe(pParse);
1248 if( v==0 ) return;
1249
danielk1977fc976062007-05-10 10:46:56 +00001250
drh57dbd7b2005-07-08 18:25:26 +00001251 /* This code must be run in its entirety every time it is encountered
1252 ** if any of the following is true:
1253 **
1254 ** * The right-hand side is a correlated subquery
1255 ** * The right-hand side is an expression list containing variables
1256 ** * We are inside a trigger
1257 **
1258 ** If all of the above are false, then we can run this code just once
1259 ** save the results, and reuse the same result on subsequent invocations.
danielk1977b3bce662005-01-29 08:32:43 +00001260 */
1261 if( !ExprHasAnyProperty(pExpr, EP_VarSelect) && !pParse->trigStack ){
drh0a07c102008-01-03 18:03:08 +00001262 int mem = ++pParse->nMem;
drh892d3172008-01-10 03:46:36 +00001263 sqlite3VdbeAddOp1(v, OP_If, mem);
1264 testAddr = sqlite3VdbeAddOp2(v, OP_Integer, 1, mem);
drh17435752007-08-16 04:30:38 +00001265 assert( testAddr>0 || pParse->db->mallocFailed );
danielk1977b3bce662005-01-29 08:32:43 +00001266 }
1267
drhcce7d172000-05-31 15:34:51 +00001268 switch( pExpr->op ){
drhfef52082000-06-06 01:50:43 +00001269 case TK_IN: {
danielk1977e014a832004-05-17 10:48:57 +00001270 char affinity;
drhd3d39e92004-05-20 22:16:29 +00001271 KeyInfo keyInfo;
drhb9bb7c12006-06-11 23:41:55 +00001272 int addr; /* Address of OP_OpenEphemeral instruction */
drhd3d39e92004-05-20 22:16:29 +00001273
danielk19770cdc0222008-06-26 18:04:03 +00001274 if( rMayHaveNull ){
1275 sqlite3VdbeAddOp2(v, OP_Null, 0, rMayHaveNull);
1276 }
1277
danielk1977bf3b7212004-05-18 10:06:24 +00001278 affinity = sqlite3ExprAffinity(pExpr->pLeft);
danielk1977e014a832004-05-17 10:48:57 +00001279
1280 /* Whether this is an 'x IN(SELECT...)' or an 'x IN(<exprlist>)'
drh57dbd7b2005-07-08 18:25:26 +00001281 ** expression it is handled the same way. A virtual table is
danielk1977e014a832004-05-17 10:48:57 +00001282 ** filled with single-field index keys representing the results
1283 ** from the SELECT or the <exprlist>.
1284 **
1285 ** If the 'x' expression is a column value, or the SELECT...
1286 ** statement returns a column value, then the affinity of that
1287 ** column is used to build the index keys. If both 'x' and the
1288 ** SELECT... statement are columns, then numeric affinity is used
1289 ** if either column has NUMERIC or INTEGER affinity. If neither
1290 ** 'x' nor the SELECT... statement are columns, then numeric affinity
1291 ** is used.
1292 */
1293 pExpr->iTable = pParse->nTab++;
danielk1977cd3e8f72008-03-25 09:47:35 +00001294 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, 1);
drhd3d39e92004-05-20 22:16:29 +00001295 memset(&keyInfo, 0, sizeof(keyInfo));
1296 keyInfo.nField = 1;
danielk1977e014a832004-05-17 10:48:57 +00001297
drhfef52082000-06-06 01:50:43 +00001298 if( pExpr->pSelect ){
1299 /* Case 1: expr IN (SELECT ...)
1300 **
danielk1977e014a832004-05-17 10:48:57 +00001301 ** Generate code to write the results of the select into the temporary
1302 ** table allocated and opened above.
drhfef52082000-06-06 01:50:43 +00001303 */
drh1013c932008-01-06 00:25:21 +00001304 SelectDest dest;
drhbe5c89a2004-07-26 00:31:09 +00001305 ExprList *pEList;
drh1013c932008-01-06 00:25:21 +00001306
1307 sqlite3SelectDestInit(&dest, SRT_Set, pExpr->iTable);
1308 dest.affinity = (int)affinity;
danielk1977e014a832004-05-17 10:48:57 +00001309 assert( (pExpr->iTable&0x0000FFFF)==pExpr->iTable );
drh7d10d5a2008-08-20 16:35:10 +00001310 if( sqlite3Select(pParse, pExpr->pSelect, &dest) ){
drh94ccde52007-04-13 16:06:32 +00001311 return;
1312 }
drhbe5c89a2004-07-26 00:31:09 +00001313 pEList = pExpr->pSelect->pEList;
1314 if( pEList && pEList->nExpr>0 ){
danielk1977bcbb04e2007-05-29 12:11:29 +00001315 keyInfo.aColl[0] = sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft,
drhbe5c89a2004-07-26 00:31:09 +00001316 pEList->a[0].pExpr);
danielk19770202b292004-06-09 09:55:16 +00001317 }
drhfef52082000-06-06 01:50:43 +00001318 }else if( pExpr->pList ){
1319 /* Case 2: expr IN (exprlist)
1320 **
drhfd131da2007-08-07 17:13:03 +00001321 ** For each expression, build an index key from the evaluation and
danielk1977e014a832004-05-17 10:48:57 +00001322 ** store it in the temporary table. If <expr> is a column, then use
1323 ** that columns affinity when building index keys. If <expr> is not
1324 ** a column, use numeric affinity.
drhfef52082000-06-06 01:50:43 +00001325 */
danielk1977e014a832004-05-17 10:48:57 +00001326 int i;
drh57dbd7b2005-07-08 18:25:26 +00001327 ExprList *pList = pExpr->pList;
1328 struct ExprList_item *pItem;
drhecc31802008-06-26 20:06:06 +00001329 int r1, r2, r3;
drh57dbd7b2005-07-08 18:25:26 +00001330
danielk1977e014a832004-05-17 10:48:57 +00001331 if( !affinity ){
drh8159a352006-05-23 23:22:29 +00001332 affinity = SQLITE_AFF_NONE;
danielk1977e014a832004-05-17 10:48:57 +00001333 }
drh7d10d5a2008-08-20 16:35:10 +00001334 keyInfo.aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
danielk1977e014a832004-05-17 10:48:57 +00001335
1336 /* Loop through each expression in <exprlist>. */
drh2d401ab2008-01-10 23:50:11 +00001337 r1 = sqlite3GetTempReg(pParse);
1338 r2 = sqlite3GetTempReg(pParse);
drh57dbd7b2005-07-08 18:25:26 +00001339 for(i=pList->nExpr, pItem=pList->a; i>0; i--, pItem++){
1340 Expr *pE2 = pItem->pExpr;
danielk1977e014a832004-05-17 10:48:57 +00001341
drh57dbd7b2005-07-08 18:25:26 +00001342 /* If the expression is not constant then we will need to
1343 ** disable the test that was generated above that makes sure
1344 ** this code only executes once. Because for a non-constant
1345 ** expression we need to rerun this code each time.
1346 */
drh892d3172008-01-10 03:46:36 +00001347 if( testAddr && !sqlite3ExprIsConstant(pE2) ){
1348 sqlite3VdbeChangeToNoop(v, testAddr-1, 2);
drh57dbd7b2005-07-08 18:25:26 +00001349 testAddr = 0;
drh4794b982000-06-06 13:54:14 +00001350 }
danielk1977e014a832004-05-17 10:48:57 +00001351
1352 /* Evaluate the expression and insert it into the temp table */
drhe55cbd72008-03-31 23:48:03 +00001353 pParse->disableColCache++;
drhecc31802008-06-26 20:06:06 +00001354 r3 = sqlite3ExprCodeTarget(pParse, pE2, r1);
drhc5499be2008-04-01 15:06:33 +00001355 assert( pParse->disableColCache>0 );
drhe55cbd72008-03-31 23:48:03 +00001356 pParse->disableColCache--;
drhecc31802008-06-26 20:06:06 +00001357 sqlite3VdbeAddOp4(v, OP_MakeRecord, r3, 1, r2, &affinity, 1);
drh3c31fc22008-06-26 21:45:26 +00001358 sqlite3ExprCacheAffinityChange(pParse, r3, 1);
drh2d401ab2008-01-10 23:50:11 +00001359 sqlite3VdbeAddOp2(v, OP_IdxInsert, pExpr->iTable, r2);
drhfef52082000-06-06 01:50:43 +00001360 }
drh2d401ab2008-01-10 23:50:11 +00001361 sqlite3ReleaseTempReg(pParse, r1);
1362 sqlite3ReleaseTempReg(pParse, r2);
drhfef52082000-06-06 01:50:43 +00001363 }
drh66a51672008-01-03 00:01:23 +00001364 sqlite3VdbeChangeP4(v, addr, (void *)&keyInfo, P4_KEYINFO);
danielk1977b3bce662005-01-29 08:32:43 +00001365 break;
drhfef52082000-06-06 01:50:43 +00001366 }
1367
drh51522cd2005-01-20 13:36:19 +00001368 case TK_EXISTS:
drh19a775c2000-06-05 18:54:46 +00001369 case TK_SELECT: {
drhfef52082000-06-06 01:50:43 +00001370 /* This has to be a scalar SELECT. Generate code to put the
1371 ** value of this select in a memory cell and record the number
drh967e8b72000-06-21 13:59:10 +00001372 ** of the memory cell in iColumn.
drhfef52082000-06-06 01:50:43 +00001373 */
drh2646da72005-12-09 20:02:05 +00001374 static const Token one = { (u8*)"1", 0, 1 };
drh51522cd2005-01-20 13:36:19 +00001375 Select *pSel;
danielk19776c8c8ce2008-01-02 16:27:09 +00001376 SelectDest dest;
drh1398ad32005-01-19 23:24:50 +00001377
drh51522cd2005-01-20 13:36:19 +00001378 pSel = pExpr->pSelect;
drh1013c932008-01-06 00:25:21 +00001379 sqlite3SelectDestInit(&dest, 0, ++pParse->nMem);
drh51522cd2005-01-20 13:36:19 +00001380 if( pExpr->op==TK_SELECT ){
danielk19776c8c8ce2008-01-02 16:27:09 +00001381 dest.eDest = SRT_Mem;
drh4c583122008-01-04 22:01:03 +00001382 sqlite3VdbeAddOp2(v, OP_Null, 0, dest.iParm);
drhd4e70eb2008-01-02 00:34:36 +00001383 VdbeComment((v, "Init subquery result"));
drh51522cd2005-01-20 13:36:19 +00001384 }else{
danielk19776c8c8ce2008-01-02 16:27:09 +00001385 dest.eDest = SRT_Exists;
drh4c583122008-01-04 22:01:03 +00001386 sqlite3VdbeAddOp2(v, OP_Integer, 0, dest.iParm);
drhd4e70eb2008-01-02 00:34:36 +00001387 VdbeComment((v, "Init EXISTS result"));
drh51522cd2005-01-20 13:36:19 +00001388 }
drh633e6d52008-07-28 19:34:53 +00001389 sqlite3ExprDelete(pParse->db, pSel->pLimit);
danielk1977a1644fd2007-08-29 12:31:25 +00001390 pSel->pLimit = sqlite3PExpr(pParse, TK_INTEGER, 0, 0, &one);
drh7d10d5a2008-08-20 16:35:10 +00001391 if( sqlite3Select(pParse, pSel, &dest) ){
drh94ccde52007-04-13 16:06:32 +00001392 return;
1393 }
danielk19776c8c8ce2008-01-02 16:27:09 +00001394 pExpr->iColumn = dest.iParm;
danielk1977b3bce662005-01-29 08:32:43 +00001395 break;
drhcce7d172000-05-31 15:34:51 +00001396 }
1397 }
danielk1977b3bce662005-01-29 08:32:43 +00001398
drh57dbd7b2005-07-08 18:25:26 +00001399 if( testAddr ){
drh892d3172008-01-10 03:46:36 +00001400 sqlite3VdbeJumpHere(v, testAddr-1);
danielk1977b3bce662005-01-29 08:32:43 +00001401 }
danielk1977fc976062007-05-10 10:46:56 +00001402
danielk1977b3bce662005-01-29 08:32:43 +00001403 return;
drhcce7d172000-05-31 15:34:51 +00001404}
drh51522cd2005-01-20 13:36:19 +00001405#endif /* SQLITE_OMIT_SUBQUERY */
drhcce7d172000-05-31 15:34:51 +00001406
drhcce7d172000-05-31 15:34:51 +00001407/*
drh598f1342007-10-23 15:39:45 +00001408** Duplicate an 8-byte value
1409*/
1410static char *dup8bytes(Vdbe *v, const char *in){
1411 char *out = sqlite3DbMallocRaw(sqlite3VdbeDb(v), 8);
1412 if( out ){
1413 memcpy(out, in, 8);
1414 }
1415 return out;
1416}
1417
1418/*
1419** Generate an instruction that will put the floating point
drh9cbf3422008-01-17 16:22:13 +00001420** value described by z[0..n-1] into register iMem.
drh0cf19ed2007-10-23 18:55:48 +00001421**
1422** The z[] string will probably not be zero-terminated. But the
1423** z[n] character is guaranteed to be something that does not look
1424** like the continuation of the number.
drh598f1342007-10-23 15:39:45 +00001425*/
drh9de221d2008-01-05 06:51:30 +00001426static void codeReal(Vdbe *v, const char *z, int n, int negateFlag, int iMem){
drh598f1342007-10-23 15:39:45 +00001427 assert( z || v==0 || sqlite3VdbeDb(v)->mallocFailed );
1428 if( z ){
1429 double value;
1430 char *zV;
drh0cf19ed2007-10-23 18:55:48 +00001431 assert( !isdigit(z[n]) );
drh598f1342007-10-23 15:39:45 +00001432 sqlite3AtoF(z, &value);
drh2eaf93d2008-04-29 00:15:20 +00001433 if( sqlite3IsNaN(value) ){
1434 sqlite3VdbeAddOp2(v, OP_Null, 0, iMem);
1435 }else{
1436 if( negateFlag ) value = -value;
1437 zV = dup8bytes(v, (char*)&value);
1438 sqlite3VdbeAddOp4(v, OP_Real, 0, iMem, 0, zV, P4_REAL);
1439 }
drh598f1342007-10-23 15:39:45 +00001440 }
1441}
1442
1443
1444/*
drhfec19aa2004-05-19 20:41:03 +00001445** Generate an instruction that will put the integer describe by
drh9cbf3422008-01-17 16:22:13 +00001446** text z[0..n-1] into register iMem.
drh0cf19ed2007-10-23 18:55:48 +00001447**
1448** The z[] string will probably not be zero-terminated. But the
1449** z[n] character is guaranteed to be something that does not look
1450** like the continuation of the number.
drhfec19aa2004-05-19 20:41:03 +00001451*/
drh92b01d52008-06-24 00:32:35 +00001452static void codeInteger(Vdbe *v, Expr *pExpr, int negFlag, int iMem){
1453 const char *z;
1454 if( pExpr->flags & EP_IntValue ){
1455 int i = pExpr->iTable;
1456 if( negFlag ) i = -i;
1457 sqlite3VdbeAddOp2(v, OP_Integer, i, iMem);
1458 }else if( (z = (char*)pExpr->token.z)!=0 ){
danielk1977c9cf9012007-05-30 10:36:47 +00001459 int i;
drh92b01d52008-06-24 00:32:35 +00001460 int n = pExpr->token.n;
drh0cf19ed2007-10-23 18:55:48 +00001461 assert( !isdigit(z[n]) );
danielk1977c9cf9012007-05-30 10:36:47 +00001462 if( sqlite3GetInt32(z, &i) ){
drh9de221d2008-01-05 06:51:30 +00001463 if( negFlag ) i = -i;
1464 sqlite3VdbeAddOp2(v, OP_Integer, i, iMem);
1465 }else if( sqlite3FitsIn64Bits(z, negFlag) ){
drh598f1342007-10-23 15:39:45 +00001466 i64 value;
1467 char *zV;
1468 sqlite3Atoi64(z, &value);
drh9de221d2008-01-05 06:51:30 +00001469 if( negFlag ) value = -value;
drh598f1342007-10-23 15:39:45 +00001470 zV = dup8bytes(v, (char*)&value);
drh9de221d2008-01-05 06:51:30 +00001471 sqlite3VdbeAddOp4(v, OP_Int64, 0, iMem, 0, zV, P4_INT64);
danielk1977c9cf9012007-05-30 10:36:47 +00001472 }else{
drh9de221d2008-01-05 06:51:30 +00001473 codeReal(v, z, n, negFlag, iMem);
danielk1977c9cf9012007-05-30 10:36:47 +00001474 }
drhfec19aa2004-05-19 20:41:03 +00001475 }
1476}
1477
drh945498f2007-02-24 11:52:52 +00001478
1479/*
1480** Generate code that will extract the iColumn-th column from
drhe55cbd72008-03-31 23:48:03 +00001481** table pTab and store the column value in a register. An effort
1482** is made to store the column value in register iReg, but this is
1483** not guaranteed. The location of the column value is returned.
1484**
1485** There must be an open cursor to pTab in iTable when this routine
1486** is called. If iColumn<0 then code is generated that extracts the rowid.
drhda250ea2008-04-01 05:07:14 +00001487**
1488** This routine might attempt to reuse the value of the column that
1489** has already been loaded into a register. The value will always
1490** be used if it has not undergone any affinity changes. But if
1491** an affinity change has occurred, then the cached value will only be
1492** used if allowAffChng is true.
drh945498f2007-02-24 11:52:52 +00001493*/
drhe55cbd72008-03-31 23:48:03 +00001494int sqlite3ExprCodeGetColumn(
1495 Parse *pParse, /* Parsing and code generating context */
drh2133d822008-01-03 18:44:59 +00001496 Table *pTab, /* Description of the table we are reading from */
1497 int iColumn, /* Index of the table column */
1498 int iTable, /* The cursor pointing to the table */
drhda250ea2008-04-01 05:07:14 +00001499 int iReg, /* Store results here */
1500 int allowAffChng /* True if prior affinity changes are OK */
drh2133d822008-01-03 18:44:59 +00001501){
drhe55cbd72008-03-31 23:48:03 +00001502 Vdbe *v = pParse->pVdbe;
1503 int i;
drhda250ea2008-04-01 05:07:14 +00001504 struct yColCache *p;
drhe55cbd72008-03-31 23:48:03 +00001505
drhda250ea2008-04-01 05:07:14 +00001506 for(i=0, p=pParse->aColCache; i<pParse->nColCache; i++, p++){
1507 if( p->iTable==iTable && p->iColumn==iColumn
1508 && (!p->affChange || allowAffChng) ){
drhe55cbd72008-03-31 23:48:03 +00001509#if 0
1510 sqlite3VdbeAddOp0(v, OP_Noop);
drhda250ea2008-04-01 05:07:14 +00001511 VdbeComment((v, "OPT: tab%d.col%d -> r%d", iTable, iColumn, p->iReg));
drhe55cbd72008-03-31 23:48:03 +00001512#endif
drhda250ea2008-04-01 05:07:14 +00001513 return p->iReg;
drhe55cbd72008-03-31 23:48:03 +00001514 }
1515 }
1516 assert( v!=0 );
drh945498f2007-02-24 11:52:52 +00001517 if( iColumn<0 ){
1518 int op = (pTab && IsVirtual(pTab)) ? OP_VRowid : OP_Rowid;
drh2133d822008-01-03 18:44:59 +00001519 sqlite3VdbeAddOp2(v, op, iTable, iReg);
drh945498f2007-02-24 11:52:52 +00001520 }else if( pTab==0 ){
drh2133d822008-01-03 18:44:59 +00001521 sqlite3VdbeAddOp3(v, OP_Column, iTable, iColumn, iReg);
drh945498f2007-02-24 11:52:52 +00001522 }else{
1523 int op = IsVirtual(pTab) ? OP_VColumn : OP_Column;
drh2133d822008-01-03 18:44:59 +00001524 sqlite3VdbeAddOp3(v, op, iTable, iColumn, iReg);
drh945498f2007-02-24 11:52:52 +00001525 sqlite3ColumnDefault(v, pTab, iColumn);
1526#ifndef SQLITE_OMIT_FLOATING_POINT
1527 if( pTab->aCol[iColumn].affinity==SQLITE_AFF_REAL ){
drh2133d822008-01-03 18:44:59 +00001528 sqlite3VdbeAddOp1(v, OP_RealAffinity, iReg);
drh945498f2007-02-24 11:52:52 +00001529 }
1530#endif
1531 }
drhe55cbd72008-03-31 23:48:03 +00001532 if( pParse->disableColCache==0 ){
1533 i = pParse->iColCache;
drhda250ea2008-04-01 05:07:14 +00001534 p = &pParse->aColCache[i];
1535 p->iTable = iTable;
1536 p->iColumn = iColumn;
1537 p->iReg = iReg;
drhc5499be2008-04-01 15:06:33 +00001538 p->affChange = 0;
drhe55cbd72008-03-31 23:48:03 +00001539 i++;
drh2f7794c2008-04-01 03:27:39 +00001540 if( i>=ArraySize(pParse->aColCache) ) i = 0;
drhe55cbd72008-03-31 23:48:03 +00001541 if( i>pParse->nColCache ) pParse->nColCache = i;
drh2f7794c2008-04-01 03:27:39 +00001542 pParse->iColCache = i;
drhe55cbd72008-03-31 23:48:03 +00001543 }
1544 return iReg;
1545}
1546
1547/*
drhe55cbd72008-03-31 23:48:03 +00001548** Clear all column cache entries associated with the vdbe
1549** cursor with cursor number iTable.
1550*/
1551void sqlite3ExprClearColumnCache(Parse *pParse, int iTable){
1552 if( iTable<0 ){
1553 pParse->nColCache = 0;
1554 pParse->iColCache = 0;
1555 }else{
1556 int i;
1557 for(i=0; i<pParse->nColCache; i++){
1558 if( pParse->aColCache[i].iTable==iTable ){
drhc5499be2008-04-01 15:06:33 +00001559 testcase( i==pParse->nColCache-1 );
drhe55cbd72008-03-31 23:48:03 +00001560 pParse->aColCache[i] = pParse->aColCache[--pParse->nColCache];
drhda250ea2008-04-01 05:07:14 +00001561 pParse->iColCache = pParse->nColCache;
drhe55cbd72008-03-31 23:48:03 +00001562 }
1563 }
drhe55cbd72008-03-31 23:48:03 +00001564 }
1565}
1566
1567/*
drhda250ea2008-04-01 05:07:14 +00001568** Record the fact that an affinity change has occurred on iCount
1569** registers starting with iStart.
drhe55cbd72008-03-31 23:48:03 +00001570*/
drhda250ea2008-04-01 05:07:14 +00001571void sqlite3ExprCacheAffinityChange(Parse *pParse, int iStart, int iCount){
1572 int iEnd = iStart + iCount - 1;
drhe55cbd72008-03-31 23:48:03 +00001573 int i;
1574 for(i=0; i<pParse->nColCache; i++){
1575 int r = pParse->aColCache[i].iReg;
drhda250ea2008-04-01 05:07:14 +00001576 if( r>=iStart && r<=iEnd ){
1577 pParse->aColCache[i].affChange = 1;
drhe55cbd72008-03-31 23:48:03 +00001578 }
1579 }
drhe55cbd72008-03-31 23:48:03 +00001580}
1581
1582/*
drhb21e7c72008-06-22 12:37:57 +00001583** Generate code to move content from registers iFrom...iFrom+nReg-1
1584** over to iTo..iTo+nReg-1. Keep the column cache up-to-date.
drhe55cbd72008-03-31 23:48:03 +00001585*/
drhb21e7c72008-06-22 12:37:57 +00001586void sqlite3ExprCodeMove(Parse *pParse, int iFrom, int iTo, int nReg){
drhe55cbd72008-03-31 23:48:03 +00001587 int i;
1588 if( iFrom==iTo ) return;
drhb21e7c72008-06-22 12:37:57 +00001589 sqlite3VdbeAddOp3(pParse->pVdbe, OP_Move, iFrom, iTo, nReg);
drhe55cbd72008-03-31 23:48:03 +00001590 for(i=0; i<pParse->nColCache; i++){
drhb21e7c72008-06-22 12:37:57 +00001591 int x = pParse->aColCache[i].iReg;
1592 if( x>=iFrom && x<iFrom+nReg ){
1593 pParse->aColCache[i].iReg += iTo-iFrom;
drhe55cbd72008-03-31 23:48:03 +00001594 }
1595 }
drh945498f2007-02-24 11:52:52 +00001596}
1597
drhfec19aa2004-05-19 20:41:03 +00001598/*
drh92b01d52008-06-24 00:32:35 +00001599** Generate code to copy content from registers iFrom...iFrom+nReg-1
1600** over to iTo..iTo+nReg-1.
1601*/
1602void sqlite3ExprCodeCopy(Parse *pParse, int iFrom, int iTo, int nReg){
1603 int i;
1604 if( iFrom==iTo ) return;
1605 for(i=0; i<nReg; i++){
1606 sqlite3VdbeAddOp2(pParse->pVdbe, OP_Copy, iFrom+i, iTo+i);
1607 }
1608}
1609
1610/*
drh652fbf52008-04-01 01:42:41 +00001611** Return true if any register in the range iFrom..iTo (inclusive)
1612** is used as part of the column cache.
1613*/
1614static int usedAsColumnCache(Parse *pParse, int iFrom, int iTo){
1615 int i;
1616 for(i=0; i<pParse->nColCache; i++){
1617 int r = pParse->aColCache[i].iReg;
1618 if( r>=iFrom && r<=iTo ) return 1;
1619 }
1620 return 0;
1621}
1622
1623/*
1624** Theres is a value in register iCurrent. We ultimately want
1625** the value to be in register iTarget. It might be that
1626** iCurrent and iTarget are the same register.
1627**
1628** We are going to modify the value, so we need to make sure it
1629** is not a cached register. If iCurrent is a cached register,
1630** then try to move the value over to iTarget. If iTarget is a
1631** cached register, then clear the corresponding cache line.
1632**
1633** Return the register that the value ends up in.
1634*/
1635int sqlite3ExprWritableRegister(Parse *pParse, int iCurrent, int iTarget){
drhda250ea2008-04-01 05:07:14 +00001636 int i;
drh652fbf52008-04-01 01:42:41 +00001637 assert( pParse->pVdbe!=0 );
1638 if( !usedAsColumnCache(pParse, iCurrent, iCurrent) ){
1639 return iCurrent;
1640 }
drh2f7794c2008-04-01 03:27:39 +00001641 if( iCurrent!=iTarget ){
1642 sqlite3VdbeAddOp2(pParse->pVdbe, OP_SCopy, iCurrent, iTarget);
1643 }
drhda250ea2008-04-01 05:07:14 +00001644 for(i=0; i<pParse->nColCache; i++){
1645 if( pParse->aColCache[i].iReg==iTarget ){
1646 pParse->aColCache[i] = pParse->aColCache[--pParse->nColCache];
1647 pParse->iColCache = pParse->nColCache;
1648 }
1649 }
drh652fbf52008-04-01 01:42:41 +00001650 return iTarget;
1651}
1652
1653/*
drh191b54c2008-04-15 12:14:21 +00001654** If the last instruction coded is an ephemeral copy of any of
1655** the registers in the nReg registers beginning with iReg, then
1656** convert the last instruction from OP_SCopy to OP_Copy.
1657*/
1658void sqlite3ExprHardCopy(Parse *pParse, int iReg, int nReg){
1659 int addr;
1660 VdbeOp *pOp;
1661 Vdbe *v;
1662
1663 v = pParse->pVdbe;
1664 addr = sqlite3VdbeCurrentAddr(v);
1665 pOp = sqlite3VdbeGetOp(v, addr-1);
danielk1977d7eb2ed2008-04-24 12:36:35 +00001666 assert( pOp || pParse->db->mallocFailed );
1667 if( pOp && pOp->opcode==OP_SCopy && pOp->p1>=iReg && pOp->p1<iReg+nReg ){
drh191b54c2008-04-15 12:14:21 +00001668 pOp->opcode = OP_Copy;
1669 }
1670}
1671
1672/*
drhcce7d172000-05-31 15:34:51 +00001673** Generate code into the current Vdbe to evaluate the given
drh2dcef112008-01-12 19:03:48 +00001674** expression. Attempt to store the results in register "target".
1675** Return the register where results are stored.
drh389a1ad2008-01-03 23:44:53 +00001676**
drh2dcef112008-01-12 19:03:48 +00001677** With this routine, there is no guaranteed that results will
1678** be stored in target. The result might be stored in some other
1679** register if it is convenient to do so. The calling function
1680** must check the return code and move the results to the desired
1681** register.
drhcce7d172000-05-31 15:34:51 +00001682*/
drh678ccce2008-03-31 18:19:54 +00001683int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){
drh2dcef112008-01-12 19:03:48 +00001684 Vdbe *v = pParse->pVdbe; /* The VM under construction */
1685 int op; /* The opcode being coded */
1686 int inReg = target; /* Results stored in register inReg */
1687 int regFree1 = 0; /* If non-zero free this temporary register */
1688 int regFree2 = 0; /* If non-zero free this temporary register */
drh678ccce2008-03-31 18:19:54 +00001689 int r1, r2, r3, r4; /* Various register numbers */
drhffe07b22005-11-03 00:41:17 +00001690
drh389a1ad2008-01-03 23:44:53 +00001691 assert( v!=0 || pParse->db->mallocFailed );
drh9cbf3422008-01-17 16:22:13 +00001692 assert( target>0 && target<=pParse->nMem );
drh389a1ad2008-01-03 23:44:53 +00001693 if( v==0 ) return 0;
drh389a1ad2008-01-03 23:44:53 +00001694
1695 if( pExpr==0 ){
1696 op = TK_NULL;
1697 }else{
1698 op = pExpr->op;
1699 }
drhf2bc0132004-10-04 13:19:23 +00001700 switch( op ){
drh13449892005-09-07 21:22:45 +00001701 case TK_AGG_COLUMN: {
1702 AggInfo *pAggInfo = pExpr->pAggInfo;
1703 struct AggInfo_col *pCol = &pAggInfo->aCol[pExpr->iAgg];
1704 if( !pAggInfo->directMode ){
drh9de221d2008-01-05 06:51:30 +00001705 assert( pCol->iMem>0 );
1706 inReg = pCol->iMem;
drh13449892005-09-07 21:22:45 +00001707 break;
1708 }else if( pAggInfo->useSortingIdx ){
drh389a1ad2008-01-03 23:44:53 +00001709 sqlite3VdbeAddOp3(v, OP_Column, pAggInfo->sortingIdx,
1710 pCol->iSorterColumn, target);
drh13449892005-09-07 21:22:45 +00001711 break;
1712 }
1713 /* Otherwise, fall thru into the TK_COLUMN case */
1714 }
drh967e8b72000-06-21 13:59:10 +00001715 case TK_COLUMN: {
drhffe07b22005-11-03 00:41:17 +00001716 if( pExpr->iTable<0 ){
1717 /* This only happens when coding check constraints */
drhaa9b8962008-01-08 02:57:55 +00001718 assert( pParse->ckBase>0 );
1719 inReg = pExpr->iColumn + pParse->ckBase;
drhc4a3c772001-04-04 11:48:57 +00001720 }else{
drhc5499be2008-04-01 15:06:33 +00001721 testcase( (pExpr->flags & EP_AnyAff)!=0 );
drhe55cbd72008-03-31 23:48:03 +00001722 inReg = sqlite3ExprCodeGetColumn(pParse, pExpr->pTab,
drhda250ea2008-04-01 05:07:14 +00001723 pExpr->iColumn, pExpr->iTable, target,
1724 pExpr->flags & EP_AnyAff);
drh22827922000-06-06 17:27:05 +00001725 }
drhcce7d172000-05-31 15:34:51 +00001726 break;
1727 }
1728 case TK_INTEGER: {
drh92b01d52008-06-24 00:32:35 +00001729 codeInteger(v, pExpr, 0, target);
drhfec19aa2004-05-19 20:41:03 +00001730 break;
1731 }
drh598f1342007-10-23 15:39:45 +00001732 case TK_FLOAT: {
drh9de221d2008-01-05 06:51:30 +00001733 codeReal(v, (char*)pExpr->token.z, pExpr->token.n, 0, target);
drh598f1342007-10-23 15:39:45 +00001734 break;
1735 }
drhfec19aa2004-05-19 20:41:03 +00001736 case TK_STRING: {
danielk19771e536952007-08-16 10:09:01 +00001737 sqlite3DequoteExpr(pParse->db, pExpr);
drh9de221d2008-01-05 06:51:30 +00001738 sqlite3VdbeAddOp4(v,OP_String8, 0, target, 0,
drh66a51672008-01-03 00:01:23 +00001739 (char*)pExpr->token.z, pExpr->token.n);
drhcce7d172000-05-31 15:34:51 +00001740 break;
1741 }
drhf0863fe2005-06-12 21:35:51 +00001742 case TK_NULL: {
drh9de221d2008-01-05 06:51:30 +00001743 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
drhf0863fe2005-06-12 21:35:51 +00001744 break;
1745 }
danielk19775338a5f2005-01-20 13:03:10 +00001746#ifndef SQLITE_OMIT_BLOB_LITERAL
danielk1977c572ef72004-05-27 09:28:41 +00001747 case TK_BLOB: {
drh6c8c6ce2005-08-23 11:17:58 +00001748 int n;
1749 const char *z;
drhca48c902008-01-18 14:08:24 +00001750 char *zBlob;
1751 assert( pExpr->token.n>=3 );
1752 assert( pExpr->token.z[0]=='x' || pExpr->token.z[0]=='X' );
1753 assert( pExpr->token.z[1]=='\'' );
1754 assert( pExpr->token.z[pExpr->token.n-1]=='\'' );
drh6c8c6ce2005-08-23 11:17:58 +00001755 n = pExpr->token.n - 3;
drh2646da72005-12-09 20:02:05 +00001756 z = (char*)pExpr->token.z + 2;
drhca48c902008-01-18 14:08:24 +00001757 zBlob = sqlite3HexToBlob(sqlite3VdbeDb(v), z, n);
1758 sqlite3VdbeAddOp4(v, OP_Blob, n/2, target, 0, zBlob, P4_DYNAMIC);
danielk1977c572ef72004-05-27 09:28:41 +00001759 break;
1760 }
danielk19775338a5f2005-01-20 13:03:10 +00001761#endif
drh50457892003-09-06 01:10:47 +00001762 case TK_VARIABLE: {
drh9de221d2008-01-05 06:51:30 +00001763 sqlite3VdbeAddOp2(v, OP_Variable, pExpr->iTable, target);
drh895d7472004-08-20 16:02:39 +00001764 if( pExpr->token.n>1 ){
drh66a51672008-01-03 00:01:23 +00001765 sqlite3VdbeChangeP4(v, -1, (char*)pExpr->token.z, pExpr->token.n);
drh895d7472004-08-20 16:02:39 +00001766 }
drh50457892003-09-06 01:10:47 +00001767 break;
1768 }
drh4e0cff62004-11-05 05:10:28 +00001769 case TK_REGISTER: {
drh9de221d2008-01-05 06:51:30 +00001770 inReg = pExpr->iTable;
drh4e0cff62004-11-05 05:10:28 +00001771 break;
1772 }
drh487e2622005-06-25 18:42:14 +00001773#ifndef SQLITE_OMIT_CAST
1774 case TK_CAST: {
1775 /* Expressions of the form: CAST(pLeft AS token) */
danielk1977f0113002006-01-24 12:09:17 +00001776 int aff, to_op;
drh2dcef112008-01-12 19:03:48 +00001777 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
drh8a512562005-11-14 22:29:05 +00001778 aff = sqlite3AffinityType(&pExpr->token);
danielk1977f0113002006-01-24 12:09:17 +00001779 to_op = aff - SQLITE_AFF_TEXT + OP_ToText;
1780 assert( to_op==OP_ToText || aff!=SQLITE_AFF_TEXT );
1781 assert( to_op==OP_ToBlob || aff!=SQLITE_AFF_NONE );
1782 assert( to_op==OP_ToNumeric || aff!=SQLITE_AFF_NUMERIC );
1783 assert( to_op==OP_ToInt || aff!=SQLITE_AFF_INTEGER );
1784 assert( to_op==OP_ToReal || aff!=SQLITE_AFF_REAL );
drhc5499be2008-04-01 15:06:33 +00001785 testcase( to_op==OP_ToText );
1786 testcase( to_op==OP_ToBlob );
1787 testcase( to_op==OP_ToNumeric );
1788 testcase( to_op==OP_ToInt );
1789 testcase( to_op==OP_ToReal );
drh2dcef112008-01-12 19:03:48 +00001790 sqlite3VdbeAddOp1(v, to_op, inReg);
drhc5499be2008-04-01 15:06:33 +00001791 testcase( usedAsColumnCache(pParse, inReg, inReg) );
drhb3843a82008-04-01 12:24:11 +00001792 sqlite3ExprCacheAffinityChange(pParse, inReg, 1);
drh487e2622005-06-25 18:42:14 +00001793 break;
1794 }
1795#endif /* SQLITE_OMIT_CAST */
drhc9b84a12002-06-20 11:36:48 +00001796 case TK_LT:
1797 case TK_LE:
1798 case TK_GT:
1799 case TK_GE:
1800 case TK_NE:
1801 case TK_EQ: {
drhf2bc0132004-10-04 13:19:23 +00001802 assert( TK_LT==OP_Lt );
1803 assert( TK_LE==OP_Le );
1804 assert( TK_GT==OP_Gt );
1805 assert( TK_GE==OP_Ge );
1806 assert( TK_EQ==OP_Eq );
1807 assert( TK_NE==OP_Ne );
drhc5499be2008-04-01 15:06:33 +00001808 testcase( op==TK_LT );
1809 testcase( op==TK_LE );
1810 testcase( op==TK_GT );
1811 testcase( op==TK_GE );
1812 testcase( op==TK_EQ );
1813 testcase( op==TK_NE );
drhda250ea2008-04-01 05:07:14 +00001814 codeCompareOperands(pParse, pExpr->pLeft, &r1, &regFree1,
1815 pExpr->pRight, &r2, &regFree2);
drh35573352008-01-08 23:54:25 +00001816 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
1817 r1, r2, inReg, SQLITE_STOREP2);
drhc5499be2008-04-01 15:06:33 +00001818 testcase( regFree1==0 );
1819 testcase( regFree2==0 );
danielk1977a37cdde2004-05-16 11:15:36 +00001820 break;
drhc9b84a12002-06-20 11:36:48 +00001821 }
drhcce7d172000-05-31 15:34:51 +00001822 case TK_AND:
1823 case TK_OR:
1824 case TK_PLUS:
1825 case TK_STAR:
1826 case TK_MINUS:
drhbf4133c2001-10-13 02:59:08 +00001827 case TK_REM:
1828 case TK_BITAND:
1829 case TK_BITOR:
drh17c40292004-07-21 02:53:29 +00001830 case TK_SLASH:
drhbf4133c2001-10-13 02:59:08 +00001831 case TK_LSHIFT:
drh855eb1c2004-08-31 13:45:11 +00001832 case TK_RSHIFT:
drh00400772000-06-16 20:51:26 +00001833 case TK_CONCAT: {
drhf2bc0132004-10-04 13:19:23 +00001834 assert( TK_AND==OP_And );
1835 assert( TK_OR==OP_Or );
1836 assert( TK_PLUS==OP_Add );
1837 assert( TK_MINUS==OP_Subtract );
1838 assert( TK_REM==OP_Remainder );
1839 assert( TK_BITAND==OP_BitAnd );
1840 assert( TK_BITOR==OP_BitOr );
1841 assert( TK_SLASH==OP_Divide );
1842 assert( TK_LSHIFT==OP_ShiftLeft );
1843 assert( TK_RSHIFT==OP_ShiftRight );
1844 assert( TK_CONCAT==OP_Concat );
drhc5499be2008-04-01 15:06:33 +00001845 testcase( op==TK_AND );
1846 testcase( op==TK_OR );
1847 testcase( op==TK_PLUS );
1848 testcase( op==TK_MINUS );
1849 testcase( op==TK_REM );
1850 testcase( op==TK_BITAND );
1851 testcase( op==TK_BITOR );
1852 testcase( op==TK_SLASH );
1853 testcase( op==TK_LSHIFT );
1854 testcase( op==TK_RSHIFT );
1855 testcase( op==TK_CONCAT );
drh2dcef112008-01-12 19:03:48 +00001856 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
1857 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
drh5b6afba2008-01-05 16:29:28 +00001858 sqlite3VdbeAddOp3(v, op, r2, r1, target);
drhc5499be2008-04-01 15:06:33 +00001859 testcase( regFree1==0 );
1860 testcase( regFree2==0 );
drh00400772000-06-16 20:51:26 +00001861 break;
1862 }
drhcce7d172000-05-31 15:34:51 +00001863 case TK_UMINUS: {
drhfec19aa2004-05-19 20:41:03 +00001864 Expr *pLeft = pExpr->pLeft;
1865 assert( pLeft );
1866 if( pLeft->op==TK_FLOAT || pLeft->op==TK_INTEGER ){
drhfec19aa2004-05-19 20:41:03 +00001867 if( pLeft->op==TK_FLOAT ){
drh92b01d52008-06-24 00:32:35 +00001868 codeReal(v, (char*)pLeft->token.z, pLeft->token.n, 1, target);
drhe6840902002-03-06 03:08:25 +00001869 }else{
drh92b01d52008-06-24 00:32:35 +00001870 codeInteger(v, pLeft, 1, target);
drhe6840902002-03-06 03:08:25 +00001871 }
drh3c84ddf2008-01-09 02:15:38 +00001872 }else{
drh2dcef112008-01-12 19:03:48 +00001873 regFree1 = r1 = sqlite3GetTempReg(pParse);
drh3c84ddf2008-01-09 02:15:38 +00001874 sqlite3VdbeAddOp2(v, OP_Integer, 0, r1);
drhe55cbd72008-03-31 23:48:03 +00001875 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree2);
drh2dcef112008-01-12 19:03:48 +00001876 sqlite3VdbeAddOp3(v, OP_Subtract, r2, r1, target);
drhc5499be2008-04-01 15:06:33 +00001877 testcase( regFree2==0 );
drh6e142f52000-06-08 13:36:40 +00001878 }
drh3c84ddf2008-01-09 02:15:38 +00001879 inReg = target;
1880 break;
drh6e142f52000-06-08 13:36:40 +00001881 }
drhbf4133c2001-10-13 02:59:08 +00001882 case TK_BITNOT:
drh6e142f52000-06-08 13:36:40 +00001883 case TK_NOT: {
drhf2bc0132004-10-04 13:19:23 +00001884 assert( TK_BITNOT==OP_BitNot );
1885 assert( TK_NOT==OP_Not );
drhc5499be2008-04-01 15:06:33 +00001886 testcase( op==TK_BITNOT );
1887 testcase( op==TK_NOT );
drh2dcef112008-01-12 19:03:48 +00001888 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
drhc5499be2008-04-01 15:06:33 +00001889 testcase( inReg==target );
1890 testcase( usedAsColumnCache(pParse, inReg, inReg) );
drh652fbf52008-04-01 01:42:41 +00001891 inReg = sqlite3ExprWritableRegister(pParse, inReg, target);
drh2dcef112008-01-12 19:03:48 +00001892 sqlite3VdbeAddOp1(v, op, inReg);
drhcce7d172000-05-31 15:34:51 +00001893 break;
1894 }
1895 case TK_ISNULL:
1896 case TK_NOTNULL: {
drh6a288a32008-01-07 19:20:24 +00001897 int addr;
drhf2bc0132004-10-04 13:19:23 +00001898 assert( TK_ISNULL==OP_IsNull );
1899 assert( TK_NOTNULL==OP_NotNull );
drhc5499be2008-04-01 15:06:33 +00001900 testcase( op==TK_ISNULL );
1901 testcase( op==TK_NOTNULL );
drh9de221d2008-01-05 06:51:30 +00001902 sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
drh2dcef112008-01-12 19:03:48 +00001903 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
drhc5499be2008-04-01 15:06:33 +00001904 testcase( regFree1==0 );
drh2dcef112008-01-12 19:03:48 +00001905 addr = sqlite3VdbeAddOp1(v, op, r1);
drh9de221d2008-01-05 06:51:30 +00001906 sqlite3VdbeAddOp2(v, OP_AddImm, target, -1);
drh6a288a32008-01-07 19:20:24 +00001907 sqlite3VdbeJumpHere(v, addr);
drhf2bc0132004-10-04 13:19:23 +00001908 break;
drhcce7d172000-05-31 15:34:51 +00001909 }
drh22827922000-06-06 17:27:05 +00001910 case TK_AGG_FUNCTION: {
drh13449892005-09-07 21:22:45 +00001911 AggInfo *pInfo = pExpr->pAggInfo;
drh7e56e712005-11-16 12:53:15 +00001912 if( pInfo==0 ){
1913 sqlite3ErrorMsg(pParse, "misuse of aggregate: %T",
1914 &pExpr->span);
1915 }else{
drh9de221d2008-01-05 06:51:30 +00001916 inReg = pInfo->aFunc[pExpr->iAgg].iMem;
drh7e56e712005-11-16 12:53:15 +00001917 }
drh22827922000-06-06 17:27:05 +00001918 break;
1919 }
drhb71090f2005-05-23 17:26:51 +00001920 case TK_CONST_FUNC:
drhcce7d172000-05-31 15:34:51 +00001921 case TK_FUNCTION: {
drhcce7d172000-05-31 15:34:51 +00001922 ExprList *pList = pExpr->pList;
drh89425d52002-02-28 03:04:48 +00001923 int nExpr = pList ? pList->nExpr : 0;
drh0bce8352002-02-28 00:41:10 +00001924 FuncDef *pDef;
drh4b59ab52002-08-24 18:24:51 +00001925 int nId;
1926 const char *zId;
drh13449892005-09-07 21:22:45 +00001927 int constMask = 0;
danielk1977682f68b2004-06-05 10:22:17 +00001928 int i;
drh17435752007-08-16 04:30:38 +00001929 sqlite3 *db = pParse->db;
1930 u8 enc = ENC(db);
danielk1977dc1bdc42004-06-11 10:51:27 +00001931 CollSeq *pColl = 0;
drh17435752007-08-16 04:30:38 +00001932
drhc5499be2008-04-01 15:06:33 +00001933 testcase( op==TK_CONST_FUNC );
1934 testcase( op==TK_FUNCTION );
drh2646da72005-12-09 20:02:05 +00001935 zId = (char*)pExpr->token.z;
drhb71090f2005-05-23 17:26:51 +00001936 nId = pExpr->token.n;
danielk1977d8123362004-06-12 09:25:12 +00001937 pDef = sqlite3FindFunction(pParse->db, zId, nId, nExpr, enc, 0);
drh0bce8352002-02-28 00:41:10 +00001938 assert( pDef!=0 );
drh892d3172008-01-10 03:46:36 +00001939 if( pList ){
1940 nExpr = pList->nExpr;
drh2dcef112008-01-12 19:03:48 +00001941 r1 = sqlite3GetTempRange(pParse, nExpr);
drh191b54c2008-04-15 12:14:21 +00001942 sqlite3ExprCodeExprList(pParse, pList, r1, 1);
drh892d3172008-01-10 03:46:36 +00001943 }else{
drhd847eaa2008-01-17 17:15:56 +00001944 nExpr = r1 = 0;
drh892d3172008-01-10 03:46:36 +00001945 }
drhb7f6f682006-07-08 17:06:43 +00001946#ifndef SQLITE_OMIT_VIRTUALTABLE
drha43fa222006-07-08 18:41:37 +00001947 /* Possibly overload the function if the first argument is
1948 ** a virtual table column.
1949 **
1950 ** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the
1951 ** second argument, not the first, as the argument to test to
1952 ** see if it is a column in a virtual table. This is done because
1953 ** the left operand of infix functions (the operand we want to
1954 ** control overloading) ends up as the second argument to the
1955 ** function. The expression "A glob B" is equivalent to
1956 ** "glob(B,A). We want to use the A in "A glob B" to test
1957 ** for function overloading. But we use the B term in "glob(B,A)".
1958 */
drh6a03a1c2006-07-08 18:34:59 +00001959 if( nExpr>=2 && (pExpr->flags & EP_InfixFunc) ){
drh17435752007-08-16 04:30:38 +00001960 pDef = sqlite3VtabOverloadFunction(db, pDef, nExpr, pList->a[1].pExpr);
drh6a03a1c2006-07-08 18:34:59 +00001961 }else if( nExpr>0 ){
drh17435752007-08-16 04:30:38 +00001962 pDef = sqlite3VtabOverloadFunction(db, pDef, nExpr, pList->a[0].pExpr);
drhb7f6f682006-07-08 17:06:43 +00001963 }
1964#endif
danielk1977682f68b2004-06-05 10:22:17 +00001965 for(i=0; i<nExpr && i<32; i++){
danielk1977d02eb1f2004-06-06 09:44:03 +00001966 if( sqlite3ExprIsConstant(pList->a[i].pExpr) ){
drh13449892005-09-07 21:22:45 +00001967 constMask |= (1<<i);
danielk1977d02eb1f2004-06-06 09:44:03 +00001968 }
danielk1977dc1bdc42004-06-11 10:51:27 +00001969 if( pDef->needCollSeq && !pColl ){
1970 pColl = sqlite3ExprCollSeq(pParse, pList->a[i].pExpr);
1971 }
1972 }
1973 if( pDef->needCollSeq ){
1974 if( !pColl ) pColl = pParse->db->pDfltColl;
drh66a51672008-01-03 00:01:23 +00001975 sqlite3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ);
danielk1977682f68b2004-06-05 10:22:17 +00001976 }
drh2dcef112008-01-12 19:03:48 +00001977 sqlite3VdbeAddOp4(v, OP_Function, constMask, r1, target,
drh66a51672008-01-03 00:01:23 +00001978 (char*)pDef, P4_FUNCDEF);
drh98757152008-01-09 23:04:12 +00001979 sqlite3VdbeChangeP5(v, nExpr);
drh2dcef112008-01-12 19:03:48 +00001980 if( nExpr ){
1981 sqlite3ReleaseTempRange(pParse, r1, nExpr);
1982 }
drhda250ea2008-04-01 05:07:14 +00001983 sqlite3ExprCacheAffinityChange(pParse, r1, nExpr);
drhcce7d172000-05-31 15:34:51 +00001984 break;
1985 }
drhfe2093d2005-01-20 22:48:47 +00001986#ifndef SQLITE_OMIT_SUBQUERY
1987 case TK_EXISTS:
drh19a775c2000-06-05 18:54:46 +00001988 case TK_SELECT: {
drhc5499be2008-04-01 15:06:33 +00001989 testcase( op==TK_EXISTS );
1990 testcase( op==TK_SELECT );
drh41714d62006-03-02 04:44:23 +00001991 if( pExpr->iColumn==0 ){
danielk19770cdc0222008-06-26 18:04:03 +00001992 sqlite3CodeSubselect(pParse, pExpr, 0);
drh41714d62006-03-02 04:44:23 +00001993 }
drh9de221d2008-01-05 06:51:30 +00001994 inReg = pExpr->iColumn;
drh19a775c2000-06-05 18:54:46 +00001995 break;
1996 }
drhfef52082000-06-06 01:50:43 +00001997 case TK_IN: {
danielk19770cdc0222008-06-26 18:04:03 +00001998 int rNotFound = 0;
1999 int rMayHaveNull = 0;
drh6fccc352008-06-27 00:52:45 +00002000 int j2, j3, j4, j5;
drh94a11212004-09-25 13:12:14 +00002001 char affinity;
danielk19779a96b662007-11-29 17:05:18 +00002002 int eType;
danielk19779a96b662007-11-29 17:05:18 +00002003
drh3c31fc22008-06-26 21:45:26 +00002004 VdbeNoopComment((v, "begin IN expr r%d", target));
danielk19770cdc0222008-06-26 18:04:03 +00002005 eType = sqlite3FindInIndex(pParse, pExpr, &rMayHaveNull);
2006 if( rMayHaveNull ){
2007 rNotFound = ++pParse->nMem;
2008 }
danielk1977e014a832004-05-17 10:48:57 +00002009
2010 /* Figure out the affinity to use to create a key from the results
2011 ** of the expression. affinityStr stores a static string suitable for
drh66a51672008-01-03 00:01:23 +00002012 ** P4 of OP_MakeRecord.
danielk1977e014a832004-05-17 10:48:57 +00002013 */
drh94a11212004-09-25 13:12:14 +00002014 affinity = comparisonAffinity(pExpr);
danielk1977e014a832004-05-17 10:48:57 +00002015
danielk1977e014a832004-05-17 10:48:57 +00002016
2017 /* Code the <expr> from "<expr> IN (...)". The temporary table
2018 ** pExpr->iTable contains the values that make up the (...) set.
2019 */
drh66ba23c2008-06-27 00:47:28 +00002020 pParse->disableColCache++;
2021 sqlite3ExprCode(pParse, pExpr->pLeft, target);
2022 pParse->disableColCache--;
2023 j2 = sqlite3VdbeAddOp1(v, OP_IsNull, target);
danielk19779a96b662007-11-29 17:05:18 +00002024 if( eType==IN_INDEX_ROWID ){
drh66ba23c2008-06-27 00:47:28 +00002025 j3 = sqlite3VdbeAddOp1(v, OP_MustBeInt, target);
2026 j4 = sqlite3VdbeAddOp3(v, OP_NotExists, pExpr->iTable, 0, target);
2027 sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
drh6a288a32008-01-07 19:20:24 +00002028 j5 = sqlite3VdbeAddOp0(v, OP_Goto);
2029 sqlite3VdbeJumpHere(v, j3);
2030 sqlite3VdbeJumpHere(v, j4);
danielk19770cdc0222008-06-26 18:04:03 +00002031 sqlite3VdbeAddOp2(v, OP_Integer, 0, target);
danielk19779a96b662007-11-29 17:05:18 +00002032 }else{
drh2dcef112008-01-12 19:03:48 +00002033 r2 = regFree2 = sqlite3GetTempReg(pParse);
danielk19770cdc0222008-06-26 18:04:03 +00002034
2035 /* Create a record and test for set membership. If the set contains
2036 ** the value, then jump to the end of the test code. The target
2037 ** register still contains the true (1) value written to it earlier.
2038 */
drh66ba23c2008-06-27 00:47:28 +00002039 sqlite3VdbeAddOp4(v, OP_MakeRecord, target, 1, r2, &affinity, 1);
2040 sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
drh2dcef112008-01-12 19:03:48 +00002041 j5 = sqlite3VdbeAddOp3(v, OP_Found, pExpr->iTable, 0, r2);
danielk19770cdc0222008-06-26 18:04:03 +00002042
2043 /* If the set membership test fails, then the result of the
2044 ** "x IN (...)" expression must be either 0 or NULL. If the set
2045 ** contains no NULL values, then the result is 0. If the set
2046 ** contains one or more NULL values, then the result of the
2047 ** expression is also NULL.
2048 */
2049 if( rNotFound==0 ){
2050 /* This branch runs if it is known at compile time (now) that
2051 ** the set contains no NULL values. This happens as the result
2052 ** of a "NOT NULL" constraint in the database schema. No need
2053 ** to test the data structure at runtime in this case.
2054 */
2055 sqlite3VdbeAddOp2(v, OP_Integer, 0, target);
2056 }else{
2057 /* This block populates the rNotFound register with either NULL
2058 ** or 0 (an integer value). If the data structure contains one
2059 ** or more NULLs, then set rNotFound to NULL. Otherwise, set it
2060 ** to 0. If register rMayHaveNull is already set to some value
2061 ** other than NULL, then the test has already been run and
2062 ** rNotFound is already populated.
2063 */
drh66ba23c2008-06-27 00:47:28 +00002064 static const char nullRecord[] = { 0x02, 0x00 };
danielk19770cdc0222008-06-26 18:04:03 +00002065 j3 = sqlite3VdbeAddOp1(v, OP_NotNull, rMayHaveNull);
2066 sqlite3VdbeAddOp2(v, OP_Null, 0, rNotFound);
drh66ba23c2008-06-27 00:47:28 +00002067 sqlite3VdbeAddOp4(v, OP_Blob, 2, rMayHaveNull, 0,
2068 nullRecord, P4_STATIC);
2069 j4 = sqlite3VdbeAddOp3(v, OP_Found, pExpr->iTable, 0, rMayHaveNull);
danielk19770cdc0222008-06-26 18:04:03 +00002070 sqlite3VdbeAddOp2(v, OP_Integer, 0, rNotFound);
2071 sqlite3VdbeJumpHere(v, j4);
2072 sqlite3VdbeJumpHere(v, j3);
2073
2074 /* Copy the value of register rNotFound (which is either NULL or 0)
2075 ** into the target register. This will be the result of the
2076 ** expression.
2077 */
2078 sqlite3VdbeAddOp2(v, OP_Copy, rNotFound, target);
2079 }
danielk19779a96b662007-11-29 17:05:18 +00002080 }
drh6a288a32008-01-07 19:20:24 +00002081 sqlite3VdbeJumpHere(v, j2);
2082 sqlite3VdbeJumpHere(v, j5);
drh3c31fc22008-06-26 21:45:26 +00002083 VdbeComment((v, "end IN expr r%d", target));
drhfef52082000-06-06 01:50:43 +00002084 break;
2085 }
danielk197793758c82005-01-21 08:13:14 +00002086#endif
drh2dcef112008-01-12 19:03:48 +00002087 /*
2088 ** x BETWEEN y AND z
2089 **
2090 ** This is equivalent to
2091 **
2092 ** x>=y AND x<=z
2093 **
2094 ** X is stored in pExpr->pLeft.
2095 ** Y is stored in pExpr->pList->a[0].pExpr.
2096 ** Z is stored in pExpr->pList->a[1].pExpr.
2097 */
drhfef52082000-06-06 01:50:43 +00002098 case TK_BETWEEN: {
drhbe5c89a2004-07-26 00:31:09 +00002099 Expr *pLeft = pExpr->pLeft;
2100 struct ExprList_item *pLItem = pExpr->pList->a;
2101 Expr *pRight = pLItem->pExpr;
drh35573352008-01-08 23:54:25 +00002102
drhda250ea2008-04-01 05:07:14 +00002103 codeCompareOperands(pParse, pLeft, &r1, &regFree1,
2104 pRight, &r2, &regFree2);
drhc5499be2008-04-01 15:06:33 +00002105 testcase( regFree1==0 );
2106 testcase( regFree2==0 );
drh2dcef112008-01-12 19:03:48 +00002107 r3 = sqlite3GetTempReg(pParse);
drh678ccce2008-03-31 18:19:54 +00002108 r4 = sqlite3GetTempReg(pParse);
drh35573352008-01-08 23:54:25 +00002109 codeCompare(pParse, pLeft, pRight, OP_Ge,
2110 r1, r2, r3, SQLITE_STOREP2);
drhbe5c89a2004-07-26 00:31:09 +00002111 pLItem++;
2112 pRight = pLItem->pExpr;
drh2dcef112008-01-12 19:03:48 +00002113 sqlite3ReleaseTempReg(pParse, regFree2);
2114 r2 = sqlite3ExprCodeTemp(pParse, pRight, &regFree2);
drhc5499be2008-04-01 15:06:33 +00002115 testcase( regFree2==0 );
drh678ccce2008-03-31 18:19:54 +00002116 codeCompare(pParse, pLeft, pRight, OP_Le, r1, r2, r4, SQLITE_STOREP2);
2117 sqlite3VdbeAddOp3(v, OP_And, r3, r4, target);
drh2dcef112008-01-12 19:03:48 +00002118 sqlite3ReleaseTempReg(pParse, r3);
drh678ccce2008-03-31 18:19:54 +00002119 sqlite3ReleaseTempReg(pParse, r4);
drhfef52082000-06-06 01:50:43 +00002120 break;
2121 }
drh4f07e5f2007-05-14 11:34:46 +00002122 case TK_UPLUS: {
drh2dcef112008-01-12 19:03:48 +00002123 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
drha2e00042002-01-22 03:13:42 +00002124 break;
2125 }
drh2dcef112008-01-12 19:03:48 +00002126
2127 /*
2128 ** Form A:
2129 ** CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
2130 **
2131 ** Form B:
2132 ** CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
2133 **
2134 ** Form A is can be transformed into the equivalent form B as follows:
2135 ** CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ...
2136 ** WHEN x=eN THEN rN ELSE y END
2137 **
2138 ** X (if it exists) is in pExpr->pLeft.
2139 ** Y is in pExpr->pRight. The Y is also optional. If there is no
2140 ** ELSE clause and no other term matches, then the result of the
2141 ** exprssion is NULL.
2142 ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1].
2143 **
2144 ** The result of the expression is the Ri for the first matching Ei,
2145 ** or if there is no matching Ei, the ELSE term Y, or if there is
2146 ** no ELSE term, NULL.
2147 */
drh17a7f8d2002-03-24 13:13:27 +00002148 case TK_CASE: {
drh2dcef112008-01-12 19:03:48 +00002149 int endLabel; /* GOTO label for end of CASE stmt */
2150 int nextCase; /* GOTO label for next WHEN clause */
2151 int nExpr; /* 2x number of WHEN terms */
2152 int i; /* Loop counter */
2153 ExprList *pEList; /* List of WHEN terms */
2154 struct ExprList_item *aListelem; /* Array of WHEN terms */
2155 Expr opCompare; /* The X==Ei expression */
2156 Expr cacheX; /* Cached expression X */
2157 Expr *pX; /* The X expression */
2158 Expr *pTest; /* X==Ei (form A) or just Ei (form B) */
drh17a7f8d2002-03-24 13:13:27 +00002159
2160 assert(pExpr->pList);
2161 assert((pExpr->pList->nExpr % 2) == 0);
2162 assert(pExpr->pList->nExpr > 0);
drhbe5c89a2004-07-26 00:31:09 +00002163 pEList = pExpr->pList;
2164 aListelem = pEList->a;
2165 nExpr = pEList->nExpr;
drh2dcef112008-01-12 19:03:48 +00002166 endLabel = sqlite3VdbeMakeLabel(v);
2167 if( (pX = pExpr->pLeft)!=0 ){
2168 cacheX = *pX;
drhc5499be2008-04-01 15:06:33 +00002169 testcase( pX->op==TK_COLUMN || pX->op==TK_REGISTER );
drh2dcef112008-01-12 19:03:48 +00002170 cacheX.iTable = sqlite3ExprCodeTemp(pParse, pX, &regFree1);
drhc5499be2008-04-01 15:06:33 +00002171 testcase( regFree1==0 );
drh2dcef112008-01-12 19:03:48 +00002172 cacheX.op = TK_REGISTER;
2173 opCompare.op = TK_EQ;
2174 opCompare.pLeft = &cacheX;
2175 pTest = &opCompare;
drh17a7f8d2002-03-24 13:13:27 +00002176 }
drhc5499be2008-04-01 15:06:33 +00002177 pParse->disableColCache++;
drhf5905aa2002-05-26 20:54:33 +00002178 for(i=0; i<nExpr; i=i+2){
drh2dcef112008-01-12 19:03:48 +00002179 if( pX ){
2180 opCompare.pRight = aListelem[i].pExpr;
drh17a7f8d2002-03-24 13:13:27 +00002181 }else{
drh2dcef112008-01-12 19:03:48 +00002182 pTest = aListelem[i].pExpr;
drh17a7f8d2002-03-24 13:13:27 +00002183 }
drh2dcef112008-01-12 19:03:48 +00002184 nextCase = sqlite3VdbeMakeLabel(v);
drhc5499be2008-04-01 15:06:33 +00002185 testcase( pTest->op==TK_COLUMN || pTest->op==TK_REGISTER );
drh2dcef112008-01-12 19:03:48 +00002186 sqlite3ExprIfFalse(pParse, pTest, nextCase, SQLITE_JUMPIFNULL);
drhc5499be2008-04-01 15:06:33 +00002187 testcase( aListelem[i+1].pExpr->op==TK_COLUMN );
2188 testcase( aListelem[i+1].pExpr->op==TK_REGISTER );
drh9de221d2008-01-05 06:51:30 +00002189 sqlite3ExprCode(pParse, aListelem[i+1].pExpr, target);
drh2dcef112008-01-12 19:03:48 +00002190 sqlite3VdbeAddOp2(v, OP_Goto, 0, endLabel);
2191 sqlite3VdbeResolveLabel(v, nextCase);
drhf570f012002-05-31 15:51:25 +00002192 }
drh17a7f8d2002-03-24 13:13:27 +00002193 if( pExpr->pRight ){
drh9de221d2008-01-05 06:51:30 +00002194 sqlite3ExprCode(pParse, pExpr->pRight, target);
drh17a7f8d2002-03-24 13:13:27 +00002195 }else{
drh9de221d2008-01-05 06:51:30 +00002196 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
drh17a7f8d2002-03-24 13:13:27 +00002197 }
drh2dcef112008-01-12 19:03:48 +00002198 sqlite3VdbeResolveLabel(v, endLabel);
drhc5499be2008-04-01 15:06:33 +00002199 assert( pParse->disableColCache>0 );
2200 pParse->disableColCache--;
danielk19776f349032002-06-11 02:25:40 +00002201 break;
2202 }
danielk19775338a5f2005-01-20 13:03:10 +00002203#ifndef SQLITE_OMIT_TRIGGER
danielk19776f349032002-06-11 02:25:40 +00002204 case TK_RAISE: {
2205 if( !pParse->trigStack ){
danielk19774adee202004-05-08 08:23:19 +00002206 sqlite3ErrorMsg(pParse,
drhda93d232003-03-31 02:12:46 +00002207 "RAISE() may only be used within a trigger-program");
drh389a1ad2008-01-03 23:44:53 +00002208 return 0;
danielk19776f349032002-06-11 02:25:40 +00002209 }
drhad6d9462004-09-19 02:15:24 +00002210 if( pExpr->iColumn!=OE_Ignore ){
2211 assert( pExpr->iColumn==OE_Rollback ||
2212 pExpr->iColumn == OE_Abort ||
2213 pExpr->iColumn == OE_Fail );
danielk19771e536952007-08-16 10:09:01 +00002214 sqlite3DequoteExpr(pParse->db, pExpr);
drh66a51672008-01-03 00:01:23 +00002215 sqlite3VdbeAddOp4(v, OP_Halt, SQLITE_CONSTRAINT, pExpr->iColumn, 0,
drh2646da72005-12-09 20:02:05 +00002216 (char*)pExpr->token.z, pExpr->token.n);
danielk19776f349032002-06-11 02:25:40 +00002217 } else {
drhad6d9462004-09-19 02:15:24 +00002218 assert( pExpr->iColumn == OE_Ignore );
drh66a51672008-01-03 00:01:23 +00002219 sqlite3VdbeAddOp2(v, OP_ContextPop, 0, 0);
2220 sqlite3VdbeAddOp2(v, OP_Goto, 0, pParse->trigStack->ignoreJump);
drhd4e70eb2008-01-02 00:34:36 +00002221 VdbeComment((v, "raise(IGNORE)"));
danielk19776f349032002-06-11 02:25:40 +00002222 }
drhffe07b22005-11-03 00:41:17 +00002223 break;
drh17a7f8d2002-03-24 13:13:27 +00002224 }
danielk19775338a5f2005-01-20 13:03:10 +00002225#endif
drhffe07b22005-11-03 00:41:17 +00002226 }
drh2dcef112008-01-12 19:03:48 +00002227 sqlite3ReleaseTempReg(pParse, regFree1);
2228 sqlite3ReleaseTempReg(pParse, regFree2);
2229 return inReg;
2230}
2231
2232/*
2233** Generate code to evaluate an expression and store the results
2234** into a register. Return the register number where the results
2235** are stored.
2236**
2237** If the register is a temporary register that can be deallocated,
drh678ccce2008-03-31 18:19:54 +00002238** then write its number into *pReg. If the result register is not
drh2dcef112008-01-12 19:03:48 +00002239** a temporary, then set *pReg to zero.
2240*/
2241int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){
2242 int r1 = sqlite3GetTempReg(pParse);
2243 int r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
2244 if( r2==r1 ){
2245 *pReg = r1;
2246 }else{
2247 sqlite3ReleaseTempReg(pParse, r1);
2248 *pReg = 0;
2249 }
2250 return r2;
2251}
2252
2253/*
2254** Generate code that will evaluate expression pExpr and store the
2255** results in register target. The results are guaranteed to appear
2256** in register target.
2257*/
2258int sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){
drh9cbf3422008-01-17 16:22:13 +00002259 int inReg;
2260
2261 assert( target>0 && target<=pParse->nMem );
2262 inReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
drh0e359b32008-01-13 19:02:11 +00002263 assert( pParse->pVdbe || pParse->db->mallocFailed );
2264 if( inReg!=target && pParse->pVdbe ){
drh9cbf3422008-01-17 16:22:13 +00002265 sqlite3VdbeAddOp2(pParse->pVdbe, OP_SCopy, inReg, target);
drhcce7d172000-05-31 15:34:51 +00002266 }
drh389a1ad2008-01-03 23:44:53 +00002267 return target;
drhcce7d172000-05-31 15:34:51 +00002268}
2269
2270/*
drh2dcef112008-01-12 19:03:48 +00002271** Generate code that evalutes the given expression and puts the result
drhde4fcfd2008-01-19 23:50:26 +00002272** in register target.
drh25303782004-12-07 15:41:48 +00002273**
drh2dcef112008-01-12 19:03:48 +00002274** Also make a copy of the expression results into another "cache" register
2275** and modify the expression so that the next time it is evaluated,
2276** the result is a copy of the cache register.
2277**
2278** This routine is used for expressions that are used multiple
2279** times. They are evaluated once and the results of the expression
2280** are reused.
drh25303782004-12-07 15:41:48 +00002281*/
drh2dcef112008-01-12 19:03:48 +00002282int sqlite3ExprCodeAndCache(Parse *pParse, Expr *pExpr, int target){
drh25303782004-12-07 15:41:48 +00002283 Vdbe *v = pParse->pVdbe;
drh2dcef112008-01-12 19:03:48 +00002284 int inReg;
2285 inReg = sqlite3ExprCode(pParse, pExpr, target);
drhde4fcfd2008-01-19 23:50:26 +00002286 assert( target>0 );
drh2dcef112008-01-12 19:03:48 +00002287 if( pExpr->op!=TK_REGISTER ){
2288 int iMem;
drhde4fcfd2008-01-19 23:50:26 +00002289 iMem = ++pParse->nMem;
2290 sqlite3VdbeAddOp2(v, OP_Copy, inReg, iMem);
drh2dcef112008-01-12 19:03:48 +00002291 pExpr->iTable = iMem;
drh25303782004-12-07 15:41:48 +00002292 pExpr->op = TK_REGISTER;
2293 }
drh2dcef112008-01-12 19:03:48 +00002294 return inReg;
drh25303782004-12-07 15:41:48 +00002295}
drh2dcef112008-01-12 19:03:48 +00002296
drh678ccce2008-03-31 18:19:54 +00002297/*
drh47de9552008-04-01 18:04:11 +00002298** Return TRUE if pExpr is an constant expression that is appropriate
2299** for factoring out of a loop. Appropriate expressions are:
2300**
2301** * Any expression that evaluates to two or more opcodes.
2302**
2303** * Any OP_Integer, OP_Real, OP_String, OP_Blob, OP_Null,
2304** or OP_Variable that does not need to be placed in a
2305** specific register.
2306**
2307** There is no point in factoring out single-instruction constant
2308** expressions that need to be placed in a particular register.
2309** We could factor them out, but then we would end up adding an
2310** OP_SCopy instruction to move the value into the correct register
2311** later. We might as well just use the original instruction and
2312** avoid the OP_SCopy.
2313*/
2314static int isAppropriateForFactoring(Expr *p){
2315 if( !sqlite3ExprIsConstantNotJoin(p) ){
2316 return 0; /* Only constant expressions are appropriate for factoring */
2317 }
2318 if( (p->flags & EP_FixedDest)==0 ){
2319 return 1; /* Any constant without a fixed destination is appropriate */
2320 }
2321 while( p->op==TK_UPLUS ) p = p->pLeft;
2322 switch( p->op ){
2323#ifndef SQLITE_OMIT_BLOB_LITERAL
2324 case TK_BLOB:
2325#endif
2326 case TK_VARIABLE:
2327 case TK_INTEGER:
2328 case TK_FLOAT:
2329 case TK_NULL:
2330 case TK_STRING: {
2331 testcase( p->op==TK_BLOB );
2332 testcase( p->op==TK_VARIABLE );
2333 testcase( p->op==TK_INTEGER );
2334 testcase( p->op==TK_FLOAT );
2335 testcase( p->op==TK_NULL );
2336 testcase( p->op==TK_STRING );
2337 /* Single-instruction constants with a fixed destination are
2338 ** better done in-line. If we factor them, they will just end
2339 ** up generating an OP_SCopy to move the value to the destination
2340 ** register. */
2341 return 0;
2342 }
2343 case TK_UMINUS: {
2344 if( p->pLeft->op==TK_FLOAT || p->pLeft->op==TK_INTEGER ){
2345 return 0;
2346 }
2347 break;
2348 }
2349 default: {
2350 break;
2351 }
2352 }
2353 return 1;
2354}
2355
2356/*
2357** If pExpr is a constant expression that is appropriate for
2358** factoring out of a loop, then evaluate the expression
drh678ccce2008-03-31 18:19:54 +00002359** into a register and convert the expression into a TK_REGISTER
2360** expression.
2361*/
drh7d10d5a2008-08-20 16:35:10 +00002362static int evalConstExpr(Walker *pWalker, Expr *pExpr){
2363 Parse *pParse = pWalker->pParse;
drh47de9552008-04-01 18:04:11 +00002364 switch( pExpr->op ){
2365 case TK_REGISTER: {
2366 return 1;
2367 }
2368 case TK_FUNCTION:
2369 case TK_AGG_FUNCTION:
2370 case TK_CONST_FUNC: {
2371 /* The arguments to a function have a fixed destination.
2372 ** Mark them this way to avoid generated unneeded OP_SCopy
2373 ** instructions.
2374 */
2375 ExprList *pList = pExpr->pList;
2376 if( pList ){
2377 int i = pList->nExpr;
2378 struct ExprList_item *pItem = pList->a;
2379 for(; i>0; i--, pItem++){
2380 if( pItem->pExpr ) pItem->pExpr->flags |= EP_FixedDest;
2381 }
2382 }
2383 break;
2384 }
drh678ccce2008-03-31 18:19:54 +00002385 }
drh47de9552008-04-01 18:04:11 +00002386 if( isAppropriateForFactoring(pExpr) ){
drh678ccce2008-03-31 18:19:54 +00002387 int r1 = ++pParse->nMem;
2388 int r2;
2389 r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
drhc5499be2008-04-01 15:06:33 +00002390 if( r1!=r2 ) sqlite3ReleaseTempReg(pParse, r1);
drh678ccce2008-03-31 18:19:54 +00002391 pExpr->op = TK_REGISTER;
2392 pExpr->iTable = r2;
drh7d10d5a2008-08-20 16:35:10 +00002393 return WRC_Prune;
drh678ccce2008-03-31 18:19:54 +00002394 }
drh7d10d5a2008-08-20 16:35:10 +00002395 return WRC_Continue;
drh678ccce2008-03-31 18:19:54 +00002396}
2397
2398/*
2399** Preevaluate constant subexpressions within pExpr and store the
2400** results in registers. Modify pExpr so that the constant subexpresions
2401** are TK_REGISTER opcodes that refer to the precomputed values.
2402*/
2403void sqlite3ExprCodeConstants(Parse *pParse, Expr *pExpr){
drh7d10d5a2008-08-20 16:35:10 +00002404 Walker w;
2405 w.xExprCallback = evalConstExpr;
2406 w.xSelectCallback = 0;
2407 w.pParse = pParse;
2408 sqlite3WalkExpr(&w, pExpr);
drh678ccce2008-03-31 18:19:54 +00002409}
2410
drh25303782004-12-07 15:41:48 +00002411
2412/*
drh268380c2004-02-25 13:47:31 +00002413** Generate code that pushes the value of every element of the given
drh9cbf3422008-01-17 16:22:13 +00002414** expression list into a sequence of registers beginning at target.
drh268380c2004-02-25 13:47:31 +00002415**
drh892d3172008-01-10 03:46:36 +00002416** Return the number of elements evaluated.
drh268380c2004-02-25 13:47:31 +00002417*/
danielk19774adee202004-05-08 08:23:19 +00002418int sqlite3ExprCodeExprList(
drh268380c2004-02-25 13:47:31 +00002419 Parse *pParse, /* Parsing context */
drh389a1ad2008-01-03 23:44:53 +00002420 ExprList *pList, /* The expression list to be coded */
drh191b54c2008-04-15 12:14:21 +00002421 int target, /* Where to write results */
2422 int doHardCopy /* Call sqlite3ExprHardCopy on each element if true */
drh268380c2004-02-25 13:47:31 +00002423){
2424 struct ExprList_item *pItem;
drh9cbf3422008-01-17 16:22:13 +00002425 int i, n;
drh892d3172008-01-10 03:46:36 +00002426 assert( pList!=0 || pParse->db->mallocFailed );
2427 if( pList==0 ){
2428 return 0;
2429 }
drh9cbf3422008-01-17 16:22:13 +00002430 assert( target>0 );
drh268380c2004-02-25 13:47:31 +00002431 n = pList->nExpr;
drh191b54c2008-04-15 12:14:21 +00002432 for(pItem=pList->a, i=0; i<n; i++, pItem++){
2433 sqlite3ExprCode(pParse, pItem->pExpr, target+i);
2434 if( doHardCopy ) sqlite3ExprHardCopy(pParse, target, n);
drh268380c2004-02-25 13:47:31 +00002435 }
drhf9b596e2004-05-26 16:54:42 +00002436 return n;
drh268380c2004-02-25 13:47:31 +00002437}
2438
2439/*
drhcce7d172000-05-31 15:34:51 +00002440** Generate code for a boolean expression such that a jump is made
2441** to the label "dest" if the expression is true but execution
2442** continues straight thru if the expression is false.
drhf5905aa2002-05-26 20:54:33 +00002443**
2444** If the expression evaluates to NULL (neither true nor false), then
drh35573352008-01-08 23:54:25 +00002445** take the jump if the jumpIfNull flag is SQLITE_JUMPIFNULL.
drhf2bc0132004-10-04 13:19:23 +00002446**
2447** This code depends on the fact that certain token values (ex: TK_EQ)
2448** are the same as opcode values (ex: OP_Eq) that implement the corresponding
2449** operation. Special comments in vdbe.c and the mkopcodeh.awk script in
2450** the make process cause these values to align. Assert()s in the code
2451** below verify that the numbers are aligned correctly.
drhcce7d172000-05-31 15:34:51 +00002452*/
danielk19774adee202004-05-08 08:23:19 +00002453void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
drhcce7d172000-05-31 15:34:51 +00002454 Vdbe *v = pParse->pVdbe;
2455 int op = 0;
drh2dcef112008-01-12 19:03:48 +00002456 int regFree1 = 0;
2457 int regFree2 = 0;
2458 int r1, r2;
2459
drh35573352008-01-08 23:54:25 +00002460 assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 );
drhdaffd0e2001-04-11 14:28:42 +00002461 if( v==0 || pExpr==0 ) return;
drhf2bc0132004-10-04 13:19:23 +00002462 op = pExpr->op;
2463 switch( op ){
drhcce7d172000-05-31 15:34:51 +00002464 case TK_AND: {
danielk19774adee202004-05-08 08:23:19 +00002465 int d2 = sqlite3VdbeMakeLabel(v);
drhc5499be2008-04-01 15:06:33 +00002466 testcase( jumpIfNull==0 );
2467 testcase( pParse->disableColCache==0 );
drh35573352008-01-08 23:54:25 +00002468 sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2,jumpIfNull^SQLITE_JUMPIFNULL);
drhe55cbd72008-03-31 23:48:03 +00002469 pParse->disableColCache++;
danielk19774adee202004-05-08 08:23:19 +00002470 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
drhc5499be2008-04-01 15:06:33 +00002471 assert( pParse->disableColCache>0 );
drhe55cbd72008-03-31 23:48:03 +00002472 pParse->disableColCache--;
danielk19774adee202004-05-08 08:23:19 +00002473 sqlite3VdbeResolveLabel(v, d2);
drhcce7d172000-05-31 15:34:51 +00002474 break;
2475 }
2476 case TK_OR: {
drhc5499be2008-04-01 15:06:33 +00002477 testcase( jumpIfNull==0 );
2478 testcase( pParse->disableColCache==0 );
danielk19774adee202004-05-08 08:23:19 +00002479 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
drhe55cbd72008-03-31 23:48:03 +00002480 pParse->disableColCache++;
danielk19774adee202004-05-08 08:23:19 +00002481 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
drhc5499be2008-04-01 15:06:33 +00002482 assert( pParse->disableColCache>0 );
drhe55cbd72008-03-31 23:48:03 +00002483 pParse->disableColCache--;
drhcce7d172000-05-31 15:34:51 +00002484 break;
2485 }
2486 case TK_NOT: {
drhc5499be2008-04-01 15:06:33 +00002487 testcase( jumpIfNull==0 );
danielk19774adee202004-05-08 08:23:19 +00002488 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
drhcce7d172000-05-31 15:34:51 +00002489 break;
2490 }
2491 case TK_LT:
2492 case TK_LE:
2493 case TK_GT:
2494 case TK_GE:
2495 case TK_NE:
drh0ac65892002-04-20 14:24:41 +00002496 case TK_EQ: {
drhf2bc0132004-10-04 13:19:23 +00002497 assert( TK_LT==OP_Lt );
2498 assert( TK_LE==OP_Le );
2499 assert( TK_GT==OP_Gt );
2500 assert( TK_GE==OP_Ge );
2501 assert( TK_EQ==OP_Eq );
2502 assert( TK_NE==OP_Ne );
drhc5499be2008-04-01 15:06:33 +00002503 testcase( op==TK_LT );
2504 testcase( op==TK_LE );
2505 testcase( op==TK_GT );
2506 testcase( op==TK_GE );
2507 testcase( op==TK_EQ );
2508 testcase( op==TK_NE );
2509 testcase( jumpIfNull==0 );
drhda250ea2008-04-01 05:07:14 +00002510 codeCompareOperands(pParse, pExpr->pLeft, &r1, &regFree1,
2511 pExpr->pRight, &r2, &regFree2);
drh35573352008-01-08 23:54:25 +00002512 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
drh2dcef112008-01-12 19:03:48 +00002513 r1, r2, dest, jumpIfNull);
drhc5499be2008-04-01 15:06:33 +00002514 testcase( regFree1==0 );
2515 testcase( regFree2==0 );
drhcce7d172000-05-31 15:34:51 +00002516 break;
2517 }
2518 case TK_ISNULL:
2519 case TK_NOTNULL: {
drhf2bc0132004-10-04 13:19:23 +00002520 assert( TK_ISNULL==OP_IsNull );
2521 assert( TK_NOTNULL==OP_NotNull );
drhc5499be2008-04-01 15:06:33 +00002522 testcase( op==TK_ISNULL );
2523 testcase( op==TK_NOTNULL );
drh2dcef112008-01-12 19:03:48 +00002524 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
2525 sqlite3VdbeAddOp2(v, op, r1, dest);
drhc5499be2008-04-01 15:06:33 +00002526 testcase( regFree1==0 );
drhcce7d172000-05-31 15:34:51 +00002527 break;
2528 }
drhfef52082000-06-06 01:50:43 +00002529 case TK_BETWEEN: {
drh2dcef112008-01-12 19:03:48 +00002530 /* x BETWEEN y AND z
danielk19770202b292004-06-09 09:55:16 +00002531 **
drh2dcef112008-01-12 19:03:48 +00002532 ** Is equivalent to
2533 **
2534 ** x>=y AND x<=z
2535 **
2536 ** Code it as such, taking care to do the common subexpression
2537 ** elementation of x.
danielk19770202b292004-06-09 09:55:16 +00002538 */
drh2dcef112008-01-12 19:03:48 +00002539 Expr exprAnd;
2540 Expr compLeft;
2541 Expr compRight;
2542 Expr exprX;
danielk19770202b292004-06-09 09:55:16 +00002543
drh2dcef112008-01-12 19:03:48 +00002544 exprX = *pExpr->pLeft;
2545 exprAnd.op = TK_AND;
2546 exprAnd.pLeft = &compLeft;
2547 exprAnd.pRight = &compRight;
2548 compLeft.op = TK_GE;
2549 compLeft.pLeft = &exprX;
2550 compLeft.pRight = pExpr->pList->a[0].pExpr;
2551 compRight.op = TK_LE;
2552 compRight.pLeft = &exprX;
2553 compRight.pRight = pExpr->pList->a[1].pExpr;
2554 exprX.iTable = sqlite3ExprCodeTemp(pParse, &exprX, &regFree1);
drhc5499be2008-04-01 15:06:33 +00002555 testcase( regFree1==0 );
drh2dcef112008-01-12 19:03:48 +00002556 exprX.op = TK_REGISTER;
drhc5499be2008-04-01 15:06:33 +00002557 testcase( jumpIfNull==0 );
drh2dcef112008-01-12 19:03:48 +00002558 sqlite3ExprIfTrue(pParse, &exprAnd, dest, jumpIfNull);
drhfef52082000-06-06 01:50:43 +00002559 break;
2560 }
drhcce7d172000-05-31 15:34:51 +00002561 default: {
drh2dcef112008-01-12 19:03:48 +00002562 r1 = sqlite3ExprCodeTemp(pParse, pExpr, &regFree1);
2563 sqlite3VdbeAddOp3(v, OP_If, r1, dest, jumpIfNull!=0);
drhc5499be2008-04-01 15:06:33 +00002564 testcase( regFree1==0 );
2565 testcase( jumpIfNull==0 );
drhcce7d172000-05-31 15:34:51 +00002566 break;
2567 }
2568 }
drh2dcef112008-01-12 19:03:48 +00002569 sqlite3ReleaseTempReg(pParse, regFree1);
2570 sqlite3ReleaseTempReg(pParse, regFree2);
drhcce7d172000-05-31 15:34:51 +00002571}
2572
2573/*
drh66b89c82000-11-28 20:47:17 +00002574** Generate code for a boolean expression such that a jump is made
drhcce7d172000-05-31 15:34:51 +00002575** to the label "dest" if the expression is false but execution
2576** continues straight thru if the expression is true.
drhf5905aa2002-05-26 20:54:33 +00002577**
2578** If the expression evaluates to NULL (neither true nor false) then
drh35573352008-01-08 23:54:25 +00002579** jump if jumpIfNull is SQLITE_JUMPIFNULL or fall through if jumpIfNull
2580** is 0.
drhcce7d172000-05-31 15:34:51 +00002581*/
danielk19774adee202004-05-08 08:23:19 +00002582void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
drhcce7d172000-05-31 15:34:51 +00002583 Vdbe *v = pParse->pVdbe;
2584 int op = 0;
drh2dcef112008-01-12 19:03:48 +00002585 int regFree1 = 0;
2586 int regFree2 = 0;
2587 int r1, r2;
2588
drh35573352008-01-08 23:54:25 +00002589 assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 );
drhdaffd0e2001-04-11 14:28:42 +00002590 if( v==0 || pExpr==0 ) return;
drhf2bc0132004-10-04 13:19:23 +00002591
2592 /* The value of pExpr->op and op are related as follows:
2593 **
2594 ** pExpr->op op
2595 ** --------- ----------
2596 ** TK_ISNULL OP_NotNull
2597 ** TK_NOTNULL OP_IsNull
2598 ** TK_NE OP_Eq
2599 ** TK_EQ OP_Ne
2600 ** TK_GT OP_Le
2601 ** TK_LE OP_Gt
2602 ** TK_GE OP_Lt
2603 ** TK_LT OP_Ge
2604 **
2605 ** For other values of pExpr->op, op is undefined and unused.
2606 ** The value of TK_ and OP_ constants are arranged such that we
2607 ** can compute the mapping above using the following expression.
2608 ** Assert()s verify that the computation is correct.
2609 */
2610 op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1);
2611
2612 /* Verify correct alignment of TK_ and OP_ constants
2613 */
2614 assert( pExpr->op!=TK_ISNULL || op==OP_NotNull );
2615 assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull );
2616 assert( pExpr->op!=TK_NE || op==OP_Eq );
2617 assert( pExpr->op!=TK_EQ || op==OP_Ne );
2618 assert( pExpr->op!=TK_LT || op==OP_Ge );
2619 assert( pExpr->op!=TK_LE || op==OP_Gt );
2620 assert( pExpr->op!=TK_GT || op==OP_Le );
2621 assert( pExpr->op!=TK_GE || op==OP_Lt );
2622
drhcce7d172000-05-31 15:34:51 +00002623 switch( pExpr->op ){
2624 case TK_AND: {
drhc5499be2008-04-01 15:06:33 +00002625 testcase( jumpIfNull==0 );
2626 testcase( pParse->disableColCache==0 );
danielk19774adee202004-05-08 08:23:19 +00002627 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
drhe55cbd72008-03-31 23:48:03 +00002628 pParse->disableColCache++;
danielk19774adee202004-05-08 08:23:19 +00002629 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
drhc5499be2008-04-01 15:06:33 +00002630 assert( pParse->disableColCache>0 );
drhe55cbd72008-03-31 23:48:03 +00002631 pParse->disableColCache--;
drhcce7d172000-05-31 15:34:51 +00002632 break;
2633 }
2634 case TK_OR: {
danielk19774adee202004-05-08 08:23:19 +00002635 int d2 = sqlite3VdbeMakeLabel(v);
drhc5499be2008-04-01 15:06:33 +00002636 testcase( jumpIfNull==0 );
2637 testcase( pParse->disableColCache==0 );
drh35573352008-01-08 23:54:25 +00002638 sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2, jumpIfNull^SQLITE_JUMPIFNULL);
drhe55cbd72008-03-31 23:48:03 +00002639 pParse->disableColCache++;
danielk19774adee202004-05-08 08:23:19 +00002640 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
drhc5499be2008-04-01 15:06:33 +00002641 assert( pParse->disableColCache>0 );
drhe55cbd72008-03-31 23:48:03 +00002642 pParse->disableColCache--;
danielk19774adee202004-05-08 08:23:19 +00002643 sqlite3VdbeResolveLabel(v, d2);
drhcce7d172000-05-31 15:34:51 +00002644 break;
2645 }
2646 case TK_NOT: {
danielk19774adee202004-05-08 08:23:19 +00002647 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
drhcce7d172000-05-31 15:34:51 +00002648 break;
2649 }
2650 case TK_LT:
2651 case TK_LE:
2652 case TK_GT:
2653 case TK_GE:
2654 case TK_NE:
2655 case TK_EQ: {
drhc5499be2008-04-01 15:06:33 +00002656 testcase( op==TK_LT );
2657 testcase( op==TK_LE );
2658 testcase( op==TK_GT );
2659 testcase( op==TK_GE );
2660 testcase( op==TK_EQ );
2661 testcase( op==TK_NE );
2662 testcase( jumpIfNull==0 );
drhda250ea2008-04-01 05:07:14 +00002663 codeCompareOperands(pParse, pExpr->pLeft, &r1, &regFree1,
2664 pExpr->pRight, &r2, &regFree2);
drh35573352008-01-08 23:54:25 +00002665 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
drh2dcef112008-01-12 19:03:48 +00002666 r1, r2, dest, jumpIfNull);
drhc5499be2008-04-01 15:06:33 +00002667 testcase( regFree1==0 );
2668 testcase( regFree2==0 );
drhcce7d172000-05-31 15:34:51 +00002669 break;
2670 }
drhcce7d172000-05-31 15:34:51 +00002671 case TK_ISNULL:
2672 case TK_NOTNULL: {
drhc5499be2008-04-01 15:06:33 +00002673 testcase( op==TK_ISNULL );
2674 testcase( op==TK_NOTNULL );
drh2dcef112008-01-12 19:03:48 +00002675 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
2676 sqlite3VdbeAddOp2(v, op, r1, dest);
drhc5499be2008-04-01 15:06:33 +00002677 testcase( regFree1==0 );
drhcce7d172000-05-31 15:34:51 +00002678 break;
2679 }
drhfef52082000-06-06 01:50:43 +00002680 case TK_BETWEEN: {
drh2dcef112008-01-12 19:03:48 +00002681 /* x BETWEEN y AND z
danielk19770202b292004-06-09 09:55:16 +00002682 **
drh2dcef112008-01-12 19:03:48 +00002683 ** Is equivalent to
2684 **
2685 ** x>=y AND x<=z
2686 **
2687 ** Code it as such, taking care to do the common subexpression
2688 ** elementation of x.
danielk19770202b292004-06-09 09:55:16 +00002689 */
drh2dcef112008-01-12 19:03:48 +00002690 Expr exprAnd;
2691 Expr compLeft;
2692 Expr compRight;
2693 Expr exprX;
drhbe5c89a2004-07-26 00:31:09 +00002694
drh2dcef112008-01-12 19:03:48 +00002695 exprX = *pExpr->pLeft;
2696 exprAnd.op = TK_AND;
2697 exprAnd.pLeft = &compLeft;
2698 exprAnd.pRight = &compRight;
2699 compLeft.op = TK_GE;
2700 compLeft.pLeft = &exprX;
2701 compLeft.pRight = pExpr->pList->a[0].pExpr;
2702 compRight.op = TK_LE;
2703 compRight.pLeft = &exprX;
2704 compRight.pRight = pExpr->pList->a[1].pExpr;
2705 exprX.iTable = sqlite3ExprCodeTemp(pParse, &exprX, &regFree1);
drhc5499be2008-04-01 15:06:33 +00002706 testcase( regFree1==0 );
drh2dcef112008-01-12 19:03:48 +00002707 exprX.op = TK_REGISTER;
drhc5499be2008-04-01 15:06:33 +00002708 testcase( jumpIfNull==0 );
drh2dcef112008-01-12 19:03:48 +00002709 sqlite3ExprIfFalse(pParse, &exprAnd, dest, jumpIfNull);
drhfef52082000-06-06 01:50:43 +00002710 break;
2711 }
drhcce7d172000-05-31 15:34:51 +00002712 default: {
drh2dcef112008-01-12 19:03:48 +00002713 r1 = sqlite3ExprCodeTemp(pParse, pExpr, &regFree1);
2714 sqlite3VdbeAddOp3(v, OP_IfNot, r1, dest, jumpIfNull!=0);
drhc5499be2008-04-01 15:06:33 +00002715 testcase( regFree1==0 );
2716 testcase( jumpIfNull==0 );
drhcce7d172000-05-31 15:34:51 +00002717 break;
2718 }
2719 }
drh2dcef112008-01-12 19:03:48 +00002720 sqlite3ReleaseTempReg(pParse, regFree1);
2721 sqlite3ReleaseTempReg(pParse, regFree2);
drhcce7d172000-05-31 15:34:51 +00002722}
drh22827922000-06-06 17:27:05 +00002723
2724/*
2725** Do a deep comparison of two expression trees. Return TRUE (non-zero)
2726** if they are identical and return FALSE if they differ in any way.
drhd40aab02007-02-24 15:29:03 +00002727**
2728** Sometimes this routine will return FALSE even if the two expressions
2729** really are equivalent. If we cannot prove that the expressions are
2730** identical, we return FALSE just to be safe. So if this routine
2731** returns false, then you do not really know for certain if the two
2732** expressions are the same. But if you get a TRUE return, then you
2733** can be sure the expressions are the same. In the places where
2734** this routine is used, it does not hurt to get an extra FALSE - that
2735** just might result in some slightly slower code. But returning
2736** an incorrect TRUE could lead to a malfunction.
drh22827922000-06-06 17:27:05 +00002737*/
danielk19774adee202004-05-08 08:23:19 +00002738int sqlite3ExprCompare(Expr *pA, Expr *pB){
drh22827922000-06-06 17:27:05 +00002739 int i;
danielk19774b202ae2006-01-23 05:50:58 +00002740 if( pA==0||pB==0 ){
2741 return pB==pA;
drh22827922000-06-06 17:27:05 +00002742 }
2743 if( pA->op!=pB->op ) return 0;
drhfd357972005-09-09 01:33:19 +00002744 if( (pA->flags & EP_Distinct)!=(pB->flags & EP_Distinct) ) return 0;
danielk19774adee202004-05-08 08:23:19 +00002745 if( !sqlite3ExprCompare(pA->pLeft, pB->pLeft) ) return 0;
2746 if( !sqlite3ExprCompare(pA->pRight, pB->pRight) ) return 0;
drh22827922000-06-06 17:27:05 +00002747 if( pA->pList ){
2748 if( pB->pList==0 ) return 0;
2749 if( pA->pList->nExpr!=pB->pList->nExpr ) return 0;
2750 for(i=0; i<pA->pList->nExpr; i++){
danielk19774adee202004-05-08 08:23:19 +00002751 if( !sqlite3ExprCompare(pA->pList->a[i].pExpr, pB->pList->a[i].pExpr) ){
drh22827922000-06-06 17:27:05 +00002752 return 0;
2753 }
2754 }
2755 }else if( pB->pList ){
2756 return 0;
2757 }
2758 if( pA->pSelect || pB->pSelect ) return 0;
drh2f2c01e2002-07-02 13:05:04 +00002759 if( pA->iTable!=pB->iTable || pA->iColumn!=pB->iColumn ) return 0;
drhdd735212007-02-24 13:53:05 +00002760 if( pA->op!=TK_COLUMN && pA->token.z ){
drh22827922000-06-06 17:27:05 +00002761 if( pB->token.z==0 ) return 0;
drh6977fea2002-10-22 23:38:04 +00002762 if( pB->token.n!=pA->token.n ) return 0;
drh2646da72005-12-09 20:02:05 +00002763 if( sqlite3StrNICmp((char*)pA->token.z,(char*)pB->token.z,pB->token.n)!=0 ){
2764 return 0;
2765 }
drh22827922000-06-06 17:27:05 +00002766 }
2767 return 1;
2768}
2769
drh13449892005-09-07 21:22:45 +00002770
drh22827922000-06-06 17:27:05 +00002771/*
drh13449892005-09-07 21:22:45 +00002772** Add a new element to the pAggInfo->aCol[] array. Return the index of
2773** the new element. Return a negative number if malloc fails.
drh22827922000-06-06 17:27:05 +00002774*/
drh17435752007-08-16 04:30:38 +00002775static int addAggInfoColumn(sqlite3 *db, AggInfo *pInfo){
drh13449892005-09-07 21:22:45 +00002776 int i;
drhcf643722007-03-27 13:36:37 +00002777 pInfo->aCol = sqlite3ArrayAllocate(
drh17435752007-08-16 04:30:38 +00002778 db,
drhcf643722007-03-27 13:36:37 +00002779 pInfo->aCol,
2780 sizeof(pInfo->aCol[0]),
2781 3,
2782 &pInfo->nColumn,
2783 &pInfo->nColumnAlloc,
2784 &i
2785 );
drh13449892005-09-07 21:22:45 +00002786 return i;
2787}
2788
2789/*
2790** Add a new element to the pAggInfo->aFunc[] array. Return the index of
2791** the new element. Return a negative number if malloc fails.
2792*/
drh17435752007-08-16 04:30:38 +00002793static int addAggInfoFunc(sqlite3 *db, AggInfo *pInfo){
drh13449892005-09-07 21:22:45 +00002794 int i;
drhcf643722007-03-27 13:36:37 +00002795 pInfo->aFunc = sqlite3ArrayAllocate(
drh17435752007-08-16 04:30:38 +00002796 db,
drhcf643722007-03-27 13:36:37 +00002797 pInfo->aFunc,
2798 sizeof(pInfo->aFunc[0]),
2799 3,
2800 &pInfo->nFunc,
2801 &pInfo->nFuncAlloc,
2802 &i
2803 );
drh13449892005-09-07 21:22:45 +00002804 return i;
2805}
drh22827922000-06-06 17:27:05 +00002806
2807/*
drh7d10d5a2008-08-20 16:35:10 +00002808** This is the xExprCallback for a tree walker. It is used to
2809** implement sqlite3ExprAnalyzeAggregates(). See sqlite3ExprAnalyzeAggregates
drh626a8792005-01-17 22:08:19 +00002810** for additional information.
drh22827922000-06-06 17:27:05 +00002811*/
drh7d10d5a2008-08-20 16:35:10 +00002812static int analyzeAggregate(Walker *pWalker, Expr *pExpr){
drh22827922000-06-06 17:27:05 +00002813 int i;
drh7d10d5a2008-08-20 16:35:10 +00002814 NameContext *pNC = pWalker->u.pNC;
danielk1977a58fdfb2005-02-08 07:50:40 +00002815 Parse *pParse = pNC->pParse;
2816 SrcList *pSrcList = pNC->pSrcList;
drh13449892005-09-07 21:22:45 +00002817 AggInfo *pAggInfo = pNC->pAggInfo;
drh22827922000-06-06 17:27:05 +00002818
drh22827922000-06-06 17:27:05 +00002819 switch( pExpr->op ){
drh89c69d02007-01-04 01:20:28 +00002820 case TK_AGG_COLUMN:
drh967e8b72000-06-21 13:59:10 +00002821 case TK_COLUMN: {
drh13449892005-09-07 21:22:45 +00002822 /* Check to see if the column is in one of the tables in the FROM
2823 ** clause of the aggregate query */
2824 if( pSrcList ){
2825 struct SrcList_item *pItem = pSrcList->a;
2826 for(i=0; i<pSrcList->nSrc; i++, pItem++){
2827 struct AggInfo_col *pCol;
2828 if( pExpr->iTable==pItem->iCursor ){
2829 /* If we reach this point, it means that pExpr refers to a table
2830 ** that is in the FROM clause of the aggregate query.
2831 **
2832 ** Make an entry for the column in pAggInfo->aCol[] if there
2833 ** is not an entry there already.
2834 */
drh7f906d62007-03-12 23:48:52 +00002835 int k;
drh13449892005-09-07 21:22:45 +00002836 pCol = pAggInfo->aCol;
drh7f906d62007-03-12 23:48:52 +00002837 for(k=0; k<pAggInfo->nColumn; k++, pCol++){
drh13449892005-09-07 21:22:45 +00002838 if( pCol->iTable==pExpr->iTable &&
2839 pCol->iColumn==pExpr->iColumn ){
2840 break;
2841 }
danielk1977a58fdfb2005-02-08 07:50:40 +00002842 }
danielk19771e536952007-08-16 10:09:01 +00002843 if( (k>=pAggInfo->nColumn)
2844 && (k = addAggInfoColumn(pParse->db, pAggInfo))>=0
2845 ){
drh7f906d62007-03-12 23:48:52 +00002846 pCol = &pAggInfo->aCol[k];
danielk19770817d0d2007-02-14 09:19:36 +00002847 pCol->pTab = pExpr->pTab;
drh13449892005-09-07 21:22:45 +00002848 pCol->iTable = pExpr->iTable;
2849 pCol->iColumn = pExpr->iColumn;
drh0a07c102008-01-03 18:03:08 +00002850 pCol->iMem = ++pParse->nMem;
drh13449892005-09-07 21:22:45 +00002851 pCol->iSorterColumn = -1;
drh5774b802005-09-07 22:48:16 +00002852 pCol->pExpr = pExpr;
drh13449892005-09-07 21:22:45 +00002853 if( pAggInfo->pGroupBy ){
2854 int j, n;
2855 ExprList *pGB = pAggInfo->pGroupBy;
2856 struct ExprList_item *pTerm = pGB->a;
2857 n = pGB->nExpr;
2858 for(j=0; j<n; j++, pTerm++){
2859 Expr *pE = pTerm->pExpr;
2860 if( pE->op==TK_COLUMN && pE->iTable==pExpr->iTable &&
2861 pE->iColumn==pExpr->iColumn ){
2862 pCol->iSorterColumn = j;
2863 break;
2864 }
2865 }
2866 }
2867 if( pCol->iSorterColumn<0 ){
2868 pCol->iSorterColumn = pAggInfo->nSortingColumn++;
2869 }
2870 }
2871 /* There is now an entry for pExpr in pAggInfo->aCol[] (either
2872 ** because it was there before or because we just created it).
2873 ** Convert the pExpr to be a TK_AGG_COLUMN referring to that
2874 ** pAggInfo->aCol[] entry.
2875 */
2876 pExpr->pAggInfo = pAggInfo;
2877 pExpr->op = TK_AGG_COLUMN;
drh7f906d62007-03-12 23:48:52 +00002878 pExpr->iAgg = k;
drh13449892005-09-07 21:22:45 +00002879 break;
2880 } /* endif pExpr->iTable==pItem->iCursor */
2881 } /* end loop over pSrcList */
drh22827922000-06-06 17:27:05 +00002882 }
drh7d10d5a2008-08-20 16:35:10 +00002883 return WRC_Prune;
drh22827922000-06-06 17:27:05 +00002884 }
2885 case TK_AGG_FUNCTION: {
drh13449892005-09-07 21:22:45 +00002886 /* The pNC->nDepth==0 test causes aggregate functions in subqueries
2887 ** to be ignored */
danielk1977a58fdfb2005-02-08 07:50:40 +00002888 if( pNC->nDepth==0 ){
drh13449892005-09-07 21:22:45 +00002889 /* Check to see if pExpr is a duplicate of another aggregate
2890 ** function that is already in the pAggInfo structure
2891 */
2892 struct AggInfo_func *pItem = pAggInfo->aFunc;
2893 for(i=0; i<pAggInfo->nFunc; i++, pItem++){
2894 if( sqlite3ExprCompare(pItem->pExpr, pExpr) ){
danielk1977a58fdfb2005-02-08 07:50:40 +00002895 break;
2896 }
drh22827922000-06-06 17:27:05 +00002897 }
drh13449892005-09-07 21:22:45 +00002898 if( i>=pAggInfo->nFunc ){
2899 /* pExpr is original. Make a new entry in pAggInfo->aFunc[]
2900 */
danielk197714db2662006-01-09 16:12:04 +00002901 u8 enc = ENC(pParse->db);
danielk19771e536952007-08-16 10:09:01 +00002902 i = addAggInfoFunc(pParse->db, pAggInfo);
drh13449892005-09-07 21:22:45 +00002903 if( i>=0 ){
2904 pItem = &pAggInfo->aFunc[i];
2905 pItem->pExpr = pExpr;
drh0a07c102008-01-03 18:03:08 +00002906 pItem->iMem = ++pParse->nMem;
drh13449892005-09-07 21:22:45 +00002907 pItem->pFunc = sqlite3FindFunction(pParse->db,
drh2646da72005-12-09 20:02:05 +00002908 (char*)pExpr->token.z, pExpr->token.n,
drh13449892005-09-07 21:22:45 +00002909 pExpr->pList ? pExpr->pList->nExpr : 0, enc, 0);
drhfd357972005-09-09 01:33:19 +00002910 if( pExpr->flags & EP_Distinct ){
2911 pItem->iDistinct = pParse->nTab++;
2912 }else{
2913 pItem->iDistinct = -1;
2914 }
drh13449892005-09-07 21:22:45 +00002915 }
danielk1977a58fdfb2005-02-08 07:50:40 +00002916 }
drh13449892005-09-07 21:22:45 +00002917 /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry
2918 */
danielk1977a58fdfb2005-02-08 07:50:40 +00002919 pExpr->iAgg = i;
drh13449892005-09-07 21:22:45 +00002920 pExpr->pAggInfo = pAggInfo;
drh7d10d5a2008-08-20 16:35:10 +00002921 return WRC_Prune;
drh22827922000-06-06 17:27:05 +00002922 }
drh22827922000-06-06 17:27:05 +00002923 }
2924 }
drh7d10d5a2008-08-20 16:35:10 +00002925 return WRC_Continue;
2926}
2927static int analyzeAggregatesInSelect(Walker *pWalker, Select *pSelect){
2928 NameContext *pNC = pWalker->u.pNC;
2929 if( pNC->nDepth==0 ){
danielk1977a58fdfb2005-02-08 07:50:40 +00002930 pNC->nDepth++;
drh7d10d5a2008-08-20 16:35:10 +00002931 sqlite3WalkSelect(pWalker, pSelect);
danielk1977a58fdfb2005-02-08 07:50:40 +00002932 pNC->nDepth--;
drh7d10d5a2008-08-20 16:35:10 +00002933 return WRC_Prune;
2934 }else{
2935 return WRC_Continue;
danielk1977a58fdfb2005-02-08 07:50:40 +00002936 }
drh626a8792005-01-17 22:08:19 +00002937}
2938
2939/*
2940** Analyze the given expression looking for aggregate functions and
2941** for variables that need to be added to the pParse->aAgg[] array.
2942** Make additional entries to the pParse->aAgg[] array as necessary.
2943**
2944** This routine should only be called after the expression has been
drh7d10d5a2008-08-20 16:35:10 +00002945** analyzed by sqlite3ResolveExprNames().
drh626a8792005-01-17 22:08:19 +00002946*/
drhd2b3e232008-01-23 14:51:49 +00002947void sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){
drh7d10d5a2008-08-20 16:35:10 +00002948 Walker w;
2949 w.xExprCallback = analyzeAggregate;
2950 w.xSelectCallback = analyzeAggregatesInSelect;
2951 w.u.pNC = pNC;
2952 sqlite3WalkExpr(&w, pExpr);
drh22827922000-06-06 17:27:05 +00002953}
drh5d9a4af2005-08-30 00:54:01 +00002954
2955/*
2956** Call sqlite3ExprAnalyzeAggregates() for every expression in an
2957** expression list. Return the number of errors.
2958**
2959** If an error is found, the analysis is cut short.
2960*/
drhd2b3e232008-01-23 14:51:49 +00002961void sqlite3ExprAnalyzeAggList(NameContext *pNC, ExprList *pList){
drh5d9a4af2005-08-30 00:54:01 +00002962 struct ExprList_item *pItem;
2963 int i;
drh5d9a4af2005-08-30 00:54:01 +00002964 if( pList ){
drhd2b3e232008-01-23 14:51:49 +00002965 for(pItem=pList->a, i=0; i<pList->nExpr; i++, pItem++){
2966 sqlite3ExprAnalyzeAggregates(pNC, pItem->pExpr);
drh5d9a4af2005-08-30 00:54:01 +00002967 }
2968 }
drh5d9a4af2005-08-30 00:54:01 +00002969}
drh892d3172008-01-10 03:46:36 +00002970
2971/*
2972** Allocate or deallocate temporary use registers during code generation.
2973*/
2974int sqlite3GetTempReg(Parse *pParse){
drhe55cbd72008-03-31 23:48:03 +00002975 if( pParse->nTempReg==0 ){
drh892d3172008-01-10 03:46:36 +00002976 return ++pParse->nMem;
2977 }
danielk19772f425f62008-07-04 09:41:39 +00002978 return pParse->aTempReg[--pParse->nTempReg];
drh892d3172008-01-10 03:46:36 +00002979}
2980void sqlite3ReleaseTempReg(Parse *pParse, int iReg){
drh2dcef112008-01-12 19:03:48 +00002981 if( iReg && pParse->nTempReg<ArraySize(pParse->aTempReg) ){
danielk1977a7d8b852008-07-04 09:15:11 +00002982 sqlite3ExprWritableRegister(pParse, iReg, iReg);
drh892d3172008-01-10 03:46:36 +00002983 pParse->aTempReg[pParse->nTempReg++] = iReg;
2984 }
2985}
2986
2987/*
2988** Allocate or deallocate a block of nReg consecutive registers
2989*/
2990int sqlite3GetTempRange(Parse *pParse, int nReg){
drhe55cbd72008-03-31 23:48:03 +00002991 int i, n;
2992 i = pParse->iRangeReg;
2993 n = pParse->nRangeReg;
2994 if( nReg<=n && !usedAsColumnCache(pParse, i, i+n-1) ){
drh892d3172008-01-10 03:46:36 +00002995 pParse->iRangeReg += nReg;
2996 pParse->nRangeReg -= nReg;
2997 }else{
2998 i = pParse->nMem+1;
2999 pParse->nMem += nReg;
3000 }
3001 return i;
3002}
3003void sqlite3ReleaseTempRange(Parse *pParse, int iReg, int nReg){
3004 if( nReg>pParse->nRangeReg ){
3005 pParse->nRangeReg = nReg;
3006 pParse->iRangeReg = iReg;
3007 }
3008}