4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
7 ** 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.
11 *************************************************************************
12 ** This file contains routines used for analyzing expressions and
13 ** for generating VDBE code that evaluates expressions in SQLite.
15 #include "sqliteInt.h"
18 ** Return the 'affinity' of the expression pExpr if any.
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.
25 ** i.e. the WHERE clause expresssions in the following statements all
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);
33 char sqlite3ExprAffinity(Expr
*pExpr
){
36 assert( pExpr
->flags
&EP_xIsSelect
);
37 return sqlite3ExprAffinity(pExpr
->x
.pSelect
->pEList
->a
[0].pExpr
);
39 #ifndef SQLITE_OMIT_CAST
41 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
42 return sqlite3AffinityType(pExpr
->u
.zToken
);
45 if( (op
==TK_AGG_COLUMN
|| op
==TK_COLUMN
|| op
==TK_REGISTER
)
48 /* 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
;
55 return pExpr
->affinity
;
59 ** Set the explicit collating sequence for an expression to the
60 ** collating sequence supplied in the second argument.
62 Expr
*sqlite3ExprSetColl(Expr
*pExpr
, CollSeq
*pColl
){
65 pExpr
->flags
|= EP_ExpCollate
;
71 ** Set the collating sequence for expression pExpr to be the collating
72 ** sequence named by pToken. Return a pointer to the revised expression.
73 ** The collating sequence is marked as "explicit" using the EP_ExpCollate
74 ** flag. An explicit collating sequence will override implicit
75 ** collating sequences.
77 Expr
*sqlite3ExprSetCollByToken(Parse
*pParse
, Expr
*pExpr
, Token
*pCollName
){
78 char *zColl
= 0; /* Dequoted name of collation sequence */
80 sqlite3
*db
= pParse
->db
;
81 zColl
= sqlite3NameFromToken(db
, pCollName
);
82 pColl
= sqlite3LocateCollSeq(pParse
, zColl
);
83 sqlite3ExprSetColl(pExpr
, pColl
);
84 sqlite3DbFree(db
, zColl
);
89 ** Return the default collation sequence for the expression pExpr. If
90 ** there is no default collation type, return 0.
92 CollSeq
*sqlite3ExprCollSeq(Parse
*pParse
, Expr
*pExpr
){
101 op
==TK_AGG_COLUMN
|| op
==TK_COLUMN
|| op
==TK_REGISTER
|| op
==TK_TRIGGER
103 /* op==TK_REGISTER && p->pTab!=0 happens when pExpr was originally
104 ** a TK_COLUMN but was previously evaluated and cached in a register */
108 sqlite3
*db
= pParse
->db
;
109 zColl
= p
->pTab
->aCol
[j
].zColl
;
110 pColl
= sqlite3FindCollSeq(db
, ENC(db
), zColl
, 0);
111 pExpr
->pColl
= pColl
;
115 if( op
!=TK_CAST
&& op
!=TK_UPLUS
){
120 if( sqlite3CheckCollSeq(pParse
, pColl
) ){
127 ** pExpr is an operand of a comparison operator. aff2 is the
128 ** type affinity of the other operand. This routine returns the
129 ** type affinity that should be used for the comparison operator.
131 char sqlite3CompareAffinity(Expr
*pExpr
, char aff2
){
132 char aff1
= sqlite3ExprAffinity(pExpr
);
134 /* Both sides of the comparison are columns. If one has numeric
135 ** affinity, use that. Otherwise use no affinity.
137 if( sqlite3IsNumericAffinity(aff1
) || sqlite3IsNumericAffinity(aff2
) ){
138 return SQLITE_AFF_NUMERIC
;
140 return SQLITE_AFF_NONE
;
142 }else if( !aff1
&& !aff2
){
143 /* Neither side of the comparison is a column. Compare the
146 return SQLITE_AFF_NONE
;
148 /* One side is a column, the other is not. Use the columns affinity. */
149 assert( aff1
==0 || aff2
==0 );
150 return (aff1
+ aff2
);
155 ** pExpr is a comparison operator. Return the type affinity that should
156 ** be applied to both operands prior to doing the comparison.
158 static char comparisonAffinity(Expr
*pExpr
){
160 assert( pExpr
->op
==TK_EQ
|| pExpr
->op
==TK_IN
|| pExpr
->op
==TK_LT
||
161 pExpr
->op
==TK_GT
|| pExpr
->op
==TK_GE
|| pExpr
->op
==TK_LE
||
162 pExpr
->op
==TK_NE
|| pExpr
->op
==TK_IS
|| pExpr
->op
==TK_ISNOT
);
163 assert( pExpr
->pLeft
);
164 aff
= sqlite3ExprAffinity(pExpr
->pLeft
);
166 aff
= sqlite3CompareAffinity(pExpr
->pRight
, aff
);
167 }else if( ExprHasProperty(pExpr
, EP_xIsSelect
) ){
168 aff
= sqlite3CompareAffinity(pExpr
->x
.pSelect
->pEList
->a
[0].pExpr
, aff
);
170 aff
= SQLITE_AFF_NONE
;
176 ** pExpr is a comparison expression, eg. '=', '<', IN(...) etc.
177 ** idx_affinity is the affinity of an indexed column. Return true
178 ** if the index with affinity idx_affinity may be used to implement
179 ** the comparison in pExpr.
181 int sqlite3IndexAffinityOk(Expr
*pExpr
, char idx_affinity
){
182 char aff
= comparisonAffinity(pExpr
);
184 case SQLITE_AFF_NONE
:
186 case SQLITE_AFF_TEXT
:
187 return idx_affinity
==SQLITE_AFF_TEXT
;
189 return sqlite3IsNumericAffinity(idx_affinity
);
194 ** Return the P5 value that should be used for a binary comparison
195 ** opcode (OP_Eq, OP_Ge etc.) used to compare pExpr1 and pExpr2.
197 static u8
binaryCompareP5(Expr
*pExpr1
, Expr
*pExpr2
, int jumpIfNull
){
198 u8 aff
= (char)sqlite3ExprAffinity(pExpr2
);
199 aff
= (u8
)sqlite3CompareAffinity(pExpr1
, aff
) | (u8
)jumpIfNull
;
204 ** Return a pointer to the collation sequence that should be used by
205 ** a binary comparison operator comparing pLeft and pRight.
207 ** If the left hand expression has a collating sequence type, then it is
208 ** used. Otherwise the collation sequence for the right hand expression
209 ** is used, or the default (BINARY) if neither expression has a collating
212 ** Argument pRight (but not pLeft) may be a null pointer. In this case,
213 ** it is not considered.
215 CollSeq
*sqlite3BinaryCompareCollSeq(
222 if( pLeft
->flags
& EP_ExpCollate
){
223 assert( pLeft
->pColl
);
224 pColl
= pLeft
->pColl
;
225 }else if( pRight
&& pRight
->flags
& EP_ExpCollate
){
226 assert( pRight
->pColl
);
227 pColl
= pRight
->pColl
;
229 pColl
= sqlite3ExprCollSeq(pParse
, pLeft
);
231 pColl
= sqlite3ExprCollSeq(pParse
, pRight
);
238 ** Generate code for a comparison operator.
240 static int codeCompare(
241 Parse
*pParse
, /* The parsing (and code generating) context */
242 Expr
*pLeft
, /* The left operand */
243 Expr
*pRight
, /* The right operand */
244 int opcode
, /* The comparison opcode */
245 int in1
, int in2
, /* Register holding operands */
246 int dest
, /* Jump here if true. */
247 int jumpIfNull
/* If true, jump if either operand is NULL */
253 p4
= sqlite3BinaryCompareCollSeq(pParse
, pLeft
, pRight
);
254 p5
= binaryCompareP5(pLeft
, pRight
, jumpIfNull
);
255 addr
= sqlite3VdbeAddOp4(pParse
->pVdbe
, opcode
, in2
, dest
, in1
,
256 (void*)p4
, P4_COLLSEQ
);
257 sqlite3VdbeChangeP5(pParse
->pVdbe
, (u8
)p5
);
261 #if SQLITE_MAX_EXPR_DEPTH>0
263 ** Check that argument nHeight is less than or equal to the maximum
264 ** expression depth allowed. If it is not, leave an error message in
267 int sqlite3ExprCheckHeight(Parse
*pParse
, int nHeight
){
269 int mxHeight
= pParse
->db
->aLimit
[SQLITE_LIMIT_EXPR_DEPTH
];
270 if( nHeight
>mxHeight
){
271 sqlite3ErrorMsg(pParse
,
272 "Expression tree is too large (maximum depth %d)", mxHeight
279 /* The following three functions, heightOfExpr(), heightOfExprList()
280 ** and heightOfSelect(), are used to determine the maximum height
281 ** of any expression tree referenced by the structure passed as the
284 ** If this maximum height is greater than the current value pointed
285 ** to by pnHeight, the second parameter, then set *pnHeight to that
288 static void heightOfExpr(Expr
*p
, int *pnHeight
){
290 if( p
->nHeight
>*pnHeight
){
291 *pnHeight
= p
->nHeight
;
295 static void heightOfExprList(ExprList
*p
, int *pnHeight
){
298 for(i
=0; i
<p
->nExpr
; i
++){
299 heightOfExpr(p
->a
[i
].pExpr
, pnHeight
);
303 static void heightOfSelect(Select
*p
, int *pnHeight
){
305 heightOfExpr(p
->pWhere
, pnHeight
);
306 heightOfExpr(p
->pHaving
, pnHeight
);
307 heightOfExpr(p
->pLimit
, pnHeight
);
308 heightOfExpr(p
->pOffset
, pnHeight
);
309 heightOfExprList(p
->pEList
, pnHeight
);
310 heightOfExprList(p
->pGroupBy
, pnHeight
);
311 heightOfExprList(p
->pOrderBy
, pnHeight
);
312 heightOfSelect(p
->pPrior
, pnHeight
);
317 ** Set the Expr.nHeight variable in the structure passed as an
318 ** argument. An expression with no children, Expr.pList or
319 ** Expr.pSelect member has a height of 1. Any other expression
320 ** has a height equal to the maximum height of any other
321 ** referenced Expr plus one.
323 static void exprSetHeight(Expr
*p
){
325 heightOfExpr(p
->pLeft
, &nHeight
);
326 heightOfExpr(p
->pRight
, &nHeight
);
327 if( ExprHasProperty(p
, EP_xIsSelect
) ){
328 heightOfSelect(p
->x
.pSelect
, &nHeight
);
330 heightOfExprList(p
->x
.pList
, &nHeight
);
332 p
->nHeight
= nHeight
+ 1;
336 ** Set the Expr.nHeight variable using the exprSetHeight() function. If
337 ** the height is greater than the maximum allowed expression depth,
338 ** leave an error in pParse.
340 void sqlite3ExprSetHeight(Parse
*pParse
, Expr
*p
){
342 sqlite3ExprCheckHeight(pParse
, p
->nHeight
);
346 ** Return the maximum height of any expression tree referenced
347 ** by the select statement passed as an argument.
349 int sqlite3SelectExprHeight(Select
*p
){
351 heightOfSelect(p
, &nHeight
);
355 #define exprSetHeight(y)
356 #endif /* SQLITE_MAX_EXPR_DEPTH>0 */
359 ** This routine is the core allocator for Expr nodes.
361 ** Construct a new expression node and return a pointer to it. Memory
362 ** for this node and for the pToken argument is a single allocation
363 ** obtained from sqlite3DbMalloc(). The calling function
364 ** is responsible for making sure the node eventually gets freed.
366 ** If dequote is true, then the token (if it exists) is dequoted.
367 ** If dequote is false, no dequoting is performance. The deQuote
368 ** parameter is ignored if pToken is NULL or if the token does not
369 ** appear to be quoted. If the quotes were of the form "..." (double-quotes)
370 ** then the EP_DblQuoted flag is set on the expression node.
372 ** Special case: If op==TK_INTEGER and pToken points to a string that
373 ** can be translated into a 32-bit integer, then the token is not
374 ** stored in u.zToken. Instead, the integer values is written
375 ** into u.iValue and the EP_IntValue flag is set. No extra storage
376 ** is allocated to hold the integer text and the dequote flag is ignored.
378 Expr
*sqlite3ExprAlloc(
379 sqlite3
*db
, /* Handle for sqlite3DbMallocZero() (may be null) */
380 int op
, /* Expression opcode */
381 const Token
*pToken
, /* Token argument. Might be NULL */
382 int dequote
/* True to dequote */
389 if( op
!=TK_INTEGER
|| pToken
->z
==0
390 || sqlite3GetInt32(pToken
->z
, &iValue
)==0 ){
391 nExtra
= pToken
->n
+1;
395 pNew
= sqlite3DbMallocZero(db
, sizeof(Expr
)+nExtra
);
401 pNew
->flags
|= EP_IntValue
;
402 pNew
->u
.iValue
= iValue
;
405 pNew
->u
.zToken
= (char*)&pNew
[1];
406 assert( pToken
->z
!=0 || pToken
->n
==0 );
407 if( pToken
->n
) memcpy(pNew
->u
.zToken
, pToken
->z
, pToken
->n
);
408 pNew
->u
.zToken
[pToken
->n
] = 0;
409 if( dequote
&& nExtra
>=3
410 && ((c
= pToken
->z
[0])=='\'' || c
=='"' || c
=='[' || c
=='`') ){
411 sqlite3Dequote(pNew
->u
.zToken
);
412 if( c
=='"' ) pNew
->flags
|= EP_DblQuoted
;
416 #if SQLITE_MAX_EXPR_DEPTH>0
424 ** Allocate a new expression node from a zero-terminated token that has
425 ** already been dequoted.
428 sqlite3
*db
, /* Handle for sqlite3DbMallocZero() (may be null) */
429 int op
, /* Expression opcode */
430 const char *zToken
/* Token argument. Might be NULL */
434 x
.n
= zToken
? sqlite3Strlen30(zToken
) : 0;
435 return sqlite3ExprAlloc(db
, op
, &x
, 0);
439 ** Attach subtrees pLeft and pRight to the Expr node pRoot.
441 ** If pRoot==NULL that means that a memory allocation error has occurred.
442 ** In that case, delete the subtrees pLeft and pRight.
444 void sqlite3ExprAttachSubtrees(
451 assert( db
->mallocFailed
);
452 sqlite3ExprDelete(db
, pLeft
);
453 sqlite3ExprDelete(db
, pRight
);
456 pRoot
->pRight
= pRight
;
457 if( pRight
->flags
& EP_ExpCollate
){
458 pRoot
->flags
|= EP_ExpCollate
;
459 pRoot
->pColl
= pRight
->pColl
;
463 pRoot
->pLeft
= pLeft
;
464 if( pLeft
->flags
& EP_ExpCollate
){
465 pRoot
->flags
|= EP_ExpCollate
;
466 pRoot
->pColl
= pLeft
->pColl
;
469 exprSetHeight(pRoot
);
474 ** Allocate a Expr node which joins as many as two subtrees.
476 ** One or both of the subtrees can be NULL. Return a pointer to the new
477 ** Expr node. Or, if an OOM error occurs, set pParse->db->mallocFailed,
478 ** free the subtrees and return NULL.
481 Parse
*pParse
, /* Parsing context */
482 int op
, /* Expression opcode */
483 Expr
*pLeft
, /* Left operand */
484 Expr
*pRight
, /* Right operand */
485 const Token
*pToken
/* Argument token */
487 Expr
*p
= sqlite3ExprAlloc(pParse
->db
, op
, pToken
, 1);
488 sqlite3ExprAttachSubtrees(pParse
->db
, p
, pLeft
, pRight
);
490 sqlite3ExprCheckHeight(pParse
, p
->nHeight
);
496 ** Join two expressions using an AND operator. If either expression is
497 ** NULL, then just return the other expression.
499 Expr
*sqlite3ExprAnd(sqlite3
*db
, Expr
*pLeft
, Expr
*pRight
){
502 }else if( pRight
==0 ){
505 Expr
*pNew
= sqlite3ExprAlloc(db
, TK_AND
, 0, 0);
506 sqlite3ExprAttachSubtrees(db
, pNew
, pLeft
, pRight
);
512 ** Construct a new expression node for a function with multiple
515 Expr
*sqlite3ExprFunction(Parse
*pParse
, ExprList
*pList
, Token
*pToken
){
517 sqlite3
*db
= pParse
->db
;
519 pNew
= sqlite3ExprAlloc(db
, TK_FUNCTION
, pToken
, 1);
521 sqlite3ExprListDelete(db
, pList
); /* Avoid memory leak when malloc fails */
524 pNew
->x
.pList
= pList
;
525 assert( !ExprHasProperty(pNew
, EP_xIsSelect
) );
526 sqlite3ExprSetHeight(pParse
, pNew
);
531 ** Assign a variable number to an expression that encodes a wildcard
532 ** in the original SQL statement.
534 ** Wildcards consisting of a single "?" are assigned the next sequential
537 ** Wildcards of the form "?nnn" are assigned the number "nnn". We make
538 ** sure "nnn" is not too be to avoid a denial of service attack when
539 ** the SQL statement comes from an external source.
541 ** Wildcards of the form ":aaa", "@aaa", or "$aaa" are assigned the same number
542 ** as the previous instance of the same wildcard. Or if this is the first
543 ** instance of the wildcard, the next sequenial variable number is
546 void sqlite3ExprAssignVarNumber(Parse
*pParse
, Expr
*pExpr
){
547 sqlite3
*db
= pParse
->db
;
550 if( pExpr
==0 ) return;
551 assert( !ExprHasAnyProperty(pExpr
, EP_IntValue
|EP_Reduced
|EP_TokenOnly
) );
556 /* Wildcard of the form "?". Assign the next variable number */
558 pExpr
->iColumn
= (ynVar
)(++pParse
->nVar
);
561 u32 n
= sqlite3Strlen30(z
);
563 /* Wildcard of the form "?nnn". Convert "nnn" to an integer and
564 ** use it as the variable number */
566 int bOk
= 0==sqlite3Atoi64(&z
[1], &i
, n
-1, SQLITE_UTF8
);
567 pExpr
->iColumn
= x
= (ynVar
)i
;
570 testcase( i
==db
->aLimit
[SQLITE_LIMIT_VARIABLE_NUMBER
]-1 );
571 testcase( i
==db
->aLimit
[SQLITE_LIMIT_VARIABLE_NUMBER
] );
572 if( bOk
==0 || i
<1 || i
>db
->aLimit
[SQLITE_LIMIT_VARIABLE_NUMBER
] ){
573 sqlite3ErrorMsg(pParse
, "variable number must be between ?1 and ?%d",
574 db
->aLimit
[SQLITE_LIMIT_VARIABLE_NUMBER
]);
577 if( i
>pParse
->nVar
){
578 pParse
->nVar
= (int)i
;
581 /* Wildcards like ":aaa", "$aaa" or "@aaa". Reuse the same variable
582 ** number as the prior appearance of the same name, or if the name
583 ** has never appeared before, reuse the same variable number
586 for(i
=0; i
<pParse
->nzVar
; i
++){
587 if( pParse
->azVar
[i
] && memcmp(pParse
->azVar
[i
],z
,n
+1)==0 ){
588 pExpr
->iColumn
= x
= (ynVar
)i
+1;
592 if( x
==0 ) x
= pExpr
->iColumn
= (ynVar
)(++pParse
->nVar
);
595 if( x
>pParse
->nzVar
){
597 a
= sqlite3DbRealloc(db
, pParse
->azVar
, x
*sizeof(a
[0]));
598 if( a
==0 ) return; /* Error reported through db->mallocFailed */
600 memset(&a
[pParse
->nzVar
], 0, (x
-pParse
->nzVar
)*sizeof(a
[0]));
603 if( z
[0]!='?' || pParse
->azVar
[x
-1]==0 ){
604 sqlite3DbFree(db
, pParse
->azVar
[x
-1]);
605 pParse
->azVar
[x
-1] = sqlite3DbStrNDup(db
, z
, n
);
609 if( !pParse
->nErr
&& pParse
->nVar
>db
->aLimit
[SQLITE_LIMIT_VARIABLE_NUMBER
] ){
610 sqlite3ErrorMsg(pParse
, "too many SQL variables");
615 ** Recursively delete an expression tree.
617 void sqlite3ExprDelete(sqlite3
*db
, Expr
*p
){
619 /* Sanity check: Assert that the IntValue is non-negative if it exists */
620 assert( !ExprHasProperty(p
, EP_IntValue
) || p
->u
.iValue
>=0 );
621 if( !ExprHasAnyProperty(p
, EP_TokenOnly
) ){
622 sqlite3ExprDelete(db
, p
->pLeft
);
623 sqlite3ExprDelete(db
, p
->pRight
);
624 if( !ExprHasProperty(p
, EP_Reduced
) && (p
->flags2
& EP2_MallocedToken
)!=0 ){
625 sqlite3DbFree(db
, p
->u
.zToken
);
627 if( ExprHasProperty(p
, EP_xIsSelect
) ){
628 sqlite3SelectDelete(db
, p
->x
.pSelect
);
630 sqlite3ExprListDelete(db
, p
->x
.pList
);
633 if( !ExprHasProperty(p
, EP_Static
) ){
634 sqlite3DbFree(db
, p
);
639 ** Return the number of bytes allocated for the expression structure
640 ** passed as the first argument. This is always one of EXPR_FULLSIZE,
641 ** EXPR_REDUCEDSIZE or EXPR_TOKENONLYSIZE.
643 static int exprStructSize(Expr
*p
){
644 if( ExprHasProperty(p
, EP_TokenOnly
) ) return EXPR_TOKENONLYSIZE
;
645 if( ExprHasProperty(p
, EP_Reduced
) ) return EXPR_REDUCEDSIZE
;
646 return EXPR_FULLSIZE
;
650 ** The dupedExpr*Size() routines each return the number of bytes required
651 ** to store a copy of an expression or expression tree. They differ in
652 ** how much of the tree is measured.
654 ** dupedExprStructSize() Size of only the Expr structure
655 ** dupedExprNodeSize() Size of Expr + space for token
656 ** dupedExprSize() Expr + token + subtree components
658 ***************************************************************************
660 ** The dupedExprStructSize() function returns two values OR-ed together:
661 ** (1) the space required for a copy of the Expr structure only and
662 ** (2) the EP_xxx flags that indicate what the structure size should be.
663 ** The return values is always one of:
666 ** EXPR_REDUCEDSIZE | EP_Reduced
667 ** EXPR_TOKENONLYSIZE | EP_TokenOnly
669 ** The size of the structure can be found by masking the return value
670 ** of this routine with 0xfff. The flags can be found by masking the
671 ** return value with EP_Reduced|EP_TokenOnly.
673 ** Note that with flags==EXPRDUP_REDUCE, this routines works on full-size
674 ** (unreduced) Expr objects as they or originally constructed by the parser.
675 ** During expression analysis, extra information is computed and moved into
676 ** later parts of teh Expr object and that extra information might get chopped
677 ** off if the expression is reduced. Note also that it does not work to
678 ** make a EXPRDUP_REDUCE copy of a reduced expression. It is only legal
679 ** to reduce a pristine expression tree from the parser. The implementation
680 ** of dupedExprStructSize() contain multiple assert() statements that attempt
681 ** to enforce this constraint.
683 static int dupedExprStructSize(Expr
*p
, int flags
){
685 assert( flags
==EXPRDUP_REDUCE
|| flags
==0 ); /* Only one flag value allowed */
686 if( 0==(flags
&EXPRDUP_REDUCE
) ){
687 nSize
= EXPR_FULLSIZE
;
689 assert( !ExprHasAnyProperty(p
, EP_TokenOnly
|EP_Reduced
) );
690 assert( !ExprHasProperty(p
, EP_FromJoin
) );
691 assert( (p
->flags2
& EP2_MallocedToken
)==0 );
692 assert( (p
->flags2
& EP2_Irreducible
)==0 );
693 if( p
->pLeft
|| p
->pRight
|| p
->pColl
|| p
->x
.pList
){
694 nSize
= EXPR_REDUCEDSIZE
| EP_Reduced
;
696 nSize
= EXPR_TOKENONLYSIZE
| EP_TokenOnly
;
703 ** This function returns the space in bytes required to store the copy
704 ** of the Expr structure and a copy of the Expr.u.zToken string (if that
705 ** string is defined.)
707 static int dupedExprNodeSize(Expr
*p
, int flags
){
708 int nByte
= dupedExprStructSize(p
, flags
) & 0xfff;
709 if( !ExprHasProperty(p
, EP_IntValue
) && p
->u
.zToken
){
710 nByte
+= sqlite3Strlen30(p
->u
.zToken
)+1;
712 return ROUND8(nByte
);
716 ** Return the number of bytes required to create a duplicate of the
717 ** expression passed as the first argument. The second argument is a
718 ** mask containing EXPRDUP_XXX flags.
720 ** The value returned includes space to create a copy of the Expr struct
721 ** itself and the buffer referred to by Expr.u.zToken, if any.
723 ** If the EXPRDUP_REDUCE flag is set, then the return value includes
724 ** space to duplicate all Expr nodes in the tree formed by Expr.pLeft
725 ** and Expr.pRight variables (but not for any structures pointed to or
726 ** descended from the Expr.x.pList or Expr.x.pSelect variables).
728 static int dupedExprSize(Expr
*p
, int flags
){
731 nByte
= dupedExprNodeSize(p
, flags
);
732 if( flags
&EXPRDUP_REDUCE
){
733 nByte
+= dupedExprSize(p
->pLeft
, flags
) + dupedExprSize(p
->pRight
, flags
);
740 ** This function is similar to sqlite3ExprDup(), except that if pzBuffer
741 ** is not NULL then *pzBuffer is assumed to point to a buffer large enough
742 ** to store the copy of expression p, the copies of p->u.zToken
743 ** (if applicable), and the copies of the p->pLeft and p->pRight expressions,
744 ** if any. Before returning, *pzBuffer is set to the first byte passed the
745 ** portion of the buffer copied into by this function.
747 static Expr
*exprDup(sqlite3
*db
, Expr
*p
, int flags
, u8
**pzBuffer
){
748 Expr
*pNew
= 0; /* Value to return */
750 const int isReduced
= (flags
&EXPRDUP_REDUCE
);
754 assert( pzBuffer
==0 || isReduced
);
756 /* Figure out where to write the new Expr structure. */
759 staticFlag
= EP_Static
;
761 zAlloc
= sqlite3DbMallocRaw(db
, dupedExprSize(p
, flags
));
763 pNew
= (Expr
*)zAlloc
;
766 /* Set nNewSize to the size allocated for the structure pointed to
767 ** by pNew. This is either EXPR_FULLSIZE, EXPR_REDUCEDSIZE or
768 ** EXPR_TOKENONLYSIZE. nToken is set to the number of bytes consumed
769 ** by the copy of the p->u.zToken string (if any).
771 const unsigned nStructSize
= dupedExprStructSize(p
, flags
);
772 const int nNewSize
= nStructSize
& 0xfff;
774 if( !ExprHasProperty(p
, EP_IntValue
) && p
->u
.zToken
){
775 nToken
= sqlite3Strlen30(p
->u
.zToken
) + 1;
780 assert( ExprHasProperty(p
, EP_Reduced
)==0 );
781 memcpy(zAlloc
, p
, nNewSize
);
783 int nSize
= exprStructSize(p
);
784 memcpy(zAlloc
, p
, nSize
);
785 memset(&zAlloc
[nSize
], 0, EXPR_FULLSIZE
-nSize
);
788 /* Set the EP_Reduced, EP_TokenOnly, and EP_Static flags appropriately. */
789 pNew
->flags
&= ~(EP_Reduced
|EP_TokenOnly
|EP_Static
);
790 pNew
->flags
|= nStructSize
& (EP_Reduced
|EP_TokenOnly
);
791 pNew
->flags
|= staticFlag
;
793 /* Copy the p->u.zToken string, if any. */
795 char *zToken
= pNew
->u
.zToken
= (char*)&zAlloc
[nNewSize
];
796 memcpy(zToken
, p
->u
.zToken
, nToken
);
799 if( 0==((p
->flags
|pNew
->flags
) & EP_TokenOnly
) ){
800 /* Fill in the pNew->x.pSelect or pNew->x.pList member. */
801 if( ExprHasProperty(p
, EP_xIsSelect
) ){
802 pNew
->x
.pSelect
= sqlite3SelectDup(db
, p
->x
.pSelect
, isReduced
);
804 pNew
->x
.pList
= sqlite3ExprListDup(db
, p
->x
.pList
, isReduced
);
808 /* Fill in pNew->pLeft and pNew->pRight. */
809 if( ExprHasAnyProperty(pNew
, EP_Reduced
|EP_TokenOnly
) ){
810 zAlloc
+= dupedExprNodeSize(p
, flags
);
811 if( ExprHasProperty(pNew
, EP_Reduced
) ){
812 pNew
->pLeft
= exprDup(db
, p
->pLeft
, EXPRDUP_REDUCE
, &zAlloc
);
813 pNew
->pRight
= exprDup(db
, p
->pRight
, EXPRDUP_REDUCE
, &zAlloc
);
820 if( !ExprHasAnyProperty(p
, EP_TokenOnly
) ){
821 pNew
->pLeft
= sqlite3ExprDup(db
, p
->pLeft
, 0);
822 pNew
->pRight
= sqlite3ExprDup(db
, p
->pRight
, 0);
832 ** The following group of routines make deep copies of expressions,
833 ** expression lists, ID lists, and select statements. The copies can
834 ** be deleted (by being passed to their respective ...Delete() routines)
835 ** without effecting the originals.
837 ** The expression list, ID, and source lists return by sqlite3ExprListDup(),
838 ** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded
839 ** by subsequent calls to sqlite*ListAppend() routines.
841 ** Any tables that the SrcList might point to are not duplicated.
843 ** The flags parameter contains a combination of the EXPRDUP_XXX flags.
844 ** If the EXPRDUP_REDUCE flag is set, then the structure returned is a
845 ** truncated version of the usual Expr structure that will be stored as
846 ** part of the in-memory representation of the database schema.
848 Expr
*sqlite3ExprDup(sqlite3
*db
, Expr
*p
, int flags
){
849 return exprDup(db
, p
, flags
, 0);
851 ExprList
*sqlite3ExprListDup(sqlite3
*db
, ExprList
*p
, int flags
){
853 struct ExprList_item
*pItem
, *pOldItem
;
856 pNew
= sqlite3DbMallocRaw(db
, sizeof(*pNew
) );
857 if( pNew
==0 ) return 0;
859 pNew
->nExpr
= pNew
->nAlloc
= p
->nExpr
;
860 pNew
->a
= pItem
= sqlite3DbMallocRaw(db
, p
->nExpr
*sizeof(p
->a
[0]) );
862 sqlite3DbFree(db
, pNew
);
866 for(i
=0; i
<p
->nExpr
; i
++, pItem
++, pOldItem
++){
867 Expr
*pOldExpr
= pOldItem
->pExpr
;
868 pItem
->pExpr
= sqlite3ExprDup(db
, pOldExpr
, flags
);
869 pItem
->zName
= sqlite3DbStrDup(db
, pOldItem
->zName
);
870 pItem
->zSpan
= sqlite3DbStrDup(db
, pOldItem
->zSpan
);
871 pItem
->sortOrder
= pOldItem
->sortOrder
;
873 pItem
->iOrderByCol
= pOldItem
->iOrderByCol
;
874 pItem
->iAlias
= pOldItem
->iAlias
;
880 ** If cursors, triggers, views and subqueries are all omitted from
881 ** the build, then none of the following routines, except for
882 ** sqlite3SelectDup(), can be called. sqlite3SelectDup() is sometimes
883 ** called with a NULL argument.
885 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) \
886 || !defined(SQLITE_OMIT_SUBQUERY)
887 SrcList
*sqlite3SrcListDup(sqlite3
*db
, SrcList
*p
, int flags
){
892 nByte
= sizeof(*p
) + (p
->nSrc
>0 ? sizeof(p
->a
[0]) * (p
->nSrc
-1) : 0);
893 pNew
= sqlite3DbMallocRaw(db
, nByte
);
894 if( pNew
==0 ) return 0;
895 pNew
->nSrc
= pNew
->nAlloc
= p
->nSrc
;
896 for(i
=0; i
<p
->nSrc
; i
++){
897 struct SrcList_item
*pNewItem
= &pNew
->a
[i
];
898 struct SrcList_item
*pOldItem
= &p
->a
[i
];
900 pNewItem
->zDatabase
= sqlite3DbStrDup(db
, pOldItem
->zDatabase
);
901 pNewItem
->zName
= sqlite3DbStrDup(db
, pOldItem
->zName
);
902 pNewItem
->zAlias
= sqlite3DbStrDup(db
, pOldItem
->zAlias
);
903 pNewItem
->jointype
= pOldItem
->jointype
;
904 pNewItem
->iCursor
= pOldItem
->iCursor
;
905 pNewItem
->addrFillSub
= pOldItem
->addrFillSub
;
906 pNewItem
->regReturn
= pOldItem
->regReturn
;
907 pNewItem
->isCorrelated
= pOldItem
->isCorrelated
;
908 pNewItem
->zIndex
= sqlite3DbStrDup(db
, pOldItem
->zIndex
);
909 pNewItem
->notIndexed
= pOldItem
->notIndexed
;
910 pNewItem
->pIndex
= pOldItem
->pIndex
;
911 pTab
= pNewItem
->pTab
= pOldItem
->pTab
;
915 pNewItem
->pSelect
= sqlite3SelectDup(db
, pOldItem
->pSelect
, flags
);
916 pNewItem
->pOn
= sqlite3ExprDup(db
, pOldItem
->pOn
, flags
);
917 pNewItem
->pUsing
= sqlite3IdListDup(db
, pOldItem
->pUsing
);
918 pNewItem
->colUsed
= pOldItem
->colUsed
;
922 IdList
*sqlite3IdListDup(sqlite3
*db
, IdList
*p
){
926 pNew
= sqlite3DbMallocRaw(db
, sizeof(*pNew
) );
927 if( pNew
==0 ) return 0;
928 pNew
->nId
= pNew
->nAlloc
= p
->nId
;
929 pNew
->a
= sqlite3DbMallocRaw(db
, p
->nId
*sizeof(p
->a
[0]) );
931 sqlite3DbFree(db
, pNew
);
934 for(i
=0; i
<p
->nId
; i
++){
935 struct IdList_item
*pNewItem
= &pNew
->a
[i
];
936 struct IdList_item
*pOldItem
= &p
->a
[i
];
937 pNewItem
->zName
= sqlite3DbStrDup(db
, pOldItem
->zName
);
938 pNewItem
->idx
= pOldItem
->idx
;
942 Select
*sqlite3SelectDup(sqlite3
*db
, Select
*p
, int flags
){
943 Select
*pNew
, *pPrior
;
945 pNew
= sqlite3DbMallocRaw(db
, sizeof(*p
) );
946 if( pNew
==0 ) return 0;
947 pNew
->pEList
= sqlite3ExprListDup(db
, p
->pEList
, flags
);
948 pNew
->pSrc
= sqlite3SrcListDup(db
, p
->pSrc
, flags
);
949 pNew
->pWhere
= sqlite3ExprDup(db
, p
->pWhere
, flags
);
950 pNew
->pGroupBy
= sqlite3ExprListDup(db
, p
->pGroupBy
, flags
);
951 pNew
->pHaving
= sqlite3ExprDup(db
, p
->pHaving
, flags
);
952 pNew
->pOrderBy
= sqlite3ExprListDup(db
, p
->pOrderBy
, flags
);
954 pNew
->pPrior
= pPrior
= sqlite3SelectDup(db
, p
->pPrior
, flags
);
955 if( pPrior
) pPrior
->pNext
= pNew
;
957 pNew
->pLimit
= sqlite3ExprDup(db
, p
->pLimit
, flags
);
958 pNew
->pOffset
= sqlite3ExprDup(db
, p
->pOffset
, flags
);
961 pNew
->selFlags
= p
->selFlags
& ~SF_UsesEphemeral
;
962 pNew
->pRightmost
= 0;
963 pNew
->addrOpenEphm
[0] = -1;
964 pNew
->addrOpenEphm
[1] = -1;
965 pNew
->addrOpenEphm
[2] = -1;
969 Select
*sqlite3SelectDup(sqlite3
*db
, Select
*p
, int flags
){
977 ** Add a new element to the end of an expression list. If pList is
978 ** initially NULL, then create a new expression list.
980 ** If a memory allocation error occurs, the entire list is freed and
981 ** NULL is returned. If non-NULL is returned, then it is guaranteed
982 ** that the new entry was successfully appended.
984 ExprList
*sqlite3ExprListAppend(
985 Parse
*pParse
, /* Parsing context */
986 ExprList
*pList
, /* List to which to append. Might be NULL */
987 Expr
*pExpr
/* Expression to be appended. Might be NULL */
989 sqlite3
*db
= pParse
->db
;
991 pList
= sqlite3DbMallocZero(db
, sizeof(ExprList
) );
995 assert( pList
->nAlloc
==0 );
997 if( pList
->nAlloc
<=pList
->nExpr
){
998 struct ExprList_item
*a
;
999 int n
= pList
->nAlloc
*2 + 4;
1000 a
= sqlite3DbRealloc(db
, pList
->a
, n
*sizeof(pList
->a
[0]));
1005 pList
->nAlloc
= sqlite3DbMallocSize(db
, a
)/sizeof(a
[0]);
1007 assert( pList
->a
!=0 );
1009 struct ExprList_item
*pItem
= &pList
->a
[pList
->nExpr
++];
1010 memset(pItem
, 0, sizeof(*pItem
));
1011 pItem
->pExpr
= pExpr
;
1016 /* Avoid leaking memory if malloc has failed. */
1017 sqlite3ExprDelete(db
, pExpr
);
1018 sqlite3ExprListDelete(db
, pList
);
1023 ** Set the ExprList.a[].zName element of the most recently added item
1024 ** on the expression list.
1026 ** pList might be NULL following an OOM error. But pName should never be
1027 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
1030 void sqlite3ExprListSetName(
1031 Parse
*pParse
, /* Parsing context */
1032 ExprList
*pList
, /* List to which to add the span. */
1033 Token
*pName
, /* Name to be added */
1034 int dequote
/* True to cause the name to be dequoted */
1036 assert( pList
!=0 || pParse
->db
->mallocFailed
!=0 );
1038 struct ExprList_item
*pItem
;
1039 assert( pList
->nExpr
>0 );
1040 pItem
= &pList
->a
[pList
->nExpr
-1];
1041 assert( pItem
->zName
==0 );
1042 pItem
->zName
= sqlite3DbStrNDup(pParse
->db
, pName
->z
, pName
->n
);
1043 if( dequote
&& pItem
->zName
) sqlite3Dequote(pItem
->zName
);
1048 ** Set the ExprList.a[].zSpan element of the most recently added item
1049 ** on the expression list.
1051 ** pList might be NULL following an OOM error. But pSpan should never be
1052 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
1055 void sqlite3ExprListSetSpan(
1056 Parse
*pParse
, /* Parsing context */
1057 ExprList
*pList
, /* List to which to add the span. */
1058 ExprSpan
*pSpan
/* The span to be added */
1060 sqlite3
*db
= pParse
->db
;
1061 assert( pList
!=0 || db
->mallocFailed
!=0 );
1063 struct ExprList_item
*pItem
= &pList
->a
[pList
->nExpr
-1];
1064 assert( pList
->nExpr
>0 );
1065 assert( db
->mallocFailed
|| pItem
->pExpr
==pSpan
->pExpr
);
1066 sqlite3DbFree(db
, pItem
->zSpan
);
1067 pItem
->zSpan
= sqlite3DbStrNDup(db
, (char*)pSpan
->zStart
,
1068 (int)(pSpan
->zEnd
- pSpan
->zStart
));
1073 ** If the expression list pEList contains more than iLimit elements,
1074 ** leave an error message in pParse.
1076 void sqlite3ExprListCheckLength(
1081 int mx
= pParse
->db
->aLimit
[SQLITE_LIMIT_COLUMN
];
1082 testcase( pEList
&& pEList
->nExpr
==mx
);
1083 testcase( pEList
&& pEList
->nExpr
==mx
+1 );
1084 if( pEList
&& pEList
->nExpr
>mx
){
1085 sqlite3ErrorMsg(pParse
, "too many columns in %s", zObject
);
1090 ** Delete an entire expression list.
1092 void sqlite3ExprListDelete(sqlite3
*db
, ExprList
*pList
){
1094 struct ExprList_item
*pItem
;
1095 if( pList
==0 ) return;
1096 assert( pList
->a
!=0 || (pList
->nExpr
==0 && pList
->nAlloc
==0) );
1097 assert( pList
->nExpr
<=pList
->nAlloc
);
1098 for(pItem
=pList
->a
, i
=0; i
<pList
->nExpr
; i
++, pItem
++){
1099 sqlite3ExprDelete(db
, pItem
->pExpr
);
1100 sqlite3DbFree(db
, pItem
->zName
);
1101 sqlite3DbFree(db
, pItem
->zSpan
);
1103 sqlite3DbFree(db
, pList
->a
);
1104 sqlite3DbFree(db
, pList
);
1108 ** These routines are Walker callbacks. Walker.u.pi is a pointer
1109 ** to an integer. These routines are checking an expression to see
1110 ** if it is a constant. Set *Walker.u.pi to 0 if the expression is
1113 ** These callback routines are used to implement the following:
1115 ** sqlite3ExprIsConstant()
1116 ** sqlite3ExprIsConstantNotJoin()
1117 ** sqlite3ExprIsConstantOrFunction()
1120 static int exprNodeIsConstant(Walker
*pWalker
, Expr
*pExpr
){
1122 /* If pWalker->u.i is 3 then any term of the expression that comes from
1123 ** the ON or USING clauses of a join disqualifies the expression
1124 ** from being considered constant. */
1125 if( pWalker
->u
.i
==3 && ExprHasAnyProperty(pExpr
, EP_FromJoin
) ){
1130 switch( pExpr
->op
){
1131 /* Consider functions to be constant if all their arguments are constant
1132 ** and pWalker->u.i==2 */
1134 if( pWalker
->u
.i
==2 ) return 0;
1138 case TK_AGG_FUNCTION
:
1140 testcase( pExpr
->op
==TK_ID
);
1141 testcase( pExpr
->op
==TK_COLUMN
);
1142 testcase( pExpr
->op
==TK_AGG_FUNCTION
);
1143 testcase( pExpr
->op
==TK_AGG_COLUMN
);
1147 testcase( pExpr
->op
==TK_SELECT
); /* selectNodeIsConstant will disallow */
1148 testcase( pExpr
->op
==TK_EXISTS
); /* selectNodeIsConstant will disallow */
1149 return WRC_Continue
;
1152 static int selectNodeIsConstant(Walker
*pWalker
, Select
*NotUsed
){
1153 UNUSED_PARAMETER(NotUsed
);
1157 static int exprIsConst(Expr
*p
, int initFlag
){
1160 w
.xExprCallback
= exprNodeIsConstant
;
1161 w
.xSelectCallback
= selectNodeIsConstant
;
1162 sqlite3WalkExpr(&w
, p
);
1167 ** Walk an expression tree. Return 1 if the expression is constant
1168 ** and 0 if it involves variables or function calls.
1170 ** For the purposes of this function, a double-quoted string (ex: "abc")
1171 ** is considered a variable but a single-quoted string (ex: 'abc') is
1174 int sqlite3ExprIsConstant(Expr
*p
){
1175 return exprIsConst(p
, 1);
1179 ** Walk an expression tree. Return 1 if the expression is constant
1180 ** that does no originate from the ON or USING clauses of a join.
1181 ** Return 0 if it involves variables or function calls or terms from
1182 ** an ON or USING clause.
1184 int sqlite3ExprIsConstantNotJoin(Expr
*p
){
1185 return exprIsConst(p
, 3);
1189 ** Walk an expression tree. Return 1 if the expression is constant
1190 ** or a function call with constant arguments. Return and 0 if there
1191 ** are any variables.
1193 ** For the purposes of this function, a double-quoted string (ex: "abc")
1194 ** is considered a variable but a single-quoted string (ex: 'abc') is
1197 int sqlite3ExprIsConstantOrFunction(Expr
*p
){
1198 return exprIsConst(p
, 2);
1202 ** If the expression p codes a constant integer that is small enough
1203 ** to fit in a 32-bit integer, return 1 and put the value of the integer
1204 ** in *pValue. If the expression is not an integer or if it is too big
1205 ** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
1207 int sqlite3ExprIsInteger(Expr
*p
, int *pValue
){
1210 /* If an expression is an integer literal that fits in a signed 32-bit
1211 ** integer, then the EP_IntValue flag will have already been set */
1212 assert( p
->op
!=TK_INTEGER
|| (p
->flags
& EP_IntValue
)!=0
1213 || sqlite3GetInt32(p
->u
.zToken
, &rc
)==0 );
1215 if( p
->flags
& EP_IntValue
){
1216 *pValue
= p
->u
.iValue
;
1221 rc
= sqlite3ExprIsInteger(p
->pLeft
, pValue
);
1226 if( sqlite3ExprIsInteger(p
->pLeft
, &v
) ){
1238 ** Return FALSE if there is no chance that the expression can be NULL.
1240 ** If the expression might be NULL or if the expression is too complex
1241 ** to tell return TRUE.
1243 ** This routine is used as an optimization, to skip OP_IsNull opcodes
1244 ** when we know that a value cannot be NULL. Hence, a false positive
1245 ** (returning TRUE when in fact the expression can never be NULL) might
1246 ** be a small performance hit but is otherwise harmless. On the other
1247 ** hand, a false negative (returning FALSE when the result could be NULL)
1248 ** will likely result in an incorrect answer. So when in doubt, return
1251 int sqlite3ExprCanBeNull(const Expr
*p
){
1253 while( p
->op
==TK_UPLUS
|| p
->op
==TK_UMINUS
){ p
= p
->pLeft
; }
1255 if( op
==TK_REGISTER
) op
= p
->op2
;
1268 ** Generate an OP_IsNull instruction that tests register iReg and jumps
1269 ** to location iDest if the value in iReg is NULL. The value in iReg
1270 ** was computed by pExpr. If we can look at pExpr at compile-time and
1271 ** determine that it can never generate a NULL, then the OP_IsNull operation
1274 void sqlite3ExprCodeIsNullJump(
1275 Vdbe
*v
, /* The VDBE under construction */
1276 const Expr
*pExpr
, /* Only generate OP_IsNull if this expr can be NULL */
1277 int iReg
, /* Test the value in this register for NULL */
1278 int iDest
/* Jump here if the value is null */
1280 if( sqlite3ExprCanBeNull(pExpr
) ){
1281 sqlite3VdbeAddOp2(v
, OP_IsNull
, iReg
, iDest
);
1286 ** Return TRUE if the given expression is a constant which would be
1287 ** unchanged by OP_Affinity with the affinity given in the second
1290 ** This routine is used to determine if the OP_Affinity operation
1291 ** can be omitted. When in doubt return FALSE. A false negative
1292 ** is harmless. A false positive, however, can result in the wrong
1295 int sqlite3ExprNeedsNoAffinityChange(const Expr
*p
, char aff
){
1297 if( aff
==SQLITE_AFF_NONE
) return 1;
1298 while( p
->op
==TK_UPLUS
|| p
->op
==TK_UMINUS
){ p
= p
->pLeft
; }
1300 if( op
==TK_REGISTER
) op
= p
->op2
;
1303 return aff
==SQLITE_AFF_INTEGER
|| aff
==SQLITE_AFF_NUMERIC
;
1306 return aff
==SQLITE_AFF_REAL
|| aff
==SQLITE_AFF_NUMERIC
;
1309 return aff
==SQLITE_AFF_TEXT
;
1315 assert( p
->iTable
>=0 ); /* p cannot be part of a CHECK constraint */
1317 && (aff
==SQLITE_AFF_INTEGER
|| aff
==SQLITE_AFF_NUMERIC
);
1326 ** Return TRUE if the given string is a row-id column name.
1328 int sqlite3IsRowid(const char *z
){
1329 if( sqlite3StrICmp(z
, "_ROWID_")==0 ) return 1;
1330 if( sqlite3StrICmp(z
, "ROWID")==0 ) return 1;
1331 if( sqlite3StrICmp(z
, "OID")==0 ) return 1;
1336 ** Return true if we are able to the IN operator optimization on a
1337 ** query of the form
1339 ** x IN (SELECT ...)
1341 ** Where the SELECT... clause is as specified by the parameter to this
1344 ** The Select object passed in has already been preprocessed and no
1345 ** errors have been found.
1347 #ifndef SQLITE_OMIT_SUBQUERY
1348 static int isCandidateForInOpt(Select
*p
){
1352 if( p
==0 ) return 0; /* right-hand side of IN is SELECT */
1353 if( p
->pPrior
) return 0; /* Not a compound SELECT */
1354 if( p
->selFlags
& (SF_Distinct
|SF_Aggregate
) ){
1355 testcase( (p
->selFlags
& (SF_Distinct
|SF_Aggregate
))==SF_Distinct
);
1356 testcase( (p
->selFlags
& (SF_Distinct
|SF_Aggregate
))==SF_Aggregate
);
1357 return 0; /* No DISTINCT keyword and no aggregate functions */
1359 assert( p
->pGroupBy
==0 ); /* Has no GROUP BY clause */
1360 if( p
->pLimit
) return 0; /* Has no LIMIT clause */
1361 assert( p
->pOffset
==0 ); /* No LIMIT means no OFFSET */
1362 if( p
->pWhere
) return 0; /* Has no WHERE clause */
1365 if( pSrc
->nSrc
!=1 ) return 0; /* Single term in FROM clause */
1366 if( pSrc
->a
[0].pSelect
) return 0; /* FROM is not a subquery or view */
1367 pTab
= pSrc
->a
[0].pTab
;
1368 if( NEVER(pTab
==0) ) return 0;
1369 assert( pTab
->pSelect
==0 ); /* FROM clause is not a view */
1370 if( IsVirtual(pTab
) ) return 0; /* FROM clause not a virtual table */
1372 if( pEList
->nExpr
!=1 ) return 0; /* One column in the result set */
1373 if( pEList
->a
[0].pExpr
->op
!=TK_COLUMN
) return 0; /* Result is a column */
1376 #endif /* SQLITE_OMIT_SUBQUERY */
1379 ** Code an OP_Once instruction and allocate space for its flag. Return the
1380 ** address of the new instruction.
1382 int sqlite3CodeOnce(Parse
*pParse
){
1383 Vdbe
*v
= sqlite3GetVdbe(pParse
); /* Virtual machine being coded */
1384 return sqlite3VdbeAddOp1(v
, OP_Once
, pParse
->nOnce
++);
1388 ** This function is used by the implementation of the IN (...) operator.
1389 ** It's job is to find or create a b-tree structure that may be used
1390 ** either to test for membership of the (...) set or to iterate through
1391 ** its members, skipping duplicates.
1393 ** The index of the cursor opened on the b-tree (database table, database index
1394 ** or ephermal table) is stored in pX->iTable before this function returns.
1395 ** The returned value of this function indicates the b-tree type, as follows:
1397 ** IN_INDEX_ROWID - The cursor was opened on a database table.
1398 ** IN_INDEX_INDEX - The cursor was opened on a database index.
1399 ** IN_INDEX_EPH - The cursor was opened on a specially created and
1400 ** populated epheremal table.
1402 ** An existing b-tree may only be used if the SELECT is of the simple
1405 ** SELECT <column> FROM <table>
1407 ** If the prNotFound parameter is 0, then the b-tree will be used to iterate
1408 ** through the set members, skipping any duplicates. In this case an
1409 ** epheremal table must be used unless the selected <column> is guaranteed
1410 ** to be unique - either because it is an INTEGER PRIMARY KEY or it
1411 ** has a UNIQUE constraint or UNIQUE index.
1413 ** If the prNotFound parameter is not 0, then the b-tree will be used
1414 ** for fast set membership tests. In this case an epheremal table must
1415 ** be used unless <column> is an INTEGER PRIMARY KEY or an index can
1416 ** be found with <column> as its left-most column.
1418 ** When the b-tree is being used for membership tests, the calling function
1419 ** needs to know whether or not the structure contains an SQL NULL
1420 ** value in order to correctly evaluate expressions like "X IN (Y, Z)".
1421 ** If there is any chance that the (...) might contain a NULL value at
1422 ** runtime, then a register is allocated and the register number written
1423 ** to *prNotFound. If there is no chance that the (...) contains a
1424 ** NULL value, then *prNotFound is left unchanged.
1426 ** If a register is allocated and its location stored in *prNotFound, then
1427 ** its initial value is NULL. If the (...) does not remain constant
1428 ** for the duration of the query (i.e. the SELECT within the (...)
1429 ** is a correlated subquery) then the value of the allocated register is
1430 ** reset to NULL each time the subquery is rerun. This allows the
1431 ** caller to use vdbe code equivalent to the following:
1433 ** if( register==NULL ){
1434 ** has_null = <test if data structure contains null>
1438 ** in order to avoid running the <test if data structure contains null>
1439 ** test more often than is necessary.
1441 #ifndef SQLITE_OMIT_SUBQUERY
1442 int sqlite3FindInIndex(Parse
*pParse
, Expr
*pX
, int *prNotFound
){
1443 Select
*p
; /* SELECT to the right of IN operator */
1444 int eType
= 0; /* Type of RHS table. IN_INDEX_* */
1445 int iTab
= pParse
->nTab
++; /* Cursor of the RHS table */
1446 int mustBeUnique
= (prNotFound
==0); /* True if RHS must be unique */
1447 Vdbe
*v
= sqlite3GetVdbe(pParse
); /* Virtual machine being coded */
1449 assert( pX
->op
==TK_IN
);
1451 /* Check to see if an existing table or index can be used to
1452 ** satisfy the query. This is preferable to generating a new
1455 p
= (ExprHasProperty(pX
, EP_xIsSelect
) ? pX
->x
.pSelect
: 0);
1456 if( ALWAYS(pParse
->nErr
==0) && isCandidateForInOpt(p
) ){
1457 sqlite3
*db
= pParse
->db
; /* Database connection */
1458 Table
*pTab
; /* Table <table>. */
1459 Expr
*pExpr
; /* Expression <column> */
1460 int iCol
; /* Index of column <column> */
1461 int iDb
; /* Database idx for pTab */
1463 assert( p
); /* Because of isCandidateForInOpt(p) */
1464 assert( p
->pEList
!=0 ); /* Because of isCandidateForInOpt(p) */
1465 assert( p
->pEList
->a
[0].pExpr
!=0 ); /* Because of isCandidateForInOpt(p) */
1466 assert( p
->pSrc
!=0 ); /* Because of isCandidateForInOpt(p) */
1467 pTab
= p
->pSrc
->a
[0].pTab
;
1468 pExpr
= p
->pEList
->a
[0].pExpr
;
1469 iCol
= pExpr
->iColumn
;
1471 /* Code an OP_VerifyCookie and OP_TableLock for <table>. */
1472 iDb
= sqlite3SchemaToIndex(db
, pTab
->pSchema
);
1473 sqlite3CodeVerifySchema(pParse
, iDb
);
1474 sqlite3TableLock(pParse
, iDb
, pTab
->tnum
, 0, pTab
->zName
);
1476 /* This function is only called from two places. In both cases the vdbe
1477 ** has already been allocated. So assume sqlite3GetVdbe() is always
1484 iAddr
= sqlite3CodeOnce(pParse
);
1486 sqlite3OpenTable(pParse
, iTab
, iDb
, pTab
, OP_OpenRead
);
1487 eType
= IN_INDEX_ROWID
;
1489 sqlite3VdbeJumpHere(v
, iAddr
);
1491 Index
*pIdx
; /* Iterator variable */
1493 /* The collation sequence used by the comparison. If an index is to
1494 ** be used in place of a temp-table, it must be ordered according
1495 ** to this collation sequence. */
1496 CollSeq
*pReq
= sqlite3BinaryCompareCollSeq(pParse
, pX
->pLeft
, pExpr
);
1498 /* Check that the affinity that will be used to perform the
1499 ** comparison is the same as the affinity of the column. If
1500 ** it is not, it is not possible to use any index.
1502 char aff
= comparisonAffinity(pX
);
1503 int affinity_ok
= (pTab
->aCol
[iCol
].affinity
==aff
||aff
==SQLITE_AFF_NONE
);
1505 for(pIdx
=pTab
->pIndex
; pIdx
&& eType
==0 && affinity_ok
; pIdx
=pIdx
->pNext
){
1506 if( (pIdx
->aiColumn
[0]==iCol
)
1507 && sqlite3FindCollSeq(db
, ENC(db
), pIdx
->azColl
[0], 0)==pReq
1508 && (!mustBeUnique
|| (pIdx
->nColumn
==1 && pIdx
->onError
!=OE_None
))
1513 pKey
= (char *)sqlite3IndexKeyinfo(pParse
, pIdx
);
1514 iAddr
= sqlite3CodeOnce(pParse
);
1516 sqlite3VdbeAddOp4(v
, OP_OpenRead
, iTab
, pIdx
->tnum
, iDb
,
1517 pKey
,P4_KEYINFO_HANDOFF
);
1518 VdbeComment((v
, "%s", pIdx
->zName
));
1519 eType
= IN_INDEX_INDEX
;
1521 sqlite3VdbeJumpHere(v
, iAddr
);
1522 if( prNotFound
&& !pTab
->aCol
[iCol
].notNull
){
1523 *prNotFound
= ++pParse
->nMem
;
1524 sqlite3VdbeAddOp2(v
, OP_Null
, 0, *prNotFound
);
1532 /* Could not found an existing table or index to use as the RHS b-tree.
1533 ** We will have to generate an ephemeral table to do the job.
1535 double savedNQueryLoop
= pParse
->nQueryLoop
;
1536 int rMayHaveNull
= 0;
1537 eType
= IN_INDEX_EPH
;
1539 *prNotFound
= rMayHaveNull
= ++pParse
->nMem
;
1540 sqlite3VdbeAddOp2(v
, OP_Null
, 0, *prNotFound
);
1542 testcase( pParse
->nQueryLoop
>(double)1 );
1543 pParse
->nQueryLoop
= (double)1;
1544 if( pX
->pLeft
->iColumn
<0 && !ExprHasAnyProperty(pX
, EP_xIsSelect
) ){
1545 eType
= IN_INDEX_ROWID
;
1548 sqlite3CodeSubselect(pParse
, pX
, rMayHaveNull
, eType
==IN_INDEX_ROWID
);
1549 pParse
->nQueryLoop
= savedNQueryLoop
;
1558 ** Generate code for scalar subqueries used as a subquery expression, EXISTS,
1559 ** or IN operators. Examples:
1561 ** (SELECT a FROM b) -- subquery
1562 ** EXISTS (SELECT a FROM b) -- EXISTS subquery
1563 ** x IN (4,5,11) -- IN operator with list on right-hand side
1564 ** x IN (SELECT a FROM b) -- IN operator with subquery on the right
1566 ** The pExpr parameter describes the expression that contains the IN
1567 ** operator or subquery.
1569 ** If parameter isRowid is non-zero, then expression pExpr is guaranteed
1570 ** to be of the form "<rowid> IN (?, ?, ?)", where <rowid> is a reference
1571 ** to some integer key column of a table B-Tree. In this case, use an
1572 ** intkey B-Tree to store the set of IN(...) values instead of the usual
1573 ** (slower) variable length keys B-Tree.
1575 ** If rMayHaveNull is non-zero, that means that the operation is an IN
1576 ** (not a SELECT or EXISTS) and that the RHS might contains NULLs.
1577 ** Furthermore, the IN is in a WHERE clause and that we really want
1578 ** to iterate over the RHS of the IN operator in order to quickly locate
1579 ** all corresponding LHS elements. All this routine does is initialize
1580 ** the register given by rMayHaveNull to NULL. Calling routines will take
1581 ** care of changing this register value to non-NULL if the RHS is NULL-free.
1583 ** If rMayHaveNull is zero, that means that the subquery is being used
1584 ** for membership testing only. There is no need to initialize any
1585 ** registers to indicate the presense or absence of NULLs on the RHS.
1587 ** For a SELECT or EXISTS operator, return the register that holds the
1588 ** result. For IN operators or if an error occurs, the return value is 0.
1590 #ifndef SQLITE_OMIT_SUBQUERY
1591 int sqlite3CodeSubselect(
1592 Parse
*pParse
, /* Parsing context */
1593 Expr
*pExpr
, /* The IN, SELECT, or EXISTS operator */
1594 int rMayHaveNull
, /* Register that records whether NULLs exist in RHS */
1595 int isRowid
/* If true, LHS of IN operator is a rowid */
1597 int testAddr
= -1; /* One-time test address */
1598 int rReg
= 0; /* Register storing resulting */
1599 Vdbe
*v
= sqlite3GetVdbe(pParse
);
1600 if( NEVER(v
==0) ) return 0;
1601 sqlite3ExprCachePush(pParse
);
1603 /* This code must be run in its entirety every time it is encountered
1604 ** if any of the following is true:
1606 ** * The right-hand side is a correlated subquery
1607 ** * The right-hand side is an expression list containing variables
1608 ** * We are inside a trigger
1610 ** If all of the above are false, then we can run this code just once
1611 ** save the results, and reuse the same result on subsequent invocations.
1613 if( !ExprHasAnyProperty(pExpr
, EP_VarSelect
) ){
1614 testAddr
= sqlite3CodeOnce(pParse
);
1617 #ifndef SQLITE_OMIT_EXPLAIN
1618 if( pParse
->explain
==2 ){
1619 char *zMsg
= sqlite3MPrintf(
1620 pParse
->db
, "EXECUTE %s%s SUBQUERY %d", testAddr
>=0?"":"CORRELATED ",
1621 pExpr
->op
==TK_IN
?"LIST":"SCALAR", pParse
->iNextSelectId
1623 sqlite3VdbeAddOp4(v
, OP_Explain
, pParse
->iSelectId
, 0, 0, zMsg
, P4_DYNAMIC
);
1627 switch( pExpr
->op
){
1629 char affinity
; /* Affinity of the LHS of the IN */
1630 KeyInfo keyInfo
; /* Keyinfo for the generated table */
1631 int addr
; /* Address of OP_OpenEphemeral instruction */
1632 Expr
*pLeft
= pExpr
->pLeft
; /* the LHS of the IN operator */
1635 sqlite3VdbeAddOp2(v
, OP_Null
, 0, rMayHaveNull
);
1638 affinity
= sqlite3ExprAffinity(pLeft
);
1640 /* Whether this is an 'x IN(SELECT...)' or an 'x IN(<exprlist>)'
1641 ** expression it is handled the same way. An ephemeral table is
1642 ** filled with single-field index keys representing the results
1643 ** from the SELECT or the <exprlist>.
1645 ** If the 'x' expression is a column value, or the SELECT...
1646 ** statement returns a column value, then the affinity of that
1647 ** column is used to build the index keys. If both 'x' and the
1648 ** SELECT... statement are columns, then numeric affinity is used
1649 ** if either column has NUMERIC or INTEGER affinity. If neither
1650 ** 'x' nor the SELECT... statement are columns, then numeric affinity
1653 pExpr
->iTable
= pParse
->nTab
++;
1654 addr
= sqlite3VdbeAddOp2(v
, OP_OpenEphemeral
, pExpr
->iTable
, !isRowid
);
1655 if( rMayHaveNull
==0 ) sqlite3VdbeChangeP5(v
, BTREE_UNORDERED
);
1656 memset(&keyInfo
, 0, sizeof(keyInfo
));
1659 if( ExprHasProperty(pExpr
, EP_xIsSelect
) ){
1660 /* Case 1: expr IN (SELECT ...)
1662 ** Generate code to write the results of the select into the temporary
1663 ** table allocated and opened above.
1669 sqlite3SelectDestInit(&dest
, SRT_Set
, pExpr
->iTable
);
1670 dest
.affinity
= (u8
)affinity
;
1671 assert( (pExpr
->iTable
&0x0000FFFF)==pExpr
->iTable
);
1672 pExpr
->x
.pSelect
->iLimit
= 0;
1673 if( sqlite3Select(pParse
, pExpr
->x
.pSelect
, &dest
) ){
1676 pEList
= pExpr
->x
.pSelect
->pEList
;
1677 if( ALWAYS(pEList
!=0 && pEList
->nExpr
>0) ){
1678 keyInfo
.aColl
[0] = sqlite3BinaryCompareCollSeq(pParse
, pExpr
->pLeft
,
1679 pEList
->a
[0].pExpr
);
1681 }else if( ALWAYS(pExpr
->x
.pList
!=0) ){
1682 /* Case 2: expr IN (exprlist)
1684 ** For each expression, build an index key from the evaluation and
1685 ** store it in the temporary table. If <expr> is a column, then use
1686 ** that columns affinity when building index keys. If <expr> is not
1687 ** a column, use numeric affinity.
1690 ExprList
*pList
= pExpr
->x
.pList
;
1691 struct ExprList_item
*pItem
;
1695 affinity
= SQLITE_AFF_NONE
;
1697 keyInfo
.aColl
[0] = sqlite3ExprCollSeq(pParse
, pExpr
->pLeft
);
1699 /* Loop through each expression in <exprlist>. */
1700 r1
= sqlite3GetTempReg(pParse
);
1701 r2
= sqlite3GetTempReg(pParse
);
1702 sqlite3VdbeAddOp2(v
, OP_Null
, 0, r2
);
1703 for(i
=pList
->nExpr
, pItem
=pList
->a
; i
>0; i
--, pItem
++){
1704 Expr
*pE2
= pItem
->pExpr
;
1707 /* If the expression is not constant then we will need to
1708 ** disable the test that was generated above that makes sure
1709 ** this code only executes once. Because for a non-constant
1710 ** expression we need to rerun this code each time.
1712 if( testAddr
>=0 && !sqlite3ExprIsConstant(pE2
) ){
1713 sqlite3VdbeChangeToNoop(v
, testAddr
);
1717 /* Evaluate the expression and insert it into the temp table */
1718 if( isRowid
&& sqlite3ExprIsInteger(pE2
, &iValToIns
) ){
1719 sqlite3VdbeAddOp3(v
, OP_InsertInt
, pExpr
->iTable
, r2
, iValToIns
);
1721 r3
= sqlite3ExprCodeTarget(pParse
, pE2
, r1
);
1723 sqlite3VdbeAddOp2(v
, OP_MustBeInt
, r3
,
1724 sqlite3VdbeCurrentAddr(v
)+2);
1725 sqlite3VdbeAddOp3(v
, OP_Insert
, pExpr
->iTable
, r2
, r3
);
1727 sqlite3VdbeAddOp4(v
, OP_MakeRecord
, r3
, 1, r2
, &affinity
, 1);
1728 sqlite3ExprCacheAffinityChange(pParse
, r3
, 1);
1729 sqlite3VdbeAddOp2(v
, OP_IdxInsert
, pExpr
->iTable
, r2
);
1733 sqlite3ReleaseTempReg(pParse
, r1
);
1734 sqlite3ReleaseTempReg(pParse
, r2
);
1737 sqlite3VdbeChangeP4(v
, addr
, (void *)&keyInfo
, P4_KEYINFO
);
1745 /* If this has to be a scalar SELECT. Generate code to put the
1746 ** value of this select in a memory cell and record the number
1747 ** of the memory cell in iColumn. If this is an EXISTS, write
1748 ** an integer 0 (not exists) or 1 (exists) into a memory cell
1749 ** and record that memory cell in iColumn.
1751 Select
*pSel
; /* SELECT statement to encode */
1752 SelectDest dest
; /* How to deal with SELECt result */
1754 testcase( pExpr
->op
==TK_EXISTS
);
1755 testcase( pExpr
->op
==TK_SELECT
);
1756 assert( pExpr
->op
==TK_EXISTS
|| pExpr
->op
==TK_SELECT
);
1758 assert( ExprHasProperty(pExpr
, EP_xIsSelect
) );
1759 pSel
= pExpr
->x
.pSelect
;
1760 sqlite3SelectDestInit(&dest
, 0, ++pParse
->nMem
);
1761 if( pExpr
->op
==TK_SELECT
){
1762 dest
.eDest
= SRT_Mem
;
1763 sqlite3VdbeAddOp2(v
, OP_Null
, 0, dest
.iParm
);
1764 VdbeComment((v
, "Init subquery result"));
1766 dest
.eDest
= SRT_Exists
;
1767 sqlite3VdbeAddOp2(v
, OP_Integer
, 0, dest
.iParm
);
1768 VdbeComment((v
, "Init EXISTS result"));
1770 sqlite3ExprDelete(pParse
->db
, pSel
->pLimit
);
1771 pSel
->pLimit
= sqlite3PExpr(pParse
, TK_INTEGER
, 0, 0,
1772 &sqlite3IntTokens
[1]);
1774 if( sqlite3Select(pParse
, pSel
, &dest
) ){
1778 ExprSetIrreducible(pExpr
);
1784 sqlite3VdbeJumpHere(v
, testAddr
);
1786 sqlite3ExprCachePop(pParse
, 1);
1790 #endif /* SQLITE_OMIT_SUBQUERY */
1792 #ifndef SQLITE_OMIT_SUBQUERY
1794 ** Generate code for an IN expression.
1796 ** x IN (SELECT ...)
1797 ** x IN (value, value, ...)
1799 ** The left-hand side (LHS) is a scalar expression. The right-hand side (RHS)
1800 ** is an array of zero or more values. The expression is true if the LHS is
1801 ** contained within the RHS. The value of the expression is unknown (NULL)
1802 ** if the LHS is NULL or if the LHS is not contained within the RHS and the
1803 ** RHS contains one or more NULL values.
1805 ** This routine generates code will jump to destIfFalse if the LHS is not
1806 ** contained within the RHS. If due to NULLs we cannot determine if the LHS
1807 ** is contained in the RHS then jump to destIfNull. If the LHS is contained
1808 ** within the RHS then fall through.
1810 static void sqlite3ExprCodeIN(
1811 Parse
*pParse
, /* Parsing and code generating context */
1812 Expr
*pExpr
, /* The IN expression */
1813 int destIfFalse
, /* Jump here if LHS is not contained in the RHS */
1814 int destIfNull
/* Jump here if the results are unknown due to NULLs */
1816 int rRhsHasNull
= 0; /* Register that is true if RHS contains NULL values */
1817 char affinity
; /* Comparison affinity to use */
1818 int eType
; /* Type of the RHS */
1819 int r1
; /* Temporary use register */
1820 Vdbe
*v
; /* Statement under construction */
1822 /* Compute the RHS. After this step, the table with cursor
1823 ** pExpr->iTable will contains the values that make up the RHS.
1826 assert( v
!=0 ); /* OOM detected prior to this routine */
1827 VdbeNoopComment((v
, "begin IN expr"));
1828 eType
= sqlite3FindInIndex(pParse
, pExpr
, &rRhsHasNull
);
1830 /* Figure out the affinity to use to create a key from the results
1831 ** of the expression. affinityStr stores a static string suitable for
1832 ** P4 of OP_MakeRecord.
1834 affinity
= comparisonAffinity(pExpr
);
1836 /* Code the LHS, the <expr> from "<expr> IN (...)".
1838 sqlite3ExprCachePush(pParse
);
1839 r1
= sqlite3GetTempReg(pParse
);
1840 sqlite3ExprCode(pParse
, pExpr
->pLeft
, r1
);
1842 /* If the LHS is NULL, then the result is either false or NULL depending
1843 ** on whether the RHS is empty or not, respectively.
1845 if( destIfNull
==destIfFalse
){
1846 /* Shortcut for the common case where the false and NULL outcomes are
1848 sqlite3VdbeAddOp2(v
, OP_IsNull
, r1
, destIfNull
);
1850 int addr1
= sqlite3VdbeAddOp1(v
, OP_NotNull
, r1
);
1851 sqlite3VdbeAddOp2(v
, OP_Rewind
, pExpr
->iTable
, destIfFalse
);
1852 sqlite3VdbeAddOp2(v
, OP_Goto
, 0, destIfNull
);
1853 sqlite3VdbeJumpHere(v
, addr1
);
1856 if( eType
==IN_INDEX_ROWID
){
1857 /* In this case, the RHS is the ROWID of table b-tree
1859 sqlite3VdbeAddOp2(v
, OP_MustBeInt
, r1
, destIfFalse
);
1860 sqlite3VdbeAddOp3(v
, OP_NotExists
, pExpr
->iTable
, destIfFalse
, r1
);
1862 /* In this case, the RHS is an index b-tree.
1864 sqlite3VdbeAddOp4(v
, OP_Affinity
, r1
, 1, 0, &affinity
, 1);
1866 /* If the set membership test fails, then the result of the
1867 ** "x IN (...)" expression must be either 0 or NULL. If the set
1868 ** contains no NULL values, then the result is 0. If the set
1869 ** contains one or more NULL values, then the result of the
1870 ** expression is also NULL.
1872 if( rRhsHasNull
==0 || destIfFalse
==destIfNull
){
1873 /* This branch runs if it is known at compile time that the RHS
1874 ** cannot contain NULL values. This happens as the result
1875 ** of a "NOT NULL" constraint in the database schema.
1877 ** Also run this branch if NULL is equivalent to FALSE
1878 ** for this particular IN operator.
1880 sqlite3VdbeAddOp4Int(v
, OP_NotFound
, pExpr
->iTable
, destIfFalse
, r1
, 1);
1883 /* In this branch, the RHS of the IN might contain a NULL and
1884 ** the presence of a NULL on the RHS makes a difference in the
1889 /* First check to see if the LHS is contained in the RHS. If so,
1890 ** then the presence of NULLs in the RHS does not matter, so jump
1891 ** over all of the code that follows.
1893 j1
= sqlite3VdbeAddOp4Int(v
, OP_Found
, pExpr
->iTable
, 0, r1
, 1);
1895 /* Here we begin generating code that runs if the LHS is not
1896 ** contained within the RHS. Generate additional code that
1897 ** tests the RHS for NULLs. If the RHS contains a NULL then
1898 ** jump to destIfNull. If there are no NULLs in the RHS then
1899 ** jump to destIfFalse.
1901 j2
= sqlite3VdbeAddOp1(v
, OP_NotNull
, rRhsHasNull
);
1902 j3
= sqlite3VdbeAddOp4Int(v
, OP_Found
, pExpr
->iTable
, 0, rRhsHasNull
, 1);
1903 sqlite3VdbeAddOp2(v
, OP_Integer
, -1, rRhsHasNull
);
1904 sqlite3VdbeJumpHere(v
, j3
);
1905 sqlite3VdbeAddOp2(v
, OP_AddImm
, rRhsHasNull
, 1);
1906 sqlite3VdbeJumpHere(v
, j2
);
1908 /* Jump to the appropriate target depending on whether or not
1909 ** the RHS contains a NULL
1911 sqlite3VdbeAddOp2(v
, OP_If
, rRhsHasNull
, destIfNull
);
1912 sqlite3VdbeAddOp2(v
, OP_Goto
, 0, destIfFalse
);
1914 /* The OP_Found at the top of this branch jumps here when true,
1915 ** causing the overall IN expression evaluation to fall through.
1917 sqlite3VdbeJumpHere(v
, j1
);
1920 sqlite3ReleaseTempReg(pParse
, r1
);
1921 sqlite3ExprCachePop(pParse
, 1);
1922 VdbeComment((v
, "end IN expr"));
1924 #endif /* SQLITE_OMIT_SUBQUERY */
1927 ** Duplicate an 8-byte value
1929 static char *dup8bytes(Vdbe
*v
, const char *in
){
1930 char *out
= sqlite3DbMallocRaw(sqlite3VdbeDb(v
), 8);
1937 #ifndef SQLITE_OMIT_FLOATING_POINT
1939 ** Generate an instruction that will put the floating point
1940 ** value described by z[0..n-1] into register iMem.
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.
1946 static void codeReal(Vdbe
*v
, const char *z
, int negateFlag
, int iMem
){
1950 sqlite3AtoF(z
, &value
, sqlite3Strlen30(z
), SQLITE_UTF8
);
1951 assert( !sqlite3IsNaN(value
) ); /* The new AtoF never returns NaN */
1952 if( negateFlag
) value
= -value
;
1953 zV
= dup8bytes(v
, (char*)&value
);
1954 sqlite3VdbeAddOp4(v
, OP_Real
, 0, iMem
, 0, zV
, P4_REAL
);
1961 ** Generate an instruction that will put the integer describe by
1962 ** text z[0..n-1] into register iMem.
1964 ** Expr.u.zToken is always UTF8 and zero-terminated.
1966 static void codeInteger(Parse
*pParse
, Expr
*pExpr
, int negFlag
, int iMem
){
1967 Vdbe
*v
= pParse
->pVdbe
;
1968 if( pExpr
->flags
& EP_IntValue
){
1969 int i
= pExpr
->u
.iValue
;
1971 if( negFlag
) i
= -i
;
1972 sqlite3VdbeAddOp2(v
, OP_Integer
, i
, iMem
);
1976 const char *z
= pExpr
->u
.zToken
;
1978 c
= sqlite3Atoi64(z
, &value
, sqlite3Strlen30(z
), SQLITE_UTF8
);
1979 if( c
==0 || (c
==2 && negFlag
) ){
1981 if( negFlag
){ value
= c
==2 ? SMALLEST_INT64
: -value
; }
1982 zV
= dup8bytes(v
, (char*)&value
);
1983 sqlite3VdbeAddOp4(v
, OP_Int64
, 0, iMem
, 0, zV
, P4_INT64
);
1985 #ifdef SQLITE_OMIT_FLOATING_POINT
1986 sqlite3ErrorMsg(pParse
, "oversized integer: %s%s", negFlag
? "-" : "", z
);
1988 codeReal(v
, z
, negFlag
, iMem
);
1995 ** Clear a cache entry.
1997 static void cacheEntryClear(Parse
*pParse
, struct yColCache
*p
){
1999 if( pParse
->nTempReg
<ArraySize(pParse
->aTempReg
) ){
2000 pParse
->aTempReg
[pParse
->nTempReg
++] = p
->iReg
;
2008 ** Record in the column cache that a particular column from a
2009 ** particular table is stored in a particular register.
2011 void sqlite3ExprCacheStore(Parse
*pParse
, int iTab
, int iCol
, int iReg
){
2015 struct yColCache
*p
;
2017 assert( iReg
>0 ); /* Register numbers are always positive */
2018 assert( iCol
>=-1 && iCol
<32768 ); /* Finite column numbers */
2020 /* The SQLITE_ColumnCache flag disables the column cache. This is used
2021 ** for testing only - to verify that SQLite always gets the same answer
2022 ** with and without the column cache.
2024 if( pParse
->db
->flags
& SQLITE_ColumnCache
) return;
2026 /* First replace any existing entry.
2028 ** Actually, the way the column cache is currently used, we are guaranteed
2029 ** that the object will never already be in cache. Verify this guarantee.
2032 for(i
=0, p
=pParse
->aColCache
; i
<SQLITE_N_COLCACHE
; i
++, p
++){
2033 #if 0 /* This code wold remove the entry from the cache if it existed */
2034 if( p
->iReg
&& p
->iTable
==iTab
&& p
->iColumn
==iCol
){
2035 cacheEntryClear(pParse
, p
);
2036 p
->iLevel
= pParse
->iCacheLevel
;
2038 p
->lru
= pParse
->iCacheCnt
++;
2042 assert( p
->iReg
==0 || p
->iTable
!=iTab
|| p
->iColumn
!=iCol
);
2046 /* Find an empty slot and replace it */
2047 for(i
=0, p
=pParse
->aColCache
; i
<SQLITE_N_COLCACHE
; i
++, p
++){
2049 p
->iLevel
= pParse
->iCacheLevel
;
2054 p
->lru
= pParse
->iCacheCnt
++;
2059 /* Replace the last recently used */
2060 minLru
= 0x7fffffff;
2062 for(i
=0, p
=pParse
->aColCache
; i
<SQLITE_N_COLCACHE
; i
++, p
++){
2063 if( p
->lru
<minLru
){
2068 if( ALWAYS(idxLru
>=0) ){
2069 p
= &pParse
->aColCache
[idxLru
];
2070 p
->iLevel
= pParse
->iCacheLevel
;
2075 p
->lru
= pParse
->iCacheCnt
++;
2081 ** Indicate that registers between iReg..iReg+nReg-1 are being overwritten.
2082 ** Purge the range of registers from the column cache.
2084 void sqlite3ExprCacheRemove(Parse
*pParse
, int iReg
, int nReg
){
2086 int iLast
= iReg
+ nReg
- 1;
2087 struct yColCache
*p
;
2088 for(i
=0, p
=pParse
->aColCache
; i
<SQLITE_N_COLCACHE
; i
++, p
++){
2090 if( r
>=iReg
&& r
<=iLast
){
2091 cacheEntryClear(pParse
, p
);
2098 ** Remember the current column cache context. Any new entries added
2099 ** added to the column cache after this call are removed when the
2100 ** corresponding pop occurs.
2102 void sqlite3ExprCachePush(Parse
*pParse
){
2103 pParse
->iCacheLevel
++;
2107 ** Remove from the column cache any entries that were added since the
2108 ** the previous N Push operations. In other words, restore the cache
2109 ** to the state it was in N Pushes ago.
2111 void sqlite3ExprCachePop(Parse
*pParse
, int N
){
2113 struct yColCache
*p
;
2115 assert( pParse
->iCacheLevel
>=N
);
2116 pParse
->iCacheLevel
-= N
;
2117 for(i
=0, p
=pParse
->aColCache
; i
<SQLITE_N_COLCACHE
; i
++, p
++){
2118 if( p
->iReg
&& p
->iLevel
>pParse
->iCacheLevel
){
2119 cacheEntryClear(pParse
, p
);
2126 ** When a cached column is reused, make sure that its register is
2127 ** no longer available as a temp register. ticket #3879: that same
2128 ** register might be in the cache in multiple places, so be sure to
2131 static void sqlite3ExprCachePinRegister(Parse
*pParse
, int iReg
){
2133 struct yColCache
*p
;
2134 for(i
=0, p
=pParse
->aColCache
; i
<SQLITE_N_COLCACHE
; i
++, p
++){
2135 if( p
->iReg
==iReg
){
2142 ** Generate code to extract the value of the iCol-th column of a table.
2144 void sqlite3ExprCodeGetColumnOfTable(
2145 Vdbe
*v
, /* The VDBE under construction */
2146 Table
*pTab
, /* The table containing the value */
2147 int iTabCur
, /* The cursor for this table */
2148 int iCol
, /* Index of the column to extract */
2149 int regOut
/* Extract the valud into this register */
2151 if( iCol
<0 || iCol
==pTab
->iPKey
){
2152 sqlite3VdbeAddOp2(v
, OP_Rowid
, iTabCur
, regOut
);
2154 int op
= IsVirtual(pTab
) ? OP_VColumn
: OP_Column
;
2155 sqlite3VdbeAddOp3(v
, op
, iTabCur
, iCol
, regOut
);
2158 sqlite3ColumnDefault(v
, pTab
, iCol
, regOut
);
2163 ** Generate code that will extract the iColumn-th column from
2164 ** table pTab and store the column value in a register. An effort
2165 ** is made to store the column value in register iReg, but this is
2166 ** not guaranteed. The location of the column value is returned.
2168 ** There must be an open cursor to pTab in iTable when this routine
2169 ** is called. If iColumn<0 then code is generated that extracts the rowid.
2171 int sqlite3ExprCodeGetColumn(
2172 Parse
*pParse
, /* Parsing and code generating context */
2173 Table
*pTab
, /* Description of the table we are reading from */
2174 int iColumn
, /* Index of the table column */
2175 int iTable
, /* The cursor pointing to the table */
2176 int iReg
/* Store results here */
2178 Vdbe
*v
= pParse
->pVdbe
;
2180 struct yColCache
*p
;
2182 for(i
=0, p
=pParse
->aColCache
; i
<SQLITE_N_COLCACHE
; i
++, p
++){
2183 if( p
->iReg
>0 && p
->iTable
==iTable
&& p
->iColumn
==iColumn
){
2184 p
->lru
= pParse
->iCacheCnt
++;
2185 sqlite3ExprCachePinRegister(pParse
, p
->iReg
);
2190 sqlite3ExprCodeGetColumnOfTable(v
, pTab
, iTable
, iColumn
, iReg
);
2191 sqlite3ExprCacheStore(pParse
, iTable
, iColumn
, iReg
);
2196 ** Clear all column cache entries.
2198 void sqlite3ExprCacheClear(Parse
*pParse
){
2200 struct yColCache
*p
;
2202 for(i
=0, p
=pParse
->aColCache
; i
<SQLITE_N_COLCACHE
; i
++, p
++){
2204 cacheEntryClear(pParse
, p
);
2211 ** Record the fact that an affinity change has occurred on iCount
2212 ** registers starting with iStart.
2214 void sqlite3ExprCacheAffinityChange(Parse
*pParse
, int iStart
, int iCount
){
2215 sqlite3ExprCacheRemove(pParse
, iStart
, iCount
);
2219 ** Generate code to move content from registers iFrom...iFrom+nReg-1
2220 ** over to iTo..iTo+nReg-1. Keep the column cache up-to-date.
2222 void sqlite3ExprCodeMove(Parse
*pParse
, int iFrom
, int iTo
, int nReg
){
2224 struct yColCache
*p
;
2225 if( NEVER(iFrom
==iTo
) ) return;
2226 sqlite3VdbeAddOp3(pParse
->pVdbe
, OP_Move
, iFrom
, iTo
, nReg
);
2227 for(i
=0, p
=pParse
->aColCache
; i
<SQLITE_N_COLCACHE
; i
++, p
++){
2229 if( x
>=iFrom
&& x
<iFrom
+nReg
){
2230 p
->iReg
+= iTo
-iFrom
;
2236 ** Generate code to copy content from registers iFrom...iFrom+nReg-1
2237 ** over to iTo..iTo+nReg-1.
2239 void sqlite3ExprCodeCopy(Parse
*pParse
, int iFrom
, int iTo
, int nReg
){
2241 if( NEVER(iFrom
==iTo
) ) return;
2242 for(i
=0; i
<nReg
; i
++){
2243 sqlite3VdbeAddOp2(pParse
->pVdbe
, OP_Copy
, iFrom
+i
, iTo
+i
);
2247 #if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST)
2249 ** Return true if any register in the range iFrom..iTo (inclusive)
2250 ** is used as part of the column cache.
2252 ** This routine is used within assert() and testcase() macros only
2253 ** and does not appear in a normal build.
2255 static int usedAsColumnCache(Parse
*pParse
, int iFrom
, int iTo
){
2257 struct yColCache
*p
;
2258 for(i
=0, p
=pParse
->aColCache
; i
<SQLITE_N_COLCACHE
; i
++, p
++){
2260 if( r
>=iFrom
&& r
<=iTo
) return 1; /*NO_TEST*/
2264 #endif /* SQLITE_DEBUG || SQLITE_COVERAGE_TEST */
2267 ** Generate code into the current Vdbe to evaluate the given
2268 ** expression. Attempt to store the results in register "target".
2269 ** Return the register where results are stored.
2271 ** With this routine, there is no guarantee that results will
2272 ** be stored in target. The result might be stored in some other
2273 ** register if it is convenient to do so. The calling function
2274 ** must check the return code and move the results to the desired
2277 int sqlite3ExprCodeTarget(Parse
*pParse
, Expr
*pExpr
, int target
){
2278 Vdbe
*v
= pParse
->pVdbe
; /* The VM under construction */
2279 int op
; /* The opcode being coded */
2280 int inReg
= target
; /* Results stored in register inReg */
2281 int regFree1
= 0; /* If non-zero free this temporary register */
2282 int regFree2
= 0; /* If non-zero free this temporary register */
2283 int r1
, r2
, r3
, r4
; /* Various register numbers */
2284 sqlite3
*db
= pParse
->db
; /* The database connection */
2286 assert( target
>0 && target
<=pParse
->nMem
);
2288 assert( pParse
->db
->mallocFailed
);
2298 case TK_AGG_COLUMN
: {
2299 AggInfo
*pAggInfo
= pExpr
->pAggInfo
;
2300 struct AggInfo_col
*pCol
= &pAggInfo
->aCol
[pExpr
->iAgg
];
2301 if( !pAggInfo
->directMode
){
2302 assert( pCol
->iMem
>0 );
2305 }else if( pAggInfo
->useSortingIdx
){
2306 sqlite3VdbeAddOp3(v
, OP_Column
, pAggInfo
->sortingIdxPTab
,
2307 pCol
->iSorterColumn
, target
);
2310 /* Otherwise, fall thru into the TK_COLUMN case */
2313 if( pExpr
->iTable
<0 ){
2314 /* This only happens when coding check constraints */
2315 assert( pParse
->ckBase
>0 );
2316 inReg
= pExpr
->iColumn
+ pParse
->ckBase
;
2318 inReg
= sqlite3ExprCodeGetColumn(pParse
, pExpr
->pTab
,
2319 pExpr
->iColumn
, pExpr
->iTable
, target
);
2324 codeInteger(pParse
, pExpr
, 0, target
);
2327 #ifndef SQLITE_OMIT_FLOATING_POINT
2329 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
2330 codeReal(v
, pExpr
->u
.zToken
, 0, target
);
2335 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
2336 sqlite3VdbeAddOp4(v
, OP_String8
, 0, target
, 0, pExpr
->u
.zToken
, 0);
2340 sqlite3VdbeAddOp2(v
, OP_Null
, 0, target
);
2343 #ifndef SQLITE_OMIT_BLOB_LITERAL
2348 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
2349 assert( pExpr
->u
.zToken
[0]=='x' || pExpr
->u
.zToken
[0]=='X' );
2350 assert( pExpr
->u
.zToken
[1]=='\'' );
2351 z
= &pExpr
->u
.zToken
[2];
2352 n
= sqlite3Strlen30(z
) - 1;
2353 assert( z
[n
]=='\'' );
2354 zBlob
= sqlite3HexToBlob(sqlite3VdbeDb(v
), z
, n
);
2355 sqlite3VdbeAddOp4(v
, OP_Blob
, n
/2, target
, 0, zBlob
, P4_DYNAMIC
);
2360 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
2361 assert( pExpr
->u
.zToken
!=0 );
2362 assert( pExpr
->u
.zToken
[0]!=0 );
2363 sqlite3VdbeAddOp2(v
, OP_Variable
, pExpr
->iColumn
, target
);
2364 if( pExpr
->u
.zToken
[1]!=0 ){
2365 assert( pExpr
->u
.zToken
[0]=='?'
2366 || strcmp(pExpr
->u
.zToken
, pParse
->azVar
[pExpr
->iColumn
-1])==0 );
2367 sqlite3VdbeChangeP4(v
, -1, pParse
->azVar
[pExpr
->iColumn
-1], P4_STATIC
);
2372 inReg
= pExpr
->iTable
;
2376 inReg
= sqlite3ExprCodeTarget(pParse
, pExpr
->pLeft
, target
);
2379 #ifndef SQLITE_OMIT_CAST
2381 /* Expressions of the form: CAST(pLeft AS token) */
2383 inReg
= sqlite3ExprCodeTarget(pParse
, pExpr
->pLeft
, target
);
2384 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
2385 aff
= sqlite3AffinityType(pExpr
->u
.zToken
);
2386 to_op
= aff
- SQLITE_AFF_TEXT
+ OP_ToText
;
2387 assert( to_op
==OP_ToText
|| aff
!=SQLITE_AFF_TEXT
);
2388 assert( to_op
==OP_ToBlob
|| aff
!=SQLITE_AFF_NONE
);
2389 assert( to_op
==OP_ToNumeric
|| aff
!=SQLITE_AFF_NUMERIC
);
2390 assert( to_op
==OP_ToInt
|| aff
!=SQLITE_AFF_INTEGER
);
2391 assert( to_op
==OP_ToReal
|| aff
!=SQLITE_AFF_REAL
);
2392 testcase( to_op
==OP_ToText
);
2393 testcase( to_op
==OP_ToBlob
);
2394 testcase( to_op
==OP_ToNumeric
);
2395 testcase( to_op
==OP_ToInt
);
2396 testcase( to_op
==OP_ToReal
);
2397 if( inReg
!=target
){
2398 sqlite3VdbeAddOp2(v
, OP_SCopy
, inReg
, target
);
2401 sqlite3VdbeAddOp1(v
, to_op
, inReg
);
2402 testcase( usedAsColumnCache(pParse
, inReg
, inReg
) );
2403 sqlite3ExprCacheAffinityChange(pParse
, inReg
, 1);
2406 #endif /* SQLITE_OMIT_CAST */
2413 assert( TK_LT
==OP_Lt
);
2414 assert( TK_LE
==OP_Le
);
2415 assert( TK_GT
==OP_Gt
);
2416 assert( TK_GE
==OP_Ge
);
2417 assert( TK_EQ
==OP_Eq
);
2418 assert( TK_NE
==OP_Ne
);
2419 testcase( op
==TK_LT
);
2420 testcase( op
==TK_LE
);
2421 testcase( op
==TK_GT
);
2422 testcase( op
==TK_GE
);
2423 testcase( op
==TK_EQ
);
2424 testcase( op
==TK_NE
);
2425 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free1
);
2426 r2
= sqlite3ExprCodeTemp(pParse
, pExpr
->pRight
, ®Free2
);
2427 codeCompare(pParse
, pExpr
->pLeft
, pExpr
->pRight
, op
,
2428 r1
, r2
, inReg
, SQLITE_STOREP2
);
2429 testcase( regFree1
==0 );
2430 testcase( regFree2
==0 );
2435 testcase( op
==TK_IS
);
2436 testcase( op
==TK_ISNOT
);
2437 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free1
);
2438 r2
= sqlite3ExprCodeTemp(pParse
, pExpr
->pRight
, ®Free2
);
2439 op
= (op
==TK_IS
) ? TK_EQ
: TK_NE
;
2440 codeCompare(pParse
, pExpr
->pLeft
, pExpr
->pRight
, op
,
2441 r1
, r2
, inReg
, SQLITE_STOREP2
| SQLITE_NULLEQ
);
2442 testcase( regFree1
==0 );
2443 testcase( regFree2
==0 );
2458 assert( TK_AND
==OP_And
);
2459 assert( TK_OR
==OP_Or
);
2460 assert( TK_PLUS
==OP_Add
);
2461 assert( TK_MINUS
==OP_Subtract
);
2462 assert( TK_REM
==OP_Remainder
);
2463 assert( TK_BITAND
==OP_BitAnd
);
2464 assert( TK_BITOR
==OP_BitOr
);
2465 assert( TK_SLASH
==OP_Divide
);
2466 assert( TK_LSHIFT
==OP_ShiftLeft
);
2467 assert( TK_RSHIFT
==OP_ShiftRight
);
2468 assert( TK_CONCAT
==OP_Concat
);
2469 testcase( op
==TK_AND
);
2470 testcase( op
==TK_OR
);
2471 testcase( op
==TK_PLUS
);
2472 testcase( op
==TK_MINUS
);
2473 testcase( op
==TK_REM
);
2474 testcase( op
==TK_BITAND
);
2475 testcase( op
==TK_BITOR
);
2476 testcase( op
==TK_SLASH
);
2477 testcase( op
==TK_LSHIFT
);
2478 testcase( op
==TK_RSHIFT
);
2479 testcase( op
==TK_CONCAT
);
2480 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free1
);
2481 r2
= sqlite3ExprCodeTemp(pParse
, pExpr
->pRight
, ®Free2
);
2482 sqlite3VdbeAddOp3(v
, op
, r2
, r1
, target
);
2483 testcase( regFree1
==0 );
2484 testcase( regFree2
==0 );
2488 Expr
*pLeft
= pExpr
->pLeft
;
2490 if( pLeft
->op
==TK_INTEGER
){
2491 codeInteger(pParse
, pLeft
, 1, target
);
2492 #ifndef SQLITE_OMIT_FLOATING_POINT
2493 }else if( pLeft
->op
==TK_FLOAT
){
2494 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
2495 codeReal(v
, pLeft
->u
.zToken
, 1, target
);
2498 regFree1
= r1
= sqlite3GetTempReg(pParse
);
2499 sqlite3VdbeAddOp2(v
, OP_Integer
, 0, r1
);
2500 r2
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free2
);
2501 sqlite3VdbeAddOp3(v
, OP_Subtract
, r2
, r1
, target
);
2502 testcase( regFree2
==0 );
2509 assert( TK_BITNOT
==OP_BitNot
);
2510 assert( TK_NOT
==OP_Not
);
2511 testcase( op
==TK_BITNOT
);
2512 testcase( op
==TK_NOT
);
2513 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free1
);
2514 testcase( regFree1
==0 );
2516 sqlite3VdbeAddOp2(v
, op
, r1
, inReg
);
2522 assert( TK_ISNULL
==OP_IsNull
);
2523 assert( TK_NOTNULL
==OP_NotNull
);
2524 testcase( op
==TK_ISNULL
);
2525 testcase( op
==TK_NOTNULL
);
2526 sqlite3VdbeAddOp2(v
, OP_Integer
, 1, target
);
2527 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free1
);
2528 testcase( regFree1
==0 );
2529 addr
= sqlite3VdbeAddOp1(v
, op
, r1
);
2530 sqlite3VdbeAddOp2(v
, OP_AddImm
, target
, -1);
2531 sqlite3VdbeJumpHere(v
, addr
);
2534 case TK_AGG_FUNCTION
: {
2535 AggInfo
*pInfo
= pExpr
->pAggInfo
;
2537 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
2538 sqlite3ErrorMsg(pParse
, "misuse of aggregate: %s()", pExpr
->u
.zToken
);
2540 inReg
= pInfo
->aFunc
[pExpr
->iAgg
].iMem
;
2546 ExprList
*pFarg
; /* List of function arguments */
2547 int nFarg
; /* Number of function arguments */
2548 FuncDef
*pDef
; /* The function definition object */
2549 int nId
; /* Length of the function name in bytes */
2550 const char *zId
; /* The function name */
2551 int constMask
= 0; /* Mask of function arguments that are constant */
2552 int i
; /* Loop counter */
2553 u8 enc
= ENC(db
); /* The text encoding used by this database */
2554 CollSeq
*pColl
= 0; /* A collating sequence */
2556 assert( !ExprHasProperty(pExpr
, EP_xIsSelect
) );
2557 testcase( op
==TK_CONST_FUNC
);
2558 testcase( op
==TK_FUNCTION
);
2559 if( ExprHasAnyProperty(pExpr
, EP_TokenOnly
) ){
2562 pFarg
= pExpr
->x
.pList
;
2564 nFarg
= pFarg
? pFarg
->nExpr
: 0;
2565 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
2566 zId
= pExpr
->u
.zToken
;
2567 nId
= sqlite3Strlen30(zId
);
2568 pDef
= sqlite3FindFunction(db
, zId
, nId
, nFarg
, enc
, 0);
2570 sqlite3ErrorMsg(pParse
, "unknown function: %.*s()", nId
, zId
);
2574 /* Attempt a direct implementation of the built-in COALESCE() and
2575 ** IFNULL() functions. This avoids unnecessary evalation of
2576 ** arguments past the first non-NULL argument.
2578 if( pDef
->flags
& SQLITE_FUNC_COALESCE
){
2579 int endCoalesce
= sqlite3VdbeMakeLabel(v
);
2581 sqlite3ExprCode(pParse
, pFarg
->a
[0].pExpr
, target
);
2582 for(i
=1; i
<nFarg
; i
++){
2583 sqlite3VdbeAddOp2(v
, OP_NotNull
, target
, endCoalesce
);
2584 sqlite3ExprCacheRemove(pParse
, target
, 1);
2585 sqlite3ExprCachePush(pParse
);
2586 sqlite3ExprCode(pParse
, pFarg
->a
[i
].pExpr
, target
);
2587 sqlite3ExprCachePop(pParse
, 1);
2589 sqlite3VdbeResolveLabel(v
, endCoalesce
);
2595 r1
= sqlite3GetTempRange(pParse
, nFarg
);
2596 sqlite3ExprCachePush(pParse
); /* Ticket 2ea2425d34be */
2597 sqlite3ExprCodeExprList(pParse
, pFarg
, r1
, 1);
2598 sqlite3ExprCachePop(pParse
, 1); /* Ticket 2ea2425d34be */
2602 #ifndef SQLITE_OMIT_VIRTUALTABLE
2603 /* Possibly overload the function if the first argument is
2604 ** a virtual table column.
2606 ** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the
2607 ** second argument, not the first, as the argument to test to
2608 ** see if it is a column in a virtual table. This is done because
2609 ** the left operand of infix functions (the operand we want to
2610 ** control overloading) ends up as the second argument to the
2611 ** function. The expression "A glob B" is equivalent to
2612 ** "glob(B,A). We want to use the A in "A glob B" to test
2613 ** for function overloading. But we use the B term in "glob(B,A)".
2615 if( nFarg
>=2 && (pExpr
->flags
& EP_InfixFunc
) ){
2616 pDef
= sqlite3VtabOverloadFunction(db
, pDef
, nFarg
, pFarg
->a
[1].pExpr
);
2617 }else if( nFarg
>0 ){
2618 pDef
= sqlite3VtabOverloadFunction(db
, pDef
, nFarg
, pFarg
->a
[0].pExpr
);
2621 for(i
=0; i
<nFarg
; i
++){
2622 if( i
<32 && sqlite3ExprIsConstant(pFarg
->a
[i
].pExpr
) ){
2623 constMask
|= (1<<i
);
2625 if( (pDef
->flags
& SQLITE_FUNC_NEEDCOLL
)!=0 && !pColl
){
2626 pColl
= sqlite3ExprCollSeq(pParse
, pFarg
->a
[i
].pExpr
);
2629 if( pDef
->flags
& SQLITE_FUNC_NEEDCOLL
){
2630 if( !pColl
) pColl
= db
->pDfltColl
;
2631 sqlite3VdbeAddOp4(v
, OP_CollSeq
, 0, 0, 0, (char *)pColl
, P4_COLLSEQ
);
2633 sqlite3VdbeAddOp4(v
, OP_Function
, constMask
, r1
, target
,
2634 (char*)pDef
, P4_FUNCDEF
);
2635 sqlite3VdbeChangeP5(v
, (u8
)nFarg
);
2637 sqlite3ReleaseTempRange(pParse
, r1
, nFarg
);
2641 #ifndef SQLITE_OMIT_SUBQUERY
2644 testcase( op
==TK_EXISTS
);
2645 testcase( op
==TK_SELECT
);
2646 inReg
= sqlite3CodeSubselect(pParse
, pExpr
, 0, 0);
2650 int destIfFalse
= sqlite3VdbeMakeLabel(v
);
2651 int destIfNull
= sqlite3VdbeMakeLabel(v
);
2652 sqlite3VdbeAddOp2(v
, OP_Null
, 0, target
);
2653 sqlite3ExprCodeIN(pParse
, pExpr
, destIfFalse
, destIfNull
);
2654 sqlite3VdbeAddOp2(v
, OP_Integer
, 1, target
);
2655 sqlite3VdbeResolveLabel(v
, destIfFalse
);
2656 sqlite3VdbeAddOp2(v
, OP_AddImm
, target
, 0);
2657 sqlite3VdbeResolveLabel(v
, destIfNull
);
2660 #endif /* SQLITE_OMIT_SUBQUERY */
2664 ** x BETWEEN y AND z
2666 ** This is equivalent to
2670 ** X is stored in pExpr->pLeft.
2671 ** Y is stored in pExpr->pList->a[0].pExpr.
2672 ** Z is stored in pExpr->pList->a[1].pExpr.
2675 Expr
*pLeft
= pExpr
->pLeft
;
2676 struct ExprList_item
*pLItem
= pExpr
->x
.pList
->a
;
2677 Expr
*pRight
= pLItem
->pExpr
;
2679 r1
= sqlite3ExprCodeTemp(pParse
, pLeft
, ®Free1
);
2680 r2
= sqlite3ExprCodeTemp(pParse
, pRight
, ®Free2
);
2681 testcase( regFree1
==0 );
2682 testcase( regFree2
==0 );
2683 r3
= sqlite3GetTempReg(pParse
);
2684 r4
= sqlite3GetTempReg(pParse
);
2685 codeCompare(pParse
, pLeft
, pRight
, OP_Ge
,
2686 r1
, r2
, r3
, SQLITE_STOREP2
);
2688 pRight
= pLItem
->pExpr
;
2689 sqlite3ReleaseTempReg(pParse
, regFree2
);
2690 r2
= sqlite3ExprCodeTemp(pParse
, pRight
, ®Free2
);
2691 testcase( regFree2
==0 );
2692 codeCompare(pParse
, pLeft
, pRight
, OP_Le
, r1
, r2
, r4
, SQLITE_STOREP2
);
2693 sqlite3VdbeAddOp3(v
, OP_And
, r3
, r4
, target
);
2694 sqlite3ReleaseTempReg(pParse
, r3
);
2695 sqlite3ReleaseTempReg(pParse
, r4
);
2699 inReg
= sqlite3ExprCodeTarget(pParse
, pExpr
->pLeft
, target
);
2704 /* If the opcode is TK_TRIGGER, then the expression is a reference
2705 ** to a column in the new.* or old.* pseudo-tables available to
2706 ** trigger programs. In this case Expr.iTable is set to 1 for the
2707 ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
2708 ** is set to the column of the pseudo-table to read, or to -1 to
2709 ** read the rowid field.
2711 ** The expression is implemented using an OP_Param opcode. The p1
2712 ** parameter is set to 0 for an old.rowid reference, or to (i+1)
2713 ** to reference another column of the old.* pseudo-table, where
2714 ** i is the index of the column. For a new.rowid reference, p1 is
2715 ** set to (n+1), where n is the number of columns in each pseudo-table.
2716 ** For a reference to any other column in the new.* pseudo-table, p1
2717 ** is set to (n+2+i), where n and i are as defined previously. For
2718 ** example, if the table on which triggers are being fired is
2721 ** CREATE TABLE t1(a, b);
2723 ** Then p1 is interpreted as follows:
2725 ** p1==0 -> old.rowid p1==3 -> new.rowid
2726 ** p1==1 -> old.a p1==4 -> new.a
2727 ** p1==2 -> old.b p1==5 -> new.b
2729 Table
*pTab
= pExpr
->pTab
;
2730 int p1
= pExpr
->iTable
* (pTab
->nCol
+1) + 1 + pExpr
->iColumn
;
2732 assert( pExpr
->iTable
==0 || pExpr
->iTable
==1 );
2733 assert( pExpr
->iColumn
>=-1 && pExpr
->iColumn
<pTab
->nCol
);
2734 assert( pTab
->iPKey
<0 || pExpr
->iColumn
!=pTab
->iPKey
);
2735 assert( p1
>=0 && p1
<(pTab
->nCol
*2+2) );
2737 sqlite3VdbeAddOp2(v
, OP_Param
, p1
, target
);
2738 VdbeComment((v
, "%s.%s -> $%d",
2739 (pExpr
->iTable
? "new" : "old"),
2740 (pExpr
->iColumn
<0 ? "rowid" : pExpr
->pTab
->aCol
[pExpr
->iColumn
].zName
),
2744 #ifndef SQLITE_OMIT_FLOATING_POINT
2745 /* If the column has REAL affinity, it may currently be stored as an
2746 ** integer. Use OP_RealAffinity to make sure it is really real. */
2747 if( pExpr
->iColumn
>=0
2748 && pTab
->aCol
[pExpr
->iColumn
].affinity
==SQLITE_AFF_REAL
2750 sqlite3VdbeAddOp1(v
, OP_RealAffinity
, target
);
2759 ** CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
2762 ** CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
2764 ** Form A is can be transformed into the equivalent form B as follows:
2765 ** CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ...
2766 ** WHEN x=eN THEN rN ELSE y END
2768 ** X (if it exists) is in pExpr->pLeft.
2769 ** Y is in pExpr->pRight. The Y is also optional. If there is no
2770 ** ELSE clause and no other term matches, then the result of the
2771 ** exprssion is NULL.
2772 ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1].
2774 ** The result of the expression is the Ri for the first matching Ei,
2775 ** or if there is no matching Ei, the ELSE term Y, or if there is
2776 ** no ELSE term, NULL.
2778 default: assert( op
==TK_CASE
); {
2779 int endLabel
; /* GOTO label for end of CASE stmt */
2780 int nextCase
; /* GOTO label for next WHEN clause */
2781 int nExpr
; /* 2x number of WHEN terms */
2782 int i
; /* Loop counter */
2783 ExprList
*pEList
; /* List of WHEN terms */
2784 struct ExprList_item
*aListelem
; /* Array of WHEN terms */
2785 Expr opCompare
; /* The X==Ei expression */
2786 Expr cacheX
; /* Cached expression X */
2787 Expr
*pX
; /* The X expression */
2788 Expr
*pTest
= 0; /* X==Ei (form A) or just Ei (form B) */
2789 VVA_ONLY( int iCacheLevel
= pParse
->iCacheLevel
; )
2791 assert( !ExprHasProperty(pExpr
, EP_xIsSelect
) && pExpr
->x
.pList
);
2792 assert((pExpr
->x
.pList
->nExpr
% 2) == 0);
2793 assert(pExpr
->x
.pList
->nExpr
> 0);
2794 pEList
= pExpr
->x
.pList
;
2795 aListelem
= pEList
->a
;
2796 nExpr
= pEList
->nExpr
;
2797 endLabel
= sqlite3VdbeMakeLabel(v
);
2798 if( (pX
= pExpr
->pLeft
)!=0 ){
2800 testcase( pX
->op
==TK_COLUMN
);
2801 testcase( pX
->op
==TK_REGISTER
);
2802 cacheX
.iTable
= sqlite3ExprCodeTemp(pParse
, pX
, ®Free1
);
2803 testcase( regFree1
==0 );
2804 cacheX
.op
= TK_REGISTER
;
2805 opCompare
.op
= TK_EQ
;
2806 opCompare
.pLeft
= &cacheX
;
2808 /* Ticket b351d95f9cd5ef17e9d9dbae18f5ca8611190001:
2809 ** The value in regFree1 might get SCopy-ed into the file result.
2810 ** So make sure that the regFree1 register is not reused for other
2811 ** purposes and possibly overwritten. */
2814 for(i
=0; i
<nExpr
; i
=i
+2){
2815 sqlite3ExprCachePush(pParse
);
2818 opCompare
.pRight
= aListelem
[i
].pExpr
;
2820 pTest
= aListelem
[i
].pExpr
;
2822 nextCase
= sqlite3VdbeMakeLabel(v
);
2823 testcase( pTest
->op
==TK_COLUMN
);
2824 sqlite3ExprIfFalse(pParse
, pTest
, nextCase
, SQLITE_JUMPIFNULL
);
2825 testcase( aListelem
[i
+1].pExpr
->op
==TK_COLUMN
);
2826 testcase( aListelem
[i
+1].pExpr
->op
==TK_REGISTER
);
2827 sqlite3ExprCode(pParse
, aListelem
[i
+1].pExpr
, target
);
2828 sqlite3VdbeAddOp2(v
, OP_Goto
, 0, endLabel
);
2829 sqlite3ExprCachePop(pParse
, 1);
2830 sqlite3VdbeResolveLabel(v
, nextCase
);
2832 if( pExpr
->pRight
){
2833 sqlite3ExprCachePush(pParse
);
2834 sqlite3ExprCode(pParse
, pExpr
->pRight
, target
);
2835 sqlite3ExprCachePop(pParse
, 1);
2837 sqlite3VdbeAddOp2(v
, OP_Null
, 0, target
);
2839 assert( db
->mallocFailed
|| pParse
->nErr
>0
2840 || pParse
->iCacheLevel
==iCacheLevel
);
2841 sqlite3VdbeResolveLabel(v
, endLabel
);
2844 #ifndef SQLITE_OMIT_TRIGGER
2846 assert( pExpr
->affinity
==OE_Rollback
2847 || pExpr
->affinity
==OE_Abort
2848 || pExpr
->affinity
==OE_Fail
2849 || pExpr
->affinity
==OE_Ignore
2851 if( !pParse
->pTriggerTab
){
2852 sqlite3ErrorMsg(pParse
,
2853 "RAISE() may only be used within a trigger-program");
2856 if( pExpr
->affinity
==OE_Abort
){
2857 sqlite3MayAbort(pParse
);
2859 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
2860 if( pExpr
->affinity
==OE_Ignore
){
2862 v
, OP_Halt
, SQLITE_OK
, OE_Ignore
, 0, pExpr
->u
.zToken
,0);
2864 sqlite3HaltConstraint(pParse
, pExpr
->affinity
, pExpr
->u
.zToken
, 0);
2871 sqlite3ReleaseTempReg(pParse
, regFree1
);
2872 sqlite3ReleaseTempReg(pParse
, regFree2
);
2877 ** Generate code to evaluate an expression and store the results
2878 ** into a register. Return the register number where the results
2881 ** If the register is a temporary register that can be deallocated,
2882 ** then write its number into *pReg. If the result register is not
2883 ** a temporary, then set *pReg to zero.
2885 int sqlite3ExprCodeTemp(Parse
*pParse
, Expr
*pExpr
, int *pReg
){
2886 int r1
= sqlite3GetTempReg(pParse
);
2887 int r2
= sqlite3ExprCodeTarget(pParse
, pExpr
, r1
);
2891 sqlite3ReleaseTempReg(pParse
, r1
);
2898 ** Generate code that will evaluate expression pExpr and store the
2899 ** results in register target. The results are guaranteed to appear
2900 ** in register target.
2902 int sqlite3ExprCode(Parse
*pParse
, Expr
*pExpr
, int target
){
2905 assert( target
>0 && target
<=pParse
->nMem
);
2906 if( pExpr
&& pExpr
->op
==TK_REGISTER
){
2907 sqlite3VdbeAddOp2(pParse
->pVdbe
, OP_Copy
, pExpr
->iTable
, target
);
2909 inReg
= sqlite3ExprCodeTarget(pParse
, pExpr
, target
);
2910 assert( pParse
->pVdbe
|| pParse
->db
->mallocFailed
);
2911 if( inReg
!=target
&& pParse
->pVdbe
){
2912 sqlite3VdbeAddOp2(pParse
->pVdbe
, OP_SCopy
, inReg
, target
);
2919 ** Generate code that evalutes the given expression and puts the result
2920 ** in register target.
2922 ** Also make a copy of the expression results into another "cache" register
2923 ** and modify the expression so that the next time it is evaluated,
2924 ** the result is a copy of the cache register.
2926 ** This routine is used for expressions that are used multiple
2927 ** times. They are evaluated once and the results of the expression
2930 int sqlite3ExprCodeAndCache(Parse
*pParse
, Expr
*pExpr
, int target
){
2931 Vdbe
*v
= pParse
->pVdbe
;
2933 inReg
= sqlite3ExprCode(pParse
, pExpr
, target
);
2935 /* This routine is called for terms to INSERT or UPDATE. And the only
2936 ** other place where expressions can be converted into TK_REGISTER is
2937 ** in WHERE clause processing. So as currently implemented, there is
2938 ** no way for a TK_REGISTER to exist here. But it seems prudent to
2939 ** keep the ALWAYS() in case the conditions above change with future
2940 ** modifications or enhancements. */
2941 if( ALWAYS(pExpr
->op
!=TK_REGISTER
) ){
2943 iMem
= ++pParse
->nMem
;
2944 sqlite3VdbeAddOp2(v
, OP_Copy
, inReg
, iMem
);
2945 pExpr
->iTable
= iMem
;
2946 pExpr
->op2
= pExpr
->op
;
2947 pExpr
->op
= TK_REGISTER
;
2952 #if defined(SQLITE_ENABLE_TREE_EXPLAIN)
2954 ** Generate a human-readable explanation of an expression tree.
2956 void sqlite3ExplainExpr(Vdbe
*pOut
, Expr
*pExpr
){
2957 int op
; /* The opcode being coded */
2958 const char *zBinOp
= 0; /* Binary operator */
2959 const char *zUniOp
= 0; /* Unary operator */
2966 case TK_AGG_COLUMN
: {
2967 sqlite3ExplainPrintf(pOut
, "AGG{%d:%d}",
2968 pExpr
->iTable
, pExpr
->iColumn
);
2972 if( pExpr
->iTable
<0 ){
2973 /* This only happens when coding check constraints */
2974 sqlite3ExplainPrintf(pOut
, "COLUMN(%d)", pExpr
->iColumn
);
2976 sqlite3ExplainPrintf(pOut
, "{%d:%d}",
2977 pExpr
->iTable
, pExpr
->iColumn
);
2982 if( pExpr
->flags
& EP_IntValue
){
2983 sqlite3ExplainPrintf(pOut
, "%d", pExpr
->u
.iValue
);
2985 sqlite3ExplainPrintf(pOut
, "%s", pExpr
->u
.zToken
);
2989 #ifndef SQLITE_OMIT_FLOATING_POINT
2991 sqlite3ExplainPrintf(pOut
,"%s", pExpr
->u
.zToken
);
2996 sqlite3ExplainPrintf(pOut
,"%Q", pExpr
->u
.zToken
);
3000 sqlite3ExplainPrintf(pOut
,"NULL");
3003 #ifndef SQLITE_OMIT_BLOB_LITERAL
3005 sqlite3ExplainPrintf(pOut
,"%s", pExpr
->u
.zToken
);
3010 sqlite3ExplainPrintf(pOut
,"VARIABLE(%s,%d)",
3011 pExpr
->u
.zToken
, pExpr
->iColumn
);
3015 sqlite3ExplainPrintf(pOut
,"REGISTER(%d)", pExpr
->iTable
);
3019 sqlite3ExplainExpr(pOut
, pExpr
->pLeft
);
3022 #ifndef SQLITE_OMIT_CAST
3024 /* Expressions of the form: CAST(pLeft AS token) */
3025 const char *zAff
= "unk";
3026 switch( sqlite3AffinityType(pExpr
->u
.zToken
) ){
3027 case SQLITE_AFF_TEXT
: zAff
= "TEXT"; break;
3028 case SQLITE_AFF_NONE
: zAff
= "NONE"; break;
3029 case SQLITE_AFF_NUMERIC
: zAff
= "NUMERIC"; break;
3030 case SQLITE_AFF_INTEGER
: zAff
= "INTEGER"; break;
3031 case SQLITE_AFF_REAL
: zAff
= "REAL"; break;
3033 sqlite3ExplainPrintf(pOut
, "CAST-%s(", zAff
);
3034 sqlite3ExplainExpr(pOut
, pExpr
->pLeft
);
3035 sqlite3ExplainPrintf(pOut
, ")");
3038 #endif /* SQLITE_OMIT_CAST */
3039 case TK_LT
: zBinOp
= "LT"; break;
3040 case TK_LE
: zBinOp
= "LE"; break;
3041 case TK_GT
: zBinOp
= "GT"; break;
3042 case TK_GE
: zBinOp
= "GE"; break;
3043 case TK_NE
: zBinOp
= "NE"; break;
3044 case TK_EQ
: zBinOp
= "EQ"; break;
3045 case TK_IS
: zBinOp
= "IS"; break;
3046 case TK_ISNOT
: zBinOp
= "ISNOT"; break;
3047 case TK_AND
: zBinOp
= "AND"; break;
3048 case TK_OR
: zBinOp
= "OR"; break;
3049 case TK_PLUS
: zBinOp
= "ADD"; break;
3050 case TK_STAR
: zBinOp
= "MUL"; break;
3051 case TK_MINUS
: zBinOp
= "SUB"; break;
3052 case TK_REM
: zBinOp
= "REM"; break;
3053 case TK_BITAND
: zBinOp
= "BITAND"; break;
3054 case TK_BITOR
: zBinOp
= "BITOR"; break;
3055 case TK_SLASH
: zBinOp
= "DIV"; break;
3056 case TK_LSHIFT
: zBinOp
= "LSHIFT"; break;
3057 case TK_RSHIFT
: zBinOp
= "RSHIFT"; break;
3058 case TK_CONCAT
: zBinOp
= "CONCAT"; break;
3060 case TK_UMINUS
: zUniOp
= "UMINUS"; break;
3061 case TK_UPLUS
: zUniOp
= "UPLUS"; break;
3062 case TK_BITNOT
: zUniOp
= "BITNOT"; break;
3063 case TK_NOT
: zUniOp
= "NOT"; break;
3064 case TK_ISNULL
: zUniOp
= "ISNULL"; break;
3065 case TK_NOTNULL
: zUniOp
= "NOTNULL"; break;
3067 case TK_AGG_FUNCTION
:
3070 ExprList
*pFarg
; /* List of function arguments */
3071 if( ExprHasAnyProperty(pExpr
, EP_TokenOnly
) ){
3074 pFarg
= pExpr
->x
.pList
;
3076 sqlite3ExplainPrintf(pOut
, "%sFUNCTION:%s(",
3077 op
==TK_AGG_FUNCTION
? "AGG_" : "",
3080 sqlite3ExplainExprList(pOut
, pFarg
);
3082 sqlite3ExplainPrintf(pOut
, ")");
3085 #ifndef SQLITE_OMIT_SUBQUERY
3087 sqlite3ExplainPrintf(pOut
, "EXISTS(");
3088 sqlite3ExplainSelect(pOut
, pExpr
->x
.pSelect
);
3089 sqlite3ExplainPrintf(pOut
,")");
3093 sqlite3ExplainPrintf(pOut
, "(");
3094 sqlite3ExplainSelect(pOut
, pExpr
->x
.pSelect
);
3095 sqlite3ExplainPrintf(pOut
, ")");
3099 sqlite3ExplainPrintf(pOut
, "IN(");
3100 sqlite3ExplainExpr(pOut
, pExpr
->pLeft
);
3101 sqlite3ExplainPrintf(pOut
, ",");
3102 if( ExprHasProperty(pExpr
, EP_xIsSelect
) ){
3103 sqlite3ExplainSelect(pOut
, pExpr
->x
.pSelect
);
3105 sqlite3ExplainExprList(pOut
, pExpr
->x
.pList
);
3107 sqlite3ExplainPrintf(pOut
, ")");
3110 #endif /* SQLITE_OMIT_SUBQUERY */
3113 ** x BETWEEN y AND z
3115 ** This is equivalent to
3119 ** X is stored in pExpr->pLeft.
3120 ** Y is stored in pExpr->pList->a[0].pExpr.
3121 ** Z is stored in pExpr->pList->a[1].pExpr.
3124 Expr
*pX
= pExpr
->pLeft
;
3125 Expr
*pY
= pExpr
->x
.pList
->a
[0].pExpr
;
3126 Expr
*pZ
= pExpr
->x
.pList
->a
[1].pExpr
;
3127 sqlite3ExplainPrintf(pOut
, "BETWEEN(");
3128 sqlite3ExplainExpr(pOut
, pX
);
3129 sqlite3ExplainPrintf(pOut
, ",");
3130 sqlite3ExplainExpr(pOut
, pY
);
3131 sqlite3ExplainPrintf(pOut
, ",");
3132 sqlite3ExplainExpr(pOut
, pZ
);
3133 sqlite3ExplainPrintf(pOut
, ")");
3137 /* If the opcode is TK_TRIGGER, then the expression is a reference
3138 ** to a column in the new.* or old.* pseudo-tables available to
3139 ** trigger programs. In this case Expr.iTable is set to 1 for the
3140 ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
3141 ** is set to the column of the pseudo-table to read, or to -1 to
3142 ** read the rowid field.
3144 sqlite3ExplainPrintf(pOut
, "%s(%d)",
3145 pExpr
->iTable
? "NEW" : "OLD", pExpr
->iColumn
);
3149 sqlite3ExplainPrintf(pOut
, "CASE(");
3150 sqlite3ExplainExpr(pOut
, pExpr
->pLeft
);
3151 sqlite3ExplainPrintf(pOut
, ",");
3152 sqlite3ExplainExprList(pOut
, pExpr
->x
.pList
);
3155 #ifndef SQLITE_OMIT_TRIGGER
3157 const char *zType
= "unk";
3158 switch( pExpr
->affinity
){
3159 case OE_Rollback
: zType
= "rollback"; break;
3160 case OE_Abort
: zType
= "abort"; break;
3161 case OE_Fail
: zType
= "fail"; break;
3162 case OE_Ignore
: zType
= "ignore"; break;
3164 sqlite3ExplainPrintf(pOut
, "RAISE-%s(%s)", zType
, pExpr
->u
.zToken
);
3170 sqlite3ExplainPrintf(pOut
,"%s(", zBinOp
);
3171 sqlite3ExplainExpr(pOut
, pExpr
->pLeft
);
3172 sqlite3ExplainPrintf(pOut
,",");
3173 sqlite3ExplainExpr(pOut
, pExpr
->pRight
);
3174 sqlite3ExplainPrintf(pOut
,")");
3176 sqlite3ExplainPrintf(pOut
,"%s(", zUniOp
);
3177 sqlite3ExplainExpr(pOut
, pExpr
->pLeft
);
3178 sqlite3ExplainPrintf(pOut
,")");
3181 #endif /* defined(SQLITE_ENABLE_TREE_EXPLAIN) */
3183 #if defined(SQLITE_ENABLE_TREE_EXPLAIN)
3185 ** Generate a human-readable explanation of an expression list.
3187 void sqlite3ExplainExprList(Vdbe
*pOut
, ExprList
*pList
){
3189 if( pList
==0 || pList
->nExpr
==0 ){
3190 sqlite3ExplainPrintf(pOut
, "(empty-list)");
3192 }else if( pList
->nExpr
==1 ){
3193 sqlite3ExplainExpr(pOut
, pList
->a
[0].pExpr
);
3195 sqlite3ExplainPush(pOut
);
3196 for(i
=0; i
<pList
->nExpr
; i
++){
3197 sqlite3ExplainPrintf(pOut
, "item[%d] = ", i
);
3198 sqlite3ExplainPush(pOut
);
3199 sqlite3ExplainExpr(pOut
, pList
->a
[i
].pExpr
);
3200 sqlite3ExplainPop(pOut
);
3201 if( i
<pList
->nExpr
-1 ){
3202 sqlite3ExplainNL(pOut
);
3205 sqlite3ExplainPop(pOut
);
3208 #endif /* SQLITE_DEBUG */
3211 ** Return TRUE if pExpr is an constant expression that is appropriate
3212 ** for factoring out of a loop. Appropriate expressions are:
3214 ** * Any expression that evaluates to two or more opcodes.
3216 ** * Any OP_Integer, OP_Real, OP_String, OP_Blob, OP_Null,
3217 ** or OP_Variable that does not need to be placed in a
3218 ** specific register.
3220 ** There is no point in factoring out single-instruction constant
3221 ** expressions that need to be placed in a particular register.
3222 ** We could factor them out, but then we would end up adding an
3223 ** OP_SCopy instruction to move the value into the correct register
3224 ** later. We might as well just use the original instruction and
3225 ** avoid the OP_SCopy.
3227 static int isAppropriateForFactoring(Expr
*p
){
3228 if( !sqlite3ExprIsConstantNotJoin(p
) ){
3229 return 0; /* Only constant expressions are appropriate for factoring */
3231 if( (p
->flags
& EP_FixedDest
)==0 ){
3232 return 1; /* Any constant without a fixed destination is appropriate */
3234 while( p
->op
==TK_UPLUS
) p
= p
->pLeft
;
3236 #ifndef SQLITE_OMIT_BLOB_LITERAL
3244 testcase( p
->op
==TK_BLOB
);
3245 testcase( p
->op
==TK_VARIABLE
);
3246 testcase( p
->op
==TK_INTEGER
);
3247 testcase( p
->op
==TK_FLOAT
);
3248 testcase( p
->op
==TK_NULL
);
3249 testcase( p
->op
==TK_STRING
);
3250 /* Single-instruction constants with a fixed destination are
3251 ** better done in-line. If we factor them, they will just end
3252 ** up generating an OP_SCopy to move the value to the destination
3257 if( p
->pLeft
->op
==TK_FLOAT
|| p
->pLeft
->op
==TK_INTEGER
){
3270 ** If pExpr is a constant expression that is appropriate for
3271 ** factoring out of a loop, then evaluate the expression
3272 ** into a register and convert the expression into a TK_REGISTER
3275 static int evalConstExpr(Walker
*pWalker
, Expr
*pExpr
){
3276 Parse
*pParse
= pWalker
->pParse
;
3277 switch( pExpr
->op
){
3283 case TK_AGG_FUNCTION
:
3284 case TK_CONST_FUNC
: {
3285 /* The arguments to a function have a fixed destination.
3286 ** Mark them this way to avoid generated unneeded OP_SCopy
3289 ExprList
*pList
= pExpr
->x
.pList
;
3290 assert( !ExprHasProperty(pExpr
, EP_xIsSelect
) );
3292 int i
= pList
->nExpr
;
3293 struct ExprList_item
*pItem
= pList
->a
;
3294 for(; i
>0; i
--, pItem
++){
3295 if( ALWAYS(pItem
->pExpr
) ) pItem
->pExpr
->flags
|= EP_FixedDest
;
3301 if( isAppropriateForFactoring(pExpr
) ){
3302 int r1
= ++pParse
->nMem
;
3304 r2
= sqlite3ExprCodeTarget(pParse
, pExpr
, r1
);
3305 if( NEVER(r1
!=r2
) ) sqlite3ReleaseTempReg(pParse
, r1
);
3306 pExpr
->op2
= pExpr
->op
;
3307 pExpr
->op
= TK_REGISTER
;
3311 return WRC_Continue
;
3315 ** Preevaluate constant subexpressions within pExpr and store the
3316 ** results in registers. Modify pExpr so that the constant subexpresions
3317 ** are TK_REGISTER opcodes that refer to the precomputed values.
3319 ** This routine is a no-op if the jump to the cookie-check code has
3320 ** already occur. Since the cookie-check jump is generated prior to
3321 ** any other serious processing, this check ensures that there is no
3322 ** way to accidently bypass the constant initializations.
3324 ** This routine is also a no-op if the SQLITE_FactorOutConst optimization
3325 ** is disabled via the sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS)
3326 ** interface. This allows test logic to verify that the same answer is
3327 ** obtained for queries regardless of whether or not constants are
3328 ** precomputed into registers or if they are inserted in-line.
3330 void sqlite3ExprCodeConstants(Parse
*pParse
, Expr
*pExpr
){
3332 if( pParse
->cookieGoto
) return;
3333 if( (pParse
->db
->flags
& SQLITE_FactorOutConst
)!=0 ) return;
3334 w
.xExprCallback
= evalConstExpr
;
3335 w
.xSelectCallback
= 0;
3337 sqlite3WalkExpr(&w
, pExpr
);
3342 ** Generate code that pushes the value of every element of the given
3343 ** expression list into a sequence of registers beginning at target.
3345 ** Return the number of elements evaluated.
3347 int sqlite3ExprCodeExprList(
3348 Parse
*pParse
, /* Parsing context */
3349 ExprList
*pList
, /* The expression list to be coded */
3350 int target
, /* Where to write results */
3351 int doHardCopy
/* Make a hard copy of every element */
3353 struct ExprList_item
*pItem
;
3357 assert( pParse
->pVdbe
!=0 ); /* Never gets this far otherwise */
3359 for(pItem
=pList
->a
, i
=0; i
<n
; i
++, pItem
++){
3360 Expr
*pExpr
= pItem
->pExpr
;
3361 int inReg
= sqlite3ExprCodeTarget(pParse
, pExpr
, target
+i
);
3362 if( inReg
!=target
+i
){
3363 sqlite3VdbeAddOp2(pParse
->pVdbe
, doHardCopy
? OP_Copy
: OP_SCopy
,
3371 ** Generate code for a BETWEEN operator.
3373 ** x BETWEEN y AND z
3375 ** The above is equivalent to
3379 ** Code it as such, taking care to do the common subexpression
3380 ** elementation of x.
3382 static void exprCodeBetween(
3383 Parse
*pParse
, /* Parsing and code generating context */
3384 Expr
*pExpr
, /* The BETWEEN expression */
3385 int dest
, /* Jump here if the jump is taken */
3386 int jumpIfTrue
, /* Take the jump if the BETWEEN is true */
3387 int jumpIfNull
/* Take the jump if the BETWEEN is NULL */
3389 Expr exprAnd
; /* The AND operator in x>=y AND x<=z */
3390 Expr compLeft
; /* The x>=y term */
3391 Expr compRight
; /* The x<=z term */
3392 Expr exprX
; /* The x subexpression */
3393 int regFree1
= 0; /* Temporary use register */
3395 assert( !ExprHasProperty(pExpr
, EP_xIsSelect
) );
3396 exprX
= *pExpr
->pLeft
;
3397 exprAnd
.op
= TK_AND
;
3398 exprAnd
.pLeft
= &compLeft
;
3399 exprAnd
.pRight
= &compRight
;
3400 compLeft
.op
= TK_GE
;
3401 compLeft
.pLeft
= &exprX
;
3402 compLeft
.pRight
= pExpr
->x
.pList
->a
[0].pExpr
;
3403 compRight
.op
= TK_LE
;
3404 compRight
.pLeft
= &exprX
;
3405 compRight
.pRight
= pExpr
->x
.pList
->a
[1].pExpr
;
3406 exprX
.iTable
= sqlite3ExprCodeTemp(pParse
, &exprX
, ®Free1
);
3407 exprX
.op
= TK_REGISTER
;
3409 sqlite3ExprIfTrue(pParse
, &exprAnd
, dest
, jumpIfNull
);
3411 sqlite3ExprIfFalse(pParse
, &exprAnd
, dest
, jumpIfNull
);
3413 sqlite3ReleaseTempReg(pParse
, regFree1
);
3415 /* Ensure adequate test coverage */
3416 testcase( jumpIfTrue
==0 && jumpIfNull
==0 && regFree1
==0 );
3417 testcase( jumpIfTrue
==0 && jumpIfNull
==0 && regFree1
!=0 );
3418 testcase( jumpIfTrue
==0 && jumpIfNull
!=0 && regFree1
==0 );
3419 testcase( jumpIfTrue
==0 && jumpIfNull
!=0 && regFree1
!=0 );
3420 testcase( jumpIfTrue
!=0 && jumpIfNull
==0 && regFree1
==0 );
3421 testcase( jumpIfTrue
!=0 && jumpIfNull
==0 && regFree1
!=0 );
3422 testcase( jumpIfTrue
!=0 && jumpIfNull
!=0 && regFree1
==0 );
3423 testcase( jumpIfTrue
!=0 && jumpIfNull
!=0 && regFree1
!=0 );
3427 ** Generate code for a boolean expression such that a jump is made
3428 ** to the label "dest" if the expression is true but execution
3429 ** continues straight thru if the expression is false.
3431 ** If the expression evaluates to NULL (neither true nor false), then
3432 ** take the jump if the jumpIfNull flag is SQLITE_JUMPIFNULL.
3434 ** This code depends on the fact that certain token values (ex: TK_EQ)
3435 ** are the same as opcode values (ex: OP_Eq) that implement the corresponding
3436 ** operation. Special comments in vdbe.c and the mkopcodeh.awk script in
3437 ** the make process cause these values to align. Assert()s in the code
3438 ** below verify that the numbers are aligned correctly.
3440 void sqlite3ExprIfTrue(Parse
*pParse
, Expr
*pExpr
, int dest
, int jumpIfNull
){
3441 Vdbe
*v
= pParse
->pVdbe
;
3447 assert( jumpIfNull
==SQLITE_JUMPIFNULL
|| jumpIfNull
==0 );
3448 if( NEVER(v
==0) ) return; /* Existance of VDBE checked by caller */
3449 if( NEVER(pExpr
==0) ) return; /* No way this can happen */
3453 int d2
= sqlite3VdbeMakeLabel(v
);
3454 testcase( jumpIfNull
==0 );
3455 sqlite3ExprCachePush(pParse
);
3456 sqlite3ExprIfFalse(pParse
, pExpr
->pLeft
, d2
,jumpIfNull
^SQLITE_JUMPIFNULL
);
3457 sqlite3ExprIfTrue(pParse
, pExpr
->pRight
, dest
, jumpIfNull
);
3458 sqlite3VdbeResolveLabel(v
, d2
);
3459 sqlite3ExprCachePop(pParse
, 1);
3463 testcase( jumpIfNull
==0 );
3464 sqlite3ExprIfTrue(pParse
, pExpr
->pLeft
, dest
, jumpIfNull
);
3465 sqlite3ExprIfTrue(pParse
, pExpr
->pRight
, dest
, jumpIfNull
);
3469 testcase( jumpIfNull
==0 );
3470 sqlite3ExprIfFalse(pParse
, pExpr
->pLeft
, dest
, jumpIfNull
);
3479 assert( TK_LT
==OP_Lt
);
3480 assert( TK_LE
==OP_Le
);
3481 assert( TK_GT
==OP_Gt
);
3482 assert( TK_GE
==OP_Ge
);
3483 assert( TK_EQ
==OP_Eq
);
3484 assert( TK_NE
==OP_Ne
);
3485 testcase( op
==TK_LT
);
3486 testcase( op
==TK_LE
);
3487 testcase( op
==TK_GT
);
3488 testcase( op
==TK_GE
);
3489 testcase( op
==TK_EQ
);
3490 testcase( op
==TK_NE
);
3491 testcase( jumpIfNull
==0 );
3492 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free1
);
3493 r2
= sqlite3ExprCodeTemp(pParse
, pExpr
->pRight
, ®Free2
);
3494 codeCompare(pParse
, pExpr
->pLeft
, pExpr
->pRight
, op
,
3495 r1
, r2
, dest
, jumpIfNull
);
3496 testcase( regFree1
==0 );
3497 testcase( regFree2
==0 );
3502 testcase( op
==TK_IS
);
3503 testcase( op
==TK_ISNOT
);
3504 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free1
);
3505 r2
= sqlite3ExprCodeTemp(pParse
, pExpr
->pRight
, ®Free2
);
3506 op
= (op
==TK_IS
) ? TK_EQ
: TK_NE
;
3507 codeCompare(pParse
, pExpr
->pLeft
, pExpr
->pRight
, op
,
3508 r1
, r2
, dest
, SQLITE_NULLEQ
);
3509 testcase( regFree1
==0 );
3510 testcase( regFree2
==0 );
3515 assert( TK_ISNULL
==OP_IsNull
);
3516 assert( TK_NOTNULL
==OP_NotNull
);
3517 testcase( op
==TK_ISNULL
);
3518 testcase( op
==TK_NOTNULL
);
3519 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free1
);
3520 sqlite3VdbeAddOp2(v
, op
, r1
, dest
);
3521 testcase( regFree1
==0 );
3525 testcase( jumpIfNull
==0 );
3526 exprCodeBetween(pParse
, pExpr
, dest
, 1, jumpIfNull
);
3529 #ifndef SQLITE_OMIT_SUBQUERY
3531 int destIfFalse
= sqlite3VdbeMakeLabel(v
);
3532 int destIfNull
= jumpIfNull
? dest
: destIfFalse
;
3533 sqlite3ExprCodeIN(pParse
, pExpr
, destIfFalse
, destIfNull
);
3534 sqlite3VdbeAddOp2(v
, OP_Goto
, 0, dest
);
3535 sqlite3VdbeResolveLabel(v
, destIfFalse
);
3540 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
, ®Free1
);
3541 sqlite3VdbeAddOp3(v
, OP_If
, r1
, dest
, jumpIfNull
!=0);
3542 testcase( regFree1
==0 );
3543 testcase( jumpIfNull
==0 );
3547 sqlite3ReleaseTempReg(pParse
, regFree1
);
3548 sqlite3ReleaseTempReg(pParse
, regFree2
);
3552 ** Generate code for a boolean expression such that a jump is made
3553 ** to the label "dest" if the expression is false but execution
3554 ** continues straight thru if the expression is true.
3556 ** If the expression evaluates to NULL (neither true nor false) then
3557 ** jump if jumpIfNull is SQLITE_JUMPIFNULL or fall through if jumpIfNull
3560 void sqlite3ExprIfFalse(Parse
*pParse
, Expr
*pExpr
, int dest
, int jumpIfNull
){
3561 Vdbe
*v
= pParse
->pVdbe
;
3567 assert( jumpIfNull
==SQLITE_JUMPIFNULL
|| jumpIfNull
==0 );
3568 if( NEVER(v
==0) ) return; /* Existance of VDBE checked by caller */
3569 if( pExpr
==0 ) return;
3571 /* The value of pExpr->op and op are related as follows:
3574 ** --------- ----------
3575 ** TK_ISNULL OP_NotNull
3576 ** TK_NOTNULL OP_IsNull
3584 ** For other values of pExpr->op, op is undefined and unused.
3585 ** The value of TK_ and OP_ constants are arranged such that we
3586 ** can compute the mapping above using the following expression.
3587 ** Assert()s verify that the computation is correct.
3589 op
= ((pExpr
->op
+(TK_ISNULL
&1))^1)-(TK_ISNULL
&1);
3591 /* Verify correct alignment of TK_ and OP_ constants
3593 assert( pExpr
->op
!=TK_ISNULL
|| op
==OP_NotNull
);
3594 assert( pExpr
->op
!=TK_NOTNULL
|| op
==OP_IsNull
);
3595 assert( pExpr
->op
!=TK_NE
|| op
==OP_Eq
);
3596 assert( pExpr
->op
!=TK_EQ
|| op
==OP_Ne
);
3597 assert( pExpr
->op
!=TK_LT
|| op
==OP_Ge
);
3598 assert( pExpr
->op
!=TK_LE
|| op
==OP_Gt
);
3599 assert( pExpr
->op
!=TK_GT
|| op
==OP_Le
);
3600 assert( pExpr
->op
!=TK_GE
|| op
==OP_Lt
);
3602 switch( pExpr
->op
){
3604 testcase( jumpIfNull
==0 );
3605 sqlite3ExprIfFalse(pParse
, pExpr
->pLeft
, dest
, jumpIfNull
);
3606 sqlite3ExprIfFalse(pParse
, pExpr
->pRight
, dest
, jumpIfNull
);
3610 int d2
= sqlite3VdbeMakeLabel(v
);
3611 testcase( jumpIfNull
==0 );
3612 sqlite3ExprCachePush(pParse
);
3613 sqlite3ExprIfTrue(pParse
, pExpr
->pLeft
, d2
, jumpIfNull
^SQLITE_JUMPIFNULL
);
3614 sqlite3ExprIfFalse(pParse
, pExpr
->pRight
, dest
, jumpIfNull
);
3615 sqlite3VdbeResolveLabel(v
, d2
);
3616 sqlite3ExprCachePop(pParse
, 1);
3620 testcase( jumpIfNull
==0 );
3621 sqlite3ExprIfTrue(pParse
, pExpr
->pLeft
, dest
, jumpIfNull
);
3630 testcase( op
==TK_LT
);
3631 testcase( op
==TK_LE
);
3632 testcase( op
==TK_GT
);
3633 testcase( op
==TK_GE
);
3634 testcase( op
==TK_EQ
);
3635 testcase( op
==TK_NE
);
3636 testcase( jumpIfNull
==0 );
3637 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free1
);
3638 r2
= sqlite3ExprCodeTemp(pParse
, pExpr
->pRight
, ®Free2
);
3639 codeCompare(pParse
, pExpr
->pLeft
, pExpr
->pRight
, op
,
3640 r1
, r2
, dest
, jumpIfNull
);
3641 testcase( regFree1
==0 );
3642 testcase( regFree2
==0 );
3647 testcase( pExpr
->op
==TK_IS
);
3648 testcase( pExpr
->op
==TK_ISNOT
);
3649 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free1
);
3650 r2
= sqlite3ExprCodeTemp(pParse
, pExpr
->pRight
, ®Free2
);
3651 op
= (pExpr
->op
==TK_IS
) ? TK_NE
: TK_EQ
;
3652 codeCompare(pParse
, pExpr
->pLeft
, pExpr
->pRight
, op
,
3653 r1
, r2
, dest
, SQLITE_NULLEQ
);
3654 testcase( regFree1
==0 );
3655 testcase( regFree2
==0 );
3660 testcase( op
==TK_ISNULL
);
3661 testcase( op
==TK_NOTNULL
);
3662 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free1
);
3663 sqlite3VdbeAddOp2(v
, op
, r1
, dest
);
3664 testcase( regFree1
==0 );
3668 testcase( jumpIfNull
==0 );
3669 exprCodeBetween(pParse
, pExpr
, dest
, 0, jumpIfNull
);
3672 #ifndef SQLITE_OMIT_SUBQUERY
3675 sqlite3ExprCodeIN(pParse
, pExpr
, dest
, dest
);
3677 int destIfNull
= sqlite3VdbeMakeLabel(v
);
3678 sqlite3ExprCodeIN(pParse
, pExpr
, dest
, destIfNull
);
3679 sqlite3VdbeResolveLabel(v
, destIfNull
);
3685 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
, ®Free1
);
3686 sqlite3VdbeAddOp3(v
, OP_IfNot
, r1
, dest
, jumpIfNull
!=0);
3687 testcase( regFree1
==0 );
3688 testcase( jumpIfNull
==0 );
3692 sqlite3ReleaseTempReg(pParse
, regFree1
);
3693 sqlite3ReleaseTempReg(pParse
, regFree2
);
3697 ** Do a deep comparison of two expression trees. Return 0 if the two
3698 ** expressions are completely identical. Return 1 if they differ only
3699 ** by a COLLATE operator at the top level. Return 2 if there are differences
3700 ** other than the top-level COLLATE operator.
3702 ** Sometimes this routine will return 2 even if the two expressions
3703 ** really are equivalent. If we cannot prove that the expressions are
3704 ** identical, we return 2 just to be safe. So if this routine
3705 ** returns 2, then you do not really know for certain if the two
3706 ** expressions are the same. But if you get a 0 or 1 return, then you
3707 ** can be sure the expressions are the same. In the places where
3708 ** this routine is used, it does not hurt to get an extra 2 - that
3709 ** just might result in some slightly slower code. But returning
3710 ** an incorrect 0 or 1 could lead to a malfunction.
3712 int sqlite3ExprCompare(Expr
*pA
, Expr
*pB
){
3714 return pB
==pA
? 0 : 2;
3716 assert( !ExprHasAnyProperty(pA
, EP_TokenOnly
|EP_Reduced
) );
3717 assert( !ExprHasAnyProperty(pB
, EP_TokenOnly
|EP_Reduced
) );
3718 if( ExprHasProperty(pA
, EP_xIsSelect
) || ExprHasProperty(pB
, EP_xIsSelect
) ){
3721 if( (pA
->flags
& EP_Distinct
)!=(pB
->flags
& EP_Distinct
) ) return 2;
3722 if( pA
->op
!=pB
->op
) return 2;
3723 if( sqlite3ExprCompare(pA
->pLeft
, pB
->pLeft
) ) return 2;
3724 if( sqlite3ExprCompare(pA
->pRight
, pB
->pRight
) ) return 2;
3725 if( sqlite3ExprListCompare(pA
->x
.pList
, pB
->x
.pList
) ) return 2;
3726 if( pA
->iTable
!=pB
->iTable
|| pA
->iColumn
!=pB
->iColumn
) return 2;
3727 if( ExprHasProperty(pA
, EP_IntValue
) ){
3728 if( !ExprHasProperty(pB
, EP_IntValue
) || pA
->u
.iValue
!=pB
->u
.iValue
){
3731 }else if( pA
->op
!=TK_COLUMN
&& pA
->u
.zToken
){
3732 if( ExprHasProperty(pB
, EP_IntValue
) || NEVER(pB
->u
.zToken
==0) ) return 2;
3733 if( strcmp(pA
->u
.zToken
,pB
->u
.zToken
)!=0 ){
3737 if( (pA
->flags
& EP_ExpCollate
)!=(pB
->flags
& EP_ExpCollate
) ) return 1;
3738 if( (pA
->flags
& EP_ExpCollate
)!=0 && pA
->pColl
!=pB
->pColl
) return 2;
3743 ** Compare two ExprList objects. Return 0 if they are identical and
3744 ** non-zero if they differ in any way.
3746 ** This routine might return non-zero for equivalent ExprLists. The
3747 ** only consequence will be disabled optimizations. But this routine
3748 ** must never return 0 if the two ExprList objects are different, or
3749 ** a malfunction will result.
3751 ** Two NULL pointers are considered to be the same. But a NULL pointer
3752 ** always differs from a non-NULL pointer.
3754 int sqlite3ExprListCompare(ExprList
*pA
, ExprList
*pB
){
3756 if( pA
==0 && pB
==0 ) return 0;
3757 if( pA
==0 || pB
==0 ) return 1;
3758 if( pA
->nExpr
!=pB
->nExpr
) return 1;
3759 for(i
=0; i
<pA
->nExpr
; i
++){
3760 Expr
*pExprA
= pA
->a
[i
].pExpr
;
3761 Expr
*pExprB
= pB
->a
[i
].pExpr
;
3762 if( pA
->a
[i
].sortOrder
!=pB
->a
[i
].sortOrder
) return 1;
3763 if( sqlite3ExprCompare(pExprA
, pExprB
) ) return 1;
3769 ** Add a new element to the pAggInfo->aCol[] array. Return the index of
3770 ** the new element. Return a negative number if malloc fails.
3772 static int addAggInfoColumn(sqlite3
*db
, AggInfo
*pInfo
){
3774 pInfo
->aCol
= sqlite3ArrayAllocate(
3777 sizeof(pInfo
->aCol
[0]),
3780 &pInfo
->nColumnAlloc
,
3787 ** Add a new element to the pAggInfo->aFunc[] array. Return the index of
3788 ** the new element. Return a negative number if malloc fails.
3790 static int addAggInfoFunc(sqlite3
*db
, AggInfo
*pInfo
){
3792 pInfo
->aFunc
= sqlite3ArrayAllocate(
3795 sizeof(pInfo
->aFunc
[0]),
3805 ** This is the xExprCallback for a tree walker. It is used to
3806 ** implement sqlite3ExprAnalyzeAggregates(). See sqlite3ExprAnalyzeAggregates
3807 ** for additional information.
3809 static int analyzeAggregate(Walker
*pWalker
, Expr
*pExpr
){
3811 NameContext
*pNC
= pWalker
->u
.pNC
;
3812 Parse
*pParse
= pNC
->pParse
;
3813 SrcList
*pSrcList
= pNC
->pSrcList
;
3814 AggInfo
*pAggInfo
= pNC
->pAggInfo
;
3816 switch( pExpr
->op
){
3819 testcase( pExpr
->op
==TK_AGG_COLUMN
);
3820 testcase( pExpr
->op
==TK_COLUMN
);
3821 /* Check to see if the column is in one of the tables in the FROM
3822 ** clause of the aggregate query */
3823 if( ALWAYS(pSrcList
!=0) ){
3824 struct SrcList_item
*pItem
= pSrcList
->a
;
3825 for(i
=0; i
<pSrcList
->nSrc
; i
++, pItem
++){
3826 struct AggInfo_col
*pCol
;
3827 assert( !ExprHasAnyProperty(pExpr
, EP_TokenOnly
|EP_Reduced
) );
3828 if( pExpr
->iTable
==pItem
->iCursor
){
3829 /* If we reach this point, it means that pExpr refers to a table
3830 ** that is in the FROM clause of the aggregate query.
3832 ** Make an entry for the column in pAggInfo->aCol[] if there
3833 ** is not an entry there already.
3836 pCol
= pAggInfo
->aCol
;
3837 for(k
=0; k
<pAggInfo
->nColumn
; k
++, pCol
++){
3838 if( pCol
->iTable
==pExpr
->iTable
&&
3839 pCol
->iColumn
==pExpr
->iColumn
){
3843 if( (k
>=pAggInfo
->nColumn
)
3844 && (k
= addAggInfoColumn(pParse
->db
, pAggInfo
))>=0
3846 pCol
= &pAggInfo
->aCol
[k
];
3847 pCol
->pTab
= pExpr
->pTab
;
3848 pCol
->iTable
= pExpr
->iTable
;
3849 pCol
->iColumn
= pExpr
->iColumn
;
3850 pCol
->iMem
= ++pParse
->nMem
;
3851 pCol
->iSorterColumn
= -1;
3852 pCol
->pExpr
= pExpr
;
3853 if( pAggInfo
->pGroupBy
){
3855 ExprList
*pGB
= pAggInfo
->pGroupBy
;
3856 struct ExprList_item
*pTerm
= pGB
->a
;
3858 for(j
=0; j
<n
; j
++, pTerm
++){
3859 Expr
*pE
= pTerm
->pExpr
;
3860 if( pE
->op
==TK_COLUMN
&& pE
->iTable
==pExpr
->iTable
&&
3861 pE
->iColumn
==pExpr
->iColumn
){
3862 pCol
->iSorterColumn
= j
;
3867 if( pCol
->iSorterColumn
<0 ){
3868 pCol
->iSorterColumn
= pAggInfo
->nSortingColumn
++;
3871 /* There is now an entry for pExpr in pAggInfo->aCol[] (either
3872 ** because it was there before or because we just created it).
3873 ** Convert the pExpr to be a TK_AGG_COLUMN referring to that
3874 ** pAggInfo->aCol[] entry.
3876 ExprSetIrreducible(pExpr
);
3877 pExpr
->pAggInfo
= pAggInfo
;
3878 pExpr
->op
= TK_AGG_COLUMN
;
3879 pExpr
->iAgg
= (i16
)k
;
3881 } /* endif pExpr->iTable==pItem->iCursor */
3882 } /* end loop over pSrcList */
3886 case TK_AGG_FUNCTION
: {
3887 /* The pNC->nDepth==0 test causes aggregate functions in subqueries
3889 if( pNC
->nDepth
==0 ){
3890 /* Check to see if pExpr is a duplicate of another aggregate
3891 ** function that is already in the pAggInfo structure
3893 struct AggInfo_func
*pItem
= pAggInfo
->aFunc
;
3894 for(i
=0; i
<pAggInfo
->nFunc
; i
++, pItem
++){
3895 if( sqlite3ExprCompare(pItem
->pExpr
, pExpr
)==0 ){
3899 if( i
>=pAggInfo
->nFunc
){
3900 /* pExpr is original. Make a new entry in pAggInfo->aFunc[]
3902 u8 enc
= ENC(pParse
->db
);
3903 i
= addAggInfoFunc(pParse
->db
, pAggInfo
);
3905 assert( !ExprHasProperty(pExpr
, EP_xIsSelect
) );
3906 pItem
= &pAggInfo
->aFunc
[i
];
3907 pItem
->pExpr
= pExpr
;
3908 pItem
->iMem
= ++pParse
->nMem
;
3909 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
3910 pItem
->pFunc
= sqlite3FindFunction(pParse
->db
,
3911 pExpr
->u
.zToken
, sqlite3Strlen30(pExpr
->u
.zToken
),
3912 pExpr
->x
.pList
? pExpr
->x
.pList
->nExpr
: 0, enc
, 0);
3913 if( pExpr
->flags
& EP_Distinct
){
3914 pItem
->iDistinct
= pParse
->nTab
++;
3916 pItem
->iDistinct
= -1;
3920 /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry
3922 assert( !ExprHasAnyProperty(pExpr
, EP_TokenOnly
|EP_Reduced
) );
3923 ExprSetIrreducible(pExpr
);
3924 pExpr
->iAgg
= (i16
)i
;
3925 pExpr
->pAggInfo
= pAggInfo
;
3930 return WRC_Continue
;
3932 static int analyzeAggregatesInSelect(Walker
*pWalker
, Select
*pSelect
){
3933 NameContext
*pNC
= pWalker
->u
.pNC
;
3934 if( pNC
->nDepth
==0 ){
3936 sqlite3WalkSelect(pWalker
, pSelect
);
3940 return WRC_Continue
;
3945 ** Analyze the given expression looking for aggregate functions and
3946 ** for variables that need to be added to the pParse->aAgg[] array.
3947 ** Make additional entries to the pParse->aAgg[] array as necessary.
3949 ** This routine should only be called after the expression has been
3950 ** analyzed by sqlite3ResolveExprNames().
3952 void sqlite3ExprAnalyzeAggregates(NameContext
*pNC
, Expr
*pExpr
){
3954 w
.xExprCallback
= analyzeAggregate
;
3955 w
.xSelectCallback
= analyzeAggregatesInSelect
;
3957 assert( pNC
->pSrcList
!=0 );
3958 sqlite3WalkExpr(&w
, pExpr
);
3962 ** Call sqlite3ExprAnalyzeAggregates() for every expression in an
3963 ** expression list. Return the number of errors.
3965 ** If an error is found, the analysis is cut short.
3967 void sqlite3ExprAnalyzeAggList(NameContext
*pNC
, ExprList
*pList
){
3968 struct ExprList_item
*pItem
;
3971 for(pItem
=pList
->a
, i
=0; i
<pList
->nExpr
; i
++, pItem
++){
3972 sqlite3ExprAnalyzeAggregates(pNC
, pItem
->pExpr
);
3978 ** Allocate a single new register for use to hold some intermediate result.
3980 int sqlite3GetTempReg(Parse
*pParse
){
3981 if( pParse
->nTempReg
==0 ){
3982 return ++pParse
->nMem
;
3984 return pParse
->aTempReg
[--pParse
->nTempReg
];
3988 ** Deallocate a register, making available for reuse for some other
3991 ** If a register is currently being used by the column cache, then
3992 ** the dallocation is deferred until the column cache line that uses
3993 ** the register becomes stale.
3995 void sqlite3ReleaseTempReg(Parse
*pParse
, int iReg
){
3996 if( iReg
&& pParse
->nTempReg
<ArraySize(pParse
->aTempReg
) ){
3998 struct yColCache
*p
;
3999 for(i
=0, p
=pParse
->aColCache
; i
<SQLITE_N_COLCACHE
; i
++, p
++){
4000 if( p
->iReg
==iReg
){
4005 pParse
->aTempReg
[pParse
->nTempReg
++] = iReg
;
4010 ** Allocate or deallocate a block of nReg consecutive registers
4012 int sqlite3GetTempRange(Parse
*pParse
, int nReg
){
4014 i
= pParse
->iRangeReg
;
4015 n
= pParse
->nRangeReg
;
4017 assert( !usedAsColumnCache(pParse
, i
, i
+n
-1) );
4018 pParse
->iRangeReg
+= nReg
;
4019 pParse
->nRangeReg
-= nReg
;
4022 pParse
->nMem
+= nReg
;
4026 void sqlite3ReleaseTempRange(Parse
*pParse
, int iReg
, int nReg
){
4027 sqlite3ExprCacheRemove(pParse
, iReg
, nReg
);
4028 if( nReg
>pParse
->nRangeReg
){
4029 pParse
->nRangeReg
= nReg
;
4030 pParse
->iRangeReg
= iReg
;
4035 ** Mark all temporary registers as being unavailable for reuse.
4037 void sqlite3ClearTempRegCache(Parse
*pParse
){
4038 pParse
->nTempReg
= 0;
4039 pParse
->nRangeReg
= 0;