blob: fbb456f89520d848af677a6d75bb0f96de233f4a [file] [log] [blame]
drhcce7d172000-05-31 15:34:51 +00001/*
drhb19a2bc2001-09-16 00:13:26 +00002** 2001 September 15
drhcce7d172000-05-31 15:34:51 +00003**
drhb19a2bc2001-09-16 00:13:26 +00004** The author disclaims copyright to this source code. In place of
5** a legal notice, here is a blessing:
drhcce7d172000-05-31 15:34:51 +00006**
drhb19a2bc2001-09-16 00:13:26 +00007** May you do good and not evil.
8** May you find forgiveness for yourself and forgive others.
9** May you share freely, never taking more than you give.
drhcce7d172000-05-31 15:34:51 +000010**
11*************************************************************************
drh1ccde152000-06-17 13:12:39 +000012** This file contains routines used for analyzing expressions and
drhb19a2bc2001-09-16 00:13:26 +000013** for generating VDBE code that evaluates expressions in SQLite.
drhcce7d172000-05-31 15:34:51 +000014*/
15#include "sqliteInt.h"
drha2e00042002-01-22 03:13:42 +000016
danielk1977e014a832004-05-17 10:48:57 +000017/*
18** Return the 'affinity' of the expression pExpr if any.
19**
20** If pExpr is a column, a reference to a column via an 'AS' alias,
21** or a sub-select with a column as the return value, then the
22** affinity of that column is returned. Otherwise, 0x00 is returned,
23** indicating no affinity for the expression.
24**
25** i.e. the WHERE clause expresssions in the following statements all
26** have an affinity:
27**
28** CREATE TABLE t1(a);
29** SELECT * FROM t1 WHERE a;
30** SELECT a AS b FROM t1 WHERE b;
31** SELECT * FROM t1 WHERE (select a from t1);
32*/
danielk1977bf3b7212004-05-18 10:06:24 +000033char sqlite3ExprAffinity(Expr *pExpr){
drh487e2622005-06-25 18:42:14 +000034 int op = pExpr->op;
drh487e2622005-06-25 18:42:14 +000035 if( op==TK_SELECT ){
danielk19776ab3a2e2009-02-19 14:39:25 +000036 assert( pExpr->flags&EP_xIsSelect );
37 return sqlite3ExprAffinity(pExpr->x.pSelect->pEList->a[0].pExpr);
danielk1977a37cdde2004-05-16 11:15:36 +000038 }
drh487e2622005-06-25 18:42:14 +000039#ifndef SQLITE_OMIT_CAST
40 if( op==TK_CAST ){
drh33e619f2009-05-28 01:00:55 +000041 assert( !ExprHasProperty(pExpr, EP_IntValue) );
42 return sqlite3AffinityType(pExpr->u.zToken);
drh487e2622005-06-25 18:42:14 +000043 }
44#endif
danielk1977259a4552008-11-12 08:07:12 +000045 if( (op==TK_AGG_COLUMN || op==TK_COLUMN || op==TK_REGISTER)
46 && pExpr->pTab!=0
47 ){
drh7d10d5a2008-08-20 16:35:10 +000048 /* op==TK_REGISTER && pExpr->pTab!=0 happens when pExpr was originally
49 ** a TK_COLUMN but was previously evaluated and cached in a register */
50 int j = pExpr->iColumn;
51 if( j<0 ) return SQLITE_AFF_INTEGER;
52 assert( pExpr->pTab && j<pExpr->pTab->nCol );
53 return pExpr->pTab->aCol[j].affinity;
54 }
danielk1977a37cdde2004-05-16 11:15:36 +000055 return pExpr->affinity;
56}
57
drh53db1452004-05-20 13:54:53 +000058/*
drh8b4c40d2007-02-01 23:02:45 +000059** Set the collating sequence for expression pExpr to be the collating
60** sequence named by pToken. Return a pointer to the revised expression.
drha34001c2007-02-02 12:44:37 +000061** The collating sequence is marked as "explicit" using the EP_ExpCollate
62** flag. An explicit collating sequence will override implicit
63** collating sequences.
drh8b4c40d2007-02-01 23:02:45 +000064*/
drh7d10d5a2008-08-20 16:35:10 +000065Expr *sqlite3ExprSetColl(Parse *pParse, Expr *pExpr, Token *pCollName){
danielk197739002502007-11-12 09:50:26 +000066 char *zColl = 0; /* Dequoted name of collation sequence */
drh8b4c40d2007-02-01 23:02:45 +000067 CollSeq *pColl;
drh633e6d52008-07-28 19:34:53 +000068 sqlite3 *db = pParse->db;
drh7d10d5a2008-08-20 16:35:10 +000069 zColl = sqlite3NameFromToken(db, pCollName);
danielk197739002502007-11-12 09:50:26 +000070 if( pExpr && zColl ){
drhc4a64fa2009-05-11 20:53:28 +000071 pColl = sqlite3LocateCollSeq(pParse, zColl);
danielk197739002502007-11-12 09:50:26 +000072 if( pColl ){
73 pExpr->pColl = pColl;
74 pExpr->flags |= EP_ExpCollate;
75 }
drh8b4c40d2007-02-01 23:02:45 +000076 }
drh633e6d52008-07-28 19:34:53 +000077 sqlite3DbFree(db, zColl);
drh8b4c40d2007-02-01 23:02:45 +000078 return pExpr;
79}
80
81/*
danielk19770202b292004-06-09 09:55:16 +000082** Return the default collation sequence for the expression pExpr. If
83** there is no default collation type, return 0.
84*/
danielk19777cedc8d2004-06-10 10:50:08 +000085CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr){
86 CollSeq *pColl = 0;
drh7d10d5a2008-08-20 16:35:10 +000087 Expr *p = pExpr;
drh51f49f12009-05-21 20:41:32 +000088 while( ALWAYS(p) ){
drh7e09fe02007-06-20 16:13:23 +000089 int op;
drh7d10d5a2008-08-20 16:35:10 +000090 pColl = p->pColl;
91 if( pColl ) break;
92 op = p->op;
dan76d462e2009-08-30 11:42:51 +000093 if( p->pTab!=0 && (
94 op==TK_AGG_COLUMN || op==TK_COLUMN || op==TK_REGISTER || op==TK_TRIGGER
95 )){
drh7d10d5a2008-08-20 16:35:10 +000096 /* op==TK_REGISTER && p->pTab!=0 happens when pExpr was originally
97 ** a TK_COLUMN but was previously evaluated and cached in a register */
98 const char *zColl;
99 int j = p->iColumn;
100 if( j>=0 ){
101 sqlite3 *db = pParse->db;
102 zColl = p->pTab->aCol[j].zColl;
drhc4a64fa2009-05-11 20:53:28 +0000103 pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0);
drh7d10d5a2008-08-20 16:35:10 +0000104 pExpr->pColl = pColl;
105 }
106 break;
danielk19770202b292004-06-09 09:55:16 +0000107 }
drh7d10d5a2008-08-20 16:35:10 +0000108 if( op!=TK_CAST && op!=TK_UPLUS ){
109 break;
110 }
111 p = p->pLeft;
danielk19770202b292004-06-09 09:55:16 +0000112 }
danielk19777cedc8d2004-06-10 10:50:08 +0000113 if( sqlite3CheckCollSeq(pParse, pColl) ){
114 pColl = 0;
115 }
116 return pColl;
danielk19770202b292004-06-09 09:55:16 +0000117}
118
119/*
drh626a8792005-01-17 22:08:19 +0000120** pExpr is an operand of a comparison operator. aff2 is the
121** type affinity of the other operand. This routine returns the
drh53db1452004-05-20 13:54:53 +0000122** type affinity that should be used for the comparison operator.
123*/
danielk1977e014a832004-05-17 10:48:57 +0000124char sqlite3CompareAffinity(Expr *pExpr, char aff2){
danielk1977bf3b7212004-05-18 10:06:24 +0000125 char aff1 = sqlite3ExprAffinity(pExpr);
danielk1977e014a832004-05-17 10:48:57 +0000126 if( aff1 && aff2 ){
drh8df447f2005-11-01 15:48:24 +0000127 /* Both sides of the comparison are columns. If one has numeric
128 ** affinity, use that. Otherwise use no affinity.
danielk1977e014a832004-05-17 10:48:57 +0000129 */
drh8a512562005-11-14 22:29:05 +0000130 if( sqlite3IsNumericAffinity(aff1) || sqlite3IsNumericAffinity(aff2) ){
danielk1977e014a832004-05-17 10:48:57 +0000131 return SQLITE_AFF_NUMERIC;
132 }else{
133 return SQLITE_AFF_NONE;
134 }
135 }else if( !aff1 && !aff2 ){
drh5f6a87b2004-07-19 00:39:45 +0000136 /* Neither side of the comparison is a column. Compare the
137 ** results directly.
danielk1977e014a832004-05-17 10:48:57 +0000138 */
drh5f6a87b2004-07-19 00:39:45 +0000139 return SQLITE_AFF_NONE;
danielk1977e014a832004-05-17 10:48:57 +0000140 }else{
141 /* One side is a column, the other is not. Use the columns affinity. */
drhfe05af82005-07-21 03:14:59 +0000142 assert( aff1==0 || aff2==0 );
danielk1977e014a832004-05-17 10:48:57 +0000143 return (aff1 + aff2);
144 }
145}
146
drh53db1452004-05-20 13:54:53 +0000147/*
148** pExpr is a comparison operator. Return the type affinity that should
149** be applied to both operands prior to doing the comparison.
150*/
danielk1977e014a832004-05-17 10:48:57 +0000151static char comparisonAffinity(Expr *pExpr){
152 char aff;
153 assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT ||
154 pExpr->op==TK_GT || pExpr->op==TK_GE || pExpr->op==TK_LE ||
drh6a2fe092009-09-23 02:29:36 +0000155 pExpr->op==TK_NE || pExpr->op==TK_IS || pExpr->op==TK_ISNOT );
danielk1977e014a832004-05-17 10:48:57 +0000156 assert( pExpr->pLeft );
danielk1977bf3b7212004-05-18 10:06:24 +0000157 aff = sqlite3ExprAffinity(pExpr->pLeft);
danielk1977e014a832004-05-17 10:48:57 +0000158 if( pExpr->pRight ){
159 aff = sqlite3CompareAffinity(pExpr->pRight, aff);
danielk19776ab3a2e2009-02-19 14:39:25 +0000160 }else if( ExprHasProperty(pExpr, EP_xIsSelect) ){
161 aff = sqlite3CompareAffinity(pExpr->x.pSelect->pEList->a[0].pExpr, aff);
162 }else if( !aff ){
drhde087bd2007-02-23 03:00:44 +0000163 aff = SQLITE_AFF_NONE;
danielk1977e014a832004-05-17 10:48:57 +0000164 }
165 return aff;
166}
167
168/*
169** pExpr is a comparison expression, eg. '=', '<', IN(...) etc.
170** idx_affinity is the affinity of an indexed column. Return true
171** if the index with affinity idx_affinity may be used to implement
172** the comparison in pExpr.
173*/
174int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity){
175 char aff = comparisonAffinity(pExpr);
drh8a512562005-11-14 22:29:05 +0000176 switch( aff ){
177 case SQLITE_AFF_NONE:
178 return 1;
179 case SQLITE_AFF_TEXT:
180 return idx_affinity==SQLITE_AFF_TEXT;
181 default:
182 return sqlite3IsNumericAffinity(idx_affinity);
183 }
danielk1977e014a832004-05-17 10:48:57 +0000184}
185
danielk1977a37cdde2004-05-16 11:15:36 +0000186/*
drh35573352008-01-08 23:54:25 +0000187** Return the P5 value that should be used for a binary comparison
danielk1977a37cdde2004-05-16 11:15:36 +0000188** opcode (OP_Eq, OP_Ge etc.) used to compare pExpr1 and pExpr2.
danielk1977a37cdde2004-05-16 11:15:36 +0000189*/
drh35573352008-01-08 23:54:25 +0000190static u8 binaryCompareP5(Expr *pExpr1, Expr *pExpr2, int jumpIfNull){
191 u8 aff = (char)sqlite3ExprAffinity(pExpr2);
drh1bd10f82008-12-10 21:19:56 +0000192 aff = (u8)sqlite3CompareAffinity(pExpr1, aff) | (u8)jumpIfNull;
drh35573352008-01-08 23:54:25 +0000193 return aff;
danielk1977a37cdde2004-05-16 11:15:36 +0000194}
195
drha2e00042002-01-22 03:13:42 +0000196/*
danielk19770202b292004-06-09 09:55:16 +0000197** Return a pointer to the collation sequence that should be used by
198** a binary comparison operator comparing pLeft and pRight.
199**
200** If the left hand expression has a collating sequence type, then it is
201** used. Otherwise the collation sequence for the right hand expression
202** is used, or the default (BINARY) if neither expression has a collating
203** type.
danielk1977bcbb04e2007-05-29 12:11:29 +0000204**
205** Argument pRight (but not pLeft) may be a null pointer. In this case,
206** it is not considered.
danielk19770202b292004-06-09 09:55:16 +0000207*/
drh0a0e1312007-08-07 17:04:59 +0000208CollSeq *sqlite3BinaryCompareCollSeq(
danielk1977bcbb04e2007-05-29 12:11:29 +0000209 Parse *pParse,
210 Expr *pLeft,
211 Expr *pRight
212){
drhec41dda2007-02-07 13:09:45 +0000213 CollSeq *pColl;
214 assert( pLeft );
drhec41dda2007-02-07 13:09:45 +0000215 if( pLeft->flags & EP_ExpCollate ){
216 assert( pLeft->pColl );
217 pColl = pLeft->pColl;
danielk1977bcbb04e2007-05-29 12:11:29 +0000218 }else if( pRight && pRight->flags & EP_ExpCollate ){
drhec41dda2007-02-07 13:09:45 +0000219 assert( pRight->pColl );
220 pColl = pRight->pColl;
221 }else{
222 pColl = sqlite3ExprCollSeq(pParse, pLeft);
223 if( !pColl ){
224 pColl = sqlite3ExprCollSeq(pParse, pRight);
225 }
danielk19770202b292004-06-09 09:55:16 +0000226 }
227 return pColl;
228}
229
230/*
drhda250ea2008-04-01 05:07:14 +0000231** Generate the operands for a comparison operation. Before
232** generating the code for each operand, set the EP_AnyAff
233** flag on the expression so that it will be able to used a
234** cached column value that has previously undergone an
235** affinity change.
236*/
237static void codeCompareOperands(
238 Parse *pParse, /* Parsing and code generating context */
239 Expr *pLeft, /* The left operand */
240 int *pRegLeft, /* Register where left operand is stored */
241 int *pFreeLeft, /* Free this register when done */
242 Expr *pRight, /* The right operand */
243 int *pRegRight, /* Register where right operand is stored */
244 int *pFreeRight /* Write temp register for right operand there */
245){
246 while( pLeft->op==TK_UPLUS ) pLeft = pLeft->pLeft;
247 pLeft->flags |= EP_AnyAff;
248 *pRegLeft = sqlite3ExprCodeTemp(pParse, pLeft, pFreeLeft);
249 while( pRight->op==TK_UPLUS ) pRight = pRight->pLeft;
250 pRight->flags |= EP_AnyAff;
251 *pRegRight = sqlite3ExprCodeTemp(pParse, pRight, pFreeRight);
252}
253
254/*
drhbe5c89a2004-07-26 00:31:09 +0000255** Generate code for a comparison operator.
256*/
257static int codeCompare(
258 Parse *pParse, /* The parsing (and code generating) context */
259 Expr *pLeft, /* The left operand */
260 Expr *pRight, /* The right operand */
261 int opcode, /* The comparison opcode */
drh35573352008-01-08 23:54:25 +0000262 int in1, int in2, /* Register holding operands */
drhbe5c89a2004-07-26 00:31:09 +0000263 int dest, /* Jump here if true. */
264 int jumpIfNull /* If true, jump if either operand is NULL */
265){
drh35573352008-01-08 23:54:25 +0000266 int p5;
267 int addr;
268 CollSeq *p4;
269
270 p4 = sqlite3BinaryCompareCollSeq(pParse, pLeft, pRight);
271 p5 = binaryCompareP5(pLeft, pRight, jumpIfNull);
272 addr = sqlite3VdbeAddOp4(pParse->pVdbe, opcode, in2, dest, in1,
273 (void*)p4, P4_COLLSEQ);
drh1bd10f82008-12-10 21:19:56 +0000274 sqlite3VdbeChangeP5(pParse->pVdbe, (u8)p5);
drhe49b1462008-07-09 01:39:44 +0000275 if( (p5 & SQLITE_AFF_MASK)!=SQLITE_AFF_NONE ){
drhda250ea2008-04-01 05:07:14 +0000276 sqlite3ExprCacheAffinityChange(pParse, in1, 1);
277 sqlite3ExprCacheAffinityChange(pParse, in2, 1);
drh2f7794c2008-04-01 03:27:39 +0000278 }
drh35573352008-01-08 23:54:25 +0000279 return addr;
drhbe5c89a2004-07-26 00:31:09 +0000280}
281
danielk19774b5255a2008-06-05 16:47:39 +0000282#if SQLITE_MAX_EXPR_DEPTH>0
283/*
284** Check that argument nHeight is less than or equal to the maximum
285** expression depth allowed. If it is not, leave an error message in
286** pParse.
287*/
drh7d10d5a2008-08-20 16:35:10 +0000288int sqlite3ExprCheckHeight(Parse *pParse, int nHeight){
danielk19774b5255a2008-06-05 16:47:39 +0000289 int rc = SQLITE_OK;
290 int mxHeight = pParse->db->aLimit[SQLITE_LIMIT_EXPR_DEPTH];
291 if( nHeight>mxHeight ){
292 sqlite3ErrorMsg(pParse,
293 "Expression tree is too large (maximum depth %d)", mxHeight
294 );
295 rc = SQLITE_ERROR;
296 }
297 return rc;
298}
299
300/* The following three functions, heightOfExpr(), heightOfExprList()
301** and heightOfSelect(), are used to determine the maximum height
302** of any expression tree referenced by the structure passed as the
303** first argument.
304**
305** If this maximum height is greater than the current value pointed
306** to by pnHeight, the second parameter, then set *pnHeight to that
307** value.
308*/
309static void heightOfExpr(Expr *p, int *pnHeight){
310 if( p ){
311 if( p->nHeight>*pnHeight ){
312 *pnHeight = p->nHeight;
313 }
314 }
315}
316static void heightOfExprList(ExprList *p, int *pnHeight){
317 if( p ){
318 int i;
319 for(i=0; i<p->nExpr; i++){
320 heightOfExpr(p->a[i].pExpr, pnHeight);
321 }
322 }
323}
324static void heightOfSelect(Select *p, int *pnHeight){
325 if( p ){
326 heightOfExpr(p->pWhere, pnHeight);
327 heightOfExpr(p->pHaving, pnHeight);
328 heightOfExpr(p->pLimit, pnHeight);
329 heightOfExpr(p->pOffset, pnHeight);
330 heightOfExprList(p->pEList, pnHeight);
331 heightOfExprList(p->pGroupBy, pnHeight);
332 heightOfExprList(p->pOrderBy, pnHeight);
333 heightOfSelect(p->pPrior, pnHeight);
334 }
335}
336
337/*
338** Set the Expr.nHeight variable in the structure passed as an
339** argument. An expression with no children, Expr.pList or
340** Expr.pSelect member has a height of 1. Any other expression
341** has a height equal to the maximum height of any other
342** referenced Expr plus one.
343*/
344static void exprSetHeight(Expr *p){
345 int nHeight = 0;
346 heightOfExpr(p->pLeft, &nHeight);
347 heightOfExpr(p->pRight, &nHeight);
danielk19776ab3a2e2009-02-19 14:39:25 +0000348 if( ExprHasProperty(p, EP_xIsSelect) ){
349 heightOfSelect(p->x.pSelect, &nHeight);
350 }else{
351 heightOfExprList(p->x.pList, &nHeight);
352 }
danielk19774b5255a2008-06-05 16:47:39 +0000353 p->nHeight = nHeight + 1;
354}
355
356/*
357** Set the Expr.nHeight variable using the exprSetHeight() function. If
358** the height is greater than the maximum allowed expression depth,
359** leave an error in pParse.
360*/
361void sqlite3ExprSetHeight(Parse *pParse, Expr *p){
362 exprSetHeight(p);
drh7d10d5a2008-08-20 16:35:10 +0000363 sqlite3ExprCheckHeight(pParse, p->nHeight);
danielk19774b5255a2008-06-05 16:47:39 +0000364}
365
366/*
367** Return the maximum height of any expression tree referenced
368** by the select statement passed as an argument.
369*/
370int sqlite3SelectExprHeight(Select *p){
371 int nHeight = 0;
372 heightOfSelect(p, &nHeight);
373 return nHeight;
374}
375#else
danielk19774b5255a2008-06-05 16:47:39 +0000376 #define exprSetHeight(y)
377#endif /* SQLITE_MAX_EXPR_DEPTH>0 */
378
drhbe5c89a2004-07-26 00:31:09 +0000379/*
drhb7916a72009-05-27 10:31:29 +0000380** This routine is the core allocator for Expr nodes.
381**
drha76b5df2002-02-23 02:32:10 +0000382** Construct a new expression node and return a pointer to it. Memory
drhb7916a72009-05-27 10:31:29 +0000383** for this node and for the pToken argument is a single allocation
384** obtained from sqlite3DbMalloc(). The calling function
drha76b5df2002-02-23 02:32:10 +0000385** is responsible for making sure the node eventually gets freed.
drhb7916a72009-05-27 10:31:29 +0000386**
387** If dequote is true, then the token (if it exists) is dequoted.
388** If dequote is false, no dequoting is performance. The deQuote
389** parameter is ignored if pToken is NULL or if the token does not
390** appear to be quoted. If the quotes were of the form "..." (double-quotes)
391** then the EP_DblQuoted flag is set on the expression node.
drh33e619f2009-05-28 01:00:55 +0000392**
393** Special case: If op==TK_INTEGER and pToken points to a string that
394** can be translated into a 32-bit integer, then the token is not
395** stored in u.zToken. Instead, the integer values is written
396** into u.iValue and the EP_IntValue flag is set. No extra storage
397** is allocated to hold the integer text and the dequote flag is ignored.
drha76b5df2002-02-23 02:32:10 +0000398*/
drhb7916a72009-05-27 10:31:29 +0000399Expr *sqlite3ExprAlloc(
danielk1977a1644fd2007-08-29 12:31:25 +0000400 sqlite3 *db, /* Handle for sqlite3DbMallocZero() (may be null) */
drh17435752007-08-16 04:30:38 +0000401 int op, /* Expression opcode */
drhb7916a72009-05-27 10:31:29 +0000402 const Token *pToken, /* Token argument. Might be NULL */
403 int dequote /* True to dequote */
drh17435752007-08-16 04:30:38 +0000404){
drha76b5df2002-02-23 02:32:10 +0000405 Expr *pNew;
drh33e619f2009-05-28 01:00:55 +0000406 int nExtra = 0;
shanecf697392009-06-01 16:53:09 +0000407 int iValue = 0;
danielk1977fc976062007-05-10 10:46:56 +0000408
drhb7916a72009-05-27 10:31:29 +0000409 if( pToken ){
drh33e619f2009-05-28 01:00:55 +0000410 if( op!=TK_INTEGER || pToken->z==0
411 || sqlite3GetInt32(pToken->z, &iValue)==0 ){
412 nExtra = pToken->n+1;
413 }
drhb7916a72009-05-27 10:31:29 +0000414 }
415 pNew = sqlite3DbMallocZero(db, sizeof(Expr)+nExtra);
416 if( pNew ){
417 pNew->op = (u8)op;
418 pNew->iAgg = -1;
419 if( pToken ){
drh33e619f2009-05-28 01:00:55 +0000420 if( nExtra==0 ){
421 pNew->flags |= EP_IntValue;
422 pNew->u.iValue = iValue;
423 }else{
424 int c;
425 pNew->u.zToken = (char*)&pNew[1];
426 memcpy(pNew->u.zToken, pToken->z, pToken->n);
427 pNew->u.zToken[pToken->n] = 0;
428 if( dequote && nExtra>=3
429 && ((c = pToken->z[0])=='\'' || c=='"' || c=='[' || c=='`') ){
430 sqlite3Dequote(pNew->u.zToken);
431 if( c=='"' ) pNew->flags |= EP_DblQuoted;
432 }
drhb7916a72009-05-27 10:31:29 +0000433 }
434 }
435#if SQLITE_MAX_EXPR_DEPTH>0
436 pNew->nHeight = 1;
437#endif
438 }
drha76b5df2002-02-23 02:32:10 +0000439 return pNew;
440}
441
442/*
drhb7916a72009-05-27 10:31:29 +0000443** Allocate a new expression node from a zero-terminated token that has
444** already been dequoted.
445*/
446Expr *sqlite3Expr(
447 sqlite3 *db, /* Handle for sqlite3DbMallocZero() (may be null) */
448 int op, /* Expression opcode */
449 const char *zToken /* Token argument. Might be NULL */
450){
451 Token x;
452 x.z = zToken;
453 x.n = zToken ? sqlite3Strlen30(zToken) : 0;
454 return sqlite3ExprAlloc(db, op, &x, 0);
455}
456
457/*
458** Attach subtrees pLeft and pRight to the Expr node pRoot.
459**
460** If pRoot==NULL that means that a memory allocation error has occurred.
461** In that case, delete the subtrees pLeft and pRight.
462*/
463void sqlite3ExprAttachSubtrees(
464 sqlite3 *db,
465 Expr *pRoot,
466 Expr *pLeft,
467 Expr *pRight
468){
469 if( pRoot==0 ){
470 assert( db->mallocFailed );
471 sqlite3ExprDelete(db, pLeft);
472 sqlite3ExprDelete(db, pRight);
473 }else{
474 if( pRight ){
475 pRoot->pRight = pRight;
476 if( pRight->flags & EP_ExpCollate ){
477 pRoot->flags |= EP_ExpCollate;
478 pRoot->pColl = pRight->pColl;
479 }
480 }
481 if( pLeft ){
482 pRoot->pLeft = pLeft;
483 if( pLeft->flags & EP_ExpCollate ){
484 pRoot->flags |= EP_ExpCollate;
485 pRoot->pColl = pLeft->pColl;
486 }
487 }
488 exprSetHeight(pRoot);
489 }
490}
491
492/*
drhbf664462009-06-19 18:32:54 +0000493** Allocate a Expr node which joins as many as two subtrees.
drhb7916a72009-05-27 10:31:29 +0000494**
drhbf664462009-06-19 18:32:54 +0000495** One or both of the subtrees can be NULL. Return a pointer to the new
496** Expr node. Or, if an OOM error occurs, set pParse->db->mallocFailed,
497** free the subtrees and return NULL.
drh206f3d92006-07-11 13:15:08 +0000498*/
drh17435752007-08-16 04:30:38 +0000499Expr *sqlite3PExpr(
500 Parse *pParse, /* Parsing context */
501 int op, /* Expression opcode */
502 Expr *pLeft, /* Left operand */
503 Expr *pRight, /* Right operand */
504 const Token *pToken /* Argument token */
505){
drhb7916a72009-05-27 10:31:29 +0000506 Expr *p = sqlite3ExprAlloc(pParse->db, op, pToken, 1);
507 sqlite3ExprAttachSubtrees(pParse->db, p, pLeft, pRight);
drh4e0cff62004-11-05 05:10:28 +0000508 return p;
509}
510
511/*
drh91bb0ee2004-09-01 03:06:34 +0000512** Join two expressions using an AND operator. If either expression is
513** NULL, then just return the other expression.
514*/
danielk19771e536952007-08-16 10:09:01 +0000515Expr *sqlite3ExprAnd(sqlite3 *db, Expr *pLeft, Expr *pRight){
drh91bb0ee2004-09-01 03:06:34 +0000516 if( pLeft==0 ){
517 return pRight;
518 }else if( pRight==0 ){
519 return pLeft;
520 }else{
drhb7916a72009-05-27 10:31:29 +0000521 Expr *pNew = sqlite3ExprAlloc(db, TK_AND, 0, 0);
522 sqlite3ExprAttachSubtrees(db, pNew, pLeft, pRight);
523 return pNew;
drha76b5df2002-02-23 02:32:10 +0000524 }
525}
526
527/*
528** Construct a new expression node for a function with multiple
529** arguments.
530*/
drh17435752007-08-16 04:30:38 +0000531Expr *sqlite3ExprFunction(Parse *pParse, ExprList *pList, Token *pToken){
drha76b5df2002-02-23 02:32:10 +0000532 Expr *pNew;
drh633e6d52008-07-28 19:34:53 +0000533 sqlite3 *db = pParse->db;
danielk19774b202ae2006-01-23 05:50:58 +0000534 assert( pToken );
drhb7916a72009-05-27 10:31:29 +0000535 pNew = sqlite3ExprAlloc(db, TK_FUNCTION, pToken, 1);
drha76b5df2002-02-23 02:32:10 +0000536 if( pNew==0 ){
drhd9da78a2009-03-24 15:08:09 +0000537 sqlite3ExprListDelete(db, pList); /* Avoid memory leak when malloc fails */
drha76b5df2002-02-23 02:32:10 +0000538 return 0;
539 }
danielk19776ab3a2e2009-02-19 14:39:25 +0000540 pNew->x.pList = pList;
541 assert( !ExprHasProperty(pNew, EP_xIsSelect) );
danielk19774b5255a2008-06-05 16:47:39 +0000542 sqlite3ExprSetHeight(pParse, pNew);
drha76b5df2002-02-23 02:32:10 +0000543 return pNew;
544}
545
546/*
drhfa6bc002004-09-07 16:19:52 +0000547** Assign a variable number to an expression that encodes a wildcard
548** in the original SQL statement.
549**
550** Wildcards consisting of a single "?" are assigned the next sequential
551** variable number.
552**
553** Wildcards of the form "?nnn" are assigned the number "nnn". We make
554** sure "nnn" is not too be to avoid a denial of service attack when
555** the SQL statement comes from an external source.
556**
drh51f49f12009-05-21 20:41:32 +0000557** Wildcards of the form ":aaa", "@aaa", or "$aaa" are assigned the same number
drhfa6bc002004-09-07 16:19:52 +0000558** as the previous instance of the same wildcard. Or if this is the first
559** instance of the wildcard, the next sequenial variable number is
560** assigned.
561*/
562void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr){
drh17435752007-08-16 04:30:38 +0000563 sqlite3 *db = pParse->db;
drhb7916a72009-05-27 10:31:29 +0000564 const char *z;
drh17435752007-08-16 04:30:38 +0000565
drhfa6bc002004-09-07 16:19:52 +0000566 if( pExpr==0 ) return;
drh33e619f2009-05-28 01:00:55 +0000567 assert( !ExprHasAnyProperty(pExpr, EP_IntValue|EP_Reduced|EP_TokenOnly) );
568 z = pExpr->u.zToken;
drhb7916a72009-05-27 10:31:29 +0000569 assert( z!=0 );
570 assert( z[0]!=0 );
571 if( z[1]==0 ){
drhfa6bc002004-09-07 16:19:52 +0000572 /* Wildcard of the form "?". Assign the next variable number */
drhb7916a72009-05-27 10:31:29 +0000573 assert( z[0]=='?' );
drh8677d302009-11-04 13:17:14 +0000574 pExpr->iColumn = (ynVar)(++pParse->nVar);
drhb7916a72009-05-27 10:31:29 +0000575 }else if( z[0]=='?' ){
drhfa6bc002004-09-07 16:19:52 +0000576 /* Wildcard of the form "?nnn". Convert "nnn" to an integer and
577 ** use it as the variable number */
shanef639c402009-11-03 19:42:30 +0000578 int i = atoi((char*)&z[1]);
drh8677d302009-11-04 13:17:14 +0000579 pExpr->iColumn = (ynVar)i;
drhc5499be2008-04-01 15:06:33 +0000580 testcase( i==0 );
581 testcase( i==1 );
582 testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]-1 );
583 testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] );
drhbb4957f2008-03-20 14:03:29 +0000584 if( i<1 || i>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){
drhfa6bc002004-09-07 16:19:52 +0000585 sqlite3ErrorMsg(pParse, "variable number must be between ?1 and ?%d",
drhbb4957f2008-03-20 14:03:29 +0000586 db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]);
drhfa6bc002004-09-07 16:19:52 +0000587 }
588 if( i>pParse->nVar ){
589 pParse->nVar = i;
590 }
591 }else{
drh51f49f12009-05-21 20:41:32 +0000592 /* Wildcards like ":aaa", "$aaa" or "@aaa". Reuse the same variable
drhfa6bc002004-09-07 16:19:52 +0000593 ** number as the prior appearance of the same name, or if the name
594 ** has never appeared before, reuse the same variable number
595 */
drh1bd10f82008-12-10 21:19:56 +0000596 int i;
597 u32 n;
drhb7916a72009-05-27 10:31:29 +0000598 n = sqlite3Strlen30(z);
drhfa6bc002004-09-07 16:19:52 +0000599 for(i=0; i<pParse->nVarExpr; i++){
drh51f49f12009-05-21 20:41:32 +0000600 Expr *pE = pParse->apVarExpr[i];
601 assert( pE!=0 );
drh33e619f2009-05-28 01:00:55 +0000602 if( memcmp(pE->u.zToken, z, n)==0 && pE->u.zToken[n]==0 ){
dan937d0de2009-10-15 18:35:38 +0000603 pExpr->iColumn = pE->iColumn;
drhfa6bc002004-09-07 16:19:52 +0000604 break;
605 }
606 }
607 if( i>=pParse->nVarExpr ){
drh8677d302009-11-04 13:17:14 +0000608 pExpr->iColumn = (ynVar)(++pParse->nVar);
drhfa6bc002004-09-07 16:19:52 +0000609 if( pParse->nVarExpr>=pParse->nVarExprAlloc-1 ){
610 pParse->nVarExprAlloc += pParse->nVarExprAlloc + 10;
drh17435752007-08-16 04:30:38 +0000611 pParse->apVarExpr =
612 sqlite3DbReallocOrFree(
613 db,
614 pParse->apVarExpr,
615 pParse->nVarExprAlloc*sizeof(pParse->apVarExpr[0])
616 );
drhfa6bc002004-09-07 16:19:52 +0000617 }
drh17435752007-08-16 04:30:38 +0000618 if( !db->mallocFailed ){
drhfa6bc002004-09-07 16:19:52 +0000619 assert( pParse->apVarExpr!=0 );
620 pParse->apVarExpr[pParse->nVarExpr++] = pExpr;
621 }
622 }
623 }
drhbb4957f2008-03-20 14:03:29 +0000624 if( !pParse->nErr && pParse->nVar>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){
danielk1977832b2662007-05-09 11:37:22 +0000625 sqlite3ErrorMsg(pParse, "too many SQL variables");
626 }
drhfa6bc002004-09-07 16:19:52 +0000627}
628
629/*
drh10fe8402008-10-11 16:47:35 +0000630** Clear an expression structure without deleting the structure itself.
631** Substructure is deleted.
drha2e00042002-01-22 03:13:42 +0000632*/
drh10fe8402008-10-11 16:47:35 +0000633void sqlite3ExprClear(sqlite3 *db, Expr *p){
drh33e619f2009-05-28 01:00:55 +0000634 assert( p!=0 );
drhb7916a72009-05-27 10:31:29 +0000635 if( !ExprHasAnyProperty(p, EP_TokenOnly) ){
drh33e619f2009-05-28 01:00:55 +0000636 sqlite3ExprDelete(db, p->pLeft);
637 sqlite3ExprDelete(db, p->pRight);
638 if( !ExprHasProperty(p, EP_Reduced) && (p->flags2 & EP2_MallocedToken)!=0 ){
639 sqlite3DbFree(db, p->u.zToken);
danielk19776ab3a2e2009-02-19 14:39:25 +0000640 }
641 if( ExprHasProperty(p, EP_xIsSelect) ){
642 sqlite3SelectDelete(db, p->x.pSelect);
643 }else{
644 sqlite3ExprListDelete(db, p->x.pList);
645 }
646 }
drh10fe8402008-10-11 16:47:35 +0000647}
648
649/*
650** Recursively delete an expression tree.
651*/
652void sqlite3ExprDelete(sqlite3 *db, Expr *p){
653 if( p==0 ) return;
654 sqlite3ExprClear(db, p);
drh33e619f2009-05-28 01:00:55 +0000655 if( !ExprHasProperty(p, EP_Static) ){
656 sqlite3DbFree(db, p);
657 }
drha2e00042002-01-22 03:13:42 +0000658}
659
drhd2687b72005-08-12 22:56:09 +0000660/*
danielk19776ab3a2e2009-02-19 14:39:25 +0000661** Return the number of bytes allocated for the expression structure
662** passed as the first argument. This is always one of EXPR_FULLSIZE,
663** EXPR_REDUCEDSIZE or EXPR_TOKENONLYSIZE.
664*/
665static int exprStructSize(Expr *p){
666 if( ExprHasProperty(p, EP_TokenOnly) ) return EXPR_TOKENONLYSIZE;
danielk19776ab3a2e2009-02-19 14:39:25 +0000667 if( ExprHasProperty(p, EP_Reduced) ) return EXPR_REDUCEDSIZE;
668 return EXPR_FULLSIZE;
669}
670
671/*
drh33e619f2009-05-28 01:00:55 +0000672** The dupedExpr*Size() routines each return the number of bytes required
673** to store a copy of an expression or expression tree. They differ in
674** how much of the tree is measured.
675**
676** dupedExprStructSize() Size of only the Expr structure
677** dupedExprNodeSize() Size of Expr + space for token
678** dupedExprSize() Expr + token + subtree components
679**
680***************************************************************************
681**
682** The dupedExprStructSize() function returns two values OR-ed together:
683** (1) the space required for a copy of the Expr structure only and
684** (2) the EP_xxx flags that indicate what the structure size should be.
685** The return values is always one of:
686**
687** EXPR_FULLSIZE
688** EXPR_REDUCEDSIZE | EP_Reduced
689** EXPR_TOKENONLYSIZE | EP_TokenOnly
690**
691** The size of the structure can be found by masking the return value
692** of this routine with 0xfff. The flags can be found by masking the
693** return value with EP_Reduced|EP_TokenOnly.
694**
695** Note that with flags==EXPRDUP_REDUCE, this routines works on full-size
696** (unreduced) Expr objects as they or originally constructed by the parser.
697** During expression analysis, extra information is computed and moved into
698** later parts of teh Expr object and that extra information might get chopped
699** off if the expression is reduced. Note also that it does not work to
700** make a EXPRDUP_REDUCE copy of a reduced expression. It is only legal
701** to reduce a pristine expression tree from the parser. The implementation
702** of dupedExprStructSize() contain multiple assert() statements that attempt
703** to enforce this constraint.
danielk19776ab3a2e2009-02-19 14:39:25 +0000704*/
705static int dupedExprStructSize(Expr *p, int flags){
706 int nSize;
drh33e619f2009-05-28 01:00:55 +0000707 assert( flags==EXPRDUP_REDUCE || flags==0 ); /* Only one flag value allowed */
danielk19776ab3a2e2009-02-19 14:39:25 +0000708 if( 0==(flags&EXPRDUP_REDUCE) ){
709 nSize = EXPR_FULLSIZE;
danielk19776ab3a2e2009-02-19 14:39:25 +0000710 }else{
drh33e619f2009-05-28 01:00:55 +0000711 assert( !ExprHasAnyProperty(p, EP_TokenOnly|EP_Reduced) );
712 assert( !ExprHasProperty(p, EP_FromJoin) );
713 assert( (p->flags2 & EP2_MallocedToken)==0 );
714 assert( (p->flags2 & EP2_Irreducible)==0 );
715 if( p->pLeft || p->pRight || p->pColl || p->x.pList ){
716 nSize = EXPR_REDUCEDSIZE | EP_Reduced;
717 }else{
718 nSize = EXPR_TOKENONLYSIZE | EP_TokenOnly;
719 }
danielk19776ab3a2e2009-02-19 14:39:25 +0000720 }
721 return nSize;
722}
723
724/*
drh33e619f2009-05-28 01:00:55 +0000725** This function returns the space in bytes required to store the copy
726** of the Expr structure and a copy of the Expr.u.zToken string (if that
727** string is defined.)
danielk19776ab3a2e2009-02-19 14:39:25 +0000728*/
729static int dupedExprNodeSize(Expr *p, int flags){
drh33e619f2009-05-28 01:00:55 +0000730 int nByte = dupedExprStructSize(p, flags) & 0xfff;
731 if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){
732 nByte += sqlite3Strlen30(p->u.zToken)+1;
danielk19776ab3a2e2009-02-19 14:39:25 +0000733 }
danielk1977bc739712009-03-23 04:33:32 +0000734 return ROUND8(nByte);
danielk19776ab3a2e2009-02-19 14:39:25 +0000735}
736
737/*
738** Return the number of bytes required to create a duplicate of the
739** expression passed as the first argument. The second argument is a
740** mask containing EXPRDUP_XXX flags.
741**
742** The value returned includes space to create a copy of the Expr struct
drh33e619f2009-05-28 01:00:55 +0000743** itself and the buffer referred to by Expr.u.zToken, if any.
danielk19776ab3a2e2009-02-19 14:39:25 +0000744**
745** If the EXPRDUP_REDUCE flag is set, then the return value includes
746** space to duplicate all Expr nodes in the tree formed by Expr.pLeft
747** and Expr.pRight variables (but not for any structures pointed to or
748** descended from the Expr.x.pList or Expr.x.pSelect variables).
749*/
750static int dupedExprSize(Expr *p, int flags){
751 int nByte = 0;
752 if( p ){
753 nByte = dupedExprNodeSize(p, flags);
754 if( flags&EXPRDUP_REDUCE ){
drhb7916a72009-05-27 10:31:29 +0000755 nByte += dupedExprSize(p->pLeft, flags) + dupedExprSize(p->pRight, flags);
danielk19776ab3a2e2009-02-19 14:39:25 +0000756 }
757 }
758 return nByte;
759}
760
761/*
762** This function is similar to sqlite3ExprDup(), except that if pzBuffer
763** is not NULL then *pzBuffer is assumed to point to a buffer large enough
drh33e619f2009-05-28 01:00:55 +0000764** to store the copy of expression p, the copies of p->u.zToken
danielk19776ab3a2e2009-02-19 14:39:25 +0000765** (if applicable), and the copies of the p->pLeft and p->pRight expressions,
766** if any. Before returning, *pzBuffer is set to the first byte passed the
767** portion of the buffer copied into by this function.
768*/
769static Expr *exprDup(sqlite3 *db, Expr *p, int flags, u8 **pzBuffer){
770 Expr *pNew = 0; /* Value to return */
771 if( p ){
danielk19776ab3a2e2009-02-19 14:39:25 +0000772 const int isReduced = (flags&EXPRDUP_REDUCE);
773 u8 *zAlloc;
drh33e619f2009-05-28 01:00:55 +0000774 u32 staticFlag = 0;
danielk19776ab3a2e2009-02-19 14:39:25 +0000775
776 assert( pzBuffer==0 || isReduced );
777
778 /* Figure out where to write the new Expr structure. */
779 if( pzBuffer ){
780 zAlloc = *pzBuffer;
drh33e619f2009-05-28 01:00:55 +0000781 staticFlag = EP_Static;
danielk19776ab3a2e2009-02-19 14:39:25 +0000782 }else{
783 zAlloc = sqlite3DbMallocRaw(db, dupedExprSize(p, flags));
784 }
785 pNew = (Expr *)zAlloc;
786
787 if( pNew ){
788 /* Set nNewSize to the size allocated for the structure pointed to
789 ** by pNew. This is either EXPR_FULLSIZE, EXPR_REDUCEDSIZE or
790 ** EXPR_TOKENONLYSIZE. nToken is set to the number of bytes consumed
drh33e619f2009-05-28 01:00:55 +0000791 ** by the copy of the p->u.zToken string (if any).
danielk19776ab3a2e2009-02-19 14:39:25 +0000792 */
drh33e619f2009-05-28 01:00:55 +0000793 const unsigned nStructSize = dupedExprStructSize(p, flags);
794 const int nNewSize = nStructSize & 0xfff;
795 int nToken;
796 if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){
797 nToken = sqlite3Strlen30(p->u.zToken) + 1;
798 }else{
799 nToken = 0;
800 }
danielk19776ab3a2e2009-02-19 14:39:25 +0000801 if( isReduced ){
802 assert( ExprHasProperty(p, EP_Reduced)==0 );
803 memcpy(zAlloc, p, nNewSize);
804 }else{
805 int nSize = exprStructSize(p);
806 memcpy(zAlloc, p, nSize);
807 memset(&zAlloc[nSize], 0, EXPR_FULLSIZE-nSize);
808 }
809
drh33e619f2009-05-28 01:00:55 +0000810 /* Set the EP_Reduced, EP_TokenOnly, and EP_Static flags appropriately. */
811 pNew->flags &= ~(EP_Reduced|EP_TokenOnly|EP_Static);
812 pNew->flags |= nStructSize & (EP_Reduced|EP_TokenOnly);
813 pNew->flags |= staticFlag;
danielk19776ab3a2e2009-02-19 14:39:25 +0000814
drh33e619f2009-05-28 01:00:55 +0000815 /* Copy the p->u.zToken string, if any. */
danielk19776ab3a2e2009-02-19 14:39:25 +0000816 if( nToken ){
drh33e619f2009-05-28 01:00:55 +0000817 char *zToken = pNew->u.zToken = (char*)&zAlloc[nNewSize];
818 memcpy(zToken, p->u.zToken, nToken);
danielk19776ab3a2e2009-02-19 14:39:25 +0000819 }
820
821 if( 0==((p->flags|pNew->flags) & EP_TokenOnly) ){
danielk19776ab3a2e2009-02-19 14:39:25 +0000822 /* Fill in the pNew->x.pSelect or pNew->x.pList member. */
823 if( ExprHasProperty(p, EP_xIsSelect) ){
824 pNew->x.pSelect = sqlite3SelectDup(db, p->x.pSelect, isReduced);
825 }else{
826 pNew->x.pList = sqlite3ExprListDup(db, p->x.pList, isReduced);
827 }
828 }
829
830 /* Fill in pNew->pLeft and pNew->pRight. */
drhb7916a72009-05-27 10:31:29 +0000831 if( ExprHasAnyProperty(pNew, EP_Reduced|EP_TokenOnly) ){
danielk19776ab3a2e2009-02-19 14:39:25 +0000832 zAlloc += dupedExprNodeSize(p, flags);
833 if( ExprHasProperty(pNew, EP_Reduced) ){
834 pNew->pLeft = exprDup(db, p->pLeft, EXPRDUP_REDUCE, &zAlloc);
835 pNew->pRight = exprDup(db, p->pRight, EXPRDUP_REDUCE, &zAlloc);
836 }
837 if( pzBuffer ){
838 *pzBuffer = zAlloc;
839 }
drhb7916a72009-05-27 10:31:29 +0000840 }else{
841 pNew->flags2 = 0;
842 if( !ExprHasAnyProperty(p, EP_TokenOnly) ){
843 pNew->pLeft = sqlite3ExprDup(db, p->pLeft, 0);
844 pNew->pRight = sqlite3ExprDup(db, p->pRight, 0);
845 }
danielk19776ab3a2e2009-02-19 14:39:25 +0000846 }
drhb7916a72009-05-27 10:31:29 +0000847
danielk19776ab3a2e2009-02-19 14:39:25 +0000848 }
849 }
850 return pNew;
851}
852
853/*
drhff78bd22002-02-27 01:47:11 +0000854** The following group of routines make deep copies of expressions,
855** expression lists, ID lists, and select statements. The copies can
856** be deleted (by being passed to their respective ...Delete() routines)
857** without effecting the originals.
858**
danielk19774adee202004-05-08 08:23:19 +0000859** The expression list, ID, and source lists return by sqlite3ExprListDup(),
860** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded
drhad3cab52002-05-24 02:04:32 +0000861** by subsequent calls to sqlite*ListAppend() routines.
drhff78bd22002-02-27 01:47:11 +0000862**
drhad3cab52002-05-24 02:04:32 +0000863** Any tables that the SrcList might point to are not duplicated.
danielk19776ab3a2e2009-02-19 14:39:25 +0000864**
drhb7916a72009-05-27 10:31:29 +0000865** The flags parameter contains a combination of the EXPRDUP_XXX flags.
danielk19776ab3a2e2009-02-19 14:39:25 +0000866** If the EXPRDUP_REDUCE flag is set, then the structure returned is a
867** truncated version of the usual Expr structure that will be stored as
868** part of the in-memory representation of the database schema.
drhff78bd22002-02-27 01:47:11 +0000869*/
danielk19776ab3a2e2009-02-19 14:39:25 +0000870Expr *sqlite3ExprDup(sqlite3 *db, Expr *p, int flags){
871 return exprDup(db, p, flags, 0);
drhff78bd22002-02-27 01:47:11 +0000872}
danielk19776ab3a2e2009-02-19 14:39:25 +0000873ExprList *sqlite3ExprListDup(sqlite3 *db, ExprList *p, int flags){
drhff78bd22002-02-27 01:47:11 +0000874 ExprList *pNew;
drh145716b2004-09-24 12:24:06 +0000875 struct ExprList_item *pItem, *pOldItem;
drhff78bd22002-02-27 01:47:11 +0000876 int i;
877 if( p==0 ) return 0;
drh17435752007-08-16 04:30:38 +0000878 pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
drhff78bd22002-02-27 01:47:11 +0000879 if( pNew==0 ) return 0;
danielk197731dad9d2007-08-16 11:36:15 +0000880 pNew->iECursor = 0;
drh4305d102003-07-30 12:34:12 +0000881 pNew->nExpr = pNew->nAlloc = p->nExpr;
drh17435752007-08-16 04:30:38 +0000882 pNew->a = pItem = sqlite3DbMallocRaw(db, p->nExpr*sizeof(p->a[0]) );
danielk1977e0048402004-06-15 16:51:01 +0000883 if( pItem==0 ){
drh633e6d52008-07-28 19:34:53 +0000884 sqlite3DbFree(db, pNew);
danielk1977e0048402004-06-15 16:51:01 +0000885 return 0;
886 }
drh145716b2004-09-24 12:24:06 +0000887 pOldItem = p->a;
888 for(i=0; i<p->nExpr; i++, pItem++, pOldItem++){
danielk19776ab3a2e2009-02-19 14:39:25 +0000889 Expr *pOldExpr = pOldItem->pExpr;
drhb5526ea2009-07-16 12:41:05 +0000890 pItem->pExpr = sqlite3ExprDup(db, pOldExpr, flags);
drh17435752007-08-16 04:30:38 +0000891 pItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
drhb7916a72009-05-27 10:31:29 +0000892 pItem->zSpan = sqlite3DbStrDup(db, pOldItem->zSpan);
drh145716b2004-09-24 12:24:06 +0000893 pItem->sortOrder = pOldItem->sortOrder;
drh3e7bc9c2004-02-21 19:17:17 +0000894 pItem->done = 0;
drh7d10d5a2008-08-20 16:35:10 +0000895 pItem->iCol = pOldItem->iCol;
drh8b213892008-08-29 02:14:02 +0000896 pItem->iAlias = pOldItem->iAlias;
drhff78bd22002-02-27 01:47:11 +0000897 }
898 return pNew;
899}
danielk197793758c82005-01-21 08:13:14 +0000900
901/*
902** If cursors, triggers, views and subqueries are all omitted from
903** the build, then none of the following routines, except for
904** sqlite3SelectDup(), can be called. sqlite3SelectDup() is sometimes
905** called with a NULL argument.
906*/
danielk19776a67fe82005-02-04 04:07:16 +0000907#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) \
908 || !defined(SQLITE_OMIT_SUBQUERY)
danielk19776ab3a2e2009-02-19 14:39:25 +0000909SrcList *sqlite3SrcListDup(sqlite3 *db, SrcList *p, int flags){
drhad3cab52002-05-24 02:04:32 +0000910 SrcList *pNew;
911 int i;
drh113088e2003-03-20 01:16:58 +0000912 int nByte;
drhad3cab52002-05-24 02:04:32 +0000913 if( p==0 ) return 0;
drh113088e2003-03-20 01:16:58 +0000914 nByte = sizeof(*p) + (p->nSrc>0 ? sizeof(p->a[0]) * (p->nSrc-1) : 0);
drh17435752007-08-16 04:30:38 +0000915 pNew = sqlite3DbMallocRaw(db, nByte );
drhad3cab52002-05-24 02:04:32 +0000916 if( pNew==0 ) return 0;
drh4305d102003-07-30 12:34:12 +0000917 pNew->nSrc = pNew->nAlloc = p->nSrc;
drhad3cab52002-05-24 02:04:32 +0000918 for(i=0; i<p->nSrc; i++){
drh4efc4752004-01-16 15:55:37 +0000919 struct SrcList_item *pNewItem = &pNew->a[i];
920 struct SrcList_item *pOldItem = &p->a[i];
drhed8a3bb2005-06-06 21:19:56 +0000921 Table *pTab;
drh17435752007-08-16 04:30:38 +0000922 pNewItem->zDatabase = sqlite3DbStrDup(db, pOldItem->zDatabase);
923 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
924 pNewItem->zAlias = sqlite3DbStrDup(db, pOldItem->zAlias);
drh4efc4752004-01-16 15:55:37 +0000925 pNewItem->jointype = pOldItem->jointype;
926 pNewItem->iCursor = pOldItem->iCursor;
danielk19771787cca2006-02-10 07:07:14 +0000927 pNewItem->isPopulated = pOldItem->isPopulated;
danielk197785574e32008-10-06 05:32:18 +0000928 pNewItem->zIndex = sqlite3DbStrDup(db, pOldItem->zIndex);
929 pNewItem->notIndexed = pOldItem->notIndexed;
930 pNewItem->pIndex = pOldItem->pIndex;
drhed8a3bb2005-06-06 21:19:56 +0000931 pTab = pNewItem->pTab = pOldItem->pTab;
932 if( pTab ){
933 pTab->nRef++;
danielk1977a1cb1832005-02-12 08:59:55 +0000934 }
danielk19776ab3a2e2009-02-19 14:39:25 +0000935 pNewItem->pSelect = sqlite3SelectDup(db, pOldItem->pSelect, flags);
936 pNewItem->pOn = sqlite3ExprDup(db, pOldItem->pOn, flags);
drh17435752007-08-16 04:30:38 +0000937 pNewItem->pUsing = sqlite3IdListDup(db, pOldItem->pUsing);
danielk19776c18b6e2005-01-30 09:17:58 +0000938 pNewItem->colUsed = pOldItem->colUsed;
drhad3cab52002-05-24 02:04:32 +0000939 }
940 return pNew;
941}
drh17435752007-08-16 04:30:38 +0000942IdList *sqlite3IdListDup(sqlite3 *db, IdList *p){
drhff78bd22002-02-27 01:47:11 +0000943 IdList *pNew;
944 int i;
945 if( p==0 ) return 0;
drh17435752007-08-16 04:30:38 +0000946 pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
drhff78bd22002-02-27 01:47:11 +0000947 if( pNew==0 ) return 0;
drh4305d102003-07-30 12:34:12 +0000948 pNew->nId = pNew->nAlloc = p->nId;
drh17435752007-08-16 04:30:38 +0000949 pNew->a = sqlite3DbMallocRaw(db, p->nId*sizeof(p->a[0]) );
danielk1977d5d56522005-03-16 12:15:20 +0000950 if( pNew->a==0 ){
drh633e6d52008-07-28 19:34:53 +0000951 sqlite3DbFree(db, pNew);
danielk1977d5d56522005-03-16 12:15:20 +0000952 return 0;
953 }
drhff78bd22002-02-27 01:47:11 +0000954 for(i=0; i<p->nId; i++){
drh4efc4752004-01-16 15:55:37 +0000955 struct IdList_item *pNewItem = &pNew->a[i];
956 struct IdList_item *pOldItem = &p->a[i];
drh17435752007-08-16 04:30:38 +0000957 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
drh4efc4752004-01-16 15:55:37 +0000958 pNewItem->idx = pOldItem->idx;
drhff78bd22002-02-27 01:47:11 +0000959 }
960 return pNew;
961}
danielk19776ab3a2e2009-02-19 14:39:25 +0000962Select *sqlite3SelectDup(sqlite3 *db, Select *p, int flags){
drhff78bd22002-02-27 01:47:11 +0000963 Select *pNew;
964 if( p==0 ) return 0;
drh17435752007-08-16 04:30:38 +0000965 pNew = sqlite3DbMallocRaw(db, sizeof(*p) );
drhff78bd22002-02-27 01:47:11 +0000966 if( pNew==0 ) return 0;
drhb7916a72009-05-27 10:31:29 +0000967 pNew->pEList = sqlite3ExprListDup(db, p->pEList, flags);
danielk19776ab3a2e2009-02-19 14:39:25 +0000968 pNew->pSrc = sqlite3SrcListDup(db, p->pSrc, flags);
969 pNew->pWhere = sqlite3ExprDup(db, p->pWhere, flags);
970 pNew->pGroupBy = sqlite3ExprListDup(db, p->pGroupBy, flags);
971 pNew->pHaving = sqlite3ExprDup(db, p->pHaving, flags);
972 pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, flags);
drhff78bd22002-02-27 01:47:11 +0000973 pNew->op = p->op;
danielk19776ab3a2e2009-02-19 14:39:25 +0000974 pNew->pPrior = sqlite3SelectDup(db, p->pPrior, flags);
975 pNew->pLimit = sqlite3ExprDup(db, p->pLimit, flags);
976 pNew->pOffset = sqlite3ExprDup(db, p->pOffset, flags);
drh92b01d52008-06-24 00:32:35 +0000977 pNew->iLimit = 0;
978 pNew->iOffset = 0;
drh7d10d5a2008-08-20 16:35:10 +0000979 pNew->selFlags = p->selFlags & ~SF_UsesEphemeral;
drh0342b1f2005-09-01 03:07:44 +0000980 pNew->pRightmost = 0;
drhb9bb7c12006-06-11 23:41:55 +0000981 pNew->addrOpenEphm[0] = -1;
982 pNew->addrOpenEphm[1] = -1;
983 pNew->addrOpenEphm[2] = -1;
drhff78bd22002-02-27 01:47:11 +0000984 return pNew;
985}
danielk197793758c82005-01-21 08:13:14 +0000986#else
danielk19776ab3a2e2009-02-19 14:39:25 +0000987Select *sqlite3SelectDup(sqlite3 *db, Select *p, int flags){
danielk197793758c82005-01-21 08:13:14 +0000988 assert( p==0 );
989 return 0;
990}
991#endif
drhff78bd22002-02-27 01:47:11 +0000992
993
994/*
drha76b5df2002-02-23 02:32:10 +0000995** Add a new element to the end of an expression list. If pList is
996** initially NULL, then create a new expression list.
drhb7916a72009-05-27 10:31:29 +0000997**
998** If a memory allocation error occurs, the entire list is freed and
999** NULL is returned. If non-NULL is returned, then it is guaranteed
1000** that the new entry was successfully appended.
drha76b5df2002-02-23 02:32:10 +00001001*/
drh17435752007-08-16 04:30:38 +00001002ExprList *sqlite3ExprListAppend(
1003 Parse *pParse, /* Parsing context */
1004 ExprList *pList, /* List to which to append. Might be NULL */
drhb7916a72009-05-27 10:31:29 +00001005 Expr *pExpr /* Expression to be appended. Might be NULL */
drh17435752007-08-16 04:30:38 +00001006){
1007 sqlite3 *db = pParse->db;
drha76b5df2002-02-23 02:32:10 +00001008 if( pList==0 ){
drh17435752007-08-16 04:30:38 +00001009 pList = sqlite3DbMallocZero(db, sizeof(ExprList) );
drha76b5df2002-02-23 02:32:10 +00001010 if( pList==0 ){
danielk1977d5d56522005-03-16 12:15:20 +00001011 goto no_mem;
drha76b5df2002-02-23 02:32:10 +00001012 }
drh4efc4752004-01-16 15:55:37 +00001013 assert( pList->nAlloc==0 );
drha76b5df2002-02-23 02:32:10 +00001014 }
drh4305d102003-07-30 12:34:12 +00001015 if( pList->nAlloc<=pList->nExpr ){
danielk1977d5d56522005-03-16 12:15:20 +00001016 struct ExprList_item *a;
1017 int n = pList->nAlloc*2 + 4;
danielk197726783a52007-08-29 14:06:22 +00001018 a = sqlite3DbRealloc(db, pList->a, n*sizeof(pList->a[0]));
danielk1977d5d56522005-03-16 12:15:20 +00001019 if( a==0 ){
1020 goto no_mem;
drha76b5df2002-02-23 02:32:10 +00001021 }
danielk1977d5d56522005-03-16 12:15:20 +00001022 pList->a = a;
drh6a1e0712008-12-05 15:24:15 +00001023 pList->nAlloc = sqlite3DbMallocSize(db, a)/sizeof(a[0]);
drha76b5df2002-02-23 02:32:10 +00001024 }
drh4efc4752004-01-16 15:55:37 +00001025 assert( pList->a!=0 );
drhb7916a72009-05-27 10:31:29 +00001026 if( 1 ){
drh4efc4752004-01-16 15:55:37 +00001027 struct ExprList_item *pItem = &pList->a[pList->nExpr++];
1028 memset(pItem, 0, sizeof(*pItem));
danielk1977e94ddc92005-03-21 03:53:38 +00001029 pItem->pExpr = pExpr;
drha76b5df2002-02-23 02:32:10 +00001030 }
1031 return pList;
danielk1977d5d56522005-03-16 12:15:20 +00001032
1033no_mem:
1034 /* Avoid leaking memory if malloc has failed. */
drh633e6d52008-07-28 19:34:53 +00001035 sqlite3ExprDelete(db, pExpr);
1036 sqlite3ExprListDelete(db, pList);
danielk1977d5d56522005-03-16 12:15:20 +00001037 return 0;
drha76b5df2002-02-23 02:32:10 +00001038}
1039
1040/*
drhb7916a72009-05-27 10:31:29 +00001041** Set the ExprList.a[].zName element of the most recently added item
1042** on the expression list.
1043**
1044** pList might be NULL following an OOM error. But pName should never be
1045** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
1046** is set.
1047*/
1048void sqlite3ExprListSetName(
1049 Parse *pParse, /* Parsing context */
1050 ExprList *pList, /* List to which to add the span. */
1051 Token *pName, /* Name to be added */
1052 int dequote /* True to cause the name to be dequoted */
1053){
1054 assert( pList!=0 || pParse->db->mallocFailed!=0 );
1055 if( pList ){
1056 struct ExprList_item *pItem;
1057 assert( pList->nExpr>0 );
1058 pItem = &pList->a[pList->nExpr-1];
1059 assert( pItem->zName==0 );
1060 pItem->zName = sqlite3DbStrNDup(pParse->db, pName->z, pName->n);
1061 if( dequote && pItem->zName ) sqlite3Dequote(pItem->zName);
1062 }
1063}
1064
1065/*
1066** Set the ExprList.a[].zSpan element of the most recently added item
1067** on the expression list.
1068**
1069** pList might be NULL following an OOM error. But pSpan should never be
1070** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
1071** is set.
1072*/
1073void sqlite3ExprListSetSpan(
1074 Parse *pParse, /* Parsing context */
1075 ExprList *pList, /* List to which to add the span. */
1076 ExprSpan *pSpan /* The span to be added */
1077){
1078 sqlite3 *db = pParse->db;
1079 assert( pList!=0 || db->mallocFailed!=0 );
1080 if( pList ){
1081 struct ExprList_item *pItem = &pList->a[pList->nExpr-1];
1082 assert( pList->nExpr>0 );
1083 assert( db->mallocFailed || pItem->pExpr==pSpan->pExpr );
1084 sqlite3DbFree(db, pItem->zSpan);
1085 pItem->zSpan = sqlite3DbStrNDup(db, (char*)pSpan->zStart,
shanecf697392009-06-01 16:53:09 +00001086 (int)(pSpan->zEnd - pSpan->zStart));
drhb7916a72009-05-27 10:31:29 +00001087 }
1088}
1089
1090/*
danielk19777a15a4b2007-05-08 17:54:43 +00001091** If the expression list pEList contains more than iLimit elements,
1092** leave an error message in pParse.
1093*/
1094void sqlite3ExprListCheckLength(
1095 Parse *pParse,
1096 ExprList *pEList,
danielk19777a15a4b2007-05-08 17:54:43 +00001097 const char *zObject
1098){
drhb1a6c3c2008-03-20 16:30:17 +00001099 int mx = pParse->db->aLimit[SQLITE_LIMIT_COLUMN];
drhc5499be2008-04-01 15:06:33 +00001100 testcase( pEList && pEList->nExpr==mx );
1101 testcase( pEList && pEList->nExpr==mx+1 );
drhb1a6c3c2008-03-20 16:30:17 +00001102 if( pEList && pEList->nExpr>mx ){
danielk19777a15a4b2007-05-08 17:54:43 +00001103 sqlite3ErrorMsg(pParse, "too many columns in %s", zObject);
1104 }
1105}
1106
1107/*
drha76b5df2002-02-23 02:32:10 +00001108** Delete an entire expression list.
1109*/
drh633e6d52008-07-28 19:34:53 +00001110void sqlite3ExprListDelete(sqlite3 *db, ExprList *pList){
drha76b5df2002-02-23 02:32:10 +00001111 int i;
drhbe5c89a2004-07-26 00:31:09 +00001112 struct ExprList_item *pItem;
drha76b5df2002-02-23 02:32:10 +00001113 if( pList==0 ) return;
drh1bdd9b52004-04-23 17:04:44 +00001114 assert( pList->a!=0 || (pList->nExpr==0 && pList->nAlloc==0) );
1115 assert( pList->nExpr<=pList->nAlloc );
drhbe5c89a2004-07-26 00:31:09 +00001116 for(pItem=pList->a, i=0; i<pList->nExpr; i++, pItem++){
drh633e6d52008-07-28 19:34:53 +00001117 sqlite3ExprDelete(db, pItem->pExpr);
1118 sqlite3DbFree(db, pItem->zName);
drhb7916a72009-05-27 10:31:29 +00001119 sqlite3DbFree(db, pItem->zSpan);
drha76b5df2002-02-23 02:32:10 +00001120 }
drh633e6d52008-07-28 19:34:53 +00001121 sqlite3DbFree(db, pList->a);
1122 sqlite3DbFree(db, pList);
drha76b5df2002-02-23 02:32:10 +00001123}
1124
1125/*
drh7d10d5a2008-08-20 16:35:10 +00001126** These routines are Walker callbacks. Walker.u.pi is a pointer
1127** to an integer. These routines are checking an expression to see
1128** if it is a constant. Set *Walker.u.pi to 0 if the expression is
1129** not constant.
drh73b211a2005-01-18 04:00:42 +00001130**
drh7d10d5a2008-08-20 16:35:10 +00001131** These callback routines are used to implement the following:
drh626a8792005-01-17 22:08:19 +00001132**
drh7d10d5a2008-08-20 16:35:10 +00001133** sqlite3ExprIsConstant()
1134** sqlite3ExprIsConstantNotJoin()
1135** sqlite3ExprIsConstantOrFunction()
drh87abf5c2005-08-25 12:45:04 +00001136**
drh626a8792005-01-17 22:08:19 +00001137*/
drh7d10d5a2008-08-20 16:35:10 +00001138static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){
drh626a8792005-01-17 22:08:19 +00001139
drh7d10d5a2008-08-20 16:35:10 +00001140 /* If pWalker->u.i is 3 then any term of the expression that comes from
drh0a168372007-06-08 00:20:47 +00001141 ** the ON or USING clauses of a join disqualifies the expression
1142 ** from being considered constant. */
drh7d10d5a2008-08-20 16:35:10 +00001143 if( pWalker->u.i==3 && ExprHasAnyProperty(pExpr, EP_FromJoin) ){
1144 pWalker->u.i = 0;
1145 return WRC_Abort;
drh0a168372007-06-08 00:20:47 +00001146 }
1147
drh626a8792005-01-17 22:08:19 +00001148 switch( pExpr->op ){
drheb55bd22005-06-30 17:04:21 +00001149 /* Consider functions to be constant if all their arguments are constant
drh7d10d5a2008-08-20 16:35:10 +00001150 ** and pWalker->u.i==2 */
drheb55bd22005-06-30 17:04:21 +00001151 case TK_FUNCTION:
drh7d10d5a2008-08-20 16:35:10 +00001152 if( pWalker->u.i==2 ) return 0;
drheb55bd22005-06-30 17:04:21 +00001153 /* Fall through */
drh626a8792005-01-17 22:08:19 +00001154 case TK_ID:
1155 case TK_COLUMN:
drh626a8792005-01-17 22:08:19 +00001156 case TK_AGG_FUNCTION:
drh13449892005-09-07 21:22:45 +00001157 case TK_AGG_COLUMN:
drhc5499be2008-04-01 15:06:33 +00001158 testcase( pExpr->op==TK_ID );
1159 testcase( pExpr->op==TK_COLUMN );
drhc5499be2008-04-01 15:06:33 +00001160 testcase( pExpr->op==TK_AGG_FUNCTION );
1161 testcase( pExpr->op==TK_AGG_COLUMN );
drh7d10d5a2008-08-20 16:35:10 +00001162 pWalker->u.i = 0;
1163 return WRC_Abort;
drh626a8792005-01-17 22:08:19 +00001164 default:
drhb74b1012009-05-28 21:04:37 +00001165 testcase( pExpr->op==TK_SELECT ); /* selectNodeIsConstant will disallow */
1166 testcase( pExpr->op==TK_EXISTS ); /* selectNodeIsConstant will disallow */
drh7d10d5a2008-08-20 16:35:10 +00001167 return WRC_Continue;
drh626a8792005-01-17 22:08:19 +00001168 }
1169}
danielk197762c14b32008-11-19 09:05:26 +00001170static int selectNodeIsConstant(Walker *pWalker, Select *NotUsed){
1171 UNUSED_PARAMETER(NotUsed);
drh7d10d5a2008-08-20 16:35:10 +00001172 pWalker->u.i = 0;
1173 return WRC_Abort;
1174}
1175static int exprIsConst(Expr *p, int initFlag){
1176 Walker w;
1177 w.u.i = initFlag;
1178 w.xExprCallback = exprNodeIsConstant;
1179 w.xSelectCallback = selectNodeIsConstant;
1180 sqlite3WalkExpr(&w, p);
1181 return w.u.i;
1182}
drh626a8792005-01-17 22:08:19 +00001183
1184/*
drhfef52082000-06-06 01:50:43 +00001185** Walk an expression tree. Return 1 if the expression is constant
drheb55bd22005-06-30 17:04:21 +00001186** and 0 if it involves variables or function calls.
drh23989372002-05-21 13:43:04 +00001187**
1188** For the purposes of this function, a double-quoted string (ex: "abc")
1189** is considered a variable but a single-quoted string (ex: 'abc') is
1190** a constant.
drhfef52082000-06-06 01:50:43 +00001191*/
danielk19774adee202004-05-08 08:23:19 +00001192int sqlite3ExprIsConstant(Expr *p){
drh7d10d5a2008-08-20 16:35:10 +00001193 return exprIsConst(p, 1);
drhfef52082000-06-06 01:50:43 +00001194}
1195
1196/*
drheb55bd22005-06-30 17:04:21 +00001197** Walk an expression tree. Return 1 if the expression is constant
drh0a168372007-06-08 00:20:47 +00001198** that does no originate from the ON or USING clauses of a join.
1199** Return 0 if it involves variables or function calls or terms from
1200** an ON or USING clause.
1201*/
1202int sqlite3ExprIsConstantNotJoin(Expr *p){
drh7d10d5a2008-08-20 16:35:10 +00001203 return exprIsConst(p, 3);
drh0a168372007-06-08 00:20:47 +00001204}
1205
1206/*
1207** Walk an expression tree. Return 1 if the expression is constant
drheb55bd22005-06-30 17:04:21 +00001208** or a function call with constant arguments. Return and 0 if there
1209** are any variables.
1210**
1211** For the purposes of this function, a double-quoted string (ex: "abc")
1212** is considered a variable but a single-quoted string (ex: 'abc') is
1213** a constant.
1214*/
1215int sqlite3ExprIsConstantOrFunction(Expr *p){
drh7d10d5a2008-08-20 16:35:10 +00001216 return exprIsConst(p, 2);
drheb55bd22005-06-30 17:04:21 +00001217}
1218
1219/*
drh73b211a2005-01-18 04:00:42 +00001220** If the expression p codes a constant integer that is small enough
drh202b2df2004-01-06 01:13:46 +00001221** to fit in a 32-bit integer, return 1 and put the value of the integer
1222** in *pValue. If the expression is not an integer or if it is too big
1223** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
drhe4de1fe2002-06-02 16:09:01 +00001224*/
danielk19774adee202004-05-08 08:23:19 +00001225int sqlite3ExprIsInteger(Expr *p, int *pValue){
drh92b01d52008-06-24 00:32:35 +00001226 int rc = 0;
1227 if( p->flags & EP_IntValue ){
drh33e619f2009-05-28 01:00:55 +00001228 *pValue = p->u.iValue;
drh92b01d52008-06-24 00:32:35 +00001229 return 1;
1230 }
drhe4de1fe2002-06-02 16:09:01 +00001231 switch( p->op ){
1232 case TK_INTEGER: {
drh33e619f2009-05-28 01:00:55 +00001233 rc = sqlite3GetInt32(p->u.zToken, pValue);
1234 assert( rc==0 );
drh202b2df2004-01-06 01:13:46 +00001235 break;
drhe4de1fe2002-06-02 16:09:01 +00001236 }
drh4b59ab52002-08-24 18:24:51 +00001237 case TK_UPLUS: {
drh92b01d52008-06-24 00:32:35 +00001238 rc = sqlite3ExprIsInteger(p->pLeft, pValue);
drhf6e369a2008-06-24 12:46:30 +00001239 break;
drh4b59ab52002-08-24 18:24:51 +00001240 }
drhe4de1fe2002-06-02 16:09:01 +00001241 case TK_UMINUS: {
1242 int v;
danielk19774adee202004-05-08 08:23:19 +00001243 if( sqlite3ExprIsInteger(p->pLeft, &v) ){
drhe4de1fe2002-06-02 16:09:01 +00001244 *pValue = -v;
drh92b01d52008-06-24 00:32:35 +00001245 rc = 1;
drhe4de1fe2002-06-02 16:09:01 +00001246 }
1247 break;
1248 }
1249 default: break;
1250 }
drh92b01d52008-06-24 00:32:35 +00001251 if( rc ){
drh33e619f2009-05-28 01:00:55 +00001252 assert( ExprHasAnyProperty(p, EP_Reduced|EP_TokenOnly)
1253 || (p->flags2 & EP2_MallocedToken)==0 );
drh92b01d52008-06-24 00:32:35 +00001254 p->op = TK_INTEGER;
1255 p->flags |= EP_IntValue;
drh33e619f2009-05-28 01:00:55 +00001256 p->u.iValue = *pValue;
drh92b01d52008-06-24 00:32:35 +00001257 }
1258 return rc;
drhe4de1fe2002-06-02 16:09:01 +00001259}
1260
1261/*
drh039fc322009-11-17 18:31:47 +00001262** Return FALSE if there is no chance that the expression can be NULL.
1263**
1264** If the expression might be NULL or if the expression is too complex
1265** to tell return TRUE.
1266**
1267** This routine is used as an optimization, to skip OP_IsNull opcodes
1268** when we know that a value cannot be NULL. Hence, a false positive
1269** (returning TRUE when in fact the expression can never be NULL) might
1270** be a small performance hit but is otherwise harmless. On the other
1271** hand, a false negative (returning FALSE when the result could be NULL)
1272** will likely result in an incorrect answer. So when in doubt, return
1273** TRUE.
1274*/
1275int sqlite3ExprCanBeNull(const Expr *p){
1276 u8 op;
drhcd7f4572009-11-19 14:48:40 +00001277 while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ p = p->pLeft; }
drh039fc322009-11-17 18:31:47 +00001278 op = p->op;
1279 if( op==TK_REGISTER ) op = p->op2;
1280 switch( op ){
1281 case TK_INTEGER:
1282 case TK_STRING:
1283 case TK_FLOAT:
1284 case TK_BLOB:
1285 return 0;
1286 default:
1287 return 1;
1288 }
1289}
1290
1291/*
drh2f2855b2009-11-18 01:25:26 +00001292** Generate an OP_IsNull instruction that tests register iReg and jumps
1293** to location iDest if the value in iReg is NULL. The value in iReg
1294** was computed by pExpr. If we can look at pExpr at compile-time and
1295** determine that it can never generate a NULL, then the OP_IsNull operation
1296** can be omitted.
1297*/
1298void sqlite3ExprCodeIsNullJump(
1299 Vdbe *v, /* The VDBE under construction */
1300 const Expr *pExpr, /* Only generate OP_IsNull if this expr can be NULL */
1301 int iReg, /* Test the value in this register for NULL */
1302 int iDest /* Jump here if the value is null */
1303){
1304 if( sqlite3ExprCanBeNull(pExpr) ){
1305 sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iDest);
1306 }
1307}
1308
1309/*
drh039fc322009-11-17 18:31:47 +00001310** Return TRUE if the given expression is a constant which would be
1311** unchanged by OP_Affinity with the affinity given in the second
1312** argument.
1313**
1314** This routine is used to determine if the OP_Affinity operation
1315** can be omitted. When in doubt return FALSE. A false negative
1316** is harmless. A false positive, however, can result in the wrong
1317** answer.
1318*/
1319int sqlite3ExprNeedsNoAffinityChange(const Expr *p, char aff){
1320 u8 op;
1321 if( aff==SQLITE_AFF_NONE ) return 1;
drhcd7f4572009-11-19 14:48:40 +00001322 while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ p = p->pLeft; }
drh039fc322009-11-17 18:31:47 +00001323 op = p->op;
1324 if( op==TK_REGISTER ) op = p->op2;
1325 switch( op ){
1326 case TK_INTEGER: {
1327 return aff==SQLITE_AFF_INTEGER || aff==SQLITE_AFF_NUMERIC;
1328 }
1329 case TK_FLOAT: {
1330 return aff==SQLITE_AFF_REAL || aff==SQLITE_AFF_NUMERIC;
1331 }
1332 case TK_STRING: {
1333 return aff==SQLITE_AFF_TEXT;
1334 }
1335 case TK_BLOB: {
1336 return 1;
1337 }
drh2f2855b2009-11-18 01:25:26 +00001338 case TK_COLUMN: {
1339 return p->iTable>=0 && p->iColumn<0
1340 && (aff==SQLITE_AFF_INTEGER || aff==SQLITE_AFF_NUMERIC);
1341 }
drh039fc322009-11-17 18:31:47 +00001342 default: {
1343 return 0;
1344 }
1345 }
1346}
1347
1348/*
drhc4a3c772001-04-04 11:48:57 +00001349** Return TRUE if the given string is a row-id column name.
1350*/
danielk19774adee202004-05-08 08:23:19 +00001351int sqlite3IsRowid(const char *z){
1352 if( sqlite3StrICmp(z, "_ROWID_")==0 ) return 1;
1353 if( sqlite3StrICmp(z, "ROWID")==0 ) return 1;
1354 if( sqlite3StrICmp(z, "OID")==0 ) return 1;
drhc4a3c772001-04-04 11:48:57 +00001355 return 0;
1356}
1357
danielk19779a96b662007-11-29 17:05:18 +00001358/*
drhb74b1012009-05-28 21:04:37 +00001359** Return true if we are able to the IN operator optimization on a
1360** query of the form
drhb287f4b2008-04-25 00:08:38 +00001361**
drhb74b1012009-05-28 21:04:37 +00001362** x IN (SELECT ...)
drhb287f4b2008-04-25 00:08:38 +00001363**
drhb74b1012009-05-28 21:04:37 +00001364** Where the SELECT... clause is as specified by the parameter to this
1365** routine.
1366**
1367** The Select object passed in has already been preprocessed and no
1368** errors have been found.
drhb287f4b2008-04-25 00:08:38 +00001369*/
1370#ifndef SQLITE_OMIT_SUBQUERY
1371static int isCandidateForInOpt(Select *p){
1372 SrcList *pSrc;
1373 ExprList *pEList;
1374 Table *pTab;
drhb287f4b2008-04-25 00:08:38 +00001375 if( p==0 ) return 0; /* right-hand side of IN is SELECT */
1376 if( p->pPrior ) return 0; /* Not a compound SELECT */
drh7d10d5a2008-08-20 16:35:10 +00001377 if( p->selFlags & (SF_Distinct|SF_Aggregate) ){
drhb74b1012009-05-28 21:04:37 +00001378 testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct );
1379 testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate );
1380 return 0; /* No DISTINCT keyword and no aggregate functions */
drh7d10d5a2008-08-20 16:35:10 +00001381 }
drhb74b1012009-05-28 21:04:37 +00001382 assert( p->pGroupBy==0 ); /* Has no GROUP BY clause */
drhb287f4b2008-04-25 00:08:38 +00001383 if( p->pLimit ) return 0; /* Has no LIMIT clause */
drhb74b1012009-05-28 21:04:37 +00001384 assert( p->pOffset==0 ); /* No LIMIT means no OFFSET */
drhb287f4b2008-04-25 00:08:38 +00001385 if( p->pWhere ) return 0; /* Has no WHERE clause */
1386 pSrc = p->pSrc;
drhd1fa7bc2009-01-10 13:24:50 +00001387 assert( pSrc!=0 );
1388 if( pSrc->nSrc!=1 ) return 0; /* Single term in FROM clause */
drhb74b1012009-05-28 21:04:37 +00001389 if( pSrc->a[0].pSelect ) return 0; /* FROM is not a subquery or view */
drhb287f4b2008-04-25 00:08:38 +00001390 pTab = pSrc->a[0].pTab;
drhb74b1012009-05-28 21:04:37 +00001391 if( NEVER(pTab==0) ) return 0;
1392 assert( pTab->pSelect==0 ); /* FROM clause is not a view */
drhb287f4b2008-04-25 00:08:38 +00001393 if( IsVirtual(pTab) ) return 0; /* FROM clause not a virtual table */
1394 pEList = p->pEList;
1395 if( pEList->nExpr!=1 ) return 0; /* One column in the result set */
1396 if( pEList->a[0].pExpr->op!=TK_COLUMN ) return 0; /* Result is a column */
1397 return 1;
1398}
1399#endif /* SQLITE_OMIT_SUBQUERY */
1400
1401/*
danielk19779a96b662007-11-29 17:05:18 +00001402** This function is used by the implementation of the IN (...) operator.
1403** It's job is to find or create a b-tree structure that may be used
1404** either to test for membership of the (...) set or to iterate through
drh85b623f2007-12-13 21:54:09 +00001405** its members, skipping duplicates.
danielk19779a96b662007-11-29 17:05:18 +00001406**
drhb74b1012009-05-28 21:04:37 +00001407** The index of the cursor opened on the b-tree (database table, database index
danielk19779a96b662007-11-29 17:05:18 +00001408** or ephermal table) is stored in pX->iTable before this function returns.
drhb74b1012009-05-28 21:04:37 +00001409** The returned value of this function indicates the b-tree type, as follows:
danielk19779a96b662007-11-29 17:05:18 +00001410**
1411** IN_INDEX_ROWID - The cursor was opened on a database table.
drh2d401ab2008-01-10 23:50:11 +00001412** IN_INDEX_INDEX - The cursor was opened on a database index.
danielk19779a96b662007-11-29 17:05:18 +00001413** IN_INDEX_EPH - The cursor was opened on a specially created and
1414** populated epheremal table.
1415**
drhb74b1012009-05-28 21:04:37 +00001416** An existing b-tree may only be used if the SELECT is of the simple
danielk19779a96b662007-11-29 17:05:18 +00001417** form:
1418**
1419** SELECT <column> FROM <table>
1420**
drhb74b1012009-05-28 21:04:37 +00001421** If the prNotFound parameter is 0, then the b-tree will be used to iterate
danielk19779a96b662007-11-29 17:05:18 +00001422** through the set members, skipping any duplicates. In this case an
1423** epheremal table must be used unless the selected <column> is guaranteed
1424** to be unique - either because it is an INTEGER PRIMARY KEY or it
drhb74b1012009-05-28 21:04:37 +00001425** has a UNIQUE constraint or UNIQUE index.
danielk19770cdc0222008-06-26 18:04:03 +00001426**
drhb74b1012009-05-28 21:04:37 +00001427** If the prNotFound parameter is not 0, then the b-tree will be used
danielk19770cdc0222008-06-26 18:04:03 +00001428** for fast set membership tests. In this case an epheremal table must
1429** be used unless <column> is an INTEGER PRIMARY KEY or an index can
1430** be found with <column> as its left-most column.
1431**
drhb74b1012009-05-28 21:04:37 +00001432** When the b-tree is being used for membership tests, the calling function
danielk19770cdc0222008-06-26 18:04:03 +00001433** needs to know whether or not the structure contains an SQL NULL
1434** value in order to correctly evaluate expressions like "X IN (Y, Z)".
drhe3365e62009-11-12 17:52:24 +00001435** If there is any chance that the (...) might contain a NULL value at
danielk19770cdc0222008-06-26 18:04:03 +00001436** runtime, then a register is allocated and the register number written
drhe3365e62009-11-12 17:52:24 +00001437** to *prNotFound. If there is no chance that the (...) contains a
danielk19770cdc0222008-06-26 18:04:03 +00001438** NULL value, then *prNotFound is left unchanged.
1439**
1440** If a register is allocated and its location stored in *prNotFound, then
drhe3365e62009-11-12 17:52:24 +00001441** its initial value is NULL. If the (...) does not remain constant
1442** for the duration of the query (i.e. the SELECT within the (...)
drhb74b1012009-05-28 21:04:37 +00001443** is a correlated subquery) then the value of the allocated register is
drhe3365e62009-11-12 17:52:24 +00001444** reset to NULL each time the subquery is rerun. This allows the
drhb74b1012009-05-28 21:04:37 +00001445** caller to use vdbe code equivalent to the following:
danielk19770cdc0222008-06-26 18:04:03 +00001446**
1447** if( register==NULL ){
1448** has_null = <test if data structure contains null>
1449** register = 1
1450** }
1451**
1452** in order to avoid running the <test if data structure contains null>
1453** test more often than is necessary.
danielk19779a96b662007-11-29 17:05:18 +00001454*/
danielk1977284f4ac2007-12-10 05:03:46 +00001455#ifndef SQLITE_OMIT_SUBQUERY
danielk19770cdc0222008-06-26 18:04:03 +00001456int sqlite3FindInIndex(Parse *pParse, Expr *pX, int *prNotFound){
drhb74b1012009-05-28 21:04:37 +00001457 Select *p; /* SELECT to the right of IN operator */
1458 int eType = 0; /* Type of RHS table. IN_INDEX_* */
1459 int iTab = pParse->nTab++; /* Cursor of the RHS table */
1460 int mustBeUnique = (prNotFound==0); /* True if RHS must be unique */
danielk19779a96b662007-11-29 17:05:18 +00001461
drh1450bc62009-10-30 13:25:56 +00001462 assert( pX->op==TK_IN );
1463
drhb74b1012009-05-28 21:04:37 +00001464 /* Check to see if an existing table or index can be used to
1465 ** satisfy the query. This is preferable to generating a new
1466 ** ephemeral table.
danielk19779a96b662007-11-29 17:05:18 +00001467 */
danielk19776ab3a2e2009-02-19 14:39:25 +00001468 p = (ExprHasProperty(pX, EP_xIsSelect) ? pX->x.pSelect : 0);
drhfd773cf2009-05-29 14:39:07 +00001469 if( ALWAYS(pParse->nErr==0) && isCandidateForInOpt(p) ){
danielk1977e1fb65a2009-04-02 17:23:32 +00001470 sqlite3 *db = pParse->db; /* Database connection */
1471 Expr *pExpr = p->pEList->a[0].pExpr; /* Expression <column> */
1472 int iCol = pExpr->iColumn; /* Index of column <column> */
1473 Vdbe *v = sqlite3GetVdbe(pParse); /* Virtual machine being coded */
1474 Table *pTab = p->pSrc->a[0].pTab; /* Table <table>. */
1475 int iDb; /* Database idx for pTab */
1476
1477 /* Code an OP_VerifyCookie and OP_TableLock for <table>. */
1478 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
1479 sqlite3CodeVerifySchema(pParse, iDb);
1480 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
danielk19779a96b662007-11-29 17:05:18 +00001481
1482 /* This function is only called from two places. In both cases the vdbe
1483 ** has already been allocated. So assume sqlite3GetVdbe() is always
1484 ** successful here.
1485 */
1486 assert(v);
1487 if( iCol<0 ){
drh0a07c102008-01-03 18:03:08 +00001488 int iMem = ++pParse->nMem;
danielk19779a96b662007-11-29 17:05:18 +00001489 int iAddr;
danielk19779a96b662007-11-29 17:05:18 +00001490
drh892d3172008-01-10 03:46:36 +00001491 iAddr = sqlite3VdbeAddOp1(v, OP_If, iMem);
drh4c583122008-01-04 22:01:03 +00001492 sqlite3VdbeAddOp2(v, OP_Integer, 1, iMem);
danielk19779a96b662007-11-29 17:05:18 +00001493
1494 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
1495 eType = IN_INDEX_ROWID;
1496
1497 sqlite3VdbeJumpHere(v, iAddr);
1498 }else{
danielk1977e1fb65a2009-04-02 17:23:32 +00001499 Index *pIdx; /* Iterator variable */
1500
drhb74b1012009-05-28 21:04:37 +00001501 /* The collation sequence used by the comparison. If an index is to
danielk19779a96b662007-11-29 17:05:18 +00001502 ** be used in place of a temp-table, it must be ordered according
danielk1977e1fb65a2009-04-02 17:23:32 +00001503 ** to this collation sequence. */
danielk19779a96b662007-11-29 17:05:18 +00001504 CollSeq *pReq = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pExpr);
1505
1506 /* Check that the affinity that will be used to perform the
1507 ** comparison is the same as the affinity of the column. If
1508 ** it is not, it is not possible to use any index.
1509 */
danielk19779a96b662007-11-29 17:05:18 +00001510 char aff = comparisonAffinity(pX);
1511 int affinity_ok = (pTab->aCol[iCol].affinity==aff||aff==SQLITE_AFF_NONE);
1512
1513 for(pIdx=pTab->pIndex; pIdx && eType==0 && affinity_ok; pIdx=pIdx->pNext){
1514 if( (pIdx->aiColumn[0]==iCol)
drhb74b1012009-05-28 21:04:37 +00001515 && sqlite3FindCollSeq(db, ENC(db), pIdx->azColl[0], 0)==pReq
danielk19779a96b662007-11-29 17:05:18 +00001516 && (!mustBeUnique || (pIdx->nColumn==1 && pIdx->onError!=OE_None))
1517 ){
drh0a07c102008-01-03 18:03:08 +00001518 int iMem = ++pParse->nMem;
danielk19779a96b662007-11-29 17:05:18 +00001519 int iAddr;
1520 char *pKey;
1521
1522 pKey = (char *)sqlite3IndexKeyinfo(pParse, pIdx);
drh892d3172008-01-10 03:46:36 +00001523 iAddr = sqlite3VdbeAddOp1(v, OP_If, iMem);
drh4c583122008-01-04 22:01:03 +00001524 sqlite3VdbeAddOp2(v, OP_Integer, 1, iMem);
danielk19779a96b662007-11-29 17:05:18 +00001525
danielk1977207872a2008-01-03 07:54:23 +00001526 sqlite3VdbeAddOp4(v, OP_OpenRead, iTab, pIdx->tnum, iDb,
drh66a51672008-01-03 00:01:23 +00001527 pKey,P4_KEYINFO_HANDOFF);
danielk1977207872a2008-01-03 07:54:23 +00001528 VdbeComment((v, "%s", pIdx->zName));
danielk19779a96b662007-11-29 17:05:18 +00001529 eType = IN_INDEX_INDEX;
danielk19779a96b662007-11-29 17:05:18 +00001530
1531 sqlite3VdbeJumpHere(v, iAddr);
danielk19770cdc0222008-06-26 18:04:03 +00001532 if( prNotFound && !pTab->aCol[iCol].notNull ){
1533 *prNotFound = ++pParse->nMem;
1534 }
danielk19779a96b662007-11-29 17:05:18 +00001535 }
1536 }
1537 }
1538 }
1539
1540 if( eType==0 ){
drh1450bc62009-10-30 13:25:56 +00001541 /* Could not found an existing table or index to use as the RHS b-tree.
drhb74b1012009-05-28 21:04:37 +00001542 ** We will have to generate an ephemeral table to do the job.
1543 */
danielk19770cdc0222008-06-26 18:04:03 +00001544 int rMayHaveNull = 0;
danielk197741a05b72008-10-02 13:50:55 +00001545 eType = IN_INDEX_EPH;
danielk19770cdc0222008-06-26 18:04:03 +00001546 if( prNotFound ){
1547 *prNotFound = rMayHaveNull = ++pParse->nMem;
danielk19776ab3a2e2009-02-19 14:39:25 +00001548 }else if( pX->pLeft->iColumn<0 && !ExprHasAnyProperty(pX, EP_xIsSelect) ){
danielk197741a05b72008-10-02 13:50:55 +00001549 eType = IN_INDEX_ROWID;
danielk19770cdc0222008-06-26 18:04:03 +00001550 }
danielk197741a05b72008-10-02 13:50:55 +00001551 sqlite3CodeSubselect(pParse, pX, rMayHaveNull, eType==IN_INDEX_ROWID);
danielk19779a96b662007-11-29 17:05:18 +00001552 }else{
1553 pX->iTable = iTab;
1554 }
1555 return eType;
1556}
danielk1977284f4ac2007-12-10 05:03:46 +00001557#endif
drh626a8792005-01-17 22:08:19 +00001558
1559/*
drh9cbe6352005-11-29 03:13:21 +00001560** Generate code for scalar subqueries used as an expression
1561** and IN operators. Examples:
drh626a8792005-01-17 22:08:19 +00001562**
drh9cbe6352005-11-29 03:13:21 +00001563** (SELECT a FROM b) -- subquery
1564** EXISTS (SELECT a FROM b) -- EXISTS subquery
1565** x IN (4,5,11) -- IN operator with list on right-hand side
1566** x IN (SELECT a FROM b) -- IN operator with subquery on the right
drhfef52082000-06-06 01:50:43 +00001567**
drh9cbe6352005-11-29 03:13:21 +00001568** The pExpr parameter describes the expression that contains the IN
1569** operator or subquery.
danielk197741a05b72008-10-02 13:50:55 +00001570**
1571** If parameter isRowid is non-zero, then expression pExpr is guaranteed
1572** to be of the form "<rowid> IN (?, ?, ?)", where <rowid> is a reference
1573** to some integer key column of a table B-Tree. In this case, use an
1574** intkey B-Tree to store the set of IN(...) values instead of the usual
1575** (slower) variable length keys B-Tree.
drhfd773cf2009-05-29 14:39:07 +00001576**
1577** If rMayHaveNull is non-zero, that means that the operation is an IN
1578** (not a SELECT or EXISTS) and that the RHS might contains NULLs.
1579** Furthermore, the IN is in a WHERE clause and that we really want
1580** to iterate over the RHS of the IN operator in order to quickly locate
1581** all corresponding LHS elements. All this routine does is initialize
1582** the register given by rMayHaveNull to NULL. Calling routines will take
1583** care of changing this register value to non-NULL if the RHS is NULL-free.
1584**
1585** If rMayHaveNull is zero, that means that the subquery is being used
1586** for membership testing only. There is no need to initialize any
1587** registers to indicate the presense or absence of NULLs on the RHS.
drh1450bc62009-10-30 13:25:56 +00001588**
1589** For a SELECT or EXISTS operator, return the register that holds the
1590** result. For IN operators or if an error occurs, the return value is 0.
drhcce7d172000-05-31 15:34:51 +00001591*/
drh51522cd2005-01-20 13:36:19 +00001592#ifndef SQLITE_OMIT_SUBQUERY
drh1450bc62009-10-30 13:25:56 +00001593int sqlite3CodeSubselect(
drhfd773cf2009-05-29 14:39:07 +00001594 Parse *pParse, /* Parsing context */
1595 Expr *pExpr, /* The IN, SELECT, or EXISTS operator */
1596 int rMayHaveNull, /* Register that records whether NULLs exist in RHS */
1597 int isRowid /* If true, LHS of IN operator is a rowid */
danielk197741a05b72008-10-02 13:50:55 +00001598){
drh57dbd7b2005-07-08 18:25:26 +00001599 int testAddr = 0; /* One-time test address */
drh1450bc62009-10-30 13:25:56 +00001600 int rReg = 0; /* Register storing resulting */
danielk1977b3bce662005-01-29 08:32:43 +00001601 Vdbe *v = sqlite3GetVdbe(pParse);
drh1450bc62009-10-30 13:25:56 +00001602 if( NEVER(v==0) ) return 0;
drhceea3322009-04-23 13:22:42 +00001603 sqlite3ExprCachePush(pParse);
danielk1977fc976062007-05-10 10:46:56 +00001604
drh57dbd7b2005-07-08 18:25:26 +00001605 /* This code must be run in its entirety every time it is encountered
1606 ** if any of the following is true:
1607 **
1608 ** * The right-hand side is a correlated subquery
1609 ** * The right-hand side is an expression list containing variables
1610 ** * We are inside a trigger
1611 **
1612 ** If all of the above are false, then we can run this code just once
1613 ** save the results, and reuse the same result on subsequent invocations.
danielk1977b3bce662005-01-29 08:32:43 +00001614 */
dan165921a2009-08-28 18:53:45 +00001615 if( !ExprHasAnyProperty(pExpr, EP_VarSelect) && !pParse->pTriggerTab ){
drh0a07c102008-01-03 18:03:08 +00001616 int mem = ++pParse->nMem;
drh892d3172008-01-10 03:46:36 +00001617 sqlite3VdbeAddOp1(v, OP_If, mem);
1618 testAddr = sqlite3VdbeAddOp2(v, OP_Integer, 1, mem);
drh17435752007-08-16 04:30:38 +00001619 assert( testAddr>0 || pParse->db->mallocFailed );
danielk1977b3bce662005-01-29 08:32:43 +00001620 }
1621
drhcce7d172000-05-31 15:34:51 +00001622 switch( pExpr->op ){
drhfef52082000-06-06 01:50:43 +00001623 case TK_IN: {
danielk1977e014a832004-05-17 10:48:57 +00001624 char affinity;
drhd3d39e92004-05-20 22:16:29 +00001625 KeyInfo keyInfo;
drhb9bb7c12006-06-11 23:41:55 +00001626 int addr; /* Address of OP_OpenEphemeral instruction */
danielk197741a05b72008-10-02 13:50:55 +00001627 Expr *pLeft = pExpr->pLeft;
drhd3d39e92004-05-20 22:16:29 +00001628
danielk19770cdc0222008-06-26 18:04:03 +00001629 if( rMayHaveNull ){
1630 sqlite3VdbeAddOp2(v, OP_Null, 0, rMayHaveNull);
1631 }
1632
danielk197741a05b72008-10-02 13:50:55 +00001633 affinity = sqlite3ExprAffinity(pLeft);
danielk1977e014a832004-05-17 10:48:57 +00001634
1635 /* Whether this is an 'x IN(SELECT...)' or an 'x IN(<exprlist>)'
drh8cff69d2009-11-12 19:59:44 +00001636 ** expression it is handled the same way. An ephemeral table is
danielk1977e014a832004-05-17 10:48:57 +00001637 ** filled with single-field index keys representing the results
1638 ** from the SELECT or the <exprlist>.
1639 **
1640 ** If the 'x' expression is a column value, or the SELECT...
1641 ** statement returns a column value, then the affinity of that
1642 ** column is used to build the index keys. If both 'x' and the
1643 ** SELECT... statement are columns, then numeric affinity is used
1644 ** if either column has NUMERIC or INTEGER affinity. If neither
1645 ** 'x' nor the SELECT... statement are columns, then numeric affinity
1646 ** is used.
1647 */
1648 pExpr->iTable = pParse->nTab++;
danielk197741a05b72008-10-02 13:50:55 +00001649 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, !isRowid);
drhd3d39e92004-05-20 22:16:29 +00001650 memset(&keyInfo, 0, sizeof(keyInfo));
1651 keyInfo.nField = 1;
danielk1977e014a832004-05-17 10:48:57 +00001652
danielk19776ab3a2e2009-02-19 14:39:25 +00001653 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
drhfef52082000-06-06 01:50:43 +00001654 /* Case 1: expr IN (SELECT ...)
1655 **
danielk1977e014a832004-05-17 10:48:57 +00001656 ** Generate code to write the results of the select into the temporary
1657 ** table allocated and opened above.
drhfef52082000-06-06 01:50:43 +00001658 */
drh1013c932008-01-06 00:25:21 +00001659 SelectDest dest;
drhbe5c89a2004-07-26 00:31:09 +00001660 ExprList *pEList;
drh1013c932008-01-06 00:25:21 +00001661
danielk197741a05b72008-10-02 13:50:55 +00001662 assert( !isRowid );
drh1013c932008-01-06 00:25:21 +00001663 sqlite3SelectDestInit(&dest, SRT_Set, pExpr->iTable);
drh1bd10f82008-12-10 21:19:56 +00001664 dest.affinity = (u8)affinity;
danielk1977e014a832004-05-17 10:48:57 +00001665 assert( (pExpr->iTable&0x0000FFFF)==pExpr->iTable );
danielk19776ab3a2e2009-02-19 14:39:25 +00001666 if( sqlite3Select(pParse, pExpr->x.pSelect, &dest) ){
drh1450bc62009-10-30 13:25:56 +00001667 return 0;
drh94ccde52007-04-13 16:06:32 +00001668 }
danielk19776ab3a2e2009-02-19 14:39:25 +00001669 pEList = pExpr->x.pSelect->pEList;
drhfd773cf2009-05-29 14:39:07 +00001670 if( ALWAYS(pEList!=0 && pEList->nExpr>0) ){
danielk1977bcbb04e2007-05-29 12:11:29 +00001671 keyInfo.aColl[0] = sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft,
drhbe5c89a2004-07-26 00:31:09 +00001672 pEList->a[0].pExpr);
danielk19770202b292004-06-09 09:55:16 +00001673 }
drhfd773cf2009-05-29 14:39:07 +00001674 }else if( pExpr->x.pList!=0 ){
drhfef52082000-06-06 01:50:43 +00001675 /* Case 2: expr IN (exprlist)
1676 **
drhfd131da2007-08-07 17:13:03 +00001677 ** For each expression, build an index key from the evaluation and
danielk1977e014a832004-05-17 10:48:57 +00001678 ** store it in the temporary table. If <expr> is a column, then use
1679 ** that columns affinity when building index keys. If <expr> is not
1680 ** a column, use numeric affinity.
drhfef52082000-06-06 01:50:43 +00001681 */
danielk1977e014a832004-05-17 10:48:57 +00001682 int i;
danielk19776ab3a2e2009-02-19 14:39:25 +00001683 ExprList *pList = pExpr->x.pList;
drh57dbd7b2005-07-08 18:25:26 +00001684 struct ExprList_item *pItem;
drhecc31802008-06-26 20:06:06 +00001685 int r1, r2, r3;
drh57dbd7b2005-07-08 18:25:26 +00001686
danielk1977e014a832004-05-17 10:48:57 +00001687 if( !affinity ){
drh8159a352006-05-23 23:22:29 +00001688 affinity = SQLITE_AFF_NONE;
danielk1977e014a832004-05-17 10:48:57 +00001689 }
drh7d10d5a2008-08-20 16:35:10 +00001690 keyInfo.aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
danielk1977e014a832004-05-17 10:48:57 +00001691
1692 /* Loop through each expression in <exprlist>. */
drh2d401ab2008-01-10 23:50:11 +00001693 r1 = sqlite3GetTempReg(pParse);
1694 r2 = sqlite3GetTempReg(pParse);
danielk19774e7f36a2008-10-02 16:42:06 +00001695 sqlite3VdbeAddOp2(v, OP_Null, 0, r2);
drh57dbd7b2005-07-08 18:25:26 +00001696 for(i=pList->nExpr, pItem=pList->a; i>0; i--, pItem++){
1697 Expr *pE2 = pItem->pExpr;
drhe05c9292009-10-29 13:48:10 +00001698 int iValToIns;
danielk1977e014a832004-05-17 10:48:57 +00001699
drh57dbd7b2005-07-08 18:25:26 +00001700 /* If the expression is not constant then we will need to
1701 ** disable the test that was generated above that makes sure
1702 ** this code only executes once. Because for a non-constant
1703 ** expression we need to rerun this code each time.
1704 */
drh892d3172008-01-10 03:46:36 +00001705 if( testAddr && !sqlite3ExprIsConstant(pE2) ){
1706 sqlite3VdbeChangeToNoop(v, testAddr-1, 2);
drh57dbd7b2005-07-08 18:25:26 +00001707 testAddr = 0;
drh4794b982000-06-06 13:54:14 +00001708 }
danielk1977e014a832004-05-17 10:48:57 +00001709
1710 /* Evaluate the expression and insert it into the temp table */
drhe05c9292009-10-29 13:48:10 +00001711 if( isRowid && sqlite3ExprIsInteger(pE2, &iValToIns) ){
1712 sqlite3VdbeAddOp3(v, OP_InsertInt, pExpr->iTable, r2, iValToIns);
danielk197741a05b72008-10-02 13:50:55 +00001713 }else{
drhe05c9292009-10-29 13:48:10 +00001714 r3 = sqlite3ExprCodeTarget(pParse, pE2, r1);
1715 if( isRowid ){
1716 sqlite3VdbeAddOp2(v, OP_MustBeInt, r3,
1717 sqlite3VdbeCurrentAddr(v)+2);
1718 sqlite3VdbeAddOp3(v, OP_Insert, pExpr->iTable, r2, r3);
1719 }else{
1720 sqlite3VdbeAddOp4(v, OP_MakeRecord, r3, 1, r2, &affinity, 1);
1721 sqlite3ExprCacheAffinityChange(pParse, r3, 1);
1722 sqlite3VdbeAddOp2(v, OP_IdxInsert, pExpr->iTable, r2);
1723 }
danielk197741a05b72008-10-02 13:50:55 +00001724 }
drhfef52082000-06-06 01:50:43 +00001725 }
drh2d401ab2008-01-10 23:50:11 +00001726 sqlite3ReleaseTempReg(pParse, r1);
1727 sqlite3ReleaseTempReg(pParse, r2);
drhfef52082000-06-06 01:50:43 +00001728 }
danielk197741a05b72008-10-02 13:50:55 +00001729 if( !isRowid ){
1730 sqlite3VdbeChangeP4(v, addr, (void *)&keyInfo, P4_KEYINFO);
1731 }
danielk1977b3bce662005-01-29 08:32:43 +00001732 break;
drhfef52082000-06-06 01:50:43 +00001733 }
1734
drh51522cd2005-01-20 13:36:19 +00001735 case TK_EXISTS:
drhfd773cf2009-05-29 14:39:07 +00001736 case TK_SELECT:
1737 default: {
drhfd773cf2009-05-29 14:39:07 +00001738 /* If this has to be a scalar SELECT. Generate code to put the
drhfef52082000-06-06 01:50:43 +00001739 ** value of this select in a memory cell and record the number
drhfd773cf2009-05-29 14:39:07 +00001740 ** of the memory cell in iColumn. If this is an EXISTS, write
1741 ** an integer 0 (not exists) or 1 (exists) into a memory cell
1742 ** and record that memory cell in iColumn.
drhfef52082000-06-06 01:50:43 +00001743 */
drhfd773cf2009-05-29 14:39:07 +00001744 static const Token one = { "1", 1 }; /* Token for literal value 1 */
1745 Select *pSel; /* SELECT statement to encode */
1746 SelectDest dest; /* How to deal with SELECt result */
drh1398ad32005-01-19 23:24:50 +00001747
shanecf697392009-06-01 16:53:09 +00001748 testcase( pExpr->op==TK_EXISTS );
1749 testcase( pExpr->op==TK_SELECT );
1750 assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT );
1751
danielk19776ab3a2e2009-02-19 14:39:25 +00001752 assert( ExprHasProperty(pExpr, EP_xIsSelect) );
1753 pSel = pExpr->x.pSelect;
drh1013c932008-01-06 00:25:21 +00001754 sqlite3SelectDestInit(&dest, 0, ++pParse->nMem);
drh51522cd2005-01-20 13:36:19 +00001755 if( pExpr->op==TK_SELECT ){
danielk19776c8c8ce2008-01-02 16:27:09 +00001756 dest.eDest = SRT_Mem;
drh4c583122008-01-04 22:01:03 +00001757 sqlite3VdbeAddOp2(v, OP_Null, 0, dest.iParm);
drhd4e70eb2008-01-02 00:34:36 +00001758 VdbeComment((v, "Init subquery result"));
drh51522cd2005-01-20 13:36:19 +00001759 }else{
danielk19776c8c8ce2008-01-02 16:27:09 +00001760 dest.eDest = SRT_Exists;
drh4c583122008-01-04 22:01:03 +00001761 sqlite3VdbeAddOp2(v, OP_Integer, 0, dest.iParm);
drhd4e70eb2008-01-02 00:34:36 +00001762 VdbeComment((v, "Init EXISTS result"));
drh51522cd2005-01-20 13:36:19 +00001763 }
drh633e6d52008-07-28 19:34:53 +00001764 sqlite3ExprDelete(pParse->db, pSel->pLimit);
danielk1977a1644fd2007-08-29 12:31:25 +00001765 pSel->pLimit = sqlite3PExpr(pParse, TK_INTEGER, 0, 0, &one);
drh7d10d5a2008-08-20 16:35:10 +00001766 if( sqlite3Select(pParse, pSel, &dest) ){
drh1450bc62009-10-30 13:25:56 +00001767 return 0;
drh94ccde52007-04-13 16:06:32 +00001768 }
drh1450bc62009-10-30 13:25:56 +00001769 rReg = dest.iParm;
drh33e619f2009-05-28 01:00:55 +00001770 ExprSetIrreducible(pExpr);
danielk1977b3bce662005-01-29 08:32:43 +00001771 break;
drhcce7d172000-05-31 15:34:51 +00001772 }
1773 }
danielk1977b3bce662005-01-29 08:32:43 +00001774
drh57dbd7b2005-07-08 18:25:26 +00001775 if( testAddr ){
drh892d3172008-01-10 03:46:36 +00001776 sqlite3VdbeJumpHere(v, testAddr-1);
danielk1977b3bce662005-01-29 08:32:43 +00001777 }
drhceea3322009-04-23 13:22:42 +00001778 sqlite3ExprCachePop(pParse, 1);
danielk1977fc976062007-05-10 10:46:56 +00001779
drh1450bc62009-10-30 13:25:56 +00001780 return rReg;
drhcce7d172000-05-31 15:34:51 +00001781}
drh51522cd2005-01-20 13:36:19 +00001782#endif /* SQLITE_OMIT_SUBQUERY */
drhcce7d172000-05-31 15:34:51 +00001783
drhe3365e62009-11-12 17:52:24 +00001784#ifndef SQLITE_OMIT_SUBQUERY
1785/*
1786** Generate code for an IN expression.
1787**
1788** x IN (SELECT ...)
1789** x IN (value, value, ...)
1790**
1791** The left-hand side (LHS) is a scalar expression. The right-hand side (RHS)
1792** is an array of zero or more values. The expression is true if the LHS is
1793** contained within the RHS. The value of the expression is unknown (NULL)
1794** if the LHS is NULL or if the LHS is not contained within the RHS and the
1795** RHS contains one or more NULL values.
1796**
1797** This routine generates code will jump to destIfFalse if the LHS is not
1798** contained within the RHS. If due to NULLs we cannot determine if the LHS
1799** is contained in the RHS then jump to destIfNull. If the LHS is contained
1800** within the RHS then fall through.
1801*/
1802static void sqlite3ExprCodeIN(
1803 Parse *pParse, /* Parsing and code generating context */
1804 Expr *pExpr, /* The IN expression */
1805 int destIfFalse, /* Jump here if LHS is not contained in the RHS */
1806 int destIfNull /* Jump here if the results are unknown due to NULLs */
1807){
1808 int rRhsHasNull = 0; /* Register that is true if RHS contains NULL values */
1809 char affinity; /* Comparison affinity to use */
1810 int eType; /* Type of the RHS */
1811 int r1; /* Temporary use register */
1812 Vdbe *v; /* Statement under construction */
1813
1814 /* Compute the RHS. After this step, the table with cursor
1815 ** pExpr->iTable will contains the values that make up the RHS.
1816 */
1817 v = pParse->pVdbe;
1818 assert( v!=0 ); /* OOM detected prior to this routine */
1819 VdbeNoopComment((v, "begin IN expr"));
1820 eType = sqlite3FindInIndex(pParse, pExpr, &rRhsHasNull);
1821
1822 /* Figure out the affinity to use to create a key from the results
1823 ** of the expression. affinityStr stores a static string suitable for
1824 ** P4 of OP_MakeRecord.
1825 */
1826 affinity = comparisonAffinity(pExpr);
1827
1828 /* Code the LHS, the <expr> from "<expr> IN (...)".
1829 */
1830 sqlite3ExprCachePush(pParse);
1831 r1 = sqlite3GetTempReg(pParse);
1832 sqlite3ExprCode(pParse, pExpr->pLeft, r1);
1833 sqlite3VdbeAddOp2(v, OP_IsNull, r1, destIfNull);
1834
1835
1836 if( eType==IN_INDEX_ROWID ){
1837 /* In this case, the RHS is the ROWID of table b-tree
1838 */
1839 sqlite3VdbeAddOp2(v, OP_MustBeInt, r1, destIfFalse);
1840 sqlite3VdbeAddOp3(v, OP_NotExists, pExpr->iTable, destIfFalse, r1);
1841 }else{
1842 /* In this case, the RHS is an index b-tree.
1843 */
drh8cff69d2009-11-12 19:59:44 +00001844 sqlite3VdbeAddOp4(v, OP_Affinity, r1, 1, 0, &affinity, 1);
drhe3365e62009-11-12 17:52:24 +00001845
1846 /* If the set membership test fails, then the result of the
1847 ** "x IN (...)" expression must be either 0 or NULL. If the set
1848 ** contains no NULL values, then the result is 0. If the set
1849 ** contains one or more NULL values, then the result of the
1850 ** expression is also NULL.
1851 */
1852 if( rRhsHasNull==0 || destIfFalse==destIfNull ){
1853 /* This branch runs if it is known at compile time that the RHS
1854 ** cannot contain NULL values. This happens as the result
1855 ** of a "NOT NULL" constraint in the database schema.
1856 **
1857 ** Also run this branch if NULL is equivalent to FALSE
1858 ** for this particular IN operator.
1859 */
drh8cff69d2009-11-12 19:59:44 +00001860 sqlite3VdbeAddOp4Int(v, OP_NotFound, pExpr->iTable, destIfFalse, r1, 1);
drhe3365e62009-11-12 17:52:24 +00001861
1862 }else{
1863 /* In this branch, the RHS of the IN might contain a NULL and
1864 ** the presence of a NULL on the RHS makes a difference in the
1865 ** outcome.
1866 */
drhe3365e62009-11-12 17:52:24 +00001867 int j1, j2, j3;
1868
1869 /* First check to see if the LHS is contained in the RHS. If so,
1870 ** then the presence of NULLs in the RHS does not matter, so jump
1871 ** over all of the code that follows.
1872 */
drh8cff69d2009-11-12 19:59:44 +00001873 j1 = sqlite3VdbeAddOp4Int(v, OP_Found, pExpr->iTable, 0, r1, 1);
drhe3365e62009-11-12 17:52:24 +00001874
1875 /* Here we begin generating code that runs if the LHS is not
1876 ** contained within the RHS. Generate additional code that
1877 ** tests the RHS for NULLs. If the RHS contains a NULL then
1878 ** jump to destIfNull. If there are no NULLs in the RHS then
1879 ** jump to destIfFalse.
1880 */
1881 j2 = sqlite3VdbeAddOp1(v, OP_NotNull, rRhsHasNull);
drh8cff69d2009-11-12 19:59:44 +00001882 j3 = sqlite3VdbeAddOp4Int(v, OP_Found, pExpr->iTable, 0, rRhsHasNull, 1);
drhe3365e62009-11-12 17:52:24 +00001883 sqlite3VdbeAddOp2(v, OP_Integer, -1, rRhsHasNull);
1884 sqlite3VdbeJumpHere(v, j3);
1885 sqlite3VdbeAddOp2(v, OP_AddImm, rRhsHasNull, 1);
1886 sqlite3VdbeJumpHere(v, j2);
1887
1888 /* Jump to the appropriate target depending on whether or not
1889 ** the RHS contains a NULL
1890 */
1891 sqlite3VdbeAddOp2(v, OP_If, rRhsHasNull, destIfNull);
1892 sqlite3VdbeAddOp2(v, OP_Goto, 0, destIfFalse);
1893
1894 /* The OP_Found at the top of this branch jumps here when true,
1895 ** causing the overall IN expression evaluation to fall through.
1896 */
1897 sqlite3VdbeJumpHere(v, j1);
1898 }
drhe3365e62009-11-12 17:52:24 +00001899 }
1900 sqlite3ReleaseTempReg(pParse, r1);
1901 sqlite3ExprCachePop(pParse, 1);
1902 VdbeComment((v, "end IN expr"));
1903}
1904#endif /* SQLITE_OMIT_SUBQUERY */
1905
drhcce7d172000-05-31 15:34:51 +00001906/*
drh598f1342007-10-23 15:39:45 +00001907** Duplicate an 8-byte value
1908*/
1909static char *dup8bytes(Vdbe *v, const char *in){
1910 char *out = sqlite3DbMallocRaw(sqlite3VdbeDb(v), 8);
1911 if( out ){
1912 memcpy(out, in, 8);
1913 }
1914 return out;
1915}
1916
1917/*
1918** Generate an instruction that will put the floating point
drh9cbf3422008-01-17 16:22:13 +00001919** value described by z[0..n-1] into register iMem.
drh0cf19ed2007-10-23 18:55:48 +00001920**
1921** The z[] string will probably not be zero-terminated. But the
1922** z[n] character is guaranteed to be something that does not look
1923** like the continuation of the number.
drh598f1342007-10-23 15:39:45 +00001924*/
drhb7916a72009-05-27 10:31:29 +00001925static void codeReal(Vdbe *v, const char *z, int negateFlag, int iMem){
drhfd773cf2009-05-29 14:39:07 +00001926 if( ALWAYS(z!=0) ){
drh598f1342007-10-23 15:39:45 +00001927 double value;
1928 char *zV;
1929 sqlite3AtoF(z, &value);
drhd0015162009-08-21 13:22:25 +00001930 assert( !sqlite3IsNaN(value) ); /* The new AtoF never returns NaN */
1931 if( negateFlag ) value = -value;
1932 zV = dup8bytes(v, (char*)&value);
1933 sqlite3VdbeAddOp4(v, OP_Real, 0, iMem, 0, zV, P4_REAL);
drh598f1342007-10-23 15:39:45 +00001934 }
1935}
1936
1937
1938/*
drhfec19aa2004-05-19 20:41:03 +00001939** Generate an instruction that will put the integer describe by
drh9cbf3422008-01-17 16:22:13 +00001940** text z[0..n-1] into register iMem.
drh0cf19ed2007-10-23 18:55:48 +00001941**
1942** The z[] string will probably not be zero-terminated. But the
1943** z[n] character is guaranteed to be something that does not look
1944** like the continuation of the number.
drhfec19aa2004-05-19 20:41:03 +00001945*/
drh92b01d52008-06-24 00:32:35 +00001946static void codeInteger(Vdbe *v, Expr *pExpr, int negFlag, int iMem){
drh92b01d52008-06-24 00:32:35 +00001947 if( pExpr->flags & EP_IntValue ){
drh33e619f2009-05-28 01:00:55 +00001948 int i = pExpr->u.iValue;
drh92b01d52008-06-24 00:32:35 +00001949 if( negFlag ) i = -i;
1950 sqlite3VdbeAddOp2(v, OP_Integer, i, iMem);
drhfd773cf2009-05-29 14:39:07 +00001951 }else{
1952 const char *z = pExpr->u.zToken;
1953 assert( z!=0 );
1954 if( sqlite3FitsIn64Bits(z, negFlag) ){
drh598f1342007-10-23 15:39:45 +00001955 i64 value;
1956 char *zV;
1957 sqlite3Atoi64(z, &value);
drh9de221d2008-01-05 06:51:30 +00001958 if( negFlag ) value = -value;
drh598f1342007-10-23 15:39:45 +00001959 zV = dup8bytes(v, (char*)&value);
drh9de221d2008-01-05 06:51:30 +00001960 sqlite3VdbeAddOp4(v, OP_Int64, 0, iMem, 0, zV, P4_INT64);
danielk1977c9cf9012007-05-30 10:36:47 +00001961 }else{
drhb7916a72009-05-27 10:31:29 +00001962 codeReal(v, z, negFlag, iMem);
danielk1977c9cf9012007-05-30 10:36:47 +00001963 }
drhfec19aa2004-05-19 20:41:03 +00001964 }
1965}
1966
drhceea3322009-04-23 13:22:42 +00001967/*
1968** Clear a cache entry.
1969*/
1970static void cacheEntryClear(Parse *pParse, struct yColCache *p){
1971 if( p->tempReg ){
1972 if( pParse->nTempReg<ArraySize(pParse->aTempReg) ){
1973 pParse->aTempReg[pParse->nTempReg++] = p->iReg;
1974 }
1975 p->tempReg = 0;
1976 }
1977}
1978
1979
1980/*
1981** Record in the column cache that a particular column from a
1982** particular table is stored in a particular register.
1983*/
1984void sqlite3ExprCacheStore(Parse *pParse, int iTab, int iCol, int iReg){
1985 int i;
1986 int minLru;
1987 int idxLru;
1988 struct yColCache *p;
1989
drh20411ea2009-05-29 19:00:12 +00001990 assert( iReg>0 ); /* Register numbers are always positive */
1991 assert( iCol>=-1 && iCol<32768 ); /* Finite column numbers */
1992
drhceea3322009-04-23 13:22:42 +00001993 /* First replace any existing entry */
1994 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
1995 if( p->iReg && p->iTable==iTab && p->iColumn==iCol ){
1996 cacheEntryClear(pParse, p);
1997 p->iLevel = pParse->iCacheLevel;
1998 p->iReg = iReg;
1999 p->affChange = 0;
2000 p->lru = pParse->iCacheCnt++;
2001 return;
2002 }
2003 }
drhceea3322009-04-23 13:22:42 +00002004
2005 /* Find an empty slot and replace it */
2006 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
2007 if( p->iReg==0 ){
2008 p->iLevel = pParse->iCacheLevel;
2009 p->iTable = iTab;
2010 p->iColumn = iCol;
2011 p->iReg = iReg;
2012 p->affChange = 0;
2013 p->tempReg = 0;
2014 p->lru = pParse->iCacheCnt++;
2015 return;
2016 }
2017 }
2018
2019 /* Replace the last recently used */
2020 minLru = 0x7fffffff;
2021 idxLru = -1;
2022 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
2023 if( p->lru<minLru ){
2024 idxLru = i;
2025 minLru = p->lru;
2026 }
2027 }
drh20411ea2009-05-29 19:00:12 +00002028 if( ALWAYS(idxLru>=0) ){
drhceea3322009-04-23 13:22:42 +00002029 p = &pParse->aColCache[idxLru];
2030 p->iLevel = pParse->iCacheLevel;
2031 p->iTable = iTab;
2032 p->iColumn = iCol;
2033 p->iReg = iReg;
2034 p->affChange = 0;
2035 p->tempReg = 0;
2036 p->lru = pParse->iCacheCnt++;
2037 return;
2038 }
2039}
2040
2041/*
2042** Indicate that a register is being overwritten. Purge the register
2043** from the column cache.
2044*/
2045void sqlite3ExprCacheRemove(Parse *pParse, int iReg){
2046 int i;
2047 struct yColCache *p;
2048 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
2049 if( p->iReg==iReg ){
2050 cacheEntryClear(pParse, p);
2051 p->iReg = 0;
2052 }
2053 }
2054}
2055
2056/*
2057** Remember the current column cache context. Any new entries added
2058** added to the column cache after this call are removed when the
2059** corresponding pop occurs.
2060*/
2061void sqlite3ExprCachePush(Parse *pParse){
2062 pParse->iCacheLevel++;
2063}
2064
2065/*
2066** Remove from the column cache any entries that were added since the
2067** the previous N Push operations. In other words, restore the cache
2068** to the state it was in N Pushes ago.
2069*/
2070void sqlite3ExprCachePop(Parse *pParse, int N){
2071 int i;
2072 struct yColCache *p;
2073 assert( N>0 );
2074 assert( pParse->iCacheLevel>=N );
2075 pParse->iCacheLevel -= N;
2076 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
2077 if( p->iReg && p->iLevel>pParse->iCacheLevel ){
2078 cacheEntryClear(pParse, p);
2079 p->iReg = 0;
2080 }
2081 }
2082}
drh945498f2007-02-24 11:52:52 +00002083
2084/*
drh5cd79232009-05-25 11:46:29 +00002085** When a cached column is reused, make sure that its register is
2086** no longer available as a temp register. ticket #3879: that same
2087** register might be in the cache in multiple places, so be sure to
2088** get them all.
2089*/
2090static void sqlite3ExprCachePinRegister(Parse *pParse, int iReg){
2091 int i;
2092 struct yColCache *p;
2093 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
2094 if( p->iReg==iReg ){
2095 p->tempReg = 0;
2096 }
2097 }
2098}
2099
2100/*
drh945498f2007-02-24 11:52:52 +00002101** Generate code that will extract the iColumn-th column from
drhe55cbd72008-03-31 23:48:03 +00002102** table pTab and store the column value in a register. An effort
2103** is made to store the column value in register iReg, but this is
2104** not guaranteed. The location of the column value is returned.
2105**
2106** There must be an open cursor to pTab in iTable when this routine
2107** is called. If iColumn<0 then code is generated that extracts the rowid.
drhda250ea2008-04-01 05:07:14 +00002108**
2109** This routine might attempt to reuse the value of the column that
2110** has already been loaded into a register. The value will always
2111** be used if it has not undergone any affinity changes. But if
2112** an affinity change has occurred, then the cached value will only be
2113** used if allowAffChng is true.
drh945498f2007-02-24 11:52:52 +00002114*/
drhe55cbd72008-03-31 23:48:03 +00002115int sqlite3ExprCodeGetColumn(
2116 Parse *pParse, /* Parsing and code generating context */
drh2133d822008-01-03 18:44:59 +00002117 Table *pTab, /* Description of the table we are reading from */
2118 int iColumn, /* Index of the table column */
2119 int iTable, /* The cursor pointing to the table */
drhda250ea2008-04-01 05:07:14 +00002120 int iReg, /* Store results here */
2121 int allowAffChng /* True if prior affinity changes are OK */
drh2133d822008-01-03 18:44:59 +00002122){
drhe55cbd72008-03-31 23:48:03 +00002123 Vdbe *v = pParse->pVdbe;
2124 int i;
drhda250ea2008-04-01 05:07:14 +00002125 struct yColCache *p;
drhe55cbd72008-03-31 23:48:03 +00002126
drhceea3322009-04-23 13:22:42 +00002127 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
2128 if( p->iReg>0 && p->iTable==iTable && p->iColumn==iColumn
drhda250ea2008-04-01 05:07:14 +00002129 && (!p->affChange || allowAffChng) ){
drhceea3322009-04-23 13:22:42 +00002130 p->lru = pParse->iCacheCnt++;
drh5cd79232009-05-25 11:46:29 +00002131 sqlite3ExprCachePinRegister(pParse, p->iReg);
drhda250ea2008-04-01 05:07:14 +00002132 return p->iReg;
drhe55cbd72008-03-31 23:48:03 +00002133 }
2134 }
2135 assert( v!=0 );
drh945498f2007-02-24 11:52:52 +00002136 if( iColumn<0 ){
drh044925b2009-04-22 17:15:02 +00002137 sqlite3VdbeAddOp2(v, OP_Rowid, iTable, iReg);
drh20411ea2009-05-29 19:00:12 +00002138 }else if( ALWAYS(pTab!=0) ){
drh945498f2007-02-24 11:52:52 +00002139 int op = IsVirtual(pTab) ? OP_VColumn : OP_Column;
drh2133d822008-01-03 18:44:59 +00002140 sqlite3VdbeAddOp3(v, op, iTable, iColumn, iReg);
danielk1977c7538b52009-07-27 10:05:04 +00002141 sqlite3ColumnDefault(v, pTab, iColumn, iReg);
drh945498f2007-02-24 11:52:52 +00002142 }
drhceea3322009-04-23 13:22:42 +00002143 sqlite3ExprCacheStore(pParse, iTable, iColumn, iReg);
drhe55cbd72008-03-31 23:48:03 +00002144 return iReg;
2145}
2146
2147/*
drhceea3322009-04-23 13:22:42 +00002148** Clear all column cache entries.
drhe55cbd72008-03-31 23:48:03 +00002149*/
drhceea3322009-04-23 13:22:42 +00002150void sqlite3ExprCacheClear(Parse *pParse){
2151 int i;
2152 struct yColCache *p;
2153
2154 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
2155 if( p->iReg ){
2156 cacheEntryClear(pParse, p);
2157 p->iReg = 0;
drhe55cbd72008-03-31 23:48:03 +00002158 }
drhe55cbd72008-03-31 23:48:03 +00002159 }
2160}
2161
2162/*
drhda250ea2008-04-01 05:07:14 +00002163** Record the fact that an affinity change has occurred on iCount
2164** registers starting with iStart.
drhe55cbd72008-03-31 23:48:03 +00002165*/
drhda250ea2008-04-01 05:07:14 +00002166void sqlite3ExprCacheAffinityChange(Parse *pParse, int iStart, int iCount){
2167 int iEnd = iStart + iCount - 1;
drhe55cbd72008-03-31 23:48:03 +00002168 int i;
drhceea3322009-04-23 13:22:42 +00002169 struct yColCache *p;
2170 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
2171 int r = p->iReg;
drhda250ea2008-04-01 05:07:14 +00002172 if( r>=iStart && r<=iEnd ){
drhceea3322009-04-23 13:22:42 +00002173 p->affChange = 1;
drhe55cbd72008-03-31 23:48:03 +00002174 }
2175 }
drhe55cbd72008-03-31 23:48:03 +00002176}
2177
2178/*
drhb21e7c72008-06-22 12:37:57 +00002179** Generate code to move content from registers iFrom...iFrom+nReg-1
2180** over to iTo..iTo+nReg-1. Keep the column cache up-to-date.
drhe55cbd72008-03-31 23:48:03 +00002181*/
drhb21e7c72008-06-22 12:37:57 +00002182void sqlite3ExprCodeMove(Parse *pParse, int iFrom, int iTo, int nReg){
drhe55cbd72008-03-31 23:48:03 +00002183 int i;
drhceea3322009-04-23 13:22:42 +00002184 struct yColCache *p;
drh20411ea2009-05-29 19:00:12 +00002185 if( NEVER(iFrom==iTo) ) return;
drhb21e7c72008-06-22 12:37:57 +00002186 sqlite3VdbeAddOp3(pParse->pVdbe, OP_Move, iFrom, iTo, nReg);
drhceea3322009-04-23 13:22:42 +00002187 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
2188 int x = p->iReg;
drhb21e7c72008-06-22 12:37:57 +00002189 if( x>=iFrom && x<iFrom+nReg ){
drhceea3322009-04-23 13:22:42 +00002190 p->iReg += iTo-iFrom;
drhe55cbd72008-03-31 23:48:03 +00002191 }
2192 }
drh945498f2007-02-24 11:52:52 +00002193}
2194
drhfec19aa2004-05-19 20:41:03 +00002195/*
drh92b01d52008-06-24 00:32:35 +00002196** Generate code to copy content from registers iFrom...iFrom+nReg-1
2197** over to iTo..iTo+nReg-1.
2198*/
2199void sqlite3ExprCodeCopy(Parse *pParse, int iFrom, int iTo, int nReg){
2200 int i;
drh20411ea2009-05-29 19:00:12 +00002201 if( NEVER(iFrom==iTo) ) return;
drh92b01d52008-06-24 00:32:35 +00002202 for(i=0; i<nReg; i++){
2203 sqlite3VdbeAddOp2(pParse->pVdbe, OP_Copy, iFrom+i, iTo+i);
2204 }
2205}
2206
2207/*
drh652fbf52008-04-01 01:42:41 +00002208** Return true if any register in the range iFrom..iTo (inclusive)
2209** is used as part of the column cache.
2210*/
2211static int usedAsColumnCache(Parse *pParse, int iFrom, int iTo){
2212 int i;
drhceea3322009-04-23 13:22:42 +00002213 struct yColCache *p;
2214 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
2215 int r = p->iReg;
drh652fbf52008-04-01 01:42:41 +00002216 if( r>=iFrom && r<=iTo ) return 1;
2217 }
2218 return 0;
2219}
2220
2221/*
drh191b54c2008-04-15 12:14:21 +00002222** If the last instruction coded is an ephemeral copy of any of
2223** the registers in the nReg registers beginning with iReg, then
2224** convert the last instruction from OP_SCopy to OP_Copy.
2225*/
2226void sqlite3ExprHardCopy(Parse *pParse, int iReg, int nReg){
drh191b54c2008-04-15 12:14:21 +00002227 VdbeOp *pOp;
2228 Vdbe *v;
2229
drh20411ea2009-05-29 19:00:12 +00002230 assert( pParse->db->mallocFailed==0 );
drh191b54c2008-04-15 12:14:21 +00002231 v = pParse->pVdbe;
drh20411ea2009-05-29 19:00:12 +00002232 assert( v!=0 );
2233 pOp = sqlite3VdbeGetOp(v, -1);
2234 assert( pOp!=0 );
2235 if( pOp->opcode==OP_SCopy && pOp->p1>=iReg && pOp->p1<iReg+nReg ){
drh191b54c2008-04-15 12:14:21 +00002236 pOp->opcode = OP_Copy;
2237 }
2238}
2239
2240/*
drh8b213892008-08-29 02:14:02 +00002241** Generate code to store the value of the iAlias-th alias in register
2242** target. The first time this is called, pExpr is evaluated to compute
2243** the value of the alias. The value is stored in an auxiliary register
2244** and the number of that register is returned. On subsequent calls,
2245** the register number is returned without generating any code.
2246**
2247** Note that in order for this to work, code must be generated in the
2248** same order that it is executed.
2249**
2250** Aliases are numbered starting with 1. So iAlias is in the range
2251** of 1 to pParse->nAlias inclusive.
2252**
2253** pParse->aAlias[iAlias-1] records the register number where the value
2254** of the iAlias-th alias is stored. If zero, that means that the
2255** alias has not yet been computed.
2256*/
drh31daa632008-10-25 15:03:20 +00002257static int codeAlias(Parse *pParse, int iAlias, Expr *pExpr, int target){
drhceea3322009-04-23 13:22:42 +00002258#if 0
drh8b213892008-08-29 02:14:02 +00002259 sqlite3 *db = pParse->db;
2260 int iReg;
drh555f8de2008-12-08 13:42:36 +00002261 if( pParse->nAliasAlloc<pParse->nAlias ){
2262 pParse->aAlias = sqlite3DbReallocOrFree(db, pParse->aAlias,
drh8b213892008-08-29 02:14:02 +00002263 sizeof(pParse->aAlias[0])*pParse->nAlias );
drh555f8de2008-12-08 13:42:36 +00002264 testcase( db->mallocFailed && pParse->nAliasAlloc>0 );
drh8b213892008-08-29 02:14:02 +00002265 if( db->mallocFailed ) return 0;
drh555f8de2008-12-08 13:42:36 +00002266 memset(&pParse->aAlias[pParse->nAliasAlloc], 0,
2267 (pParse->nAlias-pParse->nAliasAlloc)*sizeof(pParse->aAlias[0]));
2268 pParse->nAliasAlloc = pParse->nAlias;
drh8b213892008-08-29 02:14:02 +00002269 }
2270 assert( iAlias>0 && iAlias<=pParse->nAlias );
2271 iReg = pParse->aAlias[iAlias-1];
2272 if( iReg==0 ){
drhceea3322009-04-23 13:22:42 +00002273 if( pParse->iCacheLevel>0 ){
drh31daa632008-10-25 15:03:20 +00002274 iReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
2275 }else{
2276 iReg = ++pParse->nMem;
2277 sqlite3ExprCode(pParse, pExpr, iReg);
2278 pParse->aAlias[iAlias-1] = iReg;
2279 }
drh8b213892008-08-29 02:14:02 +00002280 }
2281 return iReg;
drhceea3322009-04-23 13:22:42 +00002282#else
shane60a4b532009-05-06 18:57:09 +00002283 UNUSED_PARAMETER(iAlias);
drhceea3322009-04-23 13:22:42 +00002284 return sqlite3ExprCodeTarget(pParse, pExpr, target);
2285#endif
drh8b213892008-08-29 02:14:02 +00002286}
2287
2288/*
drhcce7d172000-05-31 15:34:51 +00002289** Generate code into the current Vdbe to evaluate the given
drh2dcef112008-01-12 19:03:48 +00002290** expression. Attempt to store the results in register "target".
2291** Return the register where results are stored.
drh389a1ad2008-01-03 23:44:53 +00002292**
drh8b213892008-08-29 02:14:02 +00002293** With this routine, there is no guarantee that results will
drh2dcef112008-01-12 19:03:48 +00002294** be stored in target. The result might be stored in some other
2295** register if it is convenient to do so. The calling function
2296** must check the return code and move the results to the desired
2297** register.
drhcce7d172000-05-31 15:34:51 +00002298*/
drh678ccce2008-03-31 18:19:54 +00002299int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){
drh2dcef112008-01-12 19:03:48 +00002300 Vdbe *v = pParse->pVdbe; /* The VM under construction */
2301 int op; /* The opcode being coded */
2302 int inReg = target; /* Results stored in register inReg */
2303 int regFree1 = 0; /* If non-zero free this temporary register */
2304 int regFree2 = 0; /* If non-zero free this temporary register */
drh678ccce2008-03-31 18:19:54 +00002305 int r1, r2, r3, r4; /* Various register numbers */
drh20411ea2009-05-29 19:00:12 +00002306 sqlite3 *db = pParse->db; /* The database connection */
drhffe07b22005-11-03 00:41:17 +00002307
drh9cbf3422008-01-17 16:22:13 +00002308 assert( target>0 && target<=pParse->nMem );
drh20411ea2009-05-29 19:00:12 +00002309 if( v==0 ){
2310 assert( pParse->db->mallocFailed );
2311 return 0;
2312 }
drh389a1ad2008-01-03 23:44:53 +00002313
2314 if( pExpr==0 ){
2315 op = TK_NULL;
2316 }else{
2317 op = pExpr->op;
2318 }
drhf2bc0132004-10-04 13:19:23 +00002319 switch( op ){
drh13449892005-09-07 21:22:45 +00002320 case TK_AGG_COLUMN: {
2321 AggInfo *pAggInfo = pExpr->pAggInfo;
2322 struct AggInfo_col *pCol = &pAggInfo->aCol[pExpr->iAgg];
2323 if( !pAggInfo->directMode ){
drh9de221d2008-01-05 06:51:30 +00002324 assert( pCol->iMem>0 );
2325 inReg = pCol->iMem;
drh13449892005-09-07 21:22:45 +00002326 break;
2327 }else if( pAggInfo->useSortingIdx ){
drh389a1ad2008-01-03 23:44:53 +00002328 sqlite3VdbeAddOp3(v, OP_Column, pAggInfo->sortingIdx,
2329 pCol->iSorterColumn, target);
drh13449892005-09-07 21:22:45 +00002330 break;
2331 }
2332 /* Otherwise, fall thru into the TK_COLUMN case */
2333 }
drh967e8b72000-06-21 13:59:10 +00002334 case TK_COLUMN: {
drhffe07b22005-11-03 00:41:17 +00002335 if( pExpr->iTable<0 ){
2336 /* This only happens when coding check constraints */
drhaa9b8962008-01-08 02:57:55 +00002337 assert( pParse->ckBase>0 );
2338 inReg = pExpr->iColumn + pParse->ckBase;
drhc4a3c772001-04-04 11:48:57 +00002339 }else{
drhc5499be2008-04-01 15:06:33 +00002340 testcase( (pExpr->flags & EP_AnyAff)!=0 );
drhe55cbd72008-03-31 23:48:03 +00002341 inReg = sqlite3ExprCodeGetColumn(pParse, pExpr->pTab,
drhda250ea2008-04-01 05:07:14 +00002342 pExpr->iColumn, pExpr->iTable, target,
2343 pExpr->flags & EP_AnyAff);
drh22827922000-06-06 17:27:05 +00002344 }
drhcce7d172000-05-31 15:34:51 +00002345 break;
2346 }
2347 case TK_INTEGER: {
drh92b01d52008-06-24 00:32:35 +00002348 codeInteger(v, pExpr, 0, target);
drhfec19aa2004-05-19 20:41:03 +00002349 break;
2350 }
drh598f1342007-10-23 15:39:45 +00002351 case TK_FLOAT: {
drh33e619f2009-05-28 01:00:55 +00002352 assert( !ExprHasProperty(pExpr, EP_IntValue) );
2353 codeReal(v, pExpr->u.zToken, 0, target);
drh598f1342007-10-23 15:39:45 +00002354 break;
2355 }
drhfec19aa2004-05-19 20:41:03 +00002356 case TK_STRING: {
drh33e619f2009-05-28 01:00:55 +00002357 assert( !ExprHasProperty(pExpr, EP_IntValue) );
2358 sqlite3VdbeAddOp4(v, OP_String8, 0, target, 0, pExpr->u.zToken, 0);
drhcce7d172000-05-31 15:34:51 +00002359 break;
2360 }
drhf0863fe2005-06-12 21:35:51 +00002361 case TK_NULL: {
drh9de221d2008-01-05 06:51:30 +00002362 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
drhf0863fe2005-06-12 21:35:51 +00002363 break;
2364 }
danielk19775338a5f2005-01-20 13:03:10 +00002365#ifndef SQLITE_OMIT_BLOB_LITERAL
danielk1977c572ef72004-05-27 09:28:41 +00002366 case TK_BLOB: {
drh6c8c6ce2005-08-23 11:17:58 +00002367 int n;
2368 const char *z;
drhca48c902008-01-18 14:08:24 +00002369 char *zBlob;
drh33e619f2009-05-28 01:00:55 +00002370 assert( !ExprHasProperty(pExpr, EP_IntValue) );
2371 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
2372 assert( pExpr->u.zToken[1]=='\'' );
2373 z = &pExpr->u.zToken[2];
drhb7916a72009-05-27 10:31:29 +00002374 n = sqlite3Strlen30(z) - 1;
2375 assert( z[n]=='\'' );
drhca48c902008-01-18 14:08:24 +00002376 zBlob = sqlite3HexToBlob(sqlite3VdbeDb(v), z, n);
2377 sqlite3VdbeAddOp4(v, OP_Blob, n/2, target, 0, zBlob, P4_DYNAMIC);
danielk1977c572ef72004-05-27 09:28:41 +00002378 break;
2379 }
danielk19775338a5f2005-01-20 13:03:10 +00002380#endif
drh50457892003-09-06 01:10:47 +00002381 case TK_VARIABLE: {
drh08de1492009-02-20 03:55:05 +00002382 VdbeOp *pOp;
drh33e619f2009-05-28 01:00:55 +00002383 assert( !ExprHasProperty(pExpr, EP_IntValue) );
2384 assert( pExpr->u.zToken!=0 );
2385 assert( pExpr->u.zToken[0]!=0 );
2386 if( pExpr->u.zToken[1]==0
drh20411ea2009-05-29 19:00:12 +00002387 && (pOp = sqlite3VdbeGetOp(v, -1))->opcode==OP_Variable
dan937d0de2009-10-15 18:35:38 +00002388 && pOp->p1+pOp->p3==pExpr->iColumn
drh08de1492009-02-20 03:55:05 +00002389 && pOp->p2+pOp->p3==target
2390 && pOp->p4.z==0
2391 ){
2392 /* If the previous instruction was a copy of the previous unnamed
2393 ** parameter into the previous register, then simply increment the
2394 ** repeat count on the prior instruction rather than making a new
2395 ** instruction.
2396 */
2397 pOp->p3++;
2398 }else{
dan937d0de2009-10-15 18:35:38 +00002399 sqlite3VdbeAddOp3(v, OP_Variable, pExpr->iColumn, target, 1);
drh33e619f2009-05-28 01:00:55 +00002400 if( pExpr->u.zToken[1]!=0 ){
2401 sqlite3VdbeChangeP4(v, -1, pExpr->u.zToken, 0);
drh08de1492009-02-20 03:55:05 +00002402 }
drh895d7472004-08-20 16:02:39 +00002403 }
drh50457892003-09-06 01:10:47 +00002404 break;
2405 }
drh4e0cff62004-11-05 05:10:28 +00002406 case TK_REGISTER: {
drh9de221d2008-01-05 06:51:30 +00002407 inReg = pExpr->iTable;
drh4e0cff62004-11-05 05:10:28 +00002408 break;
2409 }
drh8b213892008-08-29 02:14:02 +00002410 case TK_AS: {
drh31daa632008-10-25 15:03:20 +00002411 inReg = codeAlias(pParse, pExpr->iTable, pExpr->pLeft, target);
drh8b213892008-08-29 02:14:02 +00002412 break;
2413 }
drh487e2622005-06-25 18:42:14 +00002414#ifndef SQLITE_OMIT_CAST
2415 case TK_CAST: {
2416 /* Expressions of the form: CAST(pLeft AS token) */
danielk1977f0113002006-01-24 12:09:17 +00002417 int aff, to_op;
drh2dcef112008-01-12 19:03:48 +00002418 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
drh33e619f2009-05-28 01:00:55 +00002419 assert( !ExprHasProperty(pExpr, EP_IntValue) );
2420 aff = sqlite3AffinityType(pExpr->u.zToken);
danielk1977f0113002006-01-24 12:09:17 +00002421 to_op = aff - SQLITE_AFF_TEXT + OP_ToText;
2422 assert( to_op==OP_ToText || aff!=SQLITE_AFF_TEXT );
2423 assert( to_op==OP_ToBlob || aff!=SQLITE_AFF_NONE );
2424 assert( to_op==OP_ToNumeric || aff!=SQLITE_AFF_NUMERIC );
2425 assert( to_op==OP_ToInt || aff!=SQLITE_AFF_INTEGER );
2426 assert( to_op==OP_ToReal || aff!=SQLITE_AFF_REAL );
drhc5499be2008-04-01 15:06:33 +00002427 testcase( to_op==OP_ToText );
2428 testcase( to_op==OP_ToBlob );
2429 testcase( to_op==OP_ToNumeric );
2430 testcase( to_op==OP_ToInt );
2431 testcase( to_op==OP_ToReal );
drh1735fa82008-11-06 15:33:03 +00002432 if( inReg!=target ){
2433 sqlite3VdbeAddOp2(v, OP_SCopy, inReg, target);
2434 inReg = target;
2435 }
drh2dcef112008-01-12 19:03:48 +00002436 sqlite3VdbeAddOp1(v, to_op, inReg);
drhc5499be2008-04-01 15:06:33 +00002437 testcase( usedAsColumnCache(pParse, inReg, inReg) );
drhb3843a82008-04-01 12:24:11 +00002438 sqlite3ExprCacheAffinityChange(pParse, inReg, 1);
drh487e2622005-06-25 18:42:14 +00002439 break;
2440 }
2441#endif /* SQLITE_OMIT_CAST */
drhc9b84a12002-06-20 11:36:48 +00002442 case TK_LT:
2443 case TK_LE:
2444 case TK_GT:
2445 case TK_GE:
2446 case TK_NE:
2447 case TK_EQ: {
drhf2bc0132004-10-04 13:19:23 +00002448 assert( TK_LT==OP_Lt );
2449 assert( TK_LE==OP_Le );
2450 assert( TK_GT==OP_Gt );
2451 assert( TK_GE==OP_Ge );
2452 assert( TK_EQ==OP_Eq );
2453 assert( TK_NE==OP_Ne );
drhc5499be2008-04-01 15:06:33 +00002454 testcase( op==TK_LT );
2455 testcase( op==TK_LE );
2456 testcase( op==TK_GT );
2457 testcase( op==TK_GE );
2458 testcase( op==TK_EQ );
2459 testcase( op==TK_NE );
drhda250ea2008-04-01 05:07:14 +00002460 codeCompareOperands(pParse, pExpr->pLeft, &r1, &regFree1,
2461 pExpr->pRight, &r2, &regFree2);
drh35573352008-01-08 23:54:25 +00002462 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
2463 r1, r2, inReg, SQLITE_STOREP2);
drhc5499be2008-04-01 15:06:33 +00002464 testcase( regFree1==0 );
2465 testcase( regFree2==0 );
danielk1977a37cdde2004-05-16 11:15:36 +00002466 break;
drhc9b84a12002-06-20 11:36:48 +00002467 }
drh6a2fe092009-09-23 02:29:36 +00002468 case TK_IS:
2469 case TK_ISNOT: {
2470 testcase( op==TK_IS );
2471 testcase( op==TK_ISNOT );
2472 codeCompareOperands(pParse, pExpr->pLeft, &r1, &regFree1,
2473 pExpr->pRight, &r2, &regFree2);
2474 op = (op==TK_IS) ? TK_EQ : TK_NE;
2475 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
2476 r1, r2, inReg, SQLITE_STOREP2 | SQLITE_NULLEQ);
2477 testcase( regFree1==0 );
2478 testcase( regFree2==0 );
2479 break;
2480 }
drhcce7d172000-05-31 15:34:51 +00002481 case TK_AND:
2482 case TK_OR:
2483 case TK_PLUS:
2484 case TK_STAR:
2485 case TK_MINUS:
drhbf4133c2001-10-13 02:59:08 +00002486 case TK_REM:
2487 case TK_BITAND:
2488 case TK_BITOR:
drh17c40292004-07-21 02:53:29 +00002489 case TK_SLASH:
drhbf4133c2001-10-13 02:59:08 +00002490 case TK_LSHIFT:
drh855eb1c2004-08-31 13:45:11 +00002491 case TK_RSHIFT:
drh00400772000-06-16 20:51:26 +00002492 case TK_CONCAT: {
drhf2bc0132004-10-04 13:19:23 +00002493 assert( TK_AND==OP_And );
2494 assert( TK_OR==OP_Or );
2495 assert( TK_PLUS==OP_Add );
2496 assert( TK_MINUS==OP_Subtract );
2497 assert( TK_REM==OP_Remainder );
2498 assert( TK_BITAND==OP_BitAnd );
2499 assert( TK_BITOR==OP_BitOr );
2500 assert( TK_SLASH==OP_Divide );
2501 assert( TK_LSHIFT==OP_ShiftLeft );
2502 assert( TK_RSHIFT==OP_ShiftRight );
2503 assert( TK_CONCAT==OP_Concat );
drhc5499be2008-04-01 15:06:33 +00002504 testcase( op==TK_AND );
2505 testcase( op==TK_OR );
2506 testcase( op==TK_PLUS );
2507 testcase( op==TK_MINUS );
2508 testcase( op==TK_REM );
2509 testcase( op==TK_BITAND );
2510 testcase( op==TK_BITOR );
2511 testcase( op==TK_SLASH );
2512 testcase( op==TK_LSHIFT );
2513 testcase( op==TK_RSHIFT );
2514 testcase( op==TK_CONCAT );
drh2dcef112008-01-12 19:03:48 +00002515 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
2516 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
drh5b6afba2008-01-05 16:29:28 +00002517 sqlite3VdbeAddOp3(v, op, r2, r1, target);
drhc5499be2008-04-01 15:06:33 +00002518 testcase( regFree1==0 );
2519 testcase( regFree2==0 );
drh00400772000-06-16 20:51:26 +00002520 break;
2521 }
drhcce7d172000-05-31 15:34:51 +00002522 case TK_UMINUS: {
drhfec19aa2004-05-19 20:41:03 +00002523 Expr *pLeft = pExpr->pLeft;
2524 assert( pLeft );
shanefbd60f82009-02-04 03:59:25 +00002525 if( pLeft->op==TK_FLOAT ){
drh33e619f2009-05-28 01:00:55 +00002526 assert( !ExprHasProperty(pExpr, EP_IntValue) );
2527 codeReal(v, pLeft->u.zToken, 1, target);
shanefbd60f82009-02-04 03:59:25 +00002528 }else if( pLeft->op==TK_INTEGER ){
2529 codeInteger(v, pLeft, 1, target);
drh3c84ddf2008-01-09 02:15:38 +00002530 }else{
drh2dcef112008-01-12 19:03:48 +00002531 regFree1 = r1 = sqlite3GetTempReg(pParse);
drh3c84ddf2008-01-09 02:15:38 +00002532 sqlite3VdbeAddOp2(v, OP_Integer, 0, r1);
drhe55cbd72008-03-31 23:48:03 +00002533 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree2);
drh2dcef112008-01-12 19:03:48 +00002534 sqlite3VdbeAddOp3(v, OP_Subtract, r2, r1, target);
drhc5499be2008-04-01 15:06:33 +00002535 testcase( regFree2==0 );
drh6e142f52000-06-08 13:36:40 +00002536 }
drh3c84ddf2008-01-09 02:15:38 +00002537 inReg = target;
2538 break;
drh6e142f52000-06-08 13:36:40 +00002539 }
drhbf4133c2001-10-13 02:59:08 +00002540 case TK_BITNOT:
drh6e142f52000-06-08 13:36:40 +00002541 case TK_NOT: {
drhf2bc0132004-10-04 13:19:23 +00002542 assert( TK_BITNOT==OP_BitNot );
2543 assert( TK_NOT==OP_Not );
drhc5499be2008-04-01 15:06:33 +00002544 testcase( op==TK_BITNOT );
2545 testcase( op==TK_NOT );
drhe99fa2a2008-12-15 15:27:51 +00002546 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
2547 testcase( regFree1==0 );
2548 inReg = target;
2549 sqlite3VdbeAddOp2(v, op, r1, inReg);
drhcce7d172000-05-31 15:34:51 +00002550 break;
2551 }
2552 case TK_ISNULL:
2553 case TK_NOTNULL: {
drh6a288a32008-01-07 19:20:24 +00002554 int addr;
drhf2bc0132004-10-04 13:19:23 +00002555 assert( TK_ISNULL==OP_IsNull );
2556 assert( TK_NOTNULL==OP_NotNull );
drhc5499be2008-04-01 15:06:33 +00002557 testcase( op==TK_ISNULL );
2558 testcase( op==TK_NOTNULL );
drh9de221d2008-01-05 06:51:30 +00002559 sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
drh2dcef112008-01-12 19:03:48 +00002560 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
drhc5499be2008-04-01 15:06:33 +00002561 testcase( regFree1==0 );
drh2dcef112008-01-12 19:03:48 +00002562 addr = sqlite3VdbeAddOp1(v, op, r1);
drh9de221d2008-01-05 06:51:30 +00002563 sqlite3VdbeAddOp2(v, OP_AddImm, target, -1);
drh6a288a32008-01-07 19:20:24 +00002564 sqlite3VdbeJumpHere(v, addr);
drhf2bc0132004-10-04 13:19:23 +00002565 break;
drhcce7d172000-05-31 15:34:51 +00002566 }
drh22827922000-06-06 17:27:05 +00002567 case TK_AGG_FUNCTION: {
drh13449892005-09-07 21:22:45 +00002568 AggInfo *pInfo = pExpr->pAggInfo;
drh7e56e712005-11-16 12:53:15 +00002569 if( pInfo==0 ){
drh33e619f2009-05-28 01:00:55 +00002570 assert( !ExprHasProperty(pExpr, EP_IntValue) );
2571 sqlite3ErrorMsg(pParse, "misuse of aggregate: %s()", pExpr->u.zToken);
drh7e56e712005-11-16 12:53:15 +00002572 }else{
drh9de221d2008-01-05 06:51:30 +00002573 inReg = pInfo->aFunc[pExpr->iAgg].iMem;
drh7e56e712005-11-16 12:53:15 +00002574 }
drh22827922000-06-06 17:27:05 +00002575 break;
2576 }
drhb71090f2005-05-23 17:26:51 +00002577 case TK_CONST_FUNC:
drhcce7d172000-05-31 15:34:51 +00002578 case TK_FUNCTION: {
drh12ffee82009-04-08 13:51:51 +00002579 ExprList *pFarg; /* List of function arguments */
2580 int nFarg; /* Number of function arguments */
2581 FuncDef *pDef; /* The function definition object */
2582 int nId; /* Length of the function name in bytes */
2583 const char *zId; /* The function name */
2584 int constMask = 0; /* Mask of function arguments that are constant */
2585 int i; /* Loop counter */
2586 u8 enc = ENC(db); /* The text encoding used by this database */
2587 CollSeq *pColl = 0; /* A collating sequence */
drh17435752007-08-16 04:30:38 +00002588
danielk19776ab3a2e2009-02-19 14:39:25 +00002589 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
drhc5499be2008-04-01 15:06:33 +00002590 testcase( op==TK_CONST_FUNC );
2591 testcase( op==TK_FUNCTION );
drhb7916a72009-05-27 10:31:29 +00002592 if( ExprHasAnyProperty(pExpr, EP_TokenOnly) ){
drh12ffee82009-04-08 13:51:51 +00002593 pFarg = 0;
2594 }else{
2595 pFarg = pExpr->x.pList;
2596 }
2597 nFarg = pFarg ? pFarg->nExpr : 0;
drh33e619f2009-05-28 01:00:55 +00002598 assert( !ExprHasProperty(pExpr, EP_IntValue) );
2599 zId = pExpr->u.zToken;
drhb7916a72009-05-27 10:31:29 +00002600 nId = sqlite3Strlen30(zId);
drh12ffee82009-04-08 13:51:51 +00002601 pDef = sqlite3FindFunction(db, zId, nId, nFarg, enc, 0);
drhfeb306f2009-08-18 16:05:46 +00002602 if( pDef==0 ){
2603 sqlite3ErrorMsg(pParse, "unknown function: %.*s()", nId, zId);
2604 break;
2605 }
drhae6bb952009-11-11 00:24:31 +00002606
2607 /* Attempt a direct implementation of the built-in COALESCE() and
2608 ** IFNULL() functions. This avoids unnecessary evalation of
2609 ** arguments past the first non-NULL argument.
2610 */
2611 if( pDef->flags & SQLITE_FUNC_COALESCE ){
2612 int endCoalesce = sqlite3VdbeMakeLabel(v);
2613 assert( nFarg>=2 );
2614 sqlite3ExprCode(pParse, pFarg->a[0].pExpr, target);
2615 for(i=1; i<nFarg; i++){
2616 sqlite3VdbeAddOp2(v, OP_NotNull, target, endCoalesce);
2617 sqlite3ExprCacheRemove(pParse, target);
2618 sqlite3ExprCachePush(pParse);
2619 sqlite3ExprCode(pParse, pFarg->a[i].pExpr, target);
2620 sqlite3ExprCachePop(pParse, 1);
2621 }
2622 sqlite3VdbeResolveLabel(v, endCoalesce);
2623 break;
2624 }
2625
2626
drh12ffee82009-04-08 13:51:51 +00002627 if( pFarg ){
2628 r1 = sqlite3GetTempRange(pParse, nFarg);
drhd7d385d2009-09-03 01:18:00 +00002629 sqlite3ExprCachePush(pParse); /* Ticket 2ea2425d34be */
drh12ffee82009-04-08 13:51:51 +00002630 sqlite3ExprCodeExprList(pParse, pFarg, r1, 1);
drhd7d385d2009-09-03 01:18:00 +00002631 sqlite3ExprCachePop(pParse, 1); /* Ticket 2ea2425d34be */
drh892d3172008-01-10 03:46:36 +00002632 }else{
drh12ffee82009-04-08 13:51:51 +00002633 r1 = 0;
drh892d3172008-01-10 03:46:36 +00002634 }
drhb7f6f682006-07-08 17:06:43 +00002635#ifndef SQLITE_OMIT_VIRTUALTABLE
drha43fa222006-07-08 18:41:37 +00002636 /* Possibly overload the function if the first argument is
2637 ** a virtual table column.
2638 **
2639 ** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the
2640 ** second argument, not the first, as the argument to test to
2641 ** see if it is a column in a virtual table. This is done because
2642 ** the left operand of infix functions (the operand we want to
2643 ** control overloading) ends up as the second argument to the
2644 ** function. The expression "A glob B" is equivalent to
2645 ** "glob(B,A). We want to use the A in "A glob B" to test
2646 ** for function overloading. But we use the B term in "glob(B,A)".
2647 */
drh12ffee82009-04-08 13:51:51 +00002648 if( nFarg>=2 && (pExpr->flags & EP_InfixFunc) ){
2649 pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[1].pExpr);
2650 }else if( nFarg>0 ){
2651 pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[0].pExpr);
drhb7f6f682006-07-08 17:06:43 +00002652 }
2653#endif
drhf7bca572009-05-30 14:16:31 +00002654 for(i=0; i<nFarg; i++){
2655 if( i<32 && sqlite3ExprIsConstant(pFarg->a[i].pExpr) ){
drh13449892005-09-07 21:22:45 +00002656 constMask |= (1<<i);
danielk1977d02eb1f2004-06-06 09:44:03 +00002657 }
drhe82f5d02008-10-07 19:53:14 +00002658 if( (pDef->flags & SQLITE_FUNC_NEEDCOLL)!=0 && !pColl ){
drh12ffee82009-04-08 13:51:51 +00002659 pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr);
danielk1977dc1bdc42004-06-11 10:51:27 +00002660 }
2661 }
drhe82f5d02008-10-07 19:53:14 +00002662 if( pDef->flags & SQLITE_FUNC_NEEDCOLL ){
drh8b213892008-08-29 02:14:02 +00002663 if( !pColl ) pColl = db->pDfltColl;
drh66a51672008-01-03 00:01:23 +00002664 sqlite3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ);
danielk1977682f68b2004-06-05 10:22:17 +00002665 }
drh2dcef112008-01-12 19:03:48 +00002666 sqlite3VdbeAddOp4(v, OP_Function, constMask, r1, target,
drh66a51672008-01-03 00:01:23 +00002667 (char*)pDef, P4_FUNCDEF);
drh12ffee82009-04-08 13:51:51 +00002668 sqlite3VdbeChangeP5(v, (u8)nFarg);
2669 if( nFarg ){
2670 sqlite3ReleaseTempRange(pParse, r1, nFarg);
drh2dcef112008-01-12 19:03:48 +00002671 }
drh12ffee82009-04-08 13:51:51 +00002672 sqlite3ExprCacheAffinityChange(pParse, r1, nFarg);
drhcce7d172000-05-31 15:34:51 +00002673 break;
2674 }
drhfe2093d2005-01-20 22:48:47 +00002675#ifndef SQLITE_OMIT_SUBQUERY
2676 case TK_EXISTS:
drh19a775c2000-06-05 18:54:46 +00002677 case TK_SELECT: {
drhc5499be2008-04-01 15:06:33 +00002678 testcase( op==TK_EXISTS );
2679 testcase( op==TK_SELECT );
drh1450bc62009-10-30 13:25:56 +00002680 inReg = sqlite3CodeSubselect(pParse, pExpr, 0, 0);
drh19a775c2000-06-05 18:54:46 +00002681 break;
2682 }
drhfef52082000-06-06 01:50:43 +00002683 case TK_IN: {
drhe3365e62009-11-12 17:52:24 +00002684 int destIfFalse = sqlite3VdbeMakeLabel(v);
2685 int destIfNull = sqlite3VdbeMakeLabel(v);
2686 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
2687 sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
2688 sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
2689 sqlite3VdbeResolveLabel(v, destIfFalse);
2690 sqlite3VdbeAddOp2(v, OP_AddImm, target, 0);
2691 sqlite3VdbeResolveLabel(v, destIfNull);
drhfef52082000-06-06 01:50:43 +00002692 break;
2693 }
drhe3365e62009-11-12 17:52:24 +00002694#endif /* SQLITE_OMIT_SUBQUERY */
2695
2696
drh2dcef112008-01-12 19:03:48 +00002697 /*
2698 ** x BETWEEN y AND z
2699 **
2700 ** This is equivalent to
2701 **
2702 ** x>=y AND x<=z
2703 **
2704 ** X is stored in pExpr->pLeft.
2705 ** Y is stored in pExpr->pList->a[0].pExpr.
2706 ** Z is stored in pExpr->pList->a[1].pExpr.
2707 */
drhfef52082000-06-06 01:50:43 +00002708 case TK_BETWEEN: {
drhbe5c89a2004-07-26 00:31:09 +00002709 Expr *pLeft = pExpr->pLeft;
danielk19776ab3a2e2009-02-19 14:39:25 +00002710 struct ExprList_item *pLItem = pExpr->x.pList->a;
drhbe5c89a2004-07-26 00:31:09 +00002711 Expr *pRight = pLItem->pExpr;
drh35573352008-01-08 23:54:25 +00002712
drhda250ea2008-04-01 05:07:14 +00002713 codeCompareOperands(pParse, pLeft, &r1, &regFree1,
2714 pRight, &r2, &regFree2);
drhc5499be2008-04-01 15:06:33 +00002715 testcase( regFree1==0 );
2716 testcase( regFree2==0 );
drh2dcef112008-01-12 19:03:48 +00002717 r3 = sqlite3GetTempReg(pParse);
drh678ccce2008-03-31 18:19:54 +00002718 r4 = sqlite3GetTempReg(pParse);
drh35573352008-01-08 23:54:25 +00002719 codeCompare(pParse, pLeft, pRight, OP_Ge,
2720 r1, r2, r3, SQLITE_STOREP2);
drhbe5c89a2004-07-26 00:31:09 +00002721 pLItem++;
2722 pRight = pLItem->pExpr;
drh2dcef112008-01-12 19:03:48 +00002723 sqlite3ReleaseTempReg(pParse, regFree2);
2724 r2 = sqlite3ExprCodeTemp(pParse, pRight, &regFree2);
drhc5499be2008-04-01 15:06:33 +00002725 testcase( regFree2==0 );
drh678ccce2008-03-31 18:19:54 +00002726 codeCompare(pParse, pLeft, pRight, OP_Le, r1, r2, r4, SQLITE_STOREP2);
2727 sqlite3VdbeAddOp3(v, OP_And, r3, r4, target);
drh2dcef112008-01-12 19:03:48 +00002728 sqlite3ReleaseTempReg(pParse, r3);
drh678ccce2008-03-31 18:19:54 +00002729 sqlite3ReleaseTempReg(pParse, r4);
drhfef52082000-06-06 01:50:43 +00002730 break;
2731 }
drh4f07e5f2007-05-14 11:34:46 +00002732 case TK_UPLUS: {
drh2dcef112008-01-12 19:03:48 +00002733 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
drha2e00042002-01-22 03:13:42 +00002734 break;
2735 }
drh2dcef112008-01-12 19:03:48 +00002736
dan165921a2009-08-28 18:53:45 +00002737 case TK_TRIGGER: {
dan65a7cd12009-09-01 12:16:01 +00002738 /* If the opcode is TK_TRIGGER, then the expression is a reference
2739 ** to a column in the new.* or old.* pseudo-tables available to
2740 ** trigger programs. In this case Expr.iTable is set to 1 for the
2741 ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
2742 ** is set to the column of the pseudo-table to read, or to -1 to
2743 ** read the rowid field.
2744 **
2745 ** The expression is implemented using an OP_Param opcode. The p1
2746 ** parameter is set to 0 for an old.rowid reference, or to (i+1)
2747 ** to reference another column of the old.* pseudo-table, where
2748 ** i is the index of the column. For a new.rowid reference, p1 is
2749 ** set to (n+1), where n is the number of columns in each pseudo-table.
2750 ** For a reference to any other column in the new.* pseudo-table, p1
2751 ** is set to (n+2+i), where n and i are as defined previously. For
2752 ** example, if the table on which triggers are being fired is
2753 ** declared as:
2754 **
2755 ** CREATE TABLE t1(a, b);
2756 **
2757 ** Then p1 is interpreted as follows:
2758 **
2759 ** p1==0 -> old.rowid p1==3 -> new.rowid
2760 ** p1==1 -> old.a p1==4 -> new.a
2761 ** p1==2 -> old.b p1==5 -> new.b
2762 */
dan2832ad42009-08-31 15:27:27 +00002763 Table *pTab = pExpr->pTab;
dan65a7cd12009-09-01 12:16:01 +00002764 int p1 = pExpr->iTable * (pTab->nCol+1) + 1 + pExpr->iColumn;
2765
2766 assert( pExpr->iTable==0 || pExpr->iTable==1 );
2767 assert( pExpr->iColumn>=-1 && pExpr->iColumn<pTab->nCol );
2768 assert( pTab->iPKey<0 || pExpr->iColumn!=pTab->iPKey );
2769 assert( p1>=0 && p1<(pTab->nCol*2+2) );
2770
2771 sqlite3VdbeAddOp2(v, OP_Param, p1, target);
dan2bd93512009-08-31 08:22:46 +00002772 VdbeComment((v, "%s.%s -> $%d",
2773 (pExpr->iTable ? "new" : "old"),
dan76d462e2009-08-30 11:42:51 +00002774 (pExpr->iColumn<0 ? "rowid" : pExpr->pTab->aCol[pExpr->iColumn].zName),
dan2bd93512009-08-31 08:22:46 +00002775 target
dan165921a2009-08-28 18:53:45 +00002776 ));
dan65a7cd12009-09-01 12:16:01 +00002777
2778 /* If the column has REAL affinity, it may currently be stored as an
2779 ** integer. Use OP_RealAffinity to make sure it is really real. */
dan2832ad42009-08-31 15:27:27 +00002780 if( pExpr->iColumn>=0
2781 && pTab->aCol[pExpr->iColumn].affinity==SQLITE_AFF_REAL
2782 ){
2783 sqlite3VdbeAddOp1(v, OP_RealAffinity, target);
2784 }
dan165921a2009-08-28 18:53:45 +00002785 break;
2786 }
2787
2788
drh2dcef112008-01-12 19:03:48 +00002789 /*
2790 ** Form A:
2791 ** CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
2792 **
2793 ** Form B:
2794 ** CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
2795 **
2796 ** Form A is can be transformed into the equivalent form B as follows:
2797 ** CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ...
2798 ** WHEN x=eN THEN rN ELSE y END
2799 **
2800 ** X (if it exists) is in pExpr->pLeft.
2801 ** Y is in pExpr->pRight. The Y is also optional. If there is no
2802 ** ELSE clause and no other term matches, then the result of the
2803 ** exprssion is NULL.
2804 ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1].
2805 **
2806 ** The result of the expression is the Ri for the first matching Ei,
2807 ** or if there is no matching Ei, the ELSE term Y, or if there is
2808 ** no ELSE term, NULL.
2809 */
drh33cd4902009-05-30 20:49:20 +00002810 default: assert( op==TK_CASE ); {
drh2dcef112008-01-12 19:03:48 +00002811 int endLabel; /* GOTO label for end of CASE stmt */
2812 int nextCase; /* GOTO label for next WHEN clause */
2813 int nExpr; /* 2x number of WHEN terms */
2814 int i; /* Loop counter */
2815 ExprList *pEList; /* List of WHEN terms */
2816 struct ExprList_item *aListelem; /* Array of WHEN terms */
2817 Expr opCompare; /* The X==Ei expression */
2818 Expr cacheX; /* Cached expression X */
2819 Expr *pX; /* The X expression */
drh1bd10f82008-12-10 21:19:56 +00002820 Expr *pTest = 0; /* X==Ei (form A) or just Ei (form B) */
drhceea3322009-04-23 13:22:42 +00002821 VVA_ONLY( int iCacheLevel = pParse->iCacheLevel; )
drh17a7f8d2002-03-24 13:13:27 +00002822
danielk19776ab3a2e2009-02-19 14:39:25 +00002823 assert( !ExprHasProperty(pExpr, EP_xIsSelect) && pExpr->x.pList );
2824 assert((pExpr->x.pList->nExpr % 2) == 0);
2825 assert(pExpr->x.pList->nExpr > 0);
2826 pEList = pExpr->x.pList;
drhbe5c89a2004-07-26 00:31:09 +00002827 aListelem = pEList->a;
2828 nExpr = pEList->nExpr;
drh2dcef112008-01-12 19:03:48 +00002829 endLabel = sqlite3VdbeMakeLabel(v);
2830 if( (pX = pExpr->pLeft)!=0 ){
2831 cacheX = *pX;
drh33cd4902009-05-30 20:49:20 +00002832 testcase( pX->op==TK_COLUMN );
2833 testcase( pX->op==TK_REGISTER );
drh2dcef112008-01-12 19:03:48 +00002834 cacheX.iTable = sqlite3ExprCodeTemp(pParse, pX, &regFree1);
drhc5499be2008-04-01 15:06:33 +00002835 testcase( regFree1==0 );
drh2dcef112008-01-12 19:03:48 +00002836 cacheX.op = TK_REGISTER;
2837 opCompare.op = TK_EQ;
2838 opCompare.pLeft = &cacheX;
2839 pTest = &opCompare;
drh17a7f8d2002-03-24 13:13:27 +00002840 }
drhf5905aa2002-05-26 20:54:33 +00002841 for(i=0; i<nExpr; i=i+2){
drhceea3322009-04-23 13:22:42 +00002842 sqlite3ExprCachePush(pParse);
drh2dcef112008-01-12 19:03:48 +00002843 if( pX ){
drh1bd10f82008-12-10 21:19:56 +00002844 assert( pTest!=0 );
drh2dcef112008-01-12 19:03:48 +00002845 opCompare.pRight = aListelem[i].pExpr;
drh17a7f8d2002-03-24 13:13:27 +00002846 }else{
drh2dcef112008-01-12 19:03:48 +00002847 pTest = aListelem[i].pExpr;
drh17a7f8d2002-03-24 13:13:27 +00002848 }
drh2dcef112008-01-12 19:03:48 +00002849 nextCase = sqlite3VdbeMakeLabel(v);
drh33cd4902009-05-30 20:49:20 +00002850 testcase( pTest->op==TK_COLUMN );
drh2dcef112008-01-12 19:03:48 +00002851 sqlite3ExprIfFalse(pParse, pTest, nextCase, SQLITE_JUMPIFNULL);
drhc5499be2008-04-01 15:06:33 +00002852 testcase( aListelem[i+1].pExpr->op==TK_COLUMN );
2853 testcase( aListelem[i+1].pExpr->op==TK_REGISTER );
drh9de221d2008-01-05 06:51:30 +00002854 sqlite3ExprCode(pParse, aListelem[i+1].pExpr, target);
drh2dcef112008-01-12 19:03:48 +00002855 sqlite3VdbeAddOp2(v, OP_Goto, 0, endLabel);
drhceea3322009-04-23 13:22:42 +00002856 sqlite3ExprCachePop(pParse, 1);
drh2dcef112008-01-12 19:03:48 +00002857 sqlite3VdbeResolveLabel(v, nextCase);
drhf570f012002-05-31 15:51:25 +00002858 }
drh17a7f8d2002-03-24 13:13:27 +00002859 if( pExpr->pRight ){
drhceea3322009-04-23 13:22:42 +00002860 sqlite3ExprCachePush(pParse);
drh9de221d2008-01-05 06:51:30 +00002861 sqlite3ExprCode(pParse, pExpr->pRight, target);
drhceea3322009-04-23 13:22:42 +00002862 sqlite3ExprCachePop(pParse, 1);
drh17a7f8d2002-03-24 13:13:27 +00002863 }else{
drh9de221d2008-01-05 06:51:30 +00002864 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
drh17a7f8d2002-03-24 13:13:27 +00002865 }
danielk1977c1f4a192009-04-28 12:08:15 +00002866 assert( db->mallocFailed || pParse->nErr>0
2867 || pParse->iCacheLevel==iCacheLevel );
drh2dcef112008-01-12 19:03:48 +00002868 sqlite3VdbeResolveLabel(v, endLabel);
danielk19776f349032002-06-11 02:25:40 +00002869 break;
2870 }
danielk19775338a5f2005-01-20 13:03:10 +00002871#ifndef SQLITE_OMIT_TRIGGER
danielk19776f349032002-06-11 02:25:40 +00002872 case TK_RAISE: {
dan165921a2009-08-28 18:53:45 +00002873 assert( pExpr->affinity==OE_Rollback
2874 || pExpr->affinity==OE_Abort
2875 || pExpr->affinity==OE_Fail
2876 || pExpr->affinity==OE_Ignore
2877 );
dane0af83a2009-09-08 19:15:01 +00002878 if( !pParse->pTriggerTab ){
2879 sqlite3ErrorMsg(pParse,
2880 "RAISE() may only be used within a trigger-program");
2881 return 0;
2882 }
2883 if( pExpr->affinity==OE_Abort ){
2884 sqlite3MayAbort(pParse);
2885 }
dan165921a2009-08-28 18:53:45 +00002886 assert( !ExprHasProperty(pExpr, EP_IntValue) );
dane0af83a2009-09-08 19:15:01 +00002887 if( pExpr->affinity==OE_Ignore ){
2888 sqlite3VdbeAddOp4(
2889 v, OP_Halt, SQLITE_OK, OE_Ignore, 0, pExpr->u.zToken,0);
2890 }else{
2891 sqlite3HaltConstraint(pParse, pExpr->affinity, pExpr->u.zToken, 0);
2892 }
2893
drhffe07b22005-11-03 00:41:17 +00002894 break;
drh17a7f8d2002-03-24 13:13:27 +00002895 }
danielk19775338a5f2005-01-20 13:03:10 +00002896#endif
drhffe07b22005-11-03 00:41:17 +00002897 }
drh2dcef112008-01-12 19:03:48 +00002898 sqlite3ReleaseTempReg(pParse, regFree1);
2899 sqlite3ReleaseTempReg(pParse, regFree2);
2900 return inReg;
2901}
2902
2903/*
2904** Generate code to evaluate an expression and store the results
2905** into a register. Return the register number where the results
2906** are stored.
2907**
2908** If the register is a temporary register that can be deallocated,
drh678ccce2008-03-31 18:19:54 +00002909** then write its number into *pReg. If the result register is not
drh2dcef112008-01-12 19:03:48 +00002910** a temporary, then set *pReg to zero.
2911*/
2912int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){
2913 int r1 = sqlite3GetTempReg(pParse);
2914 int r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
2915 if( r2==r1 ){
2916 *pReg = r1;
2917 }else{
2918 sqlite3ReleaseTempReg(pParse, r1);
2919 *pReg = 0;
2920 }
2921 return r2;
2922}
2923
2924/*
2925** Generate code that will evaluate expression pExpr and store the
2926** results in register target. The results are guaranteed to appear
2927** in register target.
2928*/
2929int sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){
drh9cbf3422008-01-17 16:22:13 +00002930 int inReg;
2931
2932 assert( target>0 && target<=pParse->nMem );
2933 inReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
drh0e359b32008-01-13 19:02:11 +00002934 assert( pParse->pVdbe || pParse->db->mallocFailed );
2935 if( inReg!=target && pParse->pVdbe ){
drh9cbf3422008-01-17 16:22:13 +00002936 sqlite3VdbeAddOp2(pParse->pVdbe, OP_SCopy, inReg, target);
drhcce7d172000-05-31 15:34:51 +00002937 }
drh389a1ad2008-01-03 23:44:53 +00002938 return target;
drhcce7d172000-05-31 15:34:51 +00002939}
2940
2941/*
drh2dcef112008-01-12 19:03:48 +00002942** Generate code that evalutes the given expression and puts the result
drhde4fcfd2008-01-19 23:50:26 +00002943** in register target.
drh25303782004-12-07 15:41:48 +00002944**
drh2dcef112008-01-12 19:03:48 +00002945** Also make a copy of the expression results into another "cache" register
2946** and modify the expression so that the next time it is evaluated,
2947** the result is a copy of the cache register.
2948**
2949** This routine is used for expressions that are used multiple
2950** times. They are evaluated once and the results of the expression
2951** are reused.
drh25303782004-12-07 15:41:48 +00002952*/
drh2dcef112008-01-12 19:03:48 +00002953int sqlite3ExprCodeAndCache(Parse *pParse, Expr *pExpr, int target){
drh25303782004-12-07 15:41:48 +00002954 Vdbe *v = pParse->pVdbe;
drh2dcef112008-01-12 19:03:48 +00002955 int inReg;
2956 inReg = sqlite3ExprCode(pParse, pExpr, target);
drhde4fcfd2008-01-19 23:50:26 +00002957 assert( target>0 );
drh20bc3932009-05-30 23:35:43 +00002958 /* This routine is called for terms to INSERT or UPDATE. And the only
2959 ** other place where expressions can be converted into TK_REGISTER is
2960 ** in WHERE clause processing. So as currently implemented, there is
2961 ** no way for a TK_REGISTER to exist here. But it seems prudent to
2962 ** keep the ALWAYS() in case the conditions above change with future
2963 ** modifications or enhancements. */
2964 if( ALWAYS(pExpr->op!=TK_REGISTER) ){
drh2dcef112008-01-12 19:03:48 +00002965 int iMem;
drhde4fcfd2008-01-19 23:50:26 +00002966 iMem = ++pParse->nMem;
2967 sqlite3VdbeAddOp2(v, OP_Copy, inReg, iMem);
drh2dcef112008-01-12 19:03:48 +00002968 pExpr->iTable = iMem;
dan937d0de2009-10-15 18:35:38 +00002969 pExpr->op2 = pExpr->op;
drh25303782004-12-07 15:41:48 +00002970 pExpr->op = TK_REGISTER;
2971 }
drh2dcef112008-01-12 19:03:48 +00002972 return inReg;
drh25303782004-12-07 15:41:48 +00002973}
drh2dcef112008-01-12 19:03:48 +00002974
drh678ccce2008-03-31 18:19:54 +00002975/*
drh47de9552008-04-01 18:04:11 +00002976** Return TRUE if pExpr is an constant expression that is appropriate
2977** for factoring out of a loop. Appropriate expressions are:
2978**
2979** * Any expression that evaluates to two or more opcodes.
2980**
2981** * Any OP_Integer, OP_Real, OP_String, OP_Blob, OP_Null,
2982** or OP_Variable that does not need to be placed in a
2983** specific register.
2984**
2985** There is no point in factoring out single-instruction constant
2986** expressions that need to be placed in a particular register.
2987** We could factor them out, but then we would end up adding an
2988** OP_SCopy instruction to move the value into the correct register
2989** later. We might as well just use the original instruction and
2990** avoid the OP_SCopy.
2991*/
2992static int isAppropriateForFactoring(Expr *p){
2993 if( !sqlite3ExprIsConstantNotJoin(p) ){
2994 return 0; /* Only constant expressions are appropriate for factoring */
2995 }
2996 if( (p->flags & EP_FixedDest)==0 ){
2997 return 1; /* Any constant without a fixed destination is appropriate */
2998 }
2999 while( p->op==TK_UPLUS ) p = p->pLeft;
3000 switch( p->op ){
3001#ifndef SQLITE_OMIT_BLOB_LITERAL
3002 case TK_BLOB:
3003#endif
3004 case TK_VARIABLE:
3005 case TK_INTEGER:
3006 case TK_FLOAT:
3007 case TK_NULL:
3008 case TK_STRING: {
3009 testcase( p->op==TK_BLOB );
3010 testcase( p->op==TK_VARIABLE );
3011 testcase( p->op==TK_INTEGER );
3012 testcase( p->op==TK_FLOAT );
3013 testcase( p->op==TK_NULL );
3014 testcase( p->op==TK_STRING );
3015 /* Single-instruction constants with a fixed destination are
3016 ** better done in-line. If we factor them, they will just end
3017 ** up generating an OP_SCopy to move the value to the destination
3018 ** register. */
3019 return 0;
3020 }
3021 case TK_UMINUS: {
drh20bc3932009-05-30 23:35:43 +00003022 if( p->pLeft->op==TK_FLOAT || p->pLeft->op==TK_INTEGER ){
3023 return 0;
3024 }
3025 break;
drh47de9552008-04-01 18:04:11 +00003026 }
3027 default: {
3028 break;
3029 }
3030 }
3031 return 1;
3032}
3033
3034/*
3035** If pExpr is a constant expression that is appropriate for
3036** factoring out of a loop, then evaluate the expression
drh678ccce2008-03-31 18:19:54 +00003037** into a register and convert the expression into a TK_REGISTER
3038** expression.
3039*/
drh7d10d5a2008-08-20 16:35:10 +00003040static int evalConstExpr(Walker *pWalker, Expr *pExpr){
3041 Parse *pParse = pWalker->pParse;
drh47de9552008-04-01 18:04:11 +00003042 switch( pExpr->op ){
drhe05c9292009-10-29 13:48:10 +00003043 case TK_IN:
drh47de9552008-04-01 18:04:11 +00003044 case TK_REGISTER: {
drh33cd4902009-05-30 20:49:20 +00003045 return WRC_Prune;
drh47de9552008-04-01 18:04:11 +00003046 }
3047 case TK_FUNCTION:
3048 case TK_AGG_FUNCTION:
3049 case TK_CONST_FUNC: {
3050 /* The arguments to a function have a fixed destination.
3051 ** Mark them this way to avoid generated unneeded OP_SCopy
3052 ** instructions.
3053 */
danielk19776ab3a2e2009-02-19 14:39:25 +00003054 ExprList *pList = pExpr->x.pList;
3055 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
drh47de9552008-04-01 18:04:11 +00003056 if( pList ){
3057 int i = pList->nExpr;
3058 struct ExprList_item *pItem = pList->a;
3059 for(; i>0; i--, pItem++){
drh33cd4902009-05-30 20:49:20 +00003060 if( ALWAYS(pItem->pExpr) ) pItem->pExpr->flags |= EP_FixedDest;
drh47de9552008-04-01 18:04:11 +00003061 }
3062 }
3063 break;
3064 }
drh678ccce2008-03-31 18:19:54 +00003065 }
drh47de9552008-04-01 18:04:11 +00003066 if( isAppropriateForFactoring(pExpr) ){
drh678ccce2008-03-31 18:19:54 +00003067 int r1 = ++pParse->nMem;
3068 int r2;
3069 r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
drh33cd4902009-05-30 20:49:20 +00003070 if( NEVER(r1!=r2) ) sqlite3ReleaseTempReg(pParse, r1);
danfcd4a152009-08-19 17:17:00 +00003071 pExpr->op2 = pExpr->op;
drh678ccce2008-03-31 18:19:54 +00003072 pExpr->op = TK_REGISTER;
3073 pExpr->iTable = r2;
drh7d10d5a2008-08-20 16:35:10 +00003074 return WRC_Prune;
drh678ccce2008-03-31 18:19:54 +00003075 }
drh7d10d5a2008-08-20 16:35:10 +00003076 return WRC_Continue;
drh678ccce2008-03-31 18:19:54 +00003077}
3078
3079/*
3080** Preevaluate constant subexpressions within pExpr and store the
3081** results in registers. Modify pExpr so that the constant subexpresions
3082** are TK_REGISTER opcodes that refer to the precomputed values.
3083*/
3084void sqlite3ExprCodeConstants(Parse *pParse, Expr *pExpr){
drh7d10d5a2008-08-20 16:35:10 +00003085 Walker w;
3086 w.xExprCallback = evalConstExpr;
3087 w.xSelectCallback = 0;
3088 w.pParse = pParse;
3089 sqlite3WalkExpr(&w, pExpr);
drh678ccce2008-03-31 18:19:54 +00003090}
3091
drh25303782004-12-07 15:41:48 +00003092
3093/*
drh268380c2004-02-25 13:47:31 +00003094** Generate code that pushes the value of every element of the given
drh9cbf3422008-01-17 16:22:13 +00003095** expression list into a sequence of registers beginning at target.
drh268380c2004-02-25 13:47:31 +00003096**
drh892d3172008-01-10 03:46:36 +00003097** Return the number of elements evaluated.
drh268380c2004-02-25 13:47:31 +00003098*/
danielk19774adee202004-05-08 08:23:19 +00003099int sqlite3ExprCodeExprList(
drh268380c2004-02-25 13:47:31 +00003100 Parse *pParse, /* Parsing context */
drh389a1ad2008-01-03 23:44:53 +00003101 ExprList *pList, /* The expression list to be coded */
drh191b54c2008-04-15 12:14:21 +00003102 int target, /* Where to write results */
drhd1766112008-09-17 00:13:12 +00003103 int doHardCopy /* Make a hard copy of every element */
drh268380c2004-02-25 13:47:31 +00003104){
3105 struct ExprList_item *pItem;
drh9cbf3422008-01-17 16:22:13 +00003106 int i, n;
drh9d8b3072008-08-22 16:29:51 +00003107 assert( pList!=0 );
drh9cbf3422008-01-17 16:22:13 +00003108 assert( target>0 );
drh268380c2004-02-25 13:47:31 +00003109 n = pList->nExpr;
drh191b54c2008-04-15 12:14:21 +00003110 for(pItem=pList->a, i=0; i<n; i++, pItem++){
drh8b213892008-08-29 02:14:02 +00003111 if( pItem->iAlias ){
drh31daa632008-10-25 15:03:20 +00003112 int iReg = codeAlias(pParse, pItem->iAlias, pItem->pExpr, target+i);
drh8b213892008-08-29 02:14:02 +00003113 Vdbe *v = sqlite3GetVdbe(pParse);
drh31daa632008-10-25 15:03:20 +00003114 if( iReg!=target+i ){
3115 sqlite3VdbeAddOp2(v, OP_SCopy, iReg, target+i);
3116 }
drhd1766112008-09-17 00:13:12 +00003117 }else{
drh8b213892008-08-29 02:14:02 +00003118 sqlite3ExprCode(pParse, pItem->pExpr, target+i);
3119 }
drh20411ea2009-05-29 19:00:12 +00003120 if( doHardCopy && !pParse->db->mallocFailed ){
drhd1766112008-09-17 00:13:12 +00003121 sqlite3ExprHardCopy(pParse, target, n);
3122 }
drh268380c2004-02-25 13:47:31 +00003123 }
drhf9b596e2004-05-26 16:54:42 +00003124 return n;
drh268380c2004-02-25 13:47:31 +00003125}
3126
3127/*
drh36c563a2009-11-12 13:32:22 +00003128** Generate code for a BETWEEN operator.
3129**
3130** x BETWEEN y AND z
3131**
3132** The above is equivalent to
3133**
3134** x>=y AND x<=z
3135**
3136** Code it as such, taking care to do the common subexpression
3137** elementation of x.
3138*/
3139static void exprCodeBetween(
3140 Parse *pParse, /* Parsing and code generating context */
3141 Expr *pExpr, /* The BETWEEN expression */
3142 int dest, /* Jump here if the jump is taken */
3143 int jumpIfTrue, /* Take the jump if the BETWEEN is true */
3144 int jumpIfNull /* Take the jump if the BETWEEN is NULL */
3145){
3146 Expr exprAnd; /* The AND operator in x>=y AND x<=z */
3147 Expr compLeft; /* The x>=y term */
3148 Expr compRight; /* The x<=z term */
3149 Expr exprX; /* The x subexpression */
3150 int regFree1 = 0; /* Temporary use register */
3151
3152 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
3153 exprX = *pExpr->pLeft;
3154 exprAnd.op = TK_AND;
3155 exprAnd.pLeft = &compLeft;
3156 exprAnd.pRight = &compRight;
3157 compLeft.op = TK_GE;
3158 compLeft.pLeft = &exprX;
3159 compLeft.pRight = pExpr->x.pList->a[0].pExpr;
3160 compRight.op = TK_LE;
3161 compRight.pLeft = &exprX;
3162 compRight.pRight = pExpr->x.pList->a[1].pExpr;
3163 exprX.iTable = sqlite3ExprCodeTemp(pParse, &exprX, &regFree1);
3164 exprX.op = TK_REGISTER;
3165 if( jumpIfTrue ){
3166 sqlite3ExprIfTrue(pParse, &exprAnd, dest, jumpIfNull);
3167 }else{
3168 sqlite3ExprIfFalse(pParse, &exprAnd, dest, jumpIfNull);
3169 }
3170 sqlite3ReleaseTempReg(pParse, regFree1);
3171
3172 /* Ensure adequate test coverage */
3173 testcase( jumpIfTrue==0 && jumpIfNull==0 && regFree1==0 );
3174 testcase( jumpIfTrue==0 && jumpIfNull==0 && regFree1!=0 );
3175 testcase( jumpIfTrue==0 && jumpIfNull!=0 && regFree1==0 );
3176 testcase( jumpIfTrue==0 && jumpIfNull!=0 && regFree1!=0 );
3177 testcase( jumpIfTrue!=0 && jumpIfNull==0 && regFree1==0 );
3178 testcase( jumpIfTrue!=0 && jumpIfNull==0 && regFree1!=0 );
3179 testcase( jumpIfTrue!=0 && jumpIfNull!=0 && regFree1==0 );
3180 testcase( jumpIfTrue!=0 && jumpIfNull!=0 && regFree1!=0 );
3181}
3182
3183/*
drhcce7d172000-05-31 15:34:51 +00003184** Generate code for a boolean expression such that a jump is made
3185** to the label "dest" if the expression is true but execution
3186** continues straight thru if the expression is false.
drhf5905aa2002-05-26 20:54:33 +00003187**
3188** If the expression evaluates to NULL (neither true nor false), then
drh35573352008-01-08 23:54:25 +00003189** take the jump if the jumpIfNull flag is SQLITE_JUMPIFNULL.
drhf2bc0132004-10-04 13:19:23 +00003190**
3191** This code depends on the fact that certain token values (ex: TK_EQ)
3192** are the same as opcode values (ex: OP_Eq) that implement the corresponding
3193** operation. Special comments in vdbe.c and the mkopcodeh.awk script in
3194** the make process cause these values to align. Assert()s in the code
3195** below verify that the numbers are aligned correctly.
drhcce7d172000-05-31 15:34:51 +00003196*/
danielk19774adee202004-05-08 08:23:19 +00003197void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
drhcce7d172000-05-31 15:34:51 +00003198 Vdbe *v = pParse->pVdbe;
3199 int op = 0;
drh2dcef112008-01-12 19:03:48 +00003200 int regFree1 = 0;
3201 int regFree2 = 0;
3202 int r1, r2;
3203
drh35573352008-01-08 23:54:25 +00003204 assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 );
drh33cd4902009-05-30 20:49:20 +00003205 if( NEVER(v==0) ) return; /* Existance of VDBE checked by caller */
3206 if( NEVER(pExpr==0) ) return; /* No way this can happen */
drhf2bc0132004-10-04 13:19:23 +00003207 op = pExpr->op;
3208 switch( op ){
drhcce7d172000-05-31 15:34:51 +00003209 case TK_AND: {
danielk19774adee202004-05-08 08:23:19 +00003210 int d2 = sqlite3VdbeMakeLabel(v);
drhc5499be2008-04-01 15:06:33 +00003211 testcase( jumpIfNull==0 );
drhceea3322009-04-23 13:22:42 +00003212 sqlite3ExprCachePush(pParse);
drh35573352008-01-08 23:54:25 +00003213 sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2,jumpIfNull^SQLITE_JUMPIFNULL);
danielk19774adee202004-05-08 08:23:19 +00003214 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
3215 sqlite3VdbeResolveLabel(v, d2);
drhceea3322009-04-23 13:22:42 +00003216 sqlite3ExprCachePop(pParse, 1);
drhcce7d172000-05-31 15:34:51 +00003217 break;
3218 }
3219 case TK_OR: {
drhc5499be2008-04-01 15:06:33 +00003220 testcase( jumpIfNull==0 );
danielk19774adee202004-05-08 08:23:19 +00003221 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
3222 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
drhcce7d172000-05-31 15:34:51 +00003223 break;
3224 }
3225 case TK_NOT: {
drhc5499be2008-04-01 15:06:33 +00003226 testcase( jumpIfNull==0 );
danielk19774adee202004-05-08 08:23:19 +00003227 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
drhcce7d172000-05-31 15:34:51 +00003228 break;
3229 }
3230 case TK_LT:
3231 case TK_LE:
3232 case TK_GT:
3233 case TK_GE:
3234 case TK_NE:
drh0ac65892002-04-20 14:24:41 +00003235 case TK_EQ: {
drhf2bc0132004-10-04 13:19:23 +00003236 assert( TK_LT==OP_Lt );
3237 assert( TK_LE==OP_Le );
3238 assert( TK_GT==OP_Gt );
3239 assert( TK_GE==OP_Ge );
3240 assert( TK_EQ==OP_Eq );
3241 assert( TK_NE==OP_Ne );
drhc5499be2008-04-01 15:06:33 +00003242 testcase( op==TK_LT );
3243 testcase( op==TK_LE );
3244 testcase( op==TK_GT );
3245 testcase( op==TK_GE );
3246 testcase( op==TK_EQ );
3247 testcase( op==TK_NE );
3248 testcase( jumpIfNull==0 );
drhda250ea2008-04-01 05:07:14 +00003249 codeCompareOperands(pParse, pExpr->pLeft, &r1, &regFree1,
3250 pExpr->pRight, &r2, &regFree2);
drh35573352008-01-08 23:54:25 +00003251 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
drh2dcef112008-01-12 19:03:48 +00003252 r1, r2, dest, jumpIfNull);
drhc5499be2008-04-01 15:06:33 +00003253 testcase( regFree1==0 );
3254 testcase( regFree2==0 );
drhcce7d172000-05-31 15:34:51 +00003255 break;
3256 }
drh6a2fe092009-09-23 02:29:36 +00003257 case TK_IS:
3258 case TK_ISNOT: {
3259 testcase( op==TK_IS );
3260 testcase( op==TK_ISNOT );
3261 codeCompareOperands(pParse, pExpr->pLeft, &r1, &regFree1,
3262 pExpr->pRight, &r2, &regFree2);
3263 op = (op==TK_IS) ? TK_EQ : TK_NE;
3264 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
3265 r1, r2, dest, SQLITE_NULLEQ);
3266 testcase( regFree1==0 );
3267 testcase( regFree2==0 );
3268 break;
3269 }
drhcce7d172000-05-31 15:34:51 +00003270 case TK_ISNULL:
3271 case TK_NOTNULL: {
drhf2bc0132004-10-04 13:19:23 +00003272 assert( TK_ISNULL==OP_IsNull );
3273 assert( TK_NOTNULL==OP_NotNull );
drhc5499be2008-04-01 15:06:33 +00003274 testcase( op==TK_ISNULL );
3275 testcase( op==TK_NOTNULL );
drh2dcef112008-01-12 19:03:48 +00003276 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
3277 sqlite3VdbeAddOp2(v, op, r1, dest);
drhc5499be2008-04-01 15:06:33 +00003278 testcase( regFree1==0 );
drhcce7d172000-05-31 15:34:51 +00003279 break;
3280 }
drhfef52082000-06-06 01:50:43 +00003281 case TK_BETWEEN: {
drh5c03f302009-11-13 15:03:59 +00003282 testcase( jumpIfNull==0 );
drh36c563a2009-11-12 13:32:22 +00003283 exprCodeBetween(pParse, pExpr, dest, 1, jumpIfNull);
drhfef52082000-06-06 01:50:43 +00003284 break;
3285 }
drhe3365e62009-11-12 17:52:24 +00003286 case TK_IN: {
3287 int destIfFalse = sqlite3VdbeMakeLabel(v);
3288 int destIfNull = jumpIfNull ? dest : destIfFalse;
3289 sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
3290 sqlite3VdbeAddOp2(v, OP_Goto, 0, dest);
3291 sqlite3VdbeResolveLabel(v, destIfFalse);
3292 break;
3293 }
drhcce7d172000-05-31 15:34:51 +00003294 default: {
drh2dcef112008-01-12 19:03:48 +00003295 r1 = sqlite3ExprCodeTemp(pParse, pExpr, &regFree1);
3296 sqlite3VdbeAddOp3(v, OP_If, r1, dest, jumpIfNull!=0);
drhc5499be2008-04-01 15:06:33 +00003297 testcase( regFree1==0 );
3298 testcase( jumpIfNull==0 );
drhcce7d172000-05-31 15:34:51 +00003299 break;
3300 }
3301 }
drh2dcef112008-01-12 19:03:48 +00003302 sqlite3ReleaseTempReg(pParse, regFree1);
3303 sqlite3ReleaseTempReg(pParse, regFree2);
drhcce7d172000-05-31 15:34:51 +00003304}
3305
3306/*
drh66b89c82000-11-28 20:47:17 +00003307** Generate code for a boolean expression such that a jump is made
drhcce7d172000-05-31 15:34:51 +00003308** to the label "dest" if the expression is false but execution
3309** continues straight thru if the expression is true.
drhf5905aa2002-05-26 20:54:33 +00003310**
3311** If the expression evaluates to NULL (neither true nor false) then
drh35573352008-01-08 23:54:25 +00003312** jump if jumpIfNull is SQLITE_JUMPIFNULL or fall through if jumpIfNull
3313** is 0.
drhcce7d172000-05-31 15:34:51 +00003314*/
danielk19774adee202004-05-08 08:23:19 +00003315void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
drhcce7d172000-05-31 15:34:51 +00003316 Vdbe *v = pParse->pVdbe;
3317 int op = 0;
drh2dcef112008-01-12 19:03:48 +00003318 int regFree1 = 0;
3319 int regFree2 = 0;
3320 int r1, r2;
3321
drh35573352008-01-08 23:54:25 +00003322 assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 );
drh33cd4902009-05-30 20:49:20 +00003323 if( NEVER(v==0) ) return; /* Existance of VDBE checked by caller */
3324 if( pExpr==0 ) return;
drhf2bc0132004-10-04 13:19:23 +00003325
3326 /* The value of pExpr->op and op are related as follows:
3327 **
3328 ** pExpr->op op
3329 ** --------- ----------
3330 ** TK_ISNULL OP_NotNull
3331 ** TK_NOTNULL OP_IsNull
3332 ** TK_NE OP_Eq
3333 ** TK_EQ OP_Ne
3334 ** TK_GT OP_Le
3335 ** TK_LE OP_Gt
3336 ** TK_GE OP_Lt
3337 ** TK_LT OP_Ge
3338 **
3339 ** For other values of pExpr->op, op is undefined and unused.
3340 ** The value of TK_ and OP_ constants are arranged such that we
3341 ** can compute the mapping above using the following expression.
3342 ** Assert()s verify that the computation is correct.
3343 */
3344 op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1);
3345
3346 /* Verify correct alignment of TK_ and OP_ constants
3347 */
3348 assert( pExpr->op!=TK_ISNULL || op==OP_NotNull );
3349 assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull );
3350 assert( pExpr->op!=TK_NE || op==OP_Eq );
3351 assert( pExpr->op!=TK_EQ || op==OP_Ne );
3352 assert( pExpr->op!=TK_LT || op==OP_Ge );
3353 assert( pExpr->op!=TK_LE || op==OP_Gt );
3354 assert( pExpr->op!=TK_GT || op==OP_Le );
3355 assert( pExpr->op!=TK_GE || op==OP_Lt );
3356
drhcce7d172000-05-31 15:34:51 +00003357 switch( pExpr->op ){
3358 case TK_AND: {
drhc5499be2008-04-01 15:06:33 +00003359 testcase( jumpIfNull==0 );
danielk19774adee202004-05-08 08:23:19 +00003360 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
3361 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
drhcce7d172000-05-31 15:34:51 +00003362 break;
3363 }
3364 case TK_OR: {
danielk19774adee202004-05-08 08:23:19 +00003365 int d2 = sqlite3VdbeMakeLabel(v);
drhc5499be2008-04-01 15:06:33 +00003366 testcase( jumpIfNull==0 );
drhceea3322009-04-23 13:22:42 +00003367 sqlite3ExprCachePush(pParse);
drh35573352008-01-08 23:54:25 +00003368 sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2, jumpIfNull^SQLITE_JUMPIFNULL);
danielk19774adee202004-05-08 08:23:19 +00003369 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
3370 sqlite3VdbeResolveLabel(v, d2);
drhceea3322009-04-23 13:22:42 +00003371 sqlite3ExprCachePop(pParse, 1);
drhcce7d172000-05-31 15:34:51 +00003372 break;
3373 }
3374 case TK_NOT: {
drh5c03f302009-11-13 15:03:59 +00003375 testcase( jumpIfNull==0 );
danielk19774adee202004-05-08 08:23:19 +00003376 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
drhcce7d172000-05-31 15:34:51 +00003377 break;
3378 }
3379 case TK_LT:
3380 case TK_LE:
3381 case TK_GT:
3382 case TK_GE:
3383 case TK_NE:
3384 case TK_EQ: {
drhc5499be2008-04-01 15:06:33 +00003385 testcase( op==TK_LT );
3386 testcase( op==TK_LE );
3387 testcase( op==TK_GT );
3388 testcase( op==TK_GE );
3389 testcase( op==TK_EQ );
3390 testcase( op==TK_NE );
3391 testcase( jumpIfNull==0 );
drhda250ea2008-04-01 05:07:14 +00003392 codeCompareOperands(pParse, pExpr->pLeft, &r1, &regFree1,
3393 pExpr->pRight, &r2, &regFree2);
drh35573352008-01-08 23:54:25 +00003394 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
drh2dcef112008-01-12 19:03:48 +00003395 r1, r2, dest, jumpIfNull);
drhc5499be2008-04-01 15:06:33 +00003396 testcase( regFree1==0 );
3397 testcase( regFree2==0 );
drhcce7d172000-05-31 15:34:51 +00003398 break;
3399 }
drh6a2fe092009-09-23 02:29:36 +00003400 case TK_IS:
3401 case TK_ISNOT: {
drh6d4486a2009-09-23 14:45:05 +00003402 testcase( pExpr->op==TK_IS );
3403 testcase( pExpr->op==TK_ISNOT );
drh6a2fe092009-09-23 02:29:36 +00003404 codeCompareOperands(pParse, pExpr->pLeft, &r1, &regFree1,
3405 pExpr->pRight, &r2, &regFree2);
3406 op = (pExpr->op==TK_IS) ? TK_NE : TK_EQ;
3407 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
3408 r1, r2, dest, SQLITE_NULLEQ);
3409 testcase( regFree1==0 );
3410 testcase( regFree2==0 );
3411 break;
3412 }
drhcce7d172000-05-31 15:34:51 +00003413 case TK_ISNULL:
3414 case TK_NOTNULL: {
drhc5499be2008-04-01 15:06:33 +00003415 testcase( op==TK_ISNULL );
3416 testcase( op==TK_NOTNULL );
drh2dcef112008-01-12 19:03:48 +00003417 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
3418 sqlite3VdbeAddOp2(v, op, r1, dest);
drhc5499be2008-04-01 15:06:33 +00003419 testcase( regFree1==0 );
drhcce7d172000-05-31 15:34:51 +00003420 break;
3421 }
drhfef52082000-06-06 01:50:43 +00003422 case TK_BETWEEN: {
drh5c03f302009-11-13 15:03:59 +00003423 testcase( jumpIfNull==0 );
drh36c563a2009-11-12 13:32:22 +00003424 exprCodeBetween(pParse, pExpr, dest, 0, jumpIfNull);
drhfef52082000-06-06 01:50:43 +00003425 break;
3426 }
drhe3365e62009-11-12 17:52:24 +00003427 case TK_IN: {
3428 if( jumpIfNull ){
3429 sqlite3ExprCodeIN(pParse, pExpr, dest, dest);
3430 }else{
3431 int destIfNull = sqlite3VdbeMakeLabel(v);
3432 sqlite3ExprCodeIN(pParse, pExpr, dest, destIfNull);
3433 sqlite3VdbeResolveLabel(v, destIfNull);
3434 }
3435 break;
3436 }
drhcce7d172000-05-31 15:34:51 +00003437 default: {
drh2dcef112008-01-12 19:03:48 +00003438 r1 = sqlite3ExprCodeTemp(pParse, pExpr, &regFree1);
3439 sqlite3VdbeAddOp3(v, OP_IfNot, r1, dest, jumpIfNull!=0);
drhc5499be2008-04-01 15:06:33 +00003440 testcase( regFree1==0 );
3441 testcase( jumpIfNull==0 );
drhcce7d172000-05-31 15:34:51 +00003442 break;
3443 }
3444 }
drh2dcef112008-01-12 19:03:48 +00003445 sqlite3ReleaseTempReg(pParse, regFree1);
3446 sqlite3ReleaseTempReg(pParse, regFree2);
drhcce7d172000-05-31 15:34:51 +00003447}
drh22827922000-06-06 17:27:05 +00003448
3449/*
3450** Do a deep comparison of two expression trees. Return TRUE (non-zero)
3451** if they are identical and return FALSE if they differ in any way.
drhd40aab02007-02-24 15:29:03 +00003452**
3453** Sometimes this routine will return FALSE even if the two expressions
3454** really are equivalent. If we cannot prove that the expressions are
3455** identical, we return FALSE just to be safe. So if this routine
3456** returns false, then you do not really know for certain if the two
3457** expressions are the same. But if you get a TRUE return, then you
3458** can be sure the expressions are the same. In the places where
3459** this routine is used, it does not hurt to get an extra FALSE - that
3460** just might result in some slightly slower code. But returning
3461** an incorrect TRUE could lead to a malfunction.
drh22827922000-06-06 17:27:05 +00003462*/
danielk19774adee202004-05-08 08:23:19 +00003463int sqlite3ExprCompare(Expr *pA, Expr *pB){
drh22827922000-06-06 17:27:05 +00003464 int i;
danielk19774b202ae2006-01-23 05:50:58 +00003465 if( pA==0||pB==0 ){
3466 return pB==pA;
drh22827922000-06-06 17:27:05 +00003467 }
drh33e619f2009-05-28 01:00:55 +00003468 assert( !ExprHasAnyProperty(pA, EP_TokenOnly|EP_Reduced) );
3469 assert( !ExprHasAnyProperty(pB, EP_TokenOnly|EP_Reduced) );
danielk19776ab3a2e2009-02-19 14:39:25 +00003470 if( ExprHasProperty(pA, EP_xIsSelect) || ExprHasProperty(pB, EP_xIsSelect) ){
drh22827922000-06-06 17:27:05 +00003471 return 0;
3472 }
danielk19776ab3a2e2009-02-19 14:39:25 +00003473 if( (pA->flags & EP_Distinct)!=(pB->flags & EP_Distinct) ) return 0;
3474 if( pA->op!=pB->op ) return 0;
3475 if( !sqlite3ExprCompare(pA->pLeft, pB->pLeft) ) return 0;
3476 if( !sqlite3ExprCompare(pA->pRight, pB->pRight) ) return 0;
3477
3478 if( pA->x.pList && pB->x.pList ){
3479 if( pA->x.pList->nExpr!=pB->x.pList->nExpr ) return 0;
3480 for(i=0; i<pA->x.pList->nExpr; i++){
3481 Expr *pExprA = pA->x.pList->a[i].pExpr;
3482 Expr *pExprB = pB->x.pList->a[i].pExpr;
3483 if( !sqlite3ExprCompare(pExprA, pExprB) ) return 0;
3484 }
3485 }else if( pA->x.pList || pB->x.pList ){
3486 return 0;
3487 }
3488
drh2f2c01e2002-07-02 13:05:04 +00003489 if( pA->iTable!=pB->iTable || pA->iColumn!=pB->iColumn ) return 0;
drh33e619f2009-05-28 01:00:55 +00003490 if( ExprHasProperty(pA, EP_IntValue) ){
3491 if( !ExprHasProperty(pB, EP_IntValue) || pA->u.iValue!=pB->u.iValue ){
3492 return 0;
3493 }
3494 }else if( pA->op!=TK_COLUMN && pA->u.zToken ){
drh20bc3932009-05-30 23:35:43 +00003495 if( ExprHasProperty(pB, EP_IntValue) || NEVER(pB->u.zToken==0) ) return 0;
drh33e619f2009-05-28 01:00:55 +00003496 if( sqlite3StrICmp(pA->u.zToken,pB->u.zToken)!=0 ){
drh2646da72005-12-09 20:02:05 +00003497 return 0;
3498 }
drh22827922000-06-06 17:27:05 +00003499 }
3500 return 1;
3501}
3502
drh13449892005-09-07 21:22:45 +00003503
drh22827922000-06-06 17:27:05 +00003504/*
drh13449892005-09-07 21:22:45 +00003505** Add a new element to the pAggInfo->aCol[] array. Return the index of
3506** the new element. Return a negative number if malloc fails.
drh22827922000-06-06 17:27:05 +00003507*/
drh17435752007-08-16 04:30:38 +00003508static int addAggInfoColumn(sqlite3 *db, AggInfo *pInfo){
drh13449892005-09-07 21:22:45 +00003509 int i;
drhcf643722007-03-27 13:36:37 +00003510 pInfo->aCol = sqlite3ArrayAllocate(
drh17435752007-08-16 04:30:38 +00003511 db,
drhcf643722007-03-27 13:36:37 +00003512 pInfo->aCol,
3513 sizeof(pInfo->aCol[0]),
3514 3,
3515 &pInfo->nColumn,
3516 &pInfo->nColumnAlloc,
3517 &i
3518 );
drh13449892005-09-07 21:22:45 +00003519 return i;
3520}
3521
3522/*
3523** Add a new element to the pAggInfo->aFunc[] array. Return the index of
3524** the new element. Return a negative number if malloc fails.
3525*/
drh17435752007-08-16 04:30:38 +00003526static int addAggInfoFunc(sqlite3 *db, AggInfo *pInfo){
drh13449892005-09-07 21:22:45 +00003527 int i;
drhcf643722007-03-27 13:36:37 +00003528 pInfo->aFunc = sqlite3ArrayAllocate(
drh17435752007-08-16 04:30:38 +00003529 db,
drhcf643722007-03-27 13:36:37 +00003530 pInfo->aFunc,
3531 sizeof(pInfo->aFunc[0]),
3532 3,
3533 &pInfo->nFunc,
3534 &pInfo->nFuncAlloc,
3535 &i
3536 );
drh13449892005-09-07 21:22:45 +00003537 return i;
3538}
drh22827922000-06-06 17:27:05 +00003539
3540/*
drh7d10d5a2008-08-20 16:35:10 +00003541** This is the xExprCallback for a tree walker. It is used to
3542** implement sqlite3ExprAnalyzeAggregates(). See sqlite3ExprAnalyzeAggregates
drh626a8792005-01-17 22:08:19 +00003543** for additional information.
drh22827922000-06-06 17:27:05 +00003544*/
drh7d10d5a2008-08-20 16:35:10 +00003545static int analyzeAggregate(Walker *pWalker, Expr *pExpr){
drh22827922000-06-06 17:27:05 +00003546 int i;
drh7d10d5a2008-08-20 16:35:10 +00003547 NameContext *pNC = pWalker->u.pNC;
danielk1977a58fdfb2005-02-08 07:50:40 +00003548 Parse *pParse = pNC->pParse;
3549 SrcList *pSrcList = pNC->pSrcList;
drh13449892005-09-07 21:22:45 +00003550 AggInfo *pAggInfo = pNC->pAggInfo;
drh22827922000-06-06 17:27:05 +00003551
drh22827922000-06-06 17:27:05 +00003552 switch( pExpr->op ){
drh89c69d02007-01-04 01:20:28 +00003553 case TK_AGG_COLUMN:
drh967e8b72000-06-21 13:59:10 +00003554 case TK_COLUMN: {
drh8b213892008-08-29 02:14:02 +00003555 testcase( pExpr->op==TK_AGG_COLUMN );
3556 testcase( pExpr->op==TK_COLUMN );
drh13449892005-09-07 21:22:45 +00003557 /* Check to see if the column is in one of the tables in the FROM
3558 ** clause of the aggregate query */
drh20bc3932009-05-30 23:35:43 +00003559 if( ALWAYS(pSrcList!=0) ){
drh13449892005-09-07 21:22:45 +00003560 struct SrcList_item *pItem = pSrcList->a;
3561 for(i=0; i<pSrcList->nSrc; i++, pItem++){
3562 struct AggInfo_col *pCol;
drh33e619f2009-05-28 01:00:55 +00003563 assert( !ExprHasAnyProperty(pExpr, EP_TokenOnly|EP_Reduced) );
drh13449892005-09-07 21:22:45 +00003564 if( pExpr->iTable==pItem->iCursor ){
3565 /* If we reach this point, it means that pExpr refers to a table
3566 ** that is in the FROM clause of the aggregate query.
3567 **
3568 ** Make an entry for the column in pAggInfo->aCol[] if there
3569 ** is not an entry there already.
3570 */
drh7f906d62007-03-12 23:48:52 +00003571 int k;
drh13449892005-09-07 21:22:45 +00003572 pCol = pAggInfo->aCol;
drh7f906d62007-03-12 23:48:52 +00003573 for(k=0; k<pAggInfo->nColumn; k++, pCol++){
drh13449892005-09-07 21:22:45 +00003574 if( pCol->iTable==pExpr->iTable &&
3575 pCol->iColumn==pExpr->iColumn ){
3576 break;
3577 }
danielk1977a58fdfb2005-02-08 07:50:40 +00003578 }
danielk19771e536952007-08-16 10:09:01 +00003579 if( (k>=pAggInfo->nColumn)
3580 && (k = addAggInfoColumn(pParse->db, pAggInfo))>=0
3581 ){
drh7f906d62007-03-12 23:48:52 +00003582 pCol = &pAggInfo->aCol[k];
danielk19770817d0d2007-02-14 09:19:36 +00003583 pCol->pTab = pExpr->pTab;
drh13449892005-09-07 21:22:45 +00003584 pCol->iTable = pExpr->iTable;
3585 pCol->iColumn = pExpr->iColumn;
drh0a07c102008-01-03 18:03:08 +00003586 pCol->iMem = ++pParse->nMem;
drh13449892005-09-07 21:22:45 +00003587 pCol->iSorterColumn = -1;
drh5774b802005-09-07 22:48:16 +00003588 pCol->pExpr = pExpr;
drh13449892005-09-07 21:22:45 +00003589 if( pAggInfo->pGroupBy ){
3590 int j, n;
3591 ExprList *pGB = pAggInfo->pGroupBy;
3592 struct ExprList_item *pTerm = pGB->a;
3593 n = pGB->nExpr;
3594 for(j=0; j<n; j++, pTerm++){
3595 Expr *pE = pTerm->pExpr;
3596 if( pE->op==TK_COLUMN && pE->iTable==pExpr->iTable &&
3597 pE->iColumn==pExpr->iColumn ){
3598 pCol->iSorterColumn = j;
3599 break;
3600 }
3601 }
3602 }
3603 if( pCol->iSorterColumn<0 ){
3604 pCol->iSorterColumn = pAggInfo->nSortingColumn++;
3605 }
3606 }
3607 /* There is now an entry for pExpr in pAggInfo->aCol[] (either
3608 ** because it was there before or because we just created it).
3609 ** Convert the pExpr to be a TK_AGG_COLUMN referring to that
3610 ** pAggInfo->aCol[] entry.
3611 */
drh33e619f2009-05-28 01:00:55 +00003612 ExprSetIrreducible(pExpr);
drh13449892005-09-07 21:22:45 +00003613 pExpr->pAggInfo = pAggInfo;
3614 pExpr->op = TK_AGG_COLUMN;
shanecf697392009-06-01 16:53:09 +00003615 pExpr->iAgg = (i16)k;
drh13449892005-09-07 21:22:45 +00003616 break;
3617 } /* endif pExpr->iTable==pItem->iCursor */
3618 } /* end loop over pSrcList */
drh22827922000-06-06 17:27:05 +00003619 }
drh7d10d5a2008-08-20 16:35:10 +00003620 return WRC_Prune;
drh22827922000-06-06 17:27:05 +00003621 }
3622 case TK_AGG_FUNCTION: {
drh13449892005-09-07 21:22:45 +00003623 /* The pNC->nDepth==0 test causes aggregate functions in subqueries
3624 ** to be ignored */
danielk1977a58fdfb2005-02-08 07:50:40 +00003625 if( pNC->nDepth==0 ){
drh13449892005-09-07 21:22:45 +00003626 /* Check to see if pExpr is a duplicate of another aggregate
3627 ** function that is already in the pAggInfo structure
3628 */
3629 struct AggInfo_func *pItem = pAggInfo->aFunc;
3630 for(i=0; i<pAggInfo->nFunc; i++, pItem++){
3631 if( sqlite3ExprCompare(pItem->pExpr, pExpr) ){
danielk1977a58fdfb2005-02-08 07:50:40 +00003632 break;
3633 }
drh22827922000-06-06 17:27:05 +00003634 }
drh13449892005-09-07 21:22:45 +00003635 if( i>=pAggInfo->nFunc ){
3636 /* pExpr is original. Make a new entry in pAggInfo->aFunc[]
3637 */
danielk197714db2662006-01-09 16:12:04 +00003638 u8 enc = ENC(pParse->db);
danielk19771e536952007-08-16 10:09:01 +00003639 i = addAggInfoFunc(pParse->db, pAggInfo);
drh13449892005-09-07 21:22:45 +00003640 if( i>=0 ){
danielk19776ab3a2e2009-02-19 14:39:25 +00003641 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
drh13449892005-09-07 21:22:45 +00003642 pItem = &pAggInfo->aFunc[i];
3643 pItem->pExpr = pExpr;
drh0a07c102008-01-03 18:03:08 +00003644 pItem->iMem = ++pParse->nMem;
drh33e619f2009-05-28 01:00:55 +00003645 assert( !ExprHasProperty(pExpr, EP_IntValue) );
drh13449892005-09-07 21:22:45 +00003646 pItem->pFunc = sqlite3FindFunction(pParse->db,
drh33e619f2009-05-28 01:00:55 +00003647 pExpr->u.zToken, sqlite3Strlen30(pExpr->u.zToken),
danielk19776ab3a2e2009-02-19 14:39:25 +00003648 pExpr->x.pList ? pExpr->x.pList->nExpr : 0, enc, 0);
drhfd357972005-09-09 01:33:19 +00003649 if( pExpr->flags & EP_Distinct ){
3650 pItem->iDistinct = pParse->nTab++;
3651 }else{
3652 pItem->iDistinct = -1;
3653 }
drh13449892005-09-07 21:22:45 +00003654 }
danielk1977a58fdfb2005-02-08 07:50:40 +00003655 }
drh13449892005-09-07 21:22:45 +00003656 /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry
3657 */
drh33e619f2009-05-28 01:00:55 +00003658 assert( !ExprHasAnyProperty(pExpr, EP_TokenOnly|EP_Reduced) );
3659 ExprSetIrreducible(pExpr);
shanecf697392009-06-01 16:53:09 +00003660 pExpr->iAgg = (i16)i;
drh13449892005-09-07 21:22:45 +00003661 pExpr->pAggInfo = pAggInfo;
drh7d10d5a2008-08-20 16:35:10 +00003662 return WRC_Prune;
drh22827922000-06-06 17:27:05 +00003663 }
drh22827922000-06-06 17:27:05 +00003664 }
3665 }
drh7d10d5a2008-08-20 16:35:10 +00003666 return WRC_Continue;
3667}
3668static int analyzeAggregatesInSelect(Walker *pWalker, Select *pSelect){
3669 NameContext *pNC = pWalker->u.pNC;
3670 if( pNC->nDepth==0 ){
danielk1977a58fdfb2005-02-08 07:50:40 +00003671 pNC->nDepth++;
drh7d10d5a2008-08-20 16:35:10 +00003672 sqlite3WalkSelect(pWalker, pSelect);
danielk1977a58fdfb2005-02-08 07:50:40 +00003673 pNC->nDepth--;
drh7d10d5a2008-08-20 16:35:10 +00003674 return WRC_Prune;
3675 }else{
3676 return WRC_Continue;
danielk1977a58fdfb2005-02-08 07:50:40 +00003677 }
drh626a8792005-01-17 22:08:19 +00003678}
3679
3680/*
3681** Analyze the given expression looking for aggregate functions and
3682** for variables that need to be added to the pParse->aAgg[] array.
3683** Make additional entries to the pParse->aAgg[] array as necessary.
3684**
3685** This routine should only be called after the expression has been
drh7d10d5a2008-08-20 16:35:10 +00003686** analyzed by sqlite3ResolveExprNames().
drh626a8792005-01-17 22:08:19 +00003687*/
drhd2b3e232008-01-23 14:51:49 +00003688void sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){
drh7d10d5a2008-08-20 16:35:10 +00003689 Walker w;
3690 w.xExprCallback = analyzeAggregate;
3691 w.xSelectCallback = analyzeAggregatesInSelect;
3692 w.u.pNC = pNC;
drh20bc3932009-05-30 23:35:43 +00003693 assert( pNC->pSrcList!=0 );
drh7d10d5a2008-08-20 16:35:10 +00003694 sqlite3WalkExpr(&w, pExpr);
drh22827922000-06-06 17:27:05 +00003695}
drh5d9a4af2005-08-30 00:54:01 +00003696
3697/*
3698** Call sqlite3ExprAnalyzeAggregates() for every expression in an
3699** expression list. Return the number of errors.
3700**
3701** If an error is found, the analysis is cut short.
3702*/
drhd2b3e232008-01-23 14:51:49 +00003703void sqlite3ExprAnalyzeAggList(NameContext *pNC, ExprList *pList){
drh5d9a4af2005-08-30 00:54:01 +00003704 struct ExprList_item *pItem;
3705 int i;
drh5d9a4af2005-08-30 00:54:01 +00003706 if( pList ){
drhd2b3e232008-01-23 14:51:49 +00003707 for(pItem=pList->a, i=0; i<pList->nExpr; i++, pItem++){
3708 sqlite3ExprAnalyzeAggregates(pNC, pItem->pExpr);
drh5d9a4af2005-08-30 00:54:01 +00003709 }
3710 }
drh5d9a4af2005-08-30 00:54:01 +00003711}
drh892d3172008-01-10 03:46:36 +00003712
3713/*
drhceea3322009-04-23 13:22:42 +00003714** Allocate a single new register for use to hold some intermediate result.
drh892d3172008-01-10 03:46:36 +00003715*/
3716int sqlite3GetTempReg(Parse *pParse){
drhe55cbd72008-03-31 23:48:03 +00003717 if( pParse->nTempReg==0 ){
drh892d3172008-01-10 03:46:36 +00003718 return ++pParse->nMem;
3719 }
danielk19772f425f62008-07-04 09:41:39 +00003720 return pParse->aTempReg[--pParse->nTempReg];
drh892d3172008-01-10 03:46:36 +00003721}
drhceea3322009-04-23 13:22:42 +00003722
3723/*
3724** Deallocate a register, making available for reuse for some other
3725** purpose.
3726**
3727** If a register is currently being used by the column cache, then
3728** the dallocation is deferred until the column cache line that uses
3729** the register becomes stale.
3730*/
drh892d3172008-01-10 03:46:36 +00003731void sqlite3ReleaseTempReg(Parse *pParse, int iReg){
drh2dcef112008-01-12 19:03:48 +00003732 if( iReg && pParse->nTempReg<ArraySize(pParse->aTempReg) ){
drhceea3322009-04-23 13:22:42 +00003733 int i;
3734 struct yColCache *p;
3735 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
3736 if( p->iReg==iReg ){
3737 p->tempReg = 1;
3738 return;
3739 }
3740 }
drh892d3172008-01-10 03:46:36 +00003741 pParse->aTempReg[pParse->nTempReg++] = iReg;
3742 }
3743}
3744
3745/*
3746** Allocate or deallocate a block of nReg consecutive registers
3747*/
3748int sqlite3GetTempRange(Parse *pParse, int nReg){
drhe55cbd72008-03-31 23:48:03 +00003749 int i, n;
3750 i = pParse->iRangeReg;
3751 n = pParse->nRangeReg;
3752 if( nReg<=n && !usedAsColumnCache(pParse, i, i+n-1) ){
drh892d3172008-01-10 03:46:36 +00003753 pParse->iRangeReg += nReg;
3754 pParse->nRangeReg -= nReg;
3755 }else{
3756 i = pParse->nMem+1;
3757 pParse->nMem += nReg;
3758 }
3759 return i;
3760}
3761void sqlite3ReleaseTempRange(Parse *pParse, int iReg, int nReg){
3762 if( nReg>pParse->nRangeReg ){
3763 pParse->nRangeReg = nReg;
3764 pParse->iRangeReg = iReg;
3765 }
3766}