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"
17 /* Forward declarations */
18 static void exprCodeBetween(Parse
*,Expr
*,int,void(*)(Parse
*,Expr
*,int,int),int);
19 static int exprCodeVector(Parse
*pParse
, Expr
*p
, int *piToFree
);
22 ** Return the affinity character for a single column of a table.
24 char sqlite3TableColumnAffinity(const Table
*pTab
, int iCol
){
25 if( iCol
<0 || NEVER(iCol
>=pTab
->nCol
) ) return SQLITE_AFF_INTEGER
;
26 return pTab
->aCol
[iCol
].affinity
;
30 ** Return the 'affinity' of the expression pExpr if any.
32 ** If pExpr is a column, a reference to a column via an 'AS' alias,
33 ** or a sub-select with a column as the return value, then the
34 ** affinity of that column is returned. Otherwise, 0x00 is returned,
35 ** indicating no affinity for the expression.
37 ** i.e. the WHERE clause expressions in the following statements all
40 ** CREATE TABLE t1(a);
41 ** SELECT * FROM t1 WHERE a;
42 ** SELECT a AS b FROM t1 WHERE b;
43 ** SELECT * FROM t1 WHERE (select a from t1);
45 char sqlite3ExprAffinity(const Expr
*pExpr
){
47 while( ExprHasProperty(pExpr
, EP_Skip
|EP_IfNullRow
) ){
48 assert( pExpr
->op
==TK_COLLATE
49 || pExpr
->op
==TK_IF_NULL_ROW
50 || (pExpr
->op
==TK_REGISTER
&& pExpr
->op2
==TK_IF_NULL_ROW
) );
55 if( op
==TK_REGISTER
) op
= pExpr
->op2
;
56 if( op
==TK_COLUMN
|| op
==TK_AGG_COLUMN
){
57 assert( ExprUseYTab(pExpr
) );
59 return sqlite3TableColumnAffinity(pExpr
->y
.pTab
, pExpr
->iColumn
);
63 assert( ExprUseXSelect(pExpr
) );
64 assert( pExpr
->x
.pSelect
!=0 );
65 assert( pExpr
->x
.pSelect
->pEList
!=0 );
66 assert( pExpr
->x
.pSelect
->pEList
->a
[0].pExpr
!=0 );
67 return sqlite3ExprAffinity(pExpr
->x
.pSelect
->pEList
->a
[0].pExpr
);
69 #ifndef SQLITE_OMIT_CAST
71 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
72 return sqlite3AffinityType(pExpr
->u
.zToken
, 0);
75 if( op
==TK_SELECT_COLUMN
){
76 assert( pExpr
->pLeft
!=0 && ExprUseXSelect(pExpr
->pLeft
) );
77 assert( pExpr
->iColumn
< pExpr
->iTable
);
78 assert( pExpr
->iTable
==pExpr
->pLeft
->x
.pSelect
->pEList
->nExpr
);
79 return sqlite3ExprAffinity(
80 pExpr
->pLeft
->x
.pSelect
->pEList
->a
[pExpr
->iColumn
].pExpr
84 assert( ExprUseXList(pExpr
) );
85 return sqlite3ExprAffinity(pExpr
->x
.pList
->a
[0].pExpr
);
87 return pExpr
->affExpr
;
91 ** Set the collating sequence for expression pExpr to be the collating
92 ** sequence named by pToken. Return a pointer to a new Expr node that
93 ** implements the COLLATE operator.
95 ** If a memory allocation error occurs, that fact is recorded in pParse->db
96 ** and the pExpr parameter is returned unchanged.
98 Expr
*sqlite3ExprAddCollateToken(
99 const Parse
*pParse
, /* Parsing context */
100 Expr
*pExpr
, /* Add the "COLLATE" clause to this expression */
101 const Token
*pCollName
, /* Name of collating sequence */
102 int dequote
/* True to dequote pCollName */
104 if( pCollName
->n
>0 ){
105 Expr
*pNew
= sqlite3ExprAlloc(pParse
->db
, TK_COLLATE
, pCollName
, dequote
);
108 pNew
->flags
|= EP_Collate
|EP_Skip
;
114 Expr
*sqlite3ExprAddCollateString(
115 const Parse
*pParse
, /* Parsing context */
116 Expr
*pExpr
, /* Add the "COLLATE" clause to this expression */
117 const char *zC
/* The collating sequence name */
121 sqlite3TokenInit(&s
, (char*)zC
);
122 return sqlite3ExprAddCollateToken(pParse
, pExpr
, &s
, 0);
126 ** Skip over any TK_COLLATE operators.
128 Expr
*sqlite3ExprSkipCollate(Expr
*pExpr
){
129 while( pExpr
&& ExprHasProperty(pExpr
, EP_Skip
) ){
130 assert( pExpr
->op
==TK_COLLATE
);
131 pExpr
= pExpr
->pLeft
;
137 ** Skip over any TK_COLLATE operators and/or any unlikely()
138 ** or likelihood() or likely() functions at the root of an
141 Expr
*sqlite3ExprSkipCollateAndLikely(Expr
*pExpr
){
142 while( pExpr
&& ExprHasProperty(pExpr
, EP_Skip
|EP_Unlikely
) ){
143 if( ExprHasProperty(pExpr
, EP_Unlikely
) ){
144 assert( ExprUseXList(pExpr
) );
145 assert( pExpr
->x
.pList
->nExpr
>0 );
146 assert( pExpr
->op
==TK_FUNCTION
);
147 pExpr
= pExpr
->x
.pList
->a
[0].pExpr
;
149 assert( pExpr
->op
==TK_COLLATE
);
150 pExpr
= pExpr
->pLeft
;
157 ** Return the collation sequence for the expression pExpr. If
158 ** there is no defined collating sequence, return NULL.
160 ** See also: sqlite3ExprNNCollSeq()
162 ** The sqlite3ExprNNCollSeq() works the same exact that it returns the
163 ** default collation if pExpr has no defined collation.
165 ** The collating sequence might be determined by a COLLATE operator
166 ** or by the presence of a column with a defined collating sequence.
167 ** COLLATE operators take first precedence. Left operands take
168 ** precedence over right operands.
170 CollSeq
*sqlite3ExprCollSeq(Parse
*pParse
, const Expr
*pExpr
){
171 sqlite3
*db
= pParse
->db
;
173 const Expr
*p
= pExpr
;
176 if( op
==TK_REGISTER
) op
= p
->op2
;
177 if( op
==TK_AGG_COLUMN
|| op
==TK_COLUMN
|| op
==TK_TRIGGER
){
178 assert( ExprUseYTab(p
) );
180 /* op==TK_REGISTER && p->y.pTab!=0 happens when pExpr was originally
181 ** a TK_COLUMN but was previously evaluated and cached in a register */
184 const char *zColl
= sqlite3ColumnColl(&p
->y
.pTab
->aCol
[j
]);
185 pColl
= sqlite3FindCollSeq(db
, ENC(db
), zColl
, 0);
190 if( op
==TK_CAST
|| op
==TK_UPLUS
){
195 assert( ExprUseXList(p
) );
196 p
= p
->x
.pList
->a
[0].pExpr
;
199 if( op
==TK_COLLATE
){
200 assert( !ExprHasProperty(p
, EP_IntValue
) );
201 pColl
= sqlite3GetCollSeq(pParse
, ENC(db
), 0, p
->u
.zToken
);
204 if( p
->flags
& EP_Collate
){
205 if( p
->pLeft
&& (p
->pLeft
->flags
& EP_Collate
)!=0 ){
208 Expr
*pNext
= p
->pRight
;
209 /* The Expr.x union is never used at the same time as Expr.pRight */
210 assert( ExprUseXList(p
) );
211 assert( p
->x
.pList
==0 || p
->pRight
==0 );
212 if( p
->x
.pList
!=0 && !db
->mallocFailed
){
214 for(i
=0; ALWAYS(i
<p
->x
.pList
->nExpr
); i
++){
215 if( ExprHasProperty(p
->x
.pList
->a
[i
].pExpr
, EP_Collate
) ){
216 pNext
= p
->x
.pList
->a
[i
].pExpr
;
227 if( sqlite3CheckCollSeq(pParse
, pColl
) ){
234 ** Return the collation sequence for the expression pExpr. If
235 ** there is no defined collating sequence, return a pointer to the
236 ** defautl collation sequence.
238 ** See also: sqlite3ExprCollSeq()
240 ** The sqlite3ExprCollSeq() routine works the same except that it
241 ** returns NULL if there is no defined collation.
243 CollSeq
*sqlite3ExprNNCollSeq(Parse
*pParse
, const Expr
*pExpr
){
244 CollSeq
*p
= sqlite3ExprCollSeq(pParse
, pExpr
);
245 if( p
==0 ) p
= pParse
->db
->pDfltColl
;
251 ** Return TRUE if the two expressions have equivalent collating sequences.
253 int sqlite3ExprCollSeqMatch(Parse
*pParse
, const Expr
*pE1
, const Expr
*pE2
){
254 CollSeq
*pColl1
= sqlite3ExprNNCollSeq(pParse
, pE1
);
255 CollSeq
*pColl2
= sqlite3ExprNNCollSeq(pParse
, pE2
);
256 return sqlite3StrICmp(pColl1
->zName
, pColl2
->zName
)==0;
260 ** pExpr is an operand of a comparison operator. aff2 is the
261 ** type affinity of the other operand. This routine returns the
262 ** type affinity that should be used for the comparison operator.
264 char sqlite3CompareAffinity(const Expr
*pExpr
, char aff2
){
265 char aff1
= sqlite3ExprAffinity(pExpr
);
266 if( aff1
>SQLITE_AFF_NONE
&& aff2
>SQLITE_AFF_NONE
){
267 /* Both sides of the comparison are columns. If one has numeric
268 ** affinity, use that. Otherwise use no affinity.
270 if( sqlite3IsNumericAffinity(aff1
) || sqlite3IsNumericAffinity(aff2
) ){
271 return SQLITE_AFF_NUMERIC
;
273 return SQLITE_AFF_BLOB
;
276 /* One side is a column, the other is not. Use the columns affinity. */
277 assert( aff1
<=SQLITE_AFF_NONE
|| aff2
<=SQLITE_AFF_NONE
);
278 return (aff1
<=SQLITE_AFF_NONE
? aff2
: aff1
) | SQLITE_AFF_NONE
;
283 ** pExpr is a comparison operator. Return the type affinity that should
284 ** be applied to both operands prior to doing the comparison.
286 static char comparisonAffinity(const Expr
*pExpr
){
288 assert( pExpr
->op
==TK_EQ
|| pExpr
->op
==TK_IN
|| pExpr
->op
==TK_LT
||
289 pExpr
->op
==TK_GT
|| pExpr
->op
==TK_GE
|| pExpr
->op
==TK_LE
||
290 pExpr
->op
==TK_NE
|| pExpr
->op
==TK_IS
|| pExpr
->op
==TK_ISNOT
);
291 assert( pExpr
->pLeft
);
292 aff
= sqlite3ExprAffinity(pExpr
->pLeft
);
294 aff
= sqlite3CompareAffinity(pExpr
->pRight
, aff
);
295 }else if( ExprUseXSelect(pExpr
) ){
296 aff
= sqlite3CompareAffinity(pExpr
->x
.pSelect
->pEList
->a
[0].pExpr
, aff
);
298 aff
= SQLITE_AFF_BLOB
;
304 ** pExpr is a comparison expression, eg. '=', '<', IN(...) etc.
305 ** idx_affinity is the affinity of an indexed column. Return true
306 ** if the index with affinity idx_affinity may be used to implement
307 ** the comparison in pExpr.
309 int sqlite3IndexAffinityOk(const Expr
*pExpr
, char idx_affinity
){
310 char aff
= comparisonAffinity(pExpr
);
311 if( aff
<SQLITE_AFF_TEXT
){
314 if( aff
==SQLITE_AFF_TEXT
){
315 return idx_affinity
==SQLITE_AFF_TEXT
;
317 return sqlite3IsNumericAffinity(idx_affinity
);
321 ** Return the P5 value that should be used for a binary comparison
322 ** opcode (OP_Eq, OP_Ge etc.) used to compare pExpr1 and pExpr2.
324 static u8
binaryCompareP5(
325 const Expr
*pExpr1
, /* Left operand */
326 const Expr
*pExpr2
, /* Right operand */
327 int jumpIfNull
/* Extra flags added to P5 */
329 u8 aff
= (char)sqlite3ExprAffinity(pExpr2
);
330 aff
= (u8
)sqlite3CompareAffinity(pExpr1
, aff
) | (u8
)jumpIfNull
;
335 ** Return a pointer to the collation sequence that should be used by
336 ** a binary comparison operator comparing pLeft and pRight.
338 ** If the left hand expression has a collating sequence type, then it is
339 ** used. Otherwise the collation sequence for the right hand expression
340 ** is used, or the default (BINARY) if neither expression has a collating
343 ** Argument pRight (but not pLeft) may be a null pointer. In this case,
344 ** it is not considered.
346 CollSeq
*sqlite3BinaryCompareCollSeq(
353 if( pLeft
->flags
& EP_Collate
){
354 pColl
= sqlite3ExprCollSeq(pParse
, pLeft
);
355 }else if( pRight
&& (pRight
->flags
& EP_Collate
)!=0 ){
356 pColl
= sqlite3ExprCollSeq(pParse
, pRight
);
358 pColl
= sqlite3ExprCollSeq(pParse
, pLeft
);
360 pColl
= sqlite3ExprCollSeq(pParse
, pRight
);
366 /* Expresssion p is a comparison operator. Return a collation sequence
367 ** appropriate for the comparison operator.
369 ** This is normally just a wrapper around sqlite3BinaryCompareCollSeq().
370 ** However, if the OP_Commuted flag is set, then the order of the operands
371 ** is reversed in the sqlite3BinaryCompareCollSeq() call so that the
372 ** correct collating sequence is found.
374 CollSeq
*sqlite3ExprCompareCollSeq(Parse
*pParse
, const Expr
*p
){
375 if( ExprHasProperty(p
, EP_Commuted
) ){
376 return sqlite3BinaryCompareCollSeq(pParse
, p
->pRight
, p
->pLeft
);
378 return sqlite3BinaryCompareCollSeq(pParse
, p
->pLeft
, p
->pRight
);
383 ** Generate code for a comparison operator.
385 static int codeCompare(
386 Parse
*pParse
, /* The parsing (and code generating) context */
387 Expr
*pLeft
, /* The left operand */
388 Expr
*pRight
, /* The right operand */
389 int opcode
, /* The comparison opcode */
390 int in1
, int in2
, /* Register holding operands */
391 int dest
, /* Jump here if true. */
392 int jumpIfNull
, /* If true, jump if either operand is NULL */
393 int isCommuted
/* The comparison has been commuted */
399 if( pParse
->nErr
) return 0;
401 p4
= sqlite3BinaryCompareCollSeq(pParse
, pRight
, pLeft
);
403 p4
= sqlite3BinaryCompareCollSeq(pParse
, pLeft
, pRight
);
405 p5
= binaryCompareP5(pLeft
, pRight
, jumpIfNull
);
406 addr
= sqlite3VdbeAddOp4(pParse
->pVdbe
, opcode
, in2
, dest
, in1
,
407 (void*)p4
, P4_COLLSEQ
);
408 sqlite3VdbeChangeP5(pParse
->pVdbe
, (u8
)p5
);
413 ** Return true if expression pExpr is a vector, or false otherwise.
415 ** A vector is defined as any expression that results in two or more
416 ** columns of result. Every TK_VECTOR node is an vector because the
417 ** parser will not generate a TK_VECTOR with fewer than two entries.
418 ** But a TK_SELECT might be either a vector or a scalar. It is only
419 ** considered a vector if it has two or more result columns.
421 int sqlite3ExprIsVector(const Expr
*pExpr
){
422 return sqlite3ExprVectorSize(pExpr
)>1;
426 ** If the expression passed as the only argument is of type TK_VECTOR
427 ** return the number of expressions in the vector. Or, if the expression
428 ** is a sub-select, return the number of columns in the sub-select. For
429 ** any other type of expression, return 1.
431 int sqlite3ExprVectorSize(const Expr
*pExpr
){
433 if( op
==TK_REGISTER
) op
= pExpr
->op2
;
435 assert( ExprUseXList(pExpr
) );
436 return pExpr
->x
.pList
->nExpr
;
437 }else if( op
==TK_SELECT
){
438 assert( ExprUseXSelect(pExpr
) );
439 return pExpr
->x
.pSelect
->pEList
->nExpr
;
446 ** Return a pointer to a subexpression of pVector that is the i-th
447 ** column of the vector (numbered starting with 0). The caller must
448 ** ensure that i is within range.
450 ** If pVector is really a scalar (and "scalar" here includes subqueries
451 ** that return a single column!) then return pVector unmodified.
453 ** pVector retains ownership of the returned subexpression.
455 ** If the vector is a (SELECT ...) then the expression returned is
456 ** just the expression for the i-th term of the result set, and may
457 ** not be ready for evaluation because the table cursor has not yet
460 Expr
*sqlite3VectorFieldSubexpr(Expr
*pVector
, int i
){
461 assert( i
<sqlite3ExprVectorSize(pVector
) || pVector
->op
==TK_ERROR
);
462 if( sqlite3ExprIsVector(pVector
) ){
463 assert( pVector
->op2
==0 || pVector
->op
==TK_REGISTER
);
464 if( pVector
->op
==TK_SELECT
|| pVector
->op2
==TK_SELECT
){
465 assert( ExprUseXSelect(pVector
) );
466 return pVector
->x
.pSelect
->pEList
->a
[i
].pExpr
;
468 assert( ExprUseXList(pVector
) );
469 return pVector
->x
.pList
->a
[i
].pExpr
;
476 ** Compute and return a new Expr object which when passed to
477 ** sqlite3ExprCode() will generate all necessary code to compute
478 ** the iField-th column of the vector expression pVector.
480 ** It is ok for pVector to be a scalar (as long as iField==0).
481 ** In that case, this routine works like sqlite3ExprDup().
483 ** The caller owns the returned Expr object and is responsible for
484 ** ensuring that the returned value eventually gets freed.
486 ** The caller retains ownership of pVector. If pVector is a TK_SELECT,
487 ** then the returned object will reference pVector and so pVector must remain
488 ** valid for the life of the returned object. If pVector is a TK_VECTOR
489 ** or a scalar expression, then it can be deleted as soon as this routine
492 ** A trick to cause a TK_SELECT pVector to be deleted together with
493 ** the returned Expr object is to attach the pVector to the pRight field
494 ** of the returned TK_SELECT_COLUMN Expr object.
496 Expr
*sqlite3ExprForVectorField(
497 Parse
*pParse
, /* Parsing context */
498 Expr
*pVector
, /* The vector. List of expressions or a sub-SELECT */
499 int iField
, /* Which column of the vector to return */
500 int nField
/* Total number of columns in the vector */
503 if( pVector
->op
==TK_SELECT
){
504 assert( ExprUseXSelect(pVector
) );
505 /* The TK_SELECT_COLUMN Expr node:
507 ** pLeft: pVector containing TK_SELECT. Not deleted.
508 ** pRight: not used. But recursively deleted.
509 ** iColumn: Index of a column in pVector
510 ** iTable: 0 or the number of columns on the LHS of an assignment
511 ** pLeft->iTable: First in an array of register holding result, or 0
512 ** if the result is not yet computed.
514 ** sqlite3ExprDelete() specifically skips the recursive delete of
515 ** pLeft on TK_SELECT_COLUMN nodes. But pRight is followed, so pVector
516 ** can be attached to pRight to cause this node to take ownership of
517 ** pVector. Typically there will be multiple TK_SELECT_COLUMN nodes
518 ** with the same pLeft pointer to the pVector, but only one of them
519 ** will own the pVector.
521 pRet
= sqlite3PExpr(pParse
, TK_SELECT_COLUMN
, 0, 0);
523 pRet
->iTable
= nField
;
524 pRet
->iColumn
= iField
;
525 pRet
->pLeft
= pVector
;
528 if( pVector
->op
==TK_VECTOR
){
530 assert( ExprUseXList(pVector
) );
531 ppVector
= &pVector
->x
.pList
->a
[iField
].pExpr
;
533 if( IN_RENAME_OBJECT
){
534 /* This must be a vector UPDATE inside a trigger */
539 pRet
= sqlite3ExprDup(pParse
->db
, pVector
, 0);
545 ** If expression pExpr is of type TK_SELECT, generate code to evaluate
546 ** it. Return the register in which the result is stored (or, if the
547 ** sub-select returns more than one column, the first in an array
548 ** of registers in which the result is stored).
550 ** If pExpr is not a TK_SELECT expression, return 0.
552 static int exprCodeSubselect(Parse
*pParse
, Expr
*pExpr
){
554 #ifndef SQLITE_OMIT_SUBQUERY
555 if( pExpr
->op
==TK_SELECT
){
556 reg
= sqlite3CodeSubselect(pParse
, pExpr
);
563 ** Argument pVector points to a vector expression - either a TK_VECTOR
564 ** or TK_SELECT that returns more than one column. This function returns
565 ** the register number of a register that contains the value of
566 ** element iField of the vector.
568 ** If pVector is a TK_SELECT expression, then code for it must have
569 ** already been generated using the exprCodeSubselect() routine. In this
570 ** case parameter regSelect should be the first in an array of registers
571 ** containing the results of the sub-select.
573 ** If pVector is of type TK_VECTOR, then code for the requested field
574 ** is generated. In this case (*pRegFree) may be set to the number of
575 ** a temporary register to be freed by the caller before returning.
577 ** Before returning, output parameter (*ppExpr) is set to point to the
578 ** Expr object corresponding to element iElem of the vector.
580 static int exprVectorRegister(
581 Parse
*pParse
, /* Parse context */
582 Expr
*pVector
, /* Vector to extract element from */
583 int iField
, /* Field to extract from pVector */
584 int regSelect
, /* First in array of registers */
585 Expr
**ppExpr
, /* OUT: Expression element */
586 int *pRegFree
/* OUT: Temp register to free */
589 assert( op
==TK_VECTOR
|| op
==TK_REGISTER
|| op
==TK_SELECT
|| op
==TK_ERROR
);
590 if( op
==TK_REGISTER
){
591 *ppExpr
= sqlite3VectorFieldSubexpr(pVector
, iField
);
592 return pVector
->iTable
+iField
;
595 assert( ExprUseXSelect(pVector
) );
596 *ppExpr
= pVector
->x
.pSelect
->pEList
->a
[iField
].pExpr
;
597 return regSelect
+iField
;
600 assert( ExprUseXList(pVector
) );
601 *ppExpr
= pVector
->x
.pList
->a
[iField
].pExpr
;
602 return sqlite3ExprCodeTemp(pParse
, *ppExpr
, pRegFree
);
608 ** Expression pExpr is a comparison between two vector values. Compute
609 ** the result of the comparison (1, 0, or NULL) and write that
610 ** result into register dest.
612 ** The caller must satisfy the following preconditions:
614 ** if pExpr->op==TK_IS: op==TK_EQ and p5==SQLITE_NULLEQ
615 ** if pExpr->op==TK_ISNOT: op==TK_NE and p5==SQLITE_NULLEQ
616 ** otherwise: op==pExpr->op and p5==0
618 static void codeVectorCompare(
619 Parse
*pParse
, /* Code generator context */
620 Expr
*pExpr
, /* The comparison operation */
621 int dest
, /* Write results into this register */
622 u8 op
, /* Comparison operator */
623 u8 p5
/* SQLITE_NULLEQ or zero */
625 Vdbe
*v
= pParse
->pVdbe
;
626 Expr
*pLeft
= pExpr
->pLeft
;
627 Expr
*pRight
= pExpr
->pRight
;
628 int nLeft
= sqlite3ExprVectorSize(pLeft
);
634 int addrDone
= sqlite3VdbeMakeLabel(pParse
);
635 int isCommuted
= ExprHasProperty(pExpr
,EP_Commuted
);
637 assert( !ExprHasVVAProperty(pExpr
,EP_Immutable
) );
638 if( pParse
->nErr
) return;
639 if( nLeft
!=sqlite3ExprVectorSize(pRight
) ){
640 sqlite3ErrorMsg(pParse
, "row value misused");
643 assert( pExpr
->op
==TK_EQ
|| pExpr
->op
==TK_NE
644 || pExpr
->op
==TK_IS
|| pExpr
->op
==TK_ISNOT
645 || pExpr
->op
==TK_LT
|| pExpr
->op
==TK_GT
646 || pExpr
->op
==TK_LE
|| pExpr
->op
==TK_GE
648 assert( pExpr
->op
==op
|| (pExpr
->op
==TK_IS
&& op
==TK_EQ
)
649 || (pExpr
->op
==TK_ISNOT
&& op
==TK_NE
) );
650 assert( p5
==0 || pExpr
->op
!=op
);
651 assert( p5
==SQLITE_NULLEQ
|| pExpr
->op
==op
);
653 if( op
==TK_LE
) opx
= TK_LT
;
654 if( op
==TK_GE
) opx
= TK_GT
;
655 if( op
==TK_NE
) opx
= TK_EQ
;
657 regLeft
= exprCodeSubselect(pParse
, pLeft
);
658 regRight
= exprCodeSubselect(pParse
, pRight
);
660 sqlite3VdbeAddOp2(v
, OP_Integer
, 1, dest
);
661 for(i
=0; 1 /*Loop exits by "break"*/; i
++){
662 int regFree1
= 0, regFree2
= 0;
663 Expr
*pL
= 0, *pR
= 0;
665 assert( i
>=0 && i
<nLeft
);
666 if( addrCmp
) sqlite3VdbeJumpHere(v
, addrCmp
);
667 r1
= exprVectorRegister(pParse
, pLeft
, i
, regLeft
, &pL
, ®Free1
);
668 r2
= exprVectorRegister(pParse
, pRight
, i
, regRight
, &pR
, ®Free2
);
669 addrCmp
= sqlite3VdbeCurrentAddr(v
);
670 codeCompare(pParse
, pL
, pR
, opx
, r1
, r2
, addrDone
, p5
, isCommuted
);
671 testcase(op
==OP_Lt
); VdbeCoverageIf(v
,op
==OP_Lt
);
672 testcase(op
==OP_Le
); VdbeCoverageIf(v
,op
==OP_Le
);
673 testcase(op
==OP_Gt
); VdbeCoverageIf(v
,op
==OP_Gt
);
674 testcase(op
==OP_Ge
); VdbeCoverageIf(v
,op
==OP_Ge
);
675 testcase(op
==OP_Eq
); VdbeCoverageIf(v
,op
==OP_Eq
);
676 testcase(op
==OP_Ne
); VdbeCoverageIf(v
,op
==OP_Ne
);
677 sqlite3ReleaseTempReg(pParse
, regFree1
);
678 sqlite3ReleaseTempReg(pParse
, regFree2
);
679 if( (opx
==TK_LT
|| opx
==TK_GT
) && i
<nLeft
-1 ){
680 addrCmp
= sqlite3VdbeAddOp0(v
, OP_ElseEq
);
681 testcase(opx
==TK_LT
); VdbeCoverageIf(v
,opx
==TK_LT
);
682 testcase(opx
==TK_GT
); VdbeCoverageIf(v
,opx
==TK_GT
);
684 if( p5
==SQLITE_NULLEQ
){
685 sqlite3VdbeAddOp2(v
, OP_Integer
, 0, dest
);
687 sqlite3VdbeAddOp3(v
, OP_ZeroOrNull
, r1
, dest
, r2
);
693 sqlite3VdbeAddOp2(v
, OP_NotNull
, dest
, addrDone
); VdbeCoverage(v
);
695 assert( op
==TK_LT
|| op
==TK_GT
|| op
==TK_LE
|| op
==TK_GE
);
696 sqlite3VdbeAddOp2(v
, OP_Goto
, 0, addrDone
);
697 if( i
==nLeft
-2 ) opx
= op
;
700 sqlite3VdbeJumpHere(v
, addrCmp
);
701 sqlite3VdbeResolveLabel(v
, addrDone
);
703 sqlite3VdbeAddOp2(v
, OP_Not
, dest
, dest
);
707 #if SQLITE_MAX_EXPR_DEPTH>0
709 ** Check that argument nHeight is less than or equal to the maximum
710 ** expression depth allowed. If it is not, leave an error message in
713 int sqlite3ExprCheckHeight(Parse
*pParse
, int nHeight
){
715 int mxHeight
= pParse
->db
->aLimit
[SQLITE_LIMIT_EXPR_DEPTH
];
716 if( nHeight
>mxHeight
){
717 sqlite3ErrorMsg(pParse
,
718 "Expression tree is too large (maximum depth %d)", mxHeight
725 /* The following three functions, heightOfExpr(), heightOfExprList()
726 ** and heightOfSelect(), are used to determine the maximum height
727 ** of any expression tree referenced by the structure passed as the
730 ** If this maximum height is greater than the current value pointed
731 ** to by pnHeight, the second parameter, then set *pnHeight to that
734 static void heightOfExpr(const Expr
*p
, int *pnHeight
){
736 if( p
->nHeight
>*pnHeight
){
737 *pnHeight
= p
->nHeight
;
741 static void heightOfExprList(const ExprList
*p
, int *pnHeight
){
744 for(i
=0; i
<p
->nExpr
; i
++){
745 heightOfExpr(p
->a
[i
].pExpr
, pnHeight
);
749 static void heightOfSelect(const Select
*pSelect
, int *pnHeight
){
751 for(p
=pSelect
; p
; p
=p
->pPrior
){
752 heightOfExpr(p
->pWhere
, pnHeight
);
753 heightOfExpr(p
->pHaving
, pnHeight
);
754 heightOfExpr(p
->pLimit
, pnHeight
);
755 heightOfExprList(p
->pEList
, pnHeight
);
756 heightOfExprList(p
->pGroupBy
, pnHeight
);
757 heightOfExprList(p
->pOrderBy
, pnHeight
);
762 ** Set the Expr.nHeight variable in the structure passed as an
763 ** argument. An expression with no children, Expr.pList or
764 ** Expr.pSelect member has a height of 1. Any other expression
765 ** has a height equal to the maximum height of any other
766 ** referenced Expr plus one.
768 ** Also propagate EP_Propagate flags up from Expr.x.pList to Expr.flags,
771 static void exprSetHeight(Expr
*p
){
773 heightOfExpr(p
->pLeft
, &nHeight
);
774 heightOfExpr(p
->pRight
, &nHeight
);
775 if( ExprUseXSelect(p
) ){
776 heightOfSelect(p
->x
.pSelect
, &nHeight
);
777 }else if( p
->x
.pList
){
778 heightOfExprList(p
->x
.pList
, &nHeight
);
779 p
->flags
|= EP_Propagate
& sqlite3ExprListFlags(p
->x
.pList
);
781 p
->nHeight
= nHeight
+ 1;
785 ** Set the Expr.nHeight variable using the exprSetHeight() function. If
786 ** the height is greater than the maximum allowed expression depth,
787 ** leave an error in pParse.
789 ** Also propagate all EP_Propagate flags from the Expr.x.pList into
792 void sqlite3ExprSetHeightAndFlags(Parse
*pParse
, Expr
*p
){
793 if( pParse
->nErr
) return;
795 sqlite3ExprCheckHeight(pParse
, p
->nHeight
);
799 ** Return the maximum height of any expression tree referenced
800 ** by the select statement passed as an argument.
802 int sqlite3SelectExprHeight(const Select
*p
){
804 heightOfSelect(p
, &nHeight
);
807 #else /* ABOVE: Height enforcement enabled. BELOW: Height enforcement off */
809 ** Propagate all EP_Propagate flags from the Expr.x.pList into
812 void sqlite3ExprSetHeightAndFlags(Parse
*pParse
, Expr
*p
){
813 if( pParse
->nErr
) return;
814 if( p
&& ExprUseXList(p
) && p
->x
.pList
){
815 p
->flags
|= EP_Propagate
& sqlite3ExprListFlags(p
->x
.pList
);
818 #define exprSetHeight(y)
819 #endif /* SQLITE_MAX_EXPR_DEPTH>0 */
822 ** This routine is the core allocator for Expr nodes.
824 ** Construct a new expression node and return a pointer to it. Memory
825 ** for this node and for the pToken argument is a single allocation
826 ** obtained from sqlite3DbMalloc(). The calling function
827 ** is responsible for making sure the node eventually gets freed.
829 ** If dequote is true, then the token (if it exists) is dequoted.
830 ** If dequote is false, no dequoting is performed. The deQuote
831 ** parameter is ignored if pToken is NULL or if the token does not
832 ** appear to be quoted. If the quotes were of the form "..." (double-quotes)
833 ** then the EP_DblQuoted flag is set on the expression node.
835 ** Special case: If op==TK_INTEGER and pToken points to a string that
836 ** can be translated into a 32-bit integer, then the token is not
837 ** stored in u.zToken. Instead, the integer values is written
838 ** into u.iValue and the EP_IntValue flag is set. No extra storage
839 ** is allocated to hold the integer text and the dequote flag is ignored.
841 Expr
*sqlite3ExprAlloc(
842 sqlite3
*db
, /* Handle for sqlite3DbMallocRawNN() */
843 int op
, /* Expression opcode */
844 const Token
*pToken
, /* Token argument. Might be NULL */
845 int dequote
/* True to dequote */
853 if( op
!=TK_INTEGER
|| pToken
->z
==0
854 || sqlite3GetInt32(pToken
->z
, &iValue
)==0 ){
855 nExtra
= pToken
->n
+1;
859 pNew
= sqlite3DbMallocRawNN(db
, sizeof(Expr
)+nExtra
);
861 memset(pNew
, 0, sizeof(Expr
));
866 pNew
->flags
|= EP_IntValue
|EP_Leaf
|(iValue
?EP_IsTrue
:EP_IsFalse
);
867 pNew
->u
.iValue
= iValue
;
869 pNew
->u
.zToken
= (char*)&pNew
[1];
870 assert( pToken
->z
!=0 || pToken
->n
==0 );
871 if( pToken
->n
) memcpy(pNew
->u
.zToken
, pToken
->z
, pToken
->n
);
872 pNew
->u
.zToken
[pToken
->n
] = 0;
873 if( dequote
&& sqlite3Isquote(pNew
->u
.zToken
[0]) ){
874 sqlite3DequoteExpr(pNew
);
878 #if SQLITE_MAX_EXPR_DEPTH>0
886 ** Allocate a new expression node from a zero-terminated token that has
887 ** already been dequoted.
890 sqlite3
*db
, /* Handle for sqlite3DbMallocZero() (may be null) */
891 int op
, /* Expression opcode */
892 const char *zToken
/* Token argument. Might be NULL */
896 x
.n
= sqlite3Strlen30(zToken
);
897 return sqlite3ExprAlloc(db
, op
, &x
, 0);
901 ** Attach subtrees pLeft and pRight to the Expr node pRoot.
903 ** If pRoot==NULL that means that a memory allocation error has occurred.
904 ** In that case, delete the subtrees pLeft and pRight.
906 void sqlite3ExprAttachSubtrees(
913 assert( db
->mallocFailed
);
914 sqlite3ExprDelete(db
, pLeft
);
915 sqlite3ExprDelete(db
, pRight
);
918 pRoot
->pRight
= pRight
;
919 pRoot
->flags
|= EP_Propagate
& pRight
->flags
;
922 pRoot
->pLeft
= pLeft
;
923 pRoot
->flags
|= EP_Propagate
& pLeft
->flags
;
925 exprSetHeight(pRoot
);
930 ** Allocate an Expr node which joins as many as two subtrees.
932 ** One or both of the subtrees can be NULL. Return a pointer to the new
933 ** Expr node. Or, if an OOM error occurs, set pParse->db->mallocFailed,
934 ** free the subtrees and return NULL.
937 Parse
*pParse
, /* Parsing context */
938 int op
, /* Expression opcode */
939 Expr
*pLeft
, /* Left operand */
940 Expr
*pRight
/* Right operand */
943 p
= sqlite3DbMallocRawNN(pParse
->db
, sizeof(Expr
));
945 memset(p
, 0, sizeof(Expr
));
948 sqlite3ExprAttachSubtrees(pParse
->db
, p
, pLeft
, pRight
);
949 sqlite3ExprCheckHeight(pParse
, p
->nHeight
);
951 sqlite3ExprDelete(pParse
->db
, pLeft
);
952 sqlite3ExprDelete(pParse
->db
, pRight
);
958 ** Add pSelect to the Expr.x.pSelect field. Or, if pExpr is NULL (due
959 ** do a memory allocation failure) then delete the pSelect object.
961 void sqlite3PExprAddSelect(Parse
*pParse
, Expr
*pExpr
, Select
*pSelect
){
963 pExpr
->x
.pSelect
= pSelect
;
964 ExprSetProperty(pExpr
, EP_xIsSelect
|EP_Subquery
);
965 sqlite3ExprSetHeightAndFlags(pParse
, pExpr
);
967 assert( pParse
->db
->mallocFailed
);
968 sqlite3SelectDelete(pParse
->db
, pSelect
);
973 ** Expression list pEList is a list of vector values. This function
974 ** converts the contents of pEList to a VALUES(...) Select statement
975 ** returning 1 row for each element of the list. For example, the
978 ** ( (1,2), (3,4) (5,6) )
980 ** is translated to the equivalent of:
982 ** VALUES(1,2), (3,4), (5,6)
984 ** Each of the vector values in pEList must contain exactly nElem terms.
985 ** If a list element that is not a vector or does not contain nElem terms,
986 ** an error message is left in pParse.
988 ** This is used as part of processing IN(...) expressions with a list
989 ** of vectors on the RHS. e.g. "... IN ((1,2), (3,4), (5,6))".
991 Select
*sqlite3ExprListToValues(Parse
*pParse
, int nElem
, ExprList
*pEList
){
995 for(ii
=0; ii
<pEList
->nExpr
; ii
++){
997 Expr
*pExpr
= pEList
->a
[ii
].pExpr
;
999 if( pExpr
->op
==TK_VECTOR
){
1000 assert( ExprUseXList(pExpr
) );
1001 nExprElem
= pExpr
->x
.pList
->nExpr
;
1005 if( nExprElem
!=nElem
){
1006 sqlite3ErrorMsg(pParse
, "IN(...) element has %d term%s - expected %d",
1007 nExprElem
, nExprElem
>1?"s":"", nElem
1011 assert( ExprUseXList(pExpr
) );
1012 pSel
= sqlite3SelectNew(pParse
, pExpr
->x
.pList
, 0, 0, 0, 0, 0, SF_Values
,0);
1017 pSel
->pPrior
= pRet
;
1023 if( pRet
&& pRet
->pPrior
){
1024 pRet
->selFlags
|= SF_MultiValue
;
1026 sqlite3ExprListDelete(pParse
->db
, pEList
);
1031 ** Join two expressions using an AND operator. If either expression is
1032 ** NULL, then just return the other expression.
1034 ** If one side or the other of the AND is known to be false, then instead
1035 ** of returning an AND expression, just return a constant expression with
1036 ** a value of false.
1038 Expr
*sqlite3ExprAnd(Parse
*pParse
, Expr
*pLeft
, Expr
*pRight
){
1039 sqlite3
*db
= pParse
->db
;
1042 }else if( pRight
==0 ){
1044 }else if( (ExprAlwaysFalse(pLeft
) || ExprAlwaysFalse(pRight
))
1045 && !IN_RENAME_OBJECT
1047 sqlite3ExprDeferredDelete(pParse
, pLeft
);
1048 sqlite3ExprDeferredDelete(pParse
, pRight
);
1049 return sqlite3Expr(db
, TK_INTEGER
, "0");
1051 return sqlite3PExpr(pParse
, TK_AND
, pLeft
, pRight
);
1056 ** Construct a new expression node for a function with multiple
1059 Expr
*sqlite3ExprFunction(
1060 Parse
*pParse
, /* Parsing context */
1061 ExprList
*pList
, /* Argument list */
1062 const Token
*pToken
, /* Name of the function */
1063 int eDistinct
/* SF_Distinct or SF_ALL or 0 */
1066 sqlite3
*db
= pParse
->db
;
1068 pNew
= sqlite3ExprAlloc(db
, TK_FUNCTION
, pToken
, 1);
1070 sqlite3ExprListDelete(db
, pList
); /* Avoid memory leak when malloc fails */
1074 && pList
->nExpr
> pParse
->db
->aLimit
[SQLITE_LIMIT_FUNCTION_ARG
]
1077 sqlite3ErrorMsg(pParse
, "too many arguments on function %T", pToken
);
1079 pNew
->x
.pList
= pList
;
1080 ExprSetProperty(pNew
, EP_HasFunc
);
1081 assert( ExprUseXList(pNew
) );
1082 sqlite3ExprSetHeightAndFlags(pParse
, pNew
);
1083 if( eDistinct
==SF_Distinct
) ExprSetProperty(pNew
, EP_Distinct
);
1088 ** Check to see if a function is usable according to current access
1091 ** SQLITE_FUNC_DIRECT - Only usable from top-level SQL
1093 ** SQLITE_FUNC_UNSAFE - Usable if TRUSTED_SCHEMA or from
1096 ** If the function is not usable, create an error.
1098 void sqlite3ExprFunctionUsable(
1099 Parse
*pParse
, /* Parsing and code generating context */
1100 const Expr
*pExpr
, /* The function invocation */
1101 const FuncDef
*pDef
/* The function being invoked */
1103 assert( !IN_RENAME_OBJECT
);
1104 assert( (pDef
->funcFlags
& (SQLITE_FUNC_DIRECT
|SQLITE_FUNC_UNSAFE
))!=0 );
1105 if( ExprHasProperty(pExpr
, EP_FromDDL
) ){
1106 if( (pDef
->funcFlags
& SQLITE_FUNC_DIRECT
)!=0
1107 || (pParse
->db
->flags
& SQLITE_TrustedSchema
)==0
1109 /* Functions prohibited in triggers and views if:
1110 ** (1) tagged with SQLITE_DIRECTONLY
1111 ** (2) not tagged with SQLITE_INNOCUOUS (which means it
1112 ** is tagged with SQLITE_FUNC_UNSAFE) and
1113 ** SQLITE_DBCONFIG_TRUSTED_SCHEMA is off (meaning
1114 ** that the schema is possibly tainted).
1116 sqlite3ErrorMsg(pParse
, "unsafe use of %s()", pDef
->zName
);
1122 ** Assign a variable number to an expression that encodes a wildcard
1123 ** in the original SQL statement.
1125 ** Wildcards consisting of a single "?" are assigned the next sequential
1128 ** Wildcards of the form "?nnn" are assigned the number "nnn". We make
1129 ** sure "nnn" is not too big to avoid a denial of service attack when
1130 ** the SQL statement comes from an external source.
1132 ** Wildcards of the form ":aaa", "@aaa", or "$aaa" are assigned the same number
1133 ** as the previous instance of the same wildcard. Or if this is the first
1134 ** instance of the wildcard, the next sequential variable number is
1137 void sqlite3ExprAssignVarNumber(Parse
*pParse
, Expr
*pExpr
, u32 n
){
1138 sqlite3
*db
= pParse
->db
;
1142 if( pExpr
==0 ) return;
1143 assert( !ExprHasProperty(pExpr
, EP_IntValue
|EP_Reduced
|EP_TokenOnly
) );
1144 z
= pExpr
->u
.zToken
;
1147 assert( n
==(u32
)sqlite3Strlen30(z
) );
1149 /* Wildcard of the form "?". Assign the next variable number */
1150 assert( z
[0]=='?' );
1151 x
= (ynVar
)(++pParse
->nVar
);
1155 /* Wildcard of the form "?nnn". Convert "nnn" to an integer and
1156 ** use it as the variable number */
1159 if( n
==2 ){ /*OPTIMIZATION-IF-TRUE*/
1160 i
= z
[1]-'0'; /* The common case of ?N for a single digit N */
1163 bOk
= 0==sqlite3Atoi64(&z
[1], &i
, n
-1, SQLITE_UTF8
);
1167 testcase( i
==db
->aLimit
[SQLITE_LIMIT_VARIABLE_NUMBER
]-1 );
1168 testcase( i
==db
->aLimit
[SQLITE_LIMIT_VARIABLE_NUMBER
] );
1169 if( bOk
==0 || i
<1 || i
>db
->aLimit
[SQLITE_LIMIT_VARIABLE_NUMBER
] ){
1170 sqlite3ErrorMsg(pParse
, "variable number must be between ?1 and ?%d",
1171 db
->aLimit
[SQLITE_LIMIT_VARIABLE_NUMBER
]);
1175 if( x
>pParse
->nVar
){
1176 pParse
->nVar
= (int)x
;
1178 }else if( sqlite3VListNumToName(pParse
->pVList
, x
)==0 ){
1182 /* Wildcards like ":aaa", "$aaa" or "@aaa". Reuse the same variable
1183 ** number as the prior appearance of the same name, or if the name
1184 ** has never appeared before, reuse the same variable number
1186 x
= (ynVar
)sqlite3VListNameToNum(pParse
->pVList
, z
, n
);
1188 x
= (ynVar
)(++pParse
->nVar
);
1193 pParse
->pVList
= sqlite3VListAdd(db
, pParse
->pVList
, z
, n
, x
);
1197 if( x
>db
->aLimit
[SQLITE_LIMIT_VARIABLE_NUMBER
] ){
1198 sqlite3ErrorMsg(pParse
, "too many SQL variables");
1203 ** Recursively delete an expression tree.
1205 static SQLITE_NOINLINE
void sqlite3ExprDeleteNN(sqlite3
*db
, Expr
*p
){
1207 assert( !ExprUseUValue(p
) || p
->u
.iValue
>=0 );
1208 assert( !ExprUseYWin(p
) || !ExprUseYSub(p
) );
1209 assert( !ExprUseYWin(p
) || p
->y
.pWin
!=0 || db
->mallocFailed
);
1210 assert( p
->op
!=TK_FUNCTION
|| !ExprUseYSub(p
) );
1212 if( ExprHasProperty(p
, EP_Leaf
) && !ExprHasProperty(p
, EP_TokenOnly
) ){
1213 assert( p
->pLeft
==0 );
1214 assert( p
->pRight
==0 );
1215 assert( !ExprUseXSelect(p
) || p
->x
.pSelect
==0 );
1216 assert( !ExprUseXList(p
) || p
->x
.pList
==0 );
1219 if( !ExprHasProperty(p
, (EP_TokenOnly
|EP_Leaf
)) ){
1220 /* The Expr.x union is never used at the same time as Expr.pRight */
1221 assert( (ExprUseXList(p
) && p
->x
.pList
==0) || p
->pRight
==0 );
1222 if( p
->pLeft
&& p
->op
!=TK_SELECT_COLUMN
) sqlite3ExprDeleteNN(db
, p
->pLeft
);
1224 assert( !ExprHasProperty(p
, EP_WinFunc
) );
1225 sqlite3ExprDeleteNN(db
, p
->pRight
);
1226 }else if( ExprUseXSelect(p
) ){
1227 assert( !ExprHasProperty(p
, EP_WinFunc
) );
1228 sqlite3SelectDelete(db
, p
->x
.pSelect
);
1230 sqlite3ExprListDelete(db
, p
->x
.pList
);
1231 #ifndef SQLITE_OMIT_WINDOWFUNC
1232 if( ExprHasProperty(p
, EP_WinFunc
) ){
1233 sqlite3WindowDelete(db
, p
->y
.pWin
);
1238 if( ExprHasProperty(p
, EP_MemToken
) ){
1239 assert( !ExprHasProperty(p
, EP_IntValue
) );
1240 sqlite3DbFree(db
, p
->u
.zToken
);
1242 if( !ExprHasProperty(p
, EP_Static
) ){
1243 sqlite3DbFreeNN(db
, p
);
1246 void sqlite3ExprDelete(sqlite3
*db
, Expr
*p
){
1247 if( p
) sqlite3ExprDeleteNN(db
, p
);
1252 ** Arrange to cause pExpr to be deleted when the pParse is deleted.
1253 ** This is similar to sqlite3ExprDelete() except that the delete is
1254 ** deferred untilthe pParse is deleted.
1256 ** The pExpr might be deleted immediately on an OOM error.
1258 ** The deferred delete is (currently) implemented by adding the
1259 ** pExpr to the pParse->pConstExpr list with a register number of 0.
1261 void sqlite3ExprDeferredDelete(Parse
*pParse
, Expr
*pExpr
){
1262 pParse
->pConstExpr
=
1263 sqlite3ExprListAppend(pParse
, pParse
->pConstExpr
, pExpr
);
1266 /* Invoke sqlite3RenameExprUnmap() and sqlite3ExprDelete() on the
1269 void sqlite3ExprUnmapAndDelete(Parse
*pParse
, Expr
*p
){
1271 if( IN_RENAME_OBJECT
){
1272 sqlite3RenameExprUnmap(pParse
, p
);
1274 sqlite3ExprDeleteNN(pParse
->db
, p
);
1279 ** Return the number of bytes allocated for the expression structure
1280 ** passed as the first argument. This is always one of EXPR_FULLSIZE,
1281 ** EXPR_REDUCEDSIZE or EXPR_TOKENONLYSIZE.
1283 static int exprStructSize(const Expr
*p
){
1284 if( ExprHasProperty(p
, EP_TokenOnly
) ) return EXPR_TOKENONLYSIZE
;
1285 if( ExprHasProperty(p
, EP_Reduced
) ) return EXPR_REDUCEDSIZE
;
1286 return EXPR_FULLSIZE
;
1290 ** The dupedExpr*Size() routines each return the number of bytes required
1291 ** to store a copy of an expression or expression tree. They differ in
1292 ** how much of the tree is measured.
1294 ** dupedExprStructSize() Size of only the Expr structure
1295 ** dupedExprNodeSize() Size of Expr + space for token
1296 ** dupedExprSize() Expr + token + subtree components
1298 ***************************************************************************
1300 ** The dupedExprStructSize() function returns two values OR-ed together:
1301 ** (1) the space required for a copy of the Expr structure only and
1302 ** (2) the EP_xxx flags that indicate what the structure size should be.
1303 ** The return values is always one of:
1306 ** EXPR_REDUCEDSIZE | EP_Reduced
1307 ** EXPR_TOKENONLYSIZE | EP_TokenOnly
1309 ** The size of the structure can be found by masking the return value
1310 ** of this routine with 0xfff. The flags can be found by masking the
1311 ** return value with EP_Reduced|EP_TokenOnly.
1313 ** Note that with flags==EXPRDUP_REDUCE, this routines works on full-size
1314 ** (unreduced) Expr objects as they or originally constructed by the parser.
1315 ** During expression analysis, extra information is computed and moved into
1316 ** later parts of the Expr object and that extra information might get chopped
1317 ** off if the expression is reduced. Note also that it does not work to
1318 ** make an EXPRDUP_REDUCE copy of a reduced expression. It is only legal
1319 ** to reduce a pristine expression tree from the parser. The implementation
1320 ** of dupedExprStructSize() contain multiple assert() statements that attempt
1321 ** to enforce this constraint.
1323 static int dupedExprStructSize(const Expr
*p
, int flags
){
1325 assert( flags
==EXPRDUP_REDUCE
|| flags
==0 ); /* Only one flag value allowed */
1326 assert( EXPR_FULLSIZE
<=0xfff );
1327 assert( (0xfff & (EP_Reduced
|EP_TokenOnly
))==0 );
1328 if( 0==flags
|| p
->op
==TK_SELECT_COLUMN
1329 #ifndef SQLITE_OMIT_WINDOWFUNC
1330 || ExprHasProperty(p
, EP_WinFunc
)
1333 nSize
= EXPR_FULLSIZE
;
1335 assert( !ExprHasProperty(p
, EP_TokenOnly
|EP_Reduced
) );
1336 assert( !ExprHasProperty(p
, EP_FromJoin
) );
1337 assert( !ExprHasProperty(p
, EP_MemToken
) );
1338 assert( !ExprHasVVAProperty(p
, EP_NoReduce
) );
1339 if( p
->pLeft
|| p
->x
.pList
){
1340 nSize
= EXPR_REDUCEDSIZE
| EP_Reduced
;
1342 assert( p
->pRight
==0 );
1343 nSize
= EXPR_TOKENONLYSIZE
| EP_TokenOnly
;
1350 ** This function returns the space in bytes required to store the copy
1351 ** of the Expr structure and a copy of the Expr.u.zToken string (if that
1352 ** string is defined.)
1354 static int dupedExprNodeSize(const Expr
*p
, int flags
){
1355 int nByte
= dupedExprStructSize(p
, flags
) & 0xfff;
1356 if( !ExprHasProperty(p
, EP_IntValue
) && p
->u
.zToken
){
1357 nByte
+= sqlite3Strlen30NN(p
->u
.zToken
)+1;
1359 return ROUND8(nByte
);
1363 ** Return the number of bytes required to create a duplicate of the
1364 ** expression passed as the first argument. The second argument is a
1365 ** mask containing EXPRDUP_XXX flags.
1367 ** The value returned includes space to create a copy of the Expr struct
1368 ** itself and the buffer referred to by Expr.u.zToken, if any.
1370 ** If the EXPRDUP_REDUCE flag is set, then the return value includes
1371 ** space to duplicate all Expr nodes in the tree formed by Expr.pLeft
1372 ** and Expr.pRight variables (but not for any structures pointed to or
1373 ** descended from the Expr.x.pList or Expr.x.pSelect variables).
1375 static int dupedExprSize(const Expr
*p
, int flags
){
1378 nByte
= dupedExprNodeSize(p
, flags
);
1379 if( flags
&EXPRDUP_REDUCE
){
1380 nByte
+= dupedExprSize(p
->pLeft
, flags
) + dupedExprSize(p
->pRight
, flags
);
1387 ** This function is similar to sqlite3ExprDup(), except that if pzBuffer
1388 ** is not NULL then *pzBuffer is assumed to point to a buffer large enough
1389 ** to store the copy of expression p, the copies of p->u.zToken
1390 ** (if applicable), and the copies of the p->pLeft and p->pRight expressions,
1391 ** if any. Before returning, *pzBuffer is set to the first byte past the
1392 ** portion of the buffer copied into by this function.
1394 static Expr
*exprDup(sqlite3
*db
, const Expr
*p
, int dupFlags
, u8
**pzBuffer
){
1395 Expr
*pNew
; /* Value to return */
1396 u8
*zAlloc
; /* Memory space from which to build Expr object */
1397 u32 staticFlag
; /* EP_Static if space not obtained from malloc */
1401 assert( dupFlags
==0 || dupFlags
==EXPRDUP_REDUCE
);
1402 assert( pzBuffer
==0 || dupFlags
==EXPRDUP_REDUCE
);
1404 /* Figure out where to write the new Expr structure. */
1407 staticFlag
= EP_Static
;
1408 assert( zAlloc
!=0 );
1410 zAlloc
= sqlite3DbMallocRawNN(db
, dupedExprSize(p
, dupFlags
));
1413 pNew
= (Expr
*)zAlloc
;
1416 /* Set nNewSize to the size allocated for the structure pointed to
1417 ** by pNew. This is either EXPR_FULLSIZE, EXPR_REDUCEDSIZE or
1418 ** EXPR_TOKENONLYSIZE. nToken is set to the number of bytes consumed
1419 ** by the copy of the p->u.zToken string (if any).
1421 const unsigned nStructSize
= dupedExprStructSize(p
, dupFlags
);
1422 const int nNewSize
= nStructSize
& 0xfff;
1424 if( !ExprHasProperty(p
, EP_IntValue
) && p
->u
.zToken
){
1425 nToken
= sqlite3Strlen30(p
->u
.zToken
) + 1;
1430 assert( ExprHasProperty(p
, EP_Reduced
)==0 );
1431 memcpy(zAlloc
, p
, nNewSize
);
1433 u32 nSize
= (u32
)exprStructSize(p
);
1434 memcpy(zAlloc
, p
, nSize
);
1435 if( nSize
<EXPR_FULLSIZE
){
1436 memset(&zAlloc
[nSize
], 0, EXPR_FULLSIZE
-nSize
);
1440 /* Set the EP_Reduced, EP_TokenOnly, and EP_Static flags appropriately. */
1441 pNew
->flags
&= ~(EP_Reduced
|EP_TokenOnly
|EP_Static
|EP_MemToken
);
1442 pNew
->flags
|= nStructSize
& (EP_Reduced
|EP_TokenOnly
);
1443 pNew
->flags
|= staticFlag
;
1444 ExprClearVVAProperties(pNew
);
1446 ExprSetVVAProperty(pNew
, EP_Immutable
);
1449 /* Copy the p->u.zToken string, if any. */
1451 char *zToken
= pNew
->u
.zToken
= (char*)&zAlloc
[nNewSize
];
1452 memcpy(zToken
, p
->u
.zToken
, nToken
);
1455 if( 0==((p
->flags
|pNew
->flags
) & (EP_TokenOnly
|EP_Leaf
)) ){
1456 /* Fill in the pNew->x.pSelect or pNew->x.pList member. */
1457 if( ExprUseXSelect(p
) ){
1458 pNew
->x
.pSelect
= sqlite3SelectDup(db
, p
->x
.pSelect
, dupFlags
);
1460 pNew
->x
.pList
= sqlite3ExprListDup(db
, p
->x
.pList
, dupFlags
);
1464 /* Fill in pNew->pLeft and pNew->pRight. */
1465 if( ExprHasProperty(pNew
, EP_Reduced
|EP_TokenOnly
|EP_WinFunc
) ){
1466 zAlloc
+= dupedExprNodeSize(p
, dupFlags
);
1467 if( !ExprHasProperty(pNew
, EP_TokenOnly
|EP_Leaf
) ){
1468 pNew
->pLeft
= p
->pLeft
?
1469 exprDup(db
, p
->pLeft
, EXPRDUP_REDUCE
, &zAlloc
) : 0;
1470 pNew
->pRight
= p
->pRight
?
1471 exprDup(db
, p
->pRight
, EXPRDUP_REDUCE
, &zAlloc
) : 0;
1473 #ifndef SQLITE_OMIT_WINDOWFUNC
1474 if( ExprHasProperty(p
, EP_WinFunc
) ){
1475 pNew
->y
.pWin
= sqlite3WindowDup(db
, pNew
, p
->y
.pWin
);
1476 assert( ExprHasProperty(pNew
, EP_WinFunc
) );
1478 #endif /* SQLITE_OMIT_WINDOWFUNC */
1483 if( !ExprHasProperty(p
, EP_TokenOnly
|EP_Leaf
) ){
1484 if( pNew
->op
==TK_SELECT_COLUMN
){
1485 pNew
->pLeft
= p
->pLeft
;
1486 assert( p
->pRight
==0 || p
->pRight
==p
->pLeft
1487 || ExprHasProperty(p
->pLeft
, EP_Subquery
) );
1489 pNew
->pLeft
= sqlite3ExprDup(db
, p
->pLeft
, 0);
1491 pNew
->pRight
= sqlite3ExprDup(db
, p
->pRight
, 0);
1499 ** Create and return a deep copy of the object passed as the second
1500 ** argument. If an OOM condition is encountered, NULL is returned
1501 ** and the db->mallocFailed flag set.
1503 #ifndef SQLITE_OMIT_CTE
1504 With
*sqlite3WithDup(sqlite3
*db
, With
*p
){
1507 sqlite3_int64 nByte
= sizeof(*p
) + sizeof(p
->a
[0]) * (p
->nCte
-1);
1508 pRet
= sqlite3DbMallocZero(db
, nByte
);
1511 pRet
->nCte
= p
->nCte
;
1512 for(i
=0; i
<p
->nCte
; i
++){
1513 pRet
->a
[i
].pSelect
= sqlite3SelectDup(db
, p
->a
[i
].pSelect
, 0);
1514 pRet
->a
[i
].pCols
= sqlite3ExprListDup(db
, p
->a
[i
].pCols
, 0);
1515 pRet
->a
[i
].zName
= sqlite3DbStrDup(db
, p
->a
[i
].zName
);
1522 # define sqlite3WithDup(x,y) 0
1525 #ifndef SQLITE_OMIT_WINDOWFUNC
1527 ** The gatherSelectWindows() procedure and its helper routine
1528 ** gatherSelectWindowsCallback() are used to scan all the expressions
1529 ** an a newly duplicated SELECT statement and gather all of the Window
1530 ** objects found there, assembling them onto the linked list at Select->pWin.
1532 static int gatherSelectWindowsCallback(Walker
*pWalker
, Expr
*pExpr
){
1533 if( pExpr
->op
==TK_FUNCTION
&& ExprHasProperty(pExpr
, EP_WinFunc
) ){
1534 Select
*pSelect
= pWalker
->u
.pSelect
;
1535 Window
*pWin
= pExpr
->y
.pWin
;
1537 assert( IsWindowFunc(pExpr
) );
1538 assert( pWin
->ppThis
==0 );
1539 sqlite3WindowLink(pSelect
, pWin
);
1541 return WRC_Continue
;
1543 static int gatherSelectWindowsSelectCallback(Walker
*pWalker
, Select
*p
){
1544 return p
==pWalker
->u
.pSelect
? WRC_Continue
: WRC_Prune
;
1546 static void gatherSelectWindows(Select
*p
){
1548 w
.xExprCallback
= gatherSelectWindowsCallback
;
1549 w
.xSelectCallback
= gatherSelectWindowsSelectCallback
;
1550 w
.xSelectCallback2
= 0;
1553 sqlite3WalkSelect(&w
, p
);
1559 ** The following group of routines make deep copies of expressions,
1560 ** expression lists, ID lists, and select statements. The copies can
1561 ** be deleted (by being passed to their respective ...Delete() routines)
1562 ** without effecting the originals.
1564 ** The expression list, ID, and source lists return by sqlite3ExprListDup(),
1565 ** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded
1566 ** by subsequent calls to sqlite*ListAppend() routines.
1568 ** Any tables that the SrcList might point to are not duplicated.
1570 ** The flags parameter contains a combination of the EXPRDUP_XXX flags.
1571 ** If the EXPRDUP_REDUCE flag is set, then the structure returned is a
1572 ** truncated version of the usual Expr structure that will be stored as
1573 ** part of the in-memory representation of the database schema.
1575 Expr
*sqlite3ExprDup(sqlite3
*db
, const Expr
*p
, int flags
){
1576 assert( flags
==0 || flags
==EXPRDUP_REDUCE
);
1577 return p
? exprDup(db
, p
, flags
, 0) : 0;
1579 ExprList
*sqlite3ExprListDup(sqlite3
*db
, const ExprList
*p
, int flags
){
1581 struct ExprList_item
*pItem
;
1582 const struct ExprList_item
*pOldItem
;
1584 Expr
*pPriorSelectColOld
= 0;
1585 Expr
*pPriorSelectColNew
= 0;
1587 if( p
==0 ) return 0;
1588 pNew
= sqlite3DbMallocRawNN(db
, sqlite3DbMallocSize(db
, p
));
1589 if( pNew
==0 ) return 0;
1590 pNew
->nExpr
= p
->nExpr
;
1591 pNew
->nAlloc
= p
->nAlloc
;
1594 for(i
=0; i
<p
->nExpr
; i
++, pItem
++, pOldItem
++){
1595 Expr
*pOldExpr
= pOldItem
->pExpr
;
1597 pItem
->pExpr
= sqlite3ExprDup(db
, pOldExpr
, flags
);
1599 && pOldExpr
->op
==TK_SELECT_COLUMN
1600 && (pNewExpr
= pItem
->pExpr
)!=0
1602 if( pNewExpr
->pRight
){
1603 pPriorSelectColOld
= pOldExpr
->pRight
;
1604 pPriorSelectColNew
= pNewExpr
->pRight
;
1605 pNewExpr
->pLeft
= pNewExpr
->pRight
;
1607 if( pOldExpr
->pLeft
!=pPriorSelectColOld
){
1608 pPriorSelectColOld
= pOldExpr
->pLeft
;
1609 pPriorSelectColNew
= sqlite3ExprDup(db
, pPriorSelectColOld
, flags
);
1610 pNewExpr
->pRight
= pPriorSelectColNew
;
1612 pNewExpr
->pLeft
= pPriorSelectColNew
;
1615 pItem
->zEName
= sqlite3DbStrDup(db
, pOldItem
->zEName
);
1616 pItem
->sortFlags
= pOldItem
->sortFlags
;
1617 pItem
->eEName
= pOldItem
->eEName
;
1619 pItem
->bNulls
= pOldItem
->bNulls
;
1620 pItem
->bSorterRef
= pOldItem
->bSorterRef
;
1621 pItem
->u
= pOldItem
->u
;
1627 ** If cursors, triggers, views and subqueries are all omitted from
1628 ** the build, then none of the following routines, except for
1629 ** sqlite3SelectDup(), can be called. sqlite3SelectDup() is sometimes
1630 ** called with a NULL argument.
1632 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) \
1633 || !defined(SQLITE_OMIT_SUBQUERY)
1634 SrcList
*sqlite3SrcListDup(sqlite3
*db
, const SrcList
*p
, int flags
){
1639 if( p
==0 ) return 0;
1640 nByte
= sizeof(*p
) + (p
->nSrc
>0 ? sizeof(p
->a
[0]) * (p
->nSrc
-1) : 0);
1641 pNew
= sqlite3DbMallocRawNN(db
, nByte
);
1642 if( pNew
==0 ) return 0;
1643 pNew
->nSrc
= pNew
->nAlloc
= p
->nSrc
;
1644 for(i
=0; i
<p
->nSrc
; i
++){
1645 SrcItem
*pNewItem
= &pNew
->a
[i
];
1646 const SrcItem
*pOldItem
= &p
->a
[i
];
1648 pNewItem
->pSchema
= pOldItem
->pSchema
;
1649 pNewItem
->zDatabase
= sqlite3DbStrDup(db
, pOldItem
->zDatabase
);
1650 pNewItem
->zName
= sqlite3DbStrDup(db
, pOldItem
->zName
);
1651 pNewItem
->zAlias
= sqlite3DbStrDup(db
, pOldItem
->zAlias
);
1652 pNewItem
->fg
= pOldItem
->fg
;
1653 pNewItem
->iCursor
= pOldItem
->iCursor
;
1654 pNewItem
->addrFillSub
= pOldItem
->addrFillSub
;
1655 pNewItem
->regReturn
= pOldItem
->regReturn
;
1656 if( pNewItem
->fg
.isIndexedBy
){
1657 pNewItem
->u1
.zIndexedBy
= sqlite3DbStrDup(db
, pOldItem
->u1
.zIndexedBy
);
1659 pNewItem
->u2
= pOldItem
->u2
;
1660 if( pNewItem
->fg
.isCte
){
1661 pNewItem
->u2
.pCteUse
->nUse
++;
1663 if( pNewItem
->fg
.isTabFunc
){
1664 pNewItem
->u1
.pFuncArg
=
1665 sqlite3ExprListDup(db
, pOldItem
->u1
.pFuncArg
, flags
);
1667 pTab
= pNewItem
->pTab
= pOldItem
->pTab
;
1671 pNewItem
->pSelect
= sqlite3SelectDup(db
, pOldItem
->pSelect
, flags
);
1672 pNewItem
->pOn
= sqlite3ExprDup(db
, pOldItem
->pOn
, flags
);
1673 pNewItem
->pUsing
= sqlite3IdListDup(db
, pOldItem
->pUsing
);
1674 pNewItem
->colUsed
= pOldItem
->colUsed
;
1678 IdList
*sqlite3IdListDup(sqlite3
*db
, const IdList
*p
){
1682 if( p
==0 ) return 0;
1683 pNew
= sqlite3DbMallocRawNN(db
, sizeof(*pNew
) );
1684 if( pNew
==0 ) return 0;
1686 pNew
->a
= sqlite3DbMallocRawNN(db
, p
->nId
*sizeof(p
->a
[0]) );
1688 sqlite3DbFreeNN(db
, pNew
);
1691 /* Note that because the size of the allocation for p->a[] is not
1692 ** necessarily a power of two, sqlite3IdListAppend() may not be called
1693 ** on the duplicate created by this function. */
1694 for(i
=0; i
<p
->nId
; i
++){
1695 struct IdList_item
*pNewItem
= &pNew
->a
[i
];
1696 struct IdList_item
*pOldItem
= &p
->a
[i
];
1697 pNewItem
->zName
= sqlite3DbStrDup(db
, pOldItem
->zName
);
1698 pNewItem
->idx
= pOldItem
->idx
;
1702 Select
*sqlite3SelectDup(sqlite3
*db
, const Select
*pDup
, int flags
){
1705 Select
**pp
= &pRet
;
1709 for(p
=pDup
; p
; p
=p
->pPrior
){
1710 Select
*pNew
= sqlite3DbMallocRawNN(db
, sizeof(*p
) );
1711 if( pNew
==0 ) break;
1712 pNew
->pEList
= sqlite3ExprListDup(db
, p
->pEList
, flags
);
1713 pNew
->pSrc
= sqlite3SrcListDup(db
, p
->pSrc
, flags
);
1714 pNew
->pWhere
= sqlite3ExprDup(db
, p
->pWhere
, flags
);
1715 pNew
->pGroupBy
= sqlite3ExprListDup(db
, p
->pGroupBy
, flags
);
1716 pNew
->pHaving
= sqlite3ExprDup(db
, p
->pHaving
, flags
);
1717 pNew
->pOrderBy
= sqlite3ExprListDup(db
, p
->pOrderBy
, flags
);
1719 pNew
->pNext
= pNext
;
1721 pNew
->pLimit
= sqlite3ExprDup(db
, p
->pLimit
, flags
);
1724 pNew
->selFlags
= p
->selFlags
& ~SF_UsesEphemeral
;
1725 pNew
->addrOpenEphm
[0] = -1;
1726 pNew
->addrOpenEphm
[1] = -1;
1727 pNew
->nSelectRow
= p
->nSelectRow
;
1728 pNew
->pWith
= sqlite3WithDup(db
, p
->pWith
);
1729 #ifndef SQLITE_OMIT_WINDOWFUNC
1731 pNew
->pWinDefn
= sqlite3WindowListDup(db
, p
->pWinDefn
);
1732 if( p
->pWin
&& db
->mallocFailed
==0 ) gatherSelectWindows(pNew
);
1734 pNew
->selId
= p
->selId
;
1735 if( db
->mallocFailed
){
1736 /* Any prior OOM might have left the Select object incomplete.
1737 ** Delete the whole thing rather than allow an incomplete Select
1738 ** to be used by the code generator. */
1740 sqlite3SelectDelete(db
, pNew
);
1751 Select
*sqlite3SelectDup(sqlite3
*db
, const Select
*p
, int flags
){
1759 ** Add a new element to the end of an expression list. If pList is
1760 ** initially NULL, then create a new expression list.
1762 ** The pList argument must be either NULL or a pointer to an ExprList
1763 ** obtained from a prior call to sqlite3ExprListAppend(). This routine
1764 ** may not be used with an ExprList obtained from sqlite3ExprListDup().
1765 ** Reason: This routine assumes that the number of slots in pList->a[]
1766 ** is a power of two. That is true for sqlite3ExprListAppend() returns
1767 ** but is not necessarily true from the return value of sqlite3ExprListDup().
1769 ** If a memory allocation error occurs, the entire list is freed and
1770 ** NULL is returned. If non-NULL is returned, then it is guaranteed
1771 ** that the new entry was successfully appended.
1773 static const struct ExprList_item zeroItem
= {0};
1774 SQLITE_NOINLINE ExprList
*sqlite3ExprListAppendNew(
1775 sqlite3
*db
, /* Database handle. Used for memory allocation */
1776 Expr
*pExpr
/* Expression to be appended. Might be NULL */
1778 struct ExprList_item
*pItem
;
1781 pList
= sqlite3DbMallocRawNN(db
, sizeof(ExprList
)+sizeof(pList
->a
[0])*4 );
1783 sqlite3ExprDelete(db
, pExpr
);
1788 pItem
= &pList
->a
[0];
1790 pItem
->pExpr
= pExpr
;
1793 SQLITE_NOINLINE ExprList
*sqlite3ExprListAppendGrow(
1794 sqlite3
*db
, /* Database handle. Used for memory allocation */
1795 ExprList
*pList
, /* List to which to append. Might be NULL */
1796 Expr
*pExpr
/* Expression to be appended. Might be NULL */
1798 struct ExprList_item
*pItem
;
1801 pNew
= sqlite3DbRealloc(db
, pList
,
1802 sizeof(*pList
)+(pList
->nAlloc
-1)*sizeof(pList
->a
[0]));
1804 sqlite3ExprListDelete(db
, pList
);
1805 sqlite3ExprDelete(db
, pExpr
);
1810 pItem
= &pList
->a
[pList
->nExpr
++];
1812 pItem
->pExpr
= pExpr
;
1815 ExprList
*sqlite3ExprListAppend(
1816 Parse
*pParse
, /* Parsing context */
1817 ExprList
*pList
, /* List to which to append. Might be NULL */
1818 Expr
*pExpr
/* Expression to be appended. Might be NULL */
1820 struct ExprList_item
*pItem
;
1822 return sqlite3ExprListAppendNew(pParse
->db
,pExpr
);
1824 if( pList
->nAlloc
<pList
->nExpr
+1 ){
1825 return sqlite3ExprListAppendGrow(pParse
->db
,pList
,pExpr
);
1827 pItem
= &pList
->a
[pList
->nExpr
++];
1829 pItem
->pExpr
= pExpr
;
1834 ** pColumns and pExpr form a vector assignment which is part of the SET
1835 ** clause of an UPDATE statement. Like this:
1837 ** (a,b,c) = (expr1,expr2,expr3)
1838 ** Or: (a,b,c) = (SELECT x,y,z FROM ....)
1840 ** For each term of the vector assignment, append new entries to the
1841 ** expression list pList. In the case of a subquery on the RHS, append
1842 ** TK_SELECT_COLUMN expressions.
1844 ExprList
*sqlite3ExprListAppendVector(
1845 Parse
*pParse
, /* Parsing context */
1846 ExprList
*pList
, /* List to which to append. Might be NULL */
1847 IdList
*pColumns
, /* List of names of LHS of the assignment */
1848 Expr
*pExpr
/* Vector expression to be appended. Might be NULL */
1850 sqlite3
*db
= pParse
->db
;
1853 int iFirst
= pList
? pList
->nExpr
: 0;
1854 /* pColumns can only be NULL due to an OOM but an OOM will cause an
1855 ** exit prior to this routine being invoked */
1856 if( NEVER(pColumns
==0) ) goto vector_append_error
;
1857 if( pExpr
==0 ) goto vector_append_error
;
1859 /* If the RHS is a vector, then we can immediately check to see that
1860 ** the size of the RHS and LHS match. But if the RHS is a SELECT,
1861 ** wildcards ("*") in the result set of the SELECT must be expanded before
1862 ** we can do the size check, so defer the size check until code generation.
1864 if( pExpr
->op
!=TK_SELECT
&& pColumns
->nId
!=(n
=sqlite3ExprVectorSize(pExpr
)) ){
1865 sqlite3ErrorMsg(pParse
, "%d columns assigned %d values",
1867 goto vector_append_error
;
1870 for(i
=0; i
<pColumns
->nId
; i
++){
1871 Expr
*pSubExpr
= sqlite3ExprForVectorField(pParse
, pExpr
, i
, pColumns
->nId
);
1872 assert( pSubExpr
!=0 || db
->mallocFailed
);
1873 if( pSubExpr
==0 ) continue;
1874 pList
= sqlite3ExprListAppend(pParse
, pList
, pSubExpr
);
1876 assert( pList
->nExpr
==iFirst
+i
+1 );
1877 pList
->a
[pList
->nExpr
-1].zEName
= pColumns
->a
[i
].zName
;
1878 pColumns
->a
[i
].zName
= 0;
1882 if( !db
->mallocFailed
&& pExpr
->op
==TK_SELECT
&& ALWAYS(pList
!=0) ){
1883 Expr
*pFirst
= pList
->a
[iFirst
].pExpr
;
1884 assert( pFirst
!=0 );
1885 assert( pFirst
->op
==TK_SELECT_COLUMN
);
1887 /* Store the SELECT statement in pRight so it will be deleted when
1888 ** sqlite3ExprListDelete() is called */
1889 pFirst
->pRight
= pExpr
;
1892 /* Remember the size of the LHS in iTable so that we can check that
1893 ** the RHS and LHS sizes match during code generation. */
1894 pFirst
->iTable
= pColumns
->nId
;
1897 vector_append_error
:
1898 sqlite3ExprUnmapAndDelete(pParse
, pExpr
);
1899 sqlite3IdListDelete(db
, pColumns
);
1904 ** Set the sort order for the last element on the given ExprList.
1906 void sqlite3ExprListSetSortOrder(ExprList
*p
, int iSortOrder
, int eNulls
){
1907 struct ExprList_item
*pItem
;
1909 assert( p
->nExpr
>0 );
1911 assert( SQLITE_SO_UNDEFINED
<0 && SQLITE_SO_ASC
==0 && SQLITE_SO_DESC
>0 );
1912 assert( iSortOrder
==SQLITE_SO_UNDEFINED
1913 || iSortOrder
==SQLITE_SO_ASC
1914 || iSortOrder
==SQLITE_SO_DESC
1916 assert( eNulls
==SQLITE_SO_UNDEFINED
1917 || eNulls
==SQLITE_SO_ASC
1918 || eNulls
==SQLITE_SO_DESC
1921 pItem
= &p
->a
[p
->nExpr
-1];
1922 assert( pItem
->bNulls
==0 );
1923 if( iSortOrder
==SQLITE_SO_UNDEFINED
){
1924 iSortOrder
= SQLITE_SO_ASC
;
1926 pItem
->sortFlags
= (u8
)iSortOrder
;
1928 if( eNulls
!=SQLITE_SO_UNDEFINED
){
1930 if( iSortOrder
!=eNulls
){
1931 pItem
->sortFlags
|= KEYINFO_ORDER_BIGNULL
;
1937 ** Set the ExprList.a[].zEName element of the most recently added item
1938 ** on the expression list.
1940 ** pList might be NULL following an OOM error. But pName should never be
1941 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
1944 void sqlite3ExprListSetName(
1945 Parse
*pParse
, /* Parsing context */
1946 ExprList
*pList
, /* List to which to add the span. */
1947 const Token
*pName
, /* Name to be added */
1948 int dequote
/* True to cause the name to be dequoted */
1950 assert( pList
!=0 || pParse
->db
->mallocFailed
!=0 );
1951 assert( pParse
->eParseMode
!=PARSE_MODE_UNMAP
|| dequote
==0 );
1953 struct ExprList_item
*pItem
;
1954 assert( pList
->nExpr
>0 );
1955 pItem
= &pList
->a
[pList
->nExpr
-1];
1956 assert( pItem
->zEName
==0 );
1957 assert( pItem
->eEName
==ENAME_NAME
);
1958 pItem
->zEName
= sqlite3DbStrNDup(pParse
->db
, pName
->z
, pName
->n
);
1960 /* If dequote==0, then pName->z does not point to part of a DDL
1961 ** statement handled by the parser. And so no token need be added
1962 ** to the token-map. */
1963 sqlite3Dequote(pItem
->zEName
);
1964 if( IN_RENAME_OBJECT
){
1965 sqlite3RenameTokenMap(pParse
, (const void*)pItem
->zEName
, pName
);
1972 ** Set the ExprList.a[].zSpan element of the most recently added item
1973 ** on the expression list.
1975 ** pList might be NULL following an OOM error. But pSpan should never be
1976 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
1979 void sqlite3ExprListSetSpan(
1980 Parse
*pParse
, /* Parsing context */
1981 ExprList
*pList
, /* List to which to add the span. */
1982 const char *zStart
, /* Start of the span */
1983 const char *zEnd
/* End of the span */
1985 sqlite3
*db
= pParse
->db
;
1986 assert( pList
!=0 || db
->mallocFailed
!=0 );
1988 struct ExprList_item
*pItem
= &pList
->a
[pList
->nExpr
-1];
1989 assert( pList
->nExpr
>0 );
1990 if( pItem
->zEName
==0 ){
1991 pItem
->zEName
= sqlite3DbSpanDup(db
, zStart
, zEnd
);
1992 pItem
->eEName
= ENAME_SPAN
;
1998 ** If the expression list pEList contains more than iLimit elements,
1999 ** leave an error message in pParse.
2001 void sqlite3ExprListCheckLength(
2006 int mx
= pParse
->db
->aLimit
[SQLITE_LIMIT_COLUMN
];
2007 testcase( pEList
&& pEList
->nExpr
==mx
);
2008 testcase( pEList
&& pEList
->nExpr
==mx
+1 );
2009 if( pEList
&& pEList
->nExpr
>mx
){
2010 sqlite3ErrorMsg(pParse
, "too many columns in %s", zObject
);
2015 ** Delete an entire expression list.
2017 static SQLITE_NOINLINE
void exprListDeleteNN(sqlite3
*db
, ExprList
*pList
){
2018 int i
= pList
->nExpr
;
2019 struct ExprList_item
*pItem
= pList
->a
;
2020 assert( pList
->nExpr
>0 );
2022 sqlite3ExprDelete(db
, pItem
->pExpr
);
2023 sqlite3DbFree(db
, pItem
->zEName
);
2026 sqlite3DbFreeNN(db
, pList
);
2028 void sqlite3ExprListDelete(sqlite3
*db
, ExprList
*pList
){
2029 if( pList
) exprListDeleteNN(db
, pList
);
2033 ** Return the bitwise-OR of all Expr.flags fields in the given
2036 u32
sqlite3ExprListFlags(const ExprList
*pList
){
2040 for(i
=0; i
<pList
->nExpr
; i
++){
2041 Expr
*pExpr
= pList
->a
[i
].pExpr
;
2049 ** This is a SELECT-node callback for the expression walker that
2050 ** always "fails". By "fail" in this case, we mean set
2051 ** pWalker->eCode to zero and abort.
2053 ** This callback is used by multiple expression walkers.
2055 int sqlite3SelectWalkFail(Walker
*pWalker
, Select
*NotUsed
){
2056 UNUSED_PARAMETER(NotUsed
);
2062 ** Check the input string to see if it is "true" or "false" (in any case).
2064 ** If the string is.... Return
2066 ** "false" EP_IsFalse
2069 u32
sqlite3IsTrueOrFalse(const char *zIn
){
2070 if( sqlite3StrICmp(zIn
, "true")==0 ) return EP_IsTrue
;
2071 if( sqlite3StrICmp(zIn
, "false")==0 ) return EP_IsFalse
;
2077 ** If the input expression is an ID with the name "true" or "false"
2078 ** then convert it into an TK_TRUEFALSE term. Return non-zero if
2079 ** the conversion happened, and zero if the expression is unaltered.
2081 int sqlite3ExprIdToTrueFalse(Expr
*pExpr
){
2083 assert( pExpr
->op
==TK_ID
|| pExpr
->op
==TK_STRING
);
2084 if( !ExprHasProperty(pExpr
, EP_Quoted
|EP_IntValue
)
2085 && (v
= sqlite3IsTrueOrFalse(pExpr
->u
.zToken
))!=0
2087 pExpr
->op
= TK_TRUEFALSE
;
2088 ExprSetProperty(pExpr
, v
);
2095 ** The argument must be a TK_TRUEFALSE Expr node. Return 1 if it is TRUE
2096 ** and 0 if it is FALSE.
2098 int sqlite3ExprTruthValue(const Expr
*pExpr
){
2099 pExpr
= sqlite3ExprSkipCollate((Expr
*)pExpr
);
2100 assert( pExpr
->op
==TK_TRUEFALSE
);
2101 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
2102 assert( sqlite3StrICmp(pExpr
->u
.zToken
,"true")==0
2103 || sqlite3StrICmp(pExpr
->u
.zToken
,"false")==0 );
2104 return pExpr
->u
.zToken
[4]==0;
2108 ** If pExpr is an AND or OR expression, try to simplify it by eliminating
2109 ** terms that are always true or false. Return the simplified expression.
2110 ** Or return the original expression if no simplification is possible.
2114 ** (x<10) AND true => (x<10)
2115 ** (x<10) AND false => false
2116 ** (x<10) AND (y=22 OR false) => (x<10) AND (y=22)
2117 ** (x<10) AND (y=22 OR true) => (x<10)
2118 ** (y=22) OR true => true
2120 Expr
*sqlite3ExprSimplifiedAndOr(Expr
*pExpr
){
2122 if( pExpr
->op
==TK_AND
|| pExpr
->op
==TK_OR
){
2123 Expr
*pRight
= sqlite3ExprSimplifiedAndOr(pExpr
->pRight
);
2124 Expr
*pLeft
= sqlite3ExprSimplifiedAndOr(pExpr
->pLeft
);
2125 if( ExprAlwaysTrue(pLeft
) || ExprAlwaysFalse(pRight
) ){
2126 pExpr
= pExpr
->op
==TK_AND
? pRight
: pLeft
;
2127 }else if( ExprAlwaysTrue(pRight
) || ExprAlwaysFalse(pLeft
) ){
2128 pExpr
= pExpr
->op
==TK_AND
? pLeft
: pRight
;
2136 ** These routines are Walker callbacks used to check expressions to
2137 ** see if they are "constant" for some definition of constant. The
2138 ** Walker.eCode value determines the type of "constant" we are looking
2141 ** These callback routines are used to implement the following:
2143 ** sqlite3ExprIsConstant() pWalker->eCode==1
2144 ** sqlite3ExprIsConstantNotJoin() pWalker->eCode==2
2145 ** sqlite3ExprIsTableConstant() pWalker->eCode==3
2146 ** sqlite3ExprIsConstantOrFunction() pWalker->eCode==4 or 5
2148 ** In all cases, the callbacks set Walker.eCode=0 and abort if the expression
2149 ** is found to not be a constant.
2151 ** The sqlite3ExprIsConstantOrFunction() is used for evaluating DEFAULT
2152 ** expressions in a CREATE TABLE statement. The Walker.eCode value is 5
2153 ** when parsing an existing schema out of the sqlite_schema table and 4
2154 ** when processing a new CREATE TABLE statement. A bound parameter raises
2155 ** an error for new statements, but is silently converted
2156 ** to NULL for existing schemas. This allows sqlite_schema tables that
2157 ** contain a bound parameter because they were generated by older versions
2158 ** of SQLite to be parsed by newer versions of SQLite without raising a
2159 ** malformed schema error.
2161 static int exprNodeIsConstant(Walker
*pWalker
, Expr
*pExpr
){
2163 /* If pWalker->eCode is 2 then any term of the expression that comes from
2164 ** the ON or USING clauses of a left join disqualifies the expression
2165 ** from being considered constant. */
2166 if( pWalker
->eCode
==2 && ExprHasProperty(pExpr
, EP_FromJoin
) ){
2171 switch( pExpr
->op
){
2172 /* Consider functions to be constant if all their arguments are constant
2173 ** and either pWalker->eCode==4 or 5 or the function has the
2174 ** SQLITE_FUNC_CONST flag. */
2176 if( (pWalker
->eCode
>=4 || ExprHasProperty(pExpr
,EP_ConstFunc
))
2177 && !ExprHasProperty(pExpr
, EP_WinFunc
)
2179 if( pWalker
->eCode
==5 ) ExprSetProperty(pExpr
, EP_FromDDL
);
2180 return WRC_Continue
;
2186 /* Convert "true" or "false" in a DEFAULT clause into the
2187 ** appropriate TK_TRUEFALSE operator */
2188 if( sqlite3ExprIdToTrueFalse(pExpr
) ){
2191 /* no break */ deliberate_fall_through
2193 case TK_AGG_FUNCTION
:
2195 testcase( pExpr
->op
==TK_ID
);
2196 testcase( pExpr
->op
==TK_COLUMN
);
2197 testcase( pExpr
->op
==TK_AGG_FUNCTION
);
2198 testcase( pExpr
->op
==TK_AGG_COLUMN
);
2199 if( ExprHasProperty(pExpr
, EP_FixedCol
) && pWalker
->eCode
!=2 ){
2200 return WRC_Continue
;
2202 if( pWalker
->eCode
==3 && pExpr
->iTable
==pWalker
->u
.iCur
){
2203 return WRC_Continue
;
2205 /* no break */ deliberate_fall_through
2206 case TK_IF_NULL_ROW
:
2209 testcase( pExpr
->op
==TK_REGISTER
);
2210 testcase( pExpr
->op
==TK_IF_NULL_ROW
);
2211 testcase( pExpr
->op
==TK_DOT
);
2215 if( pWalker
->eCode
==5 ){
2216 /* Silently convert bound parameters that appear inside of CREATE
2217 ** statements into a NULL when parsing the CREATE statement text out
2218 ** of the sqlite_schema table */
2219 pExpr
->op
= TK_NULL
;
2220 }else if( pWalker
->eCode
==4 ){
2221 /* A bound parameter in a CREATE statement that originates from
2222 ** sqlite3_prepare() causes an error */
2226 /* no break */ deliberate_fall_through
2228 testcase( pExpr
->op
==TK_SELECT
); /* sqlite3SelectWalkFail() disallows */
2229 testcase( pExpr
->op
==TK_EXISTS
); /* sqlite3SelectWalkFail() disallows */
2230 return WRC_Continue
;
2233 static int exprIsConst(Expr
*p
, int initFlag
, int iCur
){
2236 w
.xExprCallback
= exprNodeIsConstant
;
2237 w
.xSelectCallback
= sqlite3SelectWalkFail
;
2239 w
.xSelectCallback2
= sqlite3SelectWalkAssert2
;
2242 sqlite3WalkExpr(&w
, p
);
2247 ** Walk an expression tree. Return non-zero if the expression is constant
2248 ** and 0 if it involves variables or function calls.
2250 ** For the purposes of this function, a double-quoted string (ex: "abc")
2251 ** is considered a variable but a single-quoted string (ex: 'abc') is
2254 int sqlite3ExprIsConstant(Expr
*p
){
2255 return exprIsConst(p
, 1, 0);
2259 ** Walk an expression tree. Return non-zero if
2261 ** (1) the expression is constant, and
2262 ** (2) the expression does originate in the ON or USING clause
2263 ** of a LEFT JOIN, and
2264 ** (3) the expression does not contain any EP_FixedCol TK_COLUMN
2265 ** operands created by the constant propagation optimization.
2267 ** When this routine returns true, it indicates that the expression
2268 ** can be added to the pParse->pConstExpr list and evaluated once when
2269 ** the prepared statement starts up. See sqlite3ExprCodeRunJustOnce().
2271 int sqlite3ExprIsConstantNotJoin(Expr
*p
){
2272 return exprIsConst(p
, 2, 0);
2276 ** Walk an expression tree. Return non-zero if the expression is constant
2277 ** for any single row of the table with cursor iCur. In other words, the
2278 ** expression must not refer to any non-deterministic function nor any
2279 ** table other than iCur.
2281 int sqlite3ExprIsTableConstant(Expr
*p
, int iCur
){
2282 return exprIsConst(p
, 3, iCur
);
2287 ** sqlite3WalkExpr() callback used by sqlite3ExprIsConstantOrGroupBy().
2289 static int exprNodeIsConstantOrGroupBy(Walker
*pWalker
, Expr
*pExpr
){
2290 ExprList
*pGroupBy
= pWalker
->u
.pGroupBy
;
2293 /* Check if pExpr is identical to any GROUP BY term. If so, consider
2295 for(i
=0; i
<pGroupBy
->nExpr
; i
++){
2296 Expr
*p
= pGroupBy
->a
[i
].pExpr
;
2297 if( sqlite3ExprCompare(0, pExpr
, p
, -1)<2 ){
2298 CollSeq
*pColl
= sqlite3ExprNNCollSeq(pWalker
->pParse
, p
);
2299 if( sqlite3IsBinary(pColl
) ){
2305 /* Check if pExpr is a sub-select. If so, consider it variable. */
2306 if( ExprUseXSelect(pExpr
) ){
2311 return exprNodeIsConstant(pWalker
, pExpr
);
2315 ** Walk the expression tree passed as the first argument. Return non-zero
2316 ** if the expression consists entirely of constants or copies of terms
2317 ** in pGroupBy that sort with the BINARY collation sequence.
2319 ** This routine is used to determine if a term of the HAVING clause can
2320 ** be promoted into the WHERE clause. In order for such a promotion to work,
2321 ** the value of the HAVING clause term must be the same for all members of
2322 ** a "group". The requirement that the GROUP BY term must be BINARY
2323 ** assumes that no other collating sequence will have a finer-grained
2324 ** grouping than binary. In other words (A=B COLLATE binary) implies
2325 ** A=B in every other collating sequence. The requirement that the
2326 ** GROUP BY be BINARY is stricter than necessary. It would also work
2327 ** to promote HAVING clauses that use the same alternative collating
2328 ** sequence as the GROUP BY term, but that is much harder to check,
2329 ** alternative collating sequences are uncommon, and this is only an
2330 ** optimization, so we take the easy way out and simply require the
2331 ** GROUP BY to use the BINARY collating sequence.
2333 int sqlite3ExprIsConstantOrGroupBy(Parse
*pParse
, Expr
*p
, ExprList
*pGroupBy
){
2336 w
.xExprCallback
= exprNodeIsConstantOrGroupBy
;
2337 w
.xSelectCallback
= 0;
2338 w
.u
.pGroupBy
= pGroupBy
;
2340 sqlite3WalkExpr(&w
, p
);
2345 ** Walk an expression tree for the DEFAULT field of a column definition
2346 ** in a CREATE TABLE statement. Return non-zero if the expression is
2347 ** acceptable for use as a DEFAULT. That is to say, return non-zero if
2348 ** the expression is constant or a function call with constant arguments.
2349 ** Return and 0 if there are any variables.
2351 ** isInit is true when parsing from sqlite_schema. isInit is false when
2352 ** processing a new CREATE TABLE statement. When isInit is true, parameters
2353 ** (such as ? or $abc) in the expression are converted into NULL. When
2354 ** isInit is false, parameters raise an error. Parameters should not be
2355 ** allowed in a CREATE TABLE statement, but some legacy versions of SQLite
2356 ** allowed it, so we need to support it when reading sqlite_schema for
2357 ** backwards compatibility.
2359 ** If isInit is true, set EP_FromDDL on every TK_FUNCTION node.
2361 ** For the purposes of this function, a double-quoted string (ex: "abc")
2362 ** is considered a variable but a single-quoted string (ex: 'abc') is
2365 int sqlite3ExprIsConstantOrFunction(Expr
*p
, u8 isInit
){
2366 assert( isInit
==0 || isInit
==1 );
2367 return exprIsConst(p
, 4+isInit
, 0);
2370 #ifdef SQLITE_ENABLE_CURSOR_HINTS
2372 ** Walk an expression tree. Return 1 if the expression contains a
2373 ** subquery of some kind. Return 0 if there are no subqueries.
2375 int sqlite3ExprContainsSubquery(Expr
*p
){
2378 w
.xExprCallback
= sqlite3ExprWalkNoop
;
2379 w
.xSelectCallback
= sqlite3SelectWalkFail
;
2381 w
.xSelectCallback2
= sqlite3SelectWalkAssert2
;
2383 sqlite3WalkExpr(&w
, p
);
2389 ** If the expression p codes a constant integer that is small enough
2390 ** to fit in a 32-bit integer, return 1 and put the value of the integer
2391 ** in *pValue. If the expression is not an integer or if it is too big
2392 ** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
2394 int sqlite3ExprIsInteger(const Expr
*p
, int *pValue
){
2396 if( NEVER(p
==0) ) return 0; /* Used to only happen following on OOM */
2398 /* If an expression is an integer literal that fits in a signed 32-bit
2399 ** integer, then the EP_IntValue flag will have already been set */
2400 assert( p
->op
!=TK_INTEGER
|| (p
->flags
& EP_IntValue
)!=0
2401 || sqlite3GetInt32(p
->u
.zToken
, &rc
)==0 );
2403 if( p
->flags
& EP_IntValue
){
2404 *pValue
= p
->u
.iValue
;
2409 rc
= sqlite3ExprIsInteger(p
->pLeft
, pValue
);
2414 if( sqlite3ExprIsInteger(p
->pLeft
, &v
) ){
2415 assert( ((unsigned int)v
)!=0x80000000 );
2427 ** Return FALSE if there is no chance that the expression can be NULL.
2429 ** If the expression might be NULL or if the expression is too complex
2430 ** to tell return TRUE.
2432 ** This routine is used as an optimization, to skip OP_IsNull opcodes
2433 ** when we know that a value cannot be NULL. Hence, a false positive
2434 ** (returning TRUE when in fact the expression can never be NULL) might
2435 ** be a small performance hit but is otherwise harmless. On the other
2436 ** hand, a false negative (returning FALSE when the result could be NULL)
2437 ** will likely result in an incorrect answer. So when in doubt, return
2440 int sqlite3ExprCanBeNull(const Expr
*p
){
2443 while( p
->op
==TK_UPLUS
|| p
->op
==TK_UMINUS
){
2448 if( op
==TK_REGISTER
) op
= p
->op2
;
2456 assert( ExprUseYTab(p
) );
2457 return ExprHasProperty(p
, EP_CanBeNull
) ||
2458 p
->y
.pTab
==0 || /* Reference to column of index on expression */
2460 && p
->y
.pTab
->aCol
!=0 /* Possible due to prior error */
2461 && p
->y
.pTab
->aCol
[p
->iColumn
].notNull
==0);
2468 ** Return TRUE if the given expression is a constant which would be
2469 ** unchanged by OP_Affinity with the affinity given in the second
2472 ** This routine is used to determine if the OP_Affinity operation
2473 ** can be omitted. When in doubt return FALSE. A false negative
2474 ** is harmless. A false positive, however, can result in the wrong
2477 int sqlite3ExprNeedsNoAffinityChange(const Expr
*p
, char aff
){
2480 if( aff
==SQLITE_AFF_BLOB
) return 1;
2481 while( p
->op
==TK_UPLUS
|| p
->op
==TK_UMINUS
){
2482 if( p
->op
==TK_UMINUS
) unaryMinus
= 1;
2486 if( op
==TK_REGISTER
) op
= p
->op2
;
2489 return aff
>=SQLITE_AFF_NUMERIC
;
2492 return aff
>=SQLITE_AFF_NUMERIC
;
2495 return !unaryMinus
&& aff
==SQLITE_AFF_TEXT
;
2501 assert( p
->iTable
>=0 ); /* p cannot be part of a CHECK constraint */
2502 return aff
>=SQLITE_AFF_NUMERIC
&& p
->iColumn
<0;
2511 ** Return TRUE if the given string is a row-id column name.
2513 int sqlite3IsRowid(const char *z
){
2514 if( sqlite3StrICmp(z
, "_ROWID_")==0 ) return 1;
2515 if( sqlite3StrICmp(z
, "ROWID")==0 ) return 1;
2516 if( sqlite3StrICmp(z
, "OID")==0 ) return 1;
2521 ** pX is the RHS of an IN operator. If pX is a SELECT statement
2522 ** that can be simplified to a direct table access, then return
2523 ** a pointer to the SELECT statement. If pX is not a SELECT statement,
2524 ** or if the SELECT statement needs to be manifested into a transient
2525 ** table, then return NULL.
2527 #ifndef SQLITE_OMIT_SUBQUERY
2528 static Select
*isCandidateForInOpt(const Expr
*pX
){
2534 if( !ExprUseXSelect(pX
) ) return 0; /* Not a subquery */
2535 if( ExprHasProperty(pX
, EP_VarSelect
) ) return 0; /* Correlated subq */
2537 if( p
->pPrior
) return 0; /* Not a compound SELECT */
2538 if( p
->selFlags
& (SF_Distinct
|SF_Aggregate
) ){
2539 testcase( (p
->selFlags
& (SF_Distinct
|SF_Aggregate
))==SF_Distinct
);
2540 testcase( (p
->selFlags
& (SF_Distinct
|SF_Aggregate
))==SF_Aggregate
);
2541 return 0; /* No DISTINCT keyword and no aggregate functions */
2543 assert( p
->pGroupBy
==0 ); /* Has no GROUP BY clause */
2544 if( p
->pLimit
) return 0; /* Has no LIMIT clause */
2545 if( p
->pWhere
) return 0; /* Has no WHERE clause */
2548 if( pSrc
->nSrc
!=1 ) return 0; /* Single term in FROM clause */
2549 if( pSrc
->a
[0].pSelect
) return 0; /* FROM is not a subquery or view */
2550 pTab
= pSrc
->a
[0].pTab
;
2552 assert( !IsView(pTab
) ); /* FROM clause is not a view */
2553 if( IsVirtual(pTab
) ) return 0; /* FROM clause not a virtual table */
2555 assert( pEList
!=0 );
2556 /* All SELECT results must be columns. */
2557 for(i
=0; i
<pEList
->nExpr
; i
++){
2558 Expr
*pRes
= pEList
->a
[i
].pExpr
;
2559 if( pRes
->op
!=TK_COLUMN
) return 0;
2560 assert( pRes
->iTable
==pSrc
->a
[0].iCursor
); /* Not a correlated subquery */
2564 #endif /* SQLITE_OMIT_SUBQUERY */
2566 #ifndef SQLITE_OMIT_SUBQUERY
2568 ** Generate code that checks the left-most column of index table iCur to see if
2569 ** it contains any NULL entries. Cause the register at regHasNull to be set
2570 ** to a non-NULL value if iCur contains no NULLs. Cause register regHasNull
2571 ** to be set to NULL if iCur contains one or more NULL values.
2573 static void sqlite3SetHasNullFlag(Vdbe
*v
, int iCur
, int regHasNull
){
2575 sqlite3VdbeAddOp2(v
, OP_Integer
, 0, regHasNull
);
2576 addr1
= sqlite3VdbeAddOp1(v
, OP_Rewind
, iCur
); VdbeCoverage(v
);
2577 sqlite3VdbeAddOp3(v
, OP_Column
, iCur
, 0, regHasNull
);
2578 sqlite3VdbeChangeP5(v
, OPFLAG_TYPEOFARG
);
2579 VdbeComment((v
, "first_entry_in(%d)", iCur
));
2580 sqlite3VdbeJumpHere(v
, addr1
);
2585 #ifndef SQLITE_OMIT_SUBQUERY
2587 ** The argument is an IN operator with a list (not a subquery) on the
2588 ** right-hand side. Return TRUE if that list is constant.
2590 static int sqlite3InRhsIsConstant(Expr
*pIn
){
2593 assert( !ExprHasProperty(pIn
, EP_xIsSelect
) );
2596 res
= sqlite3ExprIsConstant(pIn
);
2603 ** This function is used by the implementation of the IN (...) operator.
2604 ** The pX parameter is the expression on the RHS of the IN operator, which
2605 ** might be either a list of expressions or a subquery.
2607 ** The job of this routine is to find or create a b-tree object that can
2608 ** be used either to test for membership in the RHS set or to iterate through
2609 ** all members of the RHS set, skipping duplicates.
2611 ** A cursor is opened on the b-tree object that is the RHS of the IN operator
2612 ** and pX->iTable is set to the index of that cursor.
2614 ** The returned value of this function indicates the b-tree type, as follows:
2616 ** IN_INDEX_ROWID - The cursor was opened on a database table.
2617 ** IN_INDEX_INDEX_ASC - The cursor was opened on an ascending index.
2618 ** IN_INDEX_INDEX_DESC - The cursor was opened on a descending index.
2619 ** IN_INDEX_EPH - The cursor was opened on a specially created and
2620 ** populated epheremal table.
2621 ** IN_INDEX_NOOP - No cursor was allocated. The IN operator must be
2622 ** implemented as a sequence of comparisons.
2624 ** An existing b-tree might be used if the RHS expression pX is a simple
2625 ** subquery such as:
2627 ** SELECT <column1>, <column2>... FROM <table>
2629 ** If the RHS of the IN operator is a list or a more complex subquery, then
2630 ** an ephemeral table might need to be generated from the RHS and then
2631 ** pX->iTable made to point to the ephemeral table instead of an
2634 ** The inFlags parameter must contain, at a minimum, one of the bits
2635 ** IN_INDEX_MEMBERSHIP or IN_INDEX_LOOP but not both. If inFlags contains
2636 ** IN_INDEX_MEMBERSHIP, then the generated table will be used for a fast
2637 ** membership test. When the IN_INDEX_LOOP bit is set, the IN index will
2638 ** be used to loop over all values of the RHS of the IN operator.
2640 ** When IN_INDEX_LOOP is used (and the b-tree will be used to iterate
2641 ** through the set members) then the b-tree must not contain duplicates.
2642 ** An epheremal table will be created unless the selected columns are guaranteed
2643 ** to be unique - either because it is an INTEGER PRIMARY KEY or due to
2644 ** a UNIQUE constraint or index.
2646 ** When IN_INDEX_MEMBERSHIP is used (and the b-tree will be used
2647 ** for fast set membership tests) then an epheremal table must
2648 ** be used unless <columns> is a single INTEGER PRIMARY KEY column or an
2649 ** index can be found with the specified <columns> as its left-most.
2651 ** If the IN_INDEX_NOOP_OK and IN_INDEX_MEMBERSHIP are both set and
2652 ** if the RHS of the IN operator is a list (not a subquery) then this
2653 ** routine might decide that creating an ephemeral b-tree for membership
2654 ** testing is too expensive and return IN_INDEX_NOOP. In that case, the
2655 ** calling routine should implement the IN operator using a sequence
2656 ** of Eq or Ne comparison operations.
2658 ** When the b-tree is being used for membership tests, the calling function
2659 ** might need to know whether or not the RHS side of the IN operator
2660 ** contains a NULL. If prRhsHasNull is not a NULL pointer and
2661 ** if there is any chance that the (...) might contain a NULL value at
2662 ** runtime, then a register is allocated and the register number written
2663 ** to *prRhsHasNull. If there is no chance that the (...) contains a
2664 ** NULL value, then *prRhsHasNull is left unchanged.
2666 ** If a register is allocated and its location stored in *prRhsHasNull, then
2667 ** the value in that register will be NULL if the b-tree contains one or more
2668 ** NULL values, and it will be some non-NULL value if the b-tree contains no
2671 ** If the aiMap parameter is not NULL, it must point to an array containing
2672 ** one element for each column returned by the SELECT statement on the RHS
2673 ** of the IN(...) operator. The i'th entry of the array is populated with the
2674 ** offset of the index column that matches the i'th column returned by the
2675 ** SELECT. For example, if the expression and selected index are:
2677 ** (?,?,?) IN (SELECT a, b, c FROM t1)
2678 ** CREATE INDEX i1 ON t1(b, c, a);
2680 ** then aiMap[] is populated with {2, 0, 1}.
2682 #ifndef SQLITE_OMIT_SUBQUERY
2683 int sqlite3FindInIndex(
2684 Parse
*pParse
, /* Parsing context */
2685 Expr
*pX
, /* The IN expression */
2686 u32 inFlags
, /* IN_INDEX_LOOP, _MEMBERSHIP, and/or _NOOP_OK */
2687 int *prRhsHasNull
, /* Register holding NULL status. See notes */
2688 int *aiMap
, /* Mapping from Index fields to RHS fields */
2689 int *piTab
/* OUT: index to use */
2691 Select
*p
; /* SELECT to the right of IN operator */
2692 int eType
= 0; /* Type of RHS table. IN_INDEX_* */
2693 int iTab
= pParse
->nTab
++; /* Cursor of the RHS table */
2694 int mustBeUnique
; /* True if RHS must be unique */
2695 Vdbe
*v
= sqlite3GetVdbe(pParse
); /* Virtual machine being coded */
2697 assert( pX
->op
==TK_IN
);
2698 mustBeUnique
= (inFlags
& IN_INDEX_LOOP
)!=0;
2700 /* If the RHS of this IN(...) operator is a SELECT, and if it matters
2701 ** whether or not the SELECT result contains NULL values, check whether
2702 ** or not NULL is actually possible (it may not be, for example, due
2703 ** to NOT NULL constraints in the schema). If no NULL values are possible,
2704 ** set prRhsHasNull to 0 before continuing. */
2705 if( prRhsHasNull
&& ExprUseXSelect(pX
) ){
2707 ExprList
*pEList
= pX
->x
.pSelect
->pEList
;
2708 for(i
=0; i
<pEList
->nExpr
; i
++){
2709 if( sqlite3ExprCanBeNull(pEList
->a
[i
].pExpr
) ) break;
2711 if( i
==pEList
->nExpr
){
2716 /* Check to see if an existing table or index can be used to
2717 ** satisfy the query. This is preferable to generating a new
2718 ** ephemeral table. */
2719 if( pParse
->nErr
==0 && (p
= isCandidateForInOpt(pX
))!=0 ){
2720 sqlite3
*db
= pParse
->db
; /* Database connection */
2721 Table
*pTab
; /* Table <table>. */
2722 int iDb
; /* Database idx for pTab */
2723 ExprList
*pEList
= p
->pEList
;
2724 int nExpr
= pEList
->nExpr
;
2726 assert( p
->pEList
!=0 ); /* Because of isCandidateForInOpt(p) */
2727 assert( p
->pEList
->a
[0].pExpr
!=0 ); /* Because of isCandidateForInOpt(p) */
2728 assert( p
->pSrc
!=0 ); /* Because of isCandidateForInOpt(p) */
2729 pTab
= p
->pSrc
->a
[0].pTab
;
2731 /* Code an OP_Transaction and OP_TableLock for <table>. */
2732 iDb
= sqlite3SchemaToIndex(db
, pTab
->pSchema
);
2733 assert( iDb
>=0 && iDb
<SQLITE_MAX_DB
);
2734 sqlite3CodeVerifySchema(pParse
, iDb
);
2735 sqlite3TableLock(pParse
, iDb
, pTab
->tnum
, 0, pTab
->zName
);
2737 assert(v
); /* sqlite3GetVdbe() has always been previously called */
2738 if( nExpr
==1 && pEList
->a
[0].pExpr
->iColumn
<0 ){
2739 /* The "x IN (SELECT rowid FROM table)" case */
2740 int iAddr
= sqlite3VdbeAddOp0(v
, OP_Once
);
2743 sqlite3OpenTable(pParse
, iTab
, iDb
, pTab
, OP_OpenRead
);
2744 eType
= IN_INDEX_ROWID
;
2745 ExplainQueryPlan((pParse
, 0,
2746 "USING ROWID SEARCH ON TABLE %s FOR IN-OPERATOR",pTab
->zName
));
2747 sqlite3VdbeJumpHere(v
, iAddr
);
2749 Index
*pIdx
; /* Iterator variable */
2750 int affinity_ok
= 1;
2753 /* Check that the affinity that will be used to perform each
2754 ** comparison is the same as the affinity of each column in table
2755 ** on the RHS of the IN operator. If it not, it is not possible to
2756 ** use any index of the RHS table. */
2757 for(i
=0; i
<nExpr
&& affinity_ok
; i
++){
2758 Expr
*pLhs
= sqlite3VectorFieldSubexpr(pX
->pLeft
, i
);
2759 int iCol
= pEList
->a
[i
].pExpr
->iColumn
;
2760 char idxaff
= sqlite3TableColumnAffinity(pTab
,iCol
); /* RHS table */
2761 char cmpaff
= sqlite3CompareAffinity(pLhs
, idxaff
);
2762 testcase( cmpaff
==SQLITE_AFF_BLOB
);
2763 testcase( cmpaff
==SQLITE_AFF_TEXT
);
2765 case SQLITE_AFF_BLOB
:
2767 case SQLITE_AFF_TEXT
:
2768 /* sqlite3CompareAffinity() only returns TEXT if one side or the
2769 ** other has no affinity and the other side is TEXT. Hence,
2770 ** the only way for cmpaff to be TEXT is for idxaff to be TEXT
2771 ** and for the term on the LHS of the IN to have no affinity. */
2772 assert( idxaff
==SQLITE_AFF_TEXT
);
2775 affinity_ok
= sqlite3IsNumericAffinity(idxaff
);
2780 /* Search for an existing index that will work for this IN operator */
2781 for(pIdx
=pTab
->pIndex
; pIdx
&& eType
==0; pIdx
=pIdx
->pNext
){
2782 Bitmask colUsed
; /* Columns of the index used */
2783 Bitmask mCol
; /* Mask for the current column */
2784 if( pIdx
->nColumn
<nExpr
) continue;
2785 if( pIdx
->pPartIdxWhere
!=0 ) continue;
2786 /* Maximum nColumn is BMS-2, not BMS-1, so that we can compute
2787 ** BITMASK(nExpr) without overflowing */
2788 testcase( pIdx
->nColumn
==BMS
-2 );
2789 testcase( pIdx
->nColumn
==BMS
-1 );
2790 if( pIdx
->nColumn
>=BMS
-1 ) continue;
2792 if( pIdx
->nKeyCol
>nExpr
2793 ||(pIdx
->nColumn
>nExpr
&& !IsUniqueIndex(pIdx
))
2795 continue; /* This index is not unique over the IN RHS columns */
2799 colUsed
= 0; /* Columns of index used so far */
2800 for(i
=0; i
<nExpr
; i
++){
2801 Expr
*pLhs
= sqlite3VectorFieldSubexpr(pX
->pLeft
, i
);
2802 Expr
*pRhs
= pEList
->a
[i
].pExpr
;
2803 CollSeq
*pReq
= sqlite3BinaryCompareCollSeq(pParse
, pLhs
, pRhs
);
2806 assert( pReq
!=0 || pRhs
->iColumn
==XN_ROWID
2807 || pParse
->nErr
|| db
->mallocFailed
);
2808 for(j
=0; j
<nExpr
; j
++){
2809 if( pIdx
->aiColumn
[j
]!=pRhs
->iColumn
) continue;
2810 assert( pIdx
->azColl
[j
] );
2811 if( pReq
!=0 && sqlite3StrICmp(pReq
->zName
, pIdx
->azColl
[j
])!=0 ){
2816 if( j
==nExpr
) break;
2818 if( mCol
& colUsed
) break; /* Each column used only once */
2820 if( aiMap
) aiMap
[i
] = j
;
2823 assert( i
==nExpr
|| colUsed
!=(MASKBIT(nExpr
)-1) );
2824 if( colUsed
==(MASKBIT(nExpr
)-1) ){
2825 /* If we reach this point, that means the index pIdx is usable */
2826 int iAddr
= sqlite3VdbeAddOp0(v
, OP_Once
); VdbeCoverage(v
);
2827 ExplainQueryPlan((pParse
, 0,
2828 "USING INDEX %s FOR IN-OPERATOR",pIdx
->zName
));
2829 sqlite3VdbeAddOp3(v
, OP_OpenRead
, iTab
, pIdx
->tnum
, iDb
);
2830 sqlite3VdbeSetP4KeyInfo(pParse
, pIdx
);
2831 VdbeComment((v
, "%s", pIdx
->zName
));
2832 assert( IN_INDEX_INDEX_DESC
== IN_INDEX_INDEX_ASC
+1 );
2833 eType
= IN_INDEX_INDEX_ASC
+ pIdx
->aSortOrder
[0];
2836 #ifdef SQLITE_ENABLE_COLUMN_USED_MASK
2837 i64 mask
= (1<<nExpr
)-1;
2838 sqlite3VdbeAddOp4Dup8(v
, OP_ColumnsUsed
,
2839 iTab
, 0, 0, (u8
*)&mask
, P4_INT64
);
2841 *prRhsHasNull
= ++pParse
->nMem
;
2843 sqlite3SetHasNullFlag(v
, iTab
, *prRhsHasNull
);
2846 sqlite3VdbeJumpHere(v
, iAddr
);
2848 } /* End loop over indexes */
2849 } /* End if( affinity_ok ) */
2850 } /* End if not an rowid index */
2851 } /* End attempt to optimize using an index */
2853 /* If no preexisting index is available for the IN clause
2854 ** and IN_INDEX_NOOP is an allowed reply
2855 ** and the RHS of the IN operator is a list, not a subquery
2856 ** and the RHS is not constant or has two or fewer terms,
2857 ** then it is not worth creating an ephemeral table to evaluate
2858 ** the IN operator so return IN_INDEX_NOOP.
2861 && (inFlags
& IN_INDEX_NOOP_OK
)
2863 && (!sqlite3InRhsIsConstant(pX
) || pX
->x
.pList
->nExpr
<=2)
2865 eType
= IN_INDEX_NOOP
;
2869 /* Could not find an existing table or index to use as the RHS b-tree.
2870 ** We will have to generate an ephemeral table to do the job.
2872 u32 savedNQueryLoop
= pParse
->nQueryLoop
;
2873 int rMayHaveNull
= 0;
2874 eType
= IN_INDEX_EPH
;
2875 if( inFlags
& IN_INDEX_LOOP
){
2876 pParse
->nQueryLoop
= 0;
2877 }else if( prRhsHasNull
){
2878 *prRhsHasNull
= rMayHaveNull
= ++pParse
->nMem
;
2880 assert( pX
->op
==TK_IN
);
2881 sqlite3CodeRhsOfIN(pParse
, pX
, iTab
);
2883 sqlite3SetHasNullFlag(v
, iTab
, rMayHaveNull
);
2885 pParse
->nQueryLoop
= savedNQueryLoop
;
2888 if( aiMap
&& eType
!=IN_INDEX_INDEX_ASC
&& eType
!=IN_INDEX_INDEX_DESC
){
2890 n
= sqlite3ExprVectorSize(pX
->pLeft
);
2891 for(i
=0; i
<n
; i
++) aiMap
[i
] = i
;
2898 #ifndef SQLITE_OMIT_SUBQUERY
2900 ** Argument pExpr is an (?, ?...) IN(...) expression. This
2901 ** function allocates and returns a nul-terminated string containing
2902 ** the affinities to be used for each column of the comparison.
2904 ** It is the responsibility of the caller to ensure that the returned
2905 ** string is eventually freed using sqlite3DbFree().
2907 static char *exprINAffinity(Parse
*pParse
, const Expr
*pExpr
){
2908 Expr
*pLeft
= pExpr
->pLeft
;
2909 int nVal
= sqlite3ExprVectorSize(pLeft
);
2910 Select
*pSelect
= ExprUseXSelect(pExpr
) ? pExpr
->x
.pSelect
: 0;
2913 assert( pExpr
->op
==TK_IN
);
2914 zRet
= sqlite3DbMallocRaw(pParse
->db
, nVal
+1);
2917 for(i
=0; i
<nVal
; i
++){
2918 Expr
*pA
= sqlite3VectorFieldSubexpr(pLeft
, i
);
2919 char a
= sqlite3ExprAffinity(pA
);
2921 zRet
[i
] = sqlite3CompareAffinity(pSelect
->pEList
->a
[i
].pExpr
, a
);
2932 #ifndef SQLITE_OMIT_SUBQUERY
2934 ** Load the Parse object passed as the first argument with an error
2935 ** message of the form:
2937 ** "sub-select returns N columns - expected M"
2939 void sqlite3SubselectError(Parse
*pParse
, int nActual
, int nExpect
){
2940 if( pParse
->nErr
==0 ){
2941 const char *zFmt
= "sub-select returns %d columns - expected %d";
2942 sqlite3ErrorMsg(pParse
, zFmt
, nActual
, nExpect
);
2948 ** Expression pExpr is a vector that has been used in a context where
2949 ** it is not permitted. If pExpr is a sub-select vector, this routine
2950 ** loads the Parse object with a message of the form:
2952 ** "sub-select returns N columns - expected 1"
2954 ** Or, if it is a regular scalar vector:
2956 ** "row value misused"
2958 void sqlite3VectorErrorMsg(Parse
*pParse
, Expr
*pExpr
){
2959 #ifndef SQLITE_OMIT_SUBQUERY
2960 if( ExprUseXSelect(pExpr
) ){
2961 sqlite3SubselectError(pParse
, pExpr
->x
.pSelect
->pEList
->nExpr
, 1);
2965 sqlite3ErrorMsg(pParse
, "row value misused");
2969 #ifndef SQLITE_OMIT_SUBQUERY
2971 ** Generate code that will construct an ephemeral table containing all terms
2972 ** in the RHS of an IN operator. The IN operator can be in either of two
2975 ** x IN (4,5,11) -- IN operator with list on right-hand side
2976 ** x IN (SELECT a FROM b) -- IN operator with subquery on the right
2978 ** The pExpr parameter is the IN operator. The cursor number for the
2979 ** constructed ephermeral table is returned. The first time the ephemeral
2980 ** table is computed, the cursor number is also stored in pExpr->iTable,
2981 ** however the cursor number returned might not be the same, as it might
2982 ** have been duplicated using OP_OpenDup.
2984 ** If the LHS expression ("x" in the examples) is a column value, or
2985 ** the SELECT statement returns a column value, then the affinity of that
2986 ** column is used to build the index keys. If both 'x' and the
2987 ** SELECT... statement are columns, then numeric affinity is used
2988 ** if either column has NUMERIC or INTEGER affinity. If neither
2989 ** 'x' nor the SELECT... statement are columns, then numeric affinity
2992 void sqlite3CodeRhsOfIN(
2993 Parse
*pParse
, /* Parsing context */
2994 Expr
*pExpr
, /* The IN operator */
2995 int iTab
/* Use this cursor number */
2997 int addrOnce
= 0; /* Address of the OP_Once instruction at top */
2998 int addr
; /* Address of OP_OpenEphemeral instruction */
2999 Expr
*pLeft
; /* the LHS of the IN operator */
3000 KeyInfo
*pKeyInfo
= 0; /* Key information */
3001 int nVal
; /* Size of vector pLeft */
3002 Vdbe
*v
; /* The prepared statement under construction */
3007 /* The evaluation of the IN must be repeated every time it
3008 ** is encountered if any of the following is true:
3010 ** * The right-hand side is a correlated subquery
3011 ** * The right-hand side is an expression list containing variables
3012 ** * We are inside a trigger
3014 ** If all of the above are false, then we can compute the RHS just once
3015 ** and reuse it many names.
3017 if( !ExprHasProperty(pExpr
, EP_VarSelect
) && pParse
->iSelfTab
==0 ){
3018 /* Reuse of the RHS is allowed */
3019 /* If this routine has already been coded, but the previous code
3020 ** might not have been invoked yet, so invoke it now as a subroutine.
3022 if( ExprHasProperty(pExpr
, EP_Subrtn
) ){
3023 addrOnce
= sqlite3VdbeAddOp0(v
, OP_Once
); VdbeCoverage(v
);
3024 if( ExprUseXSelect(pExpr
) ){
3025 ExplainQueryPlan((pParse
, 0, "REUSE LIST SUBQUERY %d",
3026 pExpr
->x
.pSelect
->selId
));
3028 assert( ExprUseYSub(pExpr
) );
3029 sqlite3VdbeAddOp2(v
, OP_Gosub
, pExpr
->y
.sub
.regReturn
,
3030 pExpr
->y
.sub
.iAddr
);
3031 sqlite3VdbeAddOp2(v
, OP_OpenDup
, iTab
, pExpr
->iTable
);
3032 sqlite3VdbeJumpHere(v
, addrOnce
);
3036 /* Begin coding the subroutine */
3037 assert( !ExprUseYWin(pExpr
) );
3038 ExprSetProperty(pExpr
, EP_Subrtn
);
3039 assert( !ExprHasProperty(pExpr
, EP_TokenOnly
|EP_Reduced
) );
3040 pExpr
->y
.sub
.regReturn
= ++pParse
->nMem
;
3041 pExpr
->y
.sub
.iAddr
=
3042 sqlite3VdbeAddOp2(v
, OP_Integer
, 0, pExpr
->y
.sub
.regReturn
) + 1;
3043 VdbeComment((v
, "return address"));
3045 addrOnce
= sqlite3VdbeAddOp0(v
, OP_Once
); VdbeCoverage(v
);
3048 /* Check to see if this is a vector IN operator */
3049 pLeft
= pExpr
->pLeft
;
3050 nVal
= sqlite3ExprVectorSize(pLeft
);
3052 /* Construct the ephemeral table that will contain the content of
3053 ** RHS of the IN operator.
3055 pExpr
->iTable
= iTab
;
3056 addr
= sqlite3VdbeAddOp2(v
, OP_OpenEphemeral
, pExpr
->iTable
, nVal
);
3057 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
3058 if( ExprUseXSelect(pExpr
) ){
3059 VdbeComment((v
, "Result of SELECT %u", pExpr
->x
.pSelect
->selId
));
3061 VdbeComment((v
, "RHS of IN operator"));
3064 pKeyInfo
= sqlite3KeyInfoAlloc(pParse
->db
, nVal
, 1);
3066 if( ExprUseXSelect(pExpr
) ){
3067 /* Case 1: expr IN (SELECT ...)
3069 ** Generate code to write the results of the select into the temporary
3070 ** table allocated and opened above.
3072 Select
*pSelect
= pExpr
->x
.pSelect
;
3073 ExprList
*pEList
= pSelect
->pEList
;
3075 ExplainQueryPlan((pParse
, 1, "%sLIST SUBQUERY %d",
3076 addrOnce
?"":"CORRELATED ", pSelect
->selId
3078 /* If the LHS and RHS of the IN operator do not match, that
3079 ** error will have been caught long before we reach this point. */
3080 if( ALWAYS(pEList
->nExpr
==nVal
) ){
3085 sqlite3SelectDestInit(&dest
, SRT_Set
, iTab
);
3086 dest
.zAffSdst
= exprINAffinity(pParse
, pExpr
);
3087 pSelect
->iLimit
= 0;
3088 testcase( pSelect
->selFlags
& SF_Distinct
);
3089 testcase( pKeyInfo
==0 ); /* Caused by OOM in sqlite3KeyInfoAlloc() */
3090 pCopy
= sqlite3SelectDup(pParse
->db
, pSelect
, 0);
3091 rc
= pParse
->db
->mallocFailed
? 1 :sqlite3Select(pParse
, pCopy
, &dest
);
3092 sqlite3SelectDelete(pParse
->db
, pCopy
);
3093 sqlite3DbFree(pParse
->db
, dest
.zAffSdst
);
3095 sqlite3KeyInfoUnref(pKeyInfo
);
3098 assert( pKeyInfo
!=0 ); /* OOM will cause exit after sqlite3Select() */
3099 assert( pEList
!=0 );
3100 assert( pEList
->nExpr
>0 );
3101 assert( sqlite3KeyInfoIsWriteable(pKeyInfo
) );
3102 for(i
=0; i
<nVal
; i
++){
3103 Expr
*p
= sqlite3VectorFieldSubexpr(pLeft
, i
);
3104 pKeyInfo
->aColl
[i
] = sqlite3BinaryCompareCollSeq(
3105 pParse
, p
, pEList
->a
[i
].pExpr
3109 }else if( ALWAYS(pExpr
->x
.pList
!=0) ){
3110 /* Case 2: expr IN (exprlist)
3112 ** For each expression, build an index key from the evaluation and
3113 ** store it in the temporary table. If <expr> is a column, then use
3114 ** that columns affinity when building index keys. If <expr> is not
3115 ** a column, use numeric affinity.
3117 char affinity
; /* Affinity of the LHS of the IN */
3119 ExprList
*pList
= pExpr
->x
.pList
;
3120 struct ExprList_item
*pItem
;
3122 affinity
= sqlite3ExprAffinity(pLeft
);
3123 if( affinity
<=SQLITE_AFF_NONE
){
3124 affinity
= SQLITE_AFF_BLOB
;
3125 }else if( affinity
==SQLITE_AFF_REAL
){
3126 affinity
= SQLITE_AFF_NUMERIC
;
3129 assert( sqlite3KeyInfoIsWriteable(pKeyInfo
) );
3130 pKeyInfo
->aColl
[0] = sqlite3ExprCollSeq(pParse
, pExpr
->pLeft
);
3133 /* Loop through each expression in <exprlist>. */
3134 r1
= sqlite3GetTempReg(pParse
);
3135 r2
= sqlite3GetTempReg(pParse
);
3136 for(i
=pList
->nExpr
, pItem
=pList
->a
; i
>0; i
--, pItem
++){
3137 Expr
*pE2
= pItem
->pExpr
;
3139 /* If the expression is not constant then we will need to
3140 ** disable the test that was generated above that makes sure
3141 ** this code only executes once. Because for a non-constant
3142 ** expression we need to rerun this code each time.
3144 if( addrOnce
&& !sqlite3ExprIsConstant(pE2
) ){
3145 sqlite3VdbeChangeToNoop(v
, addrOnce
);
3146 ExprClearProperty(pExpr
, EP_Subrtn
);
3150 /* Evaluate the expression and insert it into the temp table */
3151 sqlite3ExprCode(pParse
, pE2
, r1
);
3152 sqlite3VdbeAddOp4(v
, OP_MakeRecord
, r1
, 1, r2
, &affinity
, 1);
3153 sqlite3VdbeAddOp4Int(v
, OP_IdxInsert
, iTab
, r2
, r1
, 1);
3155 sqlite3ReleaseTempReg(pParse
, r1
);
3156 sqlite3ReleaseTempReg(pParse
, r2
);
3159 sqlite3VdbeChangeP4(v
, addr
, (void *)pKeyInfo
, P4_KEYINFO
);
3162 sqlite3VdbeJumpHere(v
, addrOnce
);
3163 /* Subroutine return */
3164 assert( ExprUseYSub(pExpr
) );
3165 sqlite3VdbeAddOp1(v
, OP_Return
, pExpr
->y
.sub
.regReturn
);
3166 sqlite3VdbeChangeP1(v
, pExpr
->y
.sub
.iAddr
-1, sqlite3VdbeCurrentAddr(v
)-1);
3167 sqlite3ClearTempRegCache(pParse
);
3170 #endif /* SQLITE_OMIT_SUBQUERY */
3173 ** Generate code for scalar subqueries used as a subquery expression
3174 ** or EXISTS operator:
3176 ** (SELECT a FROM b) -- subquery
3177 ** EXISTS (SELECT a FROM b) -- EXISTS subquery
3179 ** The pExpr parameter is the SELECT or EXISTS operator to be coded.
3181 ** Return the register that holds the result. For a multi-column SELECT,
3182 ** the result is stored in a contiguous array of registers and the
3183 ** return value is the register of the left-most result column.
3184 ** Return 0 if an error occurs.
3186 #ifndef SQLITE_OMIT_SUBQUERY
3187 int sqlite3CodeSubselect(Parse
*pParse
, Expr
*pExpr
){
3188 int addrOnce
= 0; /* Address of OP_Once at top of subroutine */
3189 int rReg
= 0; /* Register storing resulting */
3190 Select
*pSel
; /* SELECT statement to encode */
3191 SelectDest dest
; /* How to deal with SELECT result */
3192 int nReg
; /* Registers to allocate */
3193 Expr
*pLimit
; /* New limit expression */
3195 Vdbe
*v
= pParse
->pVdbe
;
3197 if( pParse
->nErr
) return 0;
3198 testcase( pExpr
->op
==TK_EXISTS
);
3199 testcase( pExpr
->op
==TK_SELECT
);
3200 assert( pExpr
->op
==TK_EXISTS
|| pExpr
->op
==TK_SELECT
);
3201 assert( ExprUseXSelect(pExpr
) );
3202 pSel
= pExpr
->x
.pSelect
;
3204 /* If this routine has already been coded, then invoke it as a
3206 if( ExprHasProperty(pExpr
, EP_Subrtn
) ){
3207 ExplainQueryPlan((pParse
, 0, "REUSE SUBQUERY %d", pSel
->selId
));
3208 assert( ExprUseYSub(pExpr
) );
3209 sqlite3VdbeAddOp2(v
, OP_Gosub
, pExpr
->y
.sub
.regReturn
,
3210 pExpr
->y
.sub
.iAddr
);
3211 return pExpr
->iTable
;
3214 /* Begin coding the subroutine */
3215 assert( !ExprUseYWin(pExpr
) );
3216 assert( !ExprHasProperty(pExpr
, EP_Reduced
|EP_TokenOnly
) );
3217 ExprSetProperty(pExpr
, EP_Subrtn
);
3218 pExpr
->y
.sub
.regReturn
= ++pParse
->nMem
;
3219 pExpr
->y
.sub
.iAddr
=
3220 sqlite3VdbeAddOp2(v
, OP_Integer
, 0, pExpr
->y
.sub
.regReturn
) + 1;
3221 VdbeComment((v
, "return address"));
3224 /* The evaluation of the EXISTS/SELECT must be repeated every time it
3225 ** is encountered if any of the following is true:
3227 ** * The right-hand side is a correlated subquery
3228 ** * The right-hand side is an expression list containing variables
3229 ** * We are inside a trigger
3231 ** If all of the above are false, then we can run this code just once
3232 ** save the results, and reuse the same result on subsequent invocations.
3234 if( !ExprHasProperty(pExpr
, EP_VarSelect
) ){
3235 addrOnce
= sqlite3VdbeAddOp0(v
, OP_Once
); VdbeCoverage(v
);
3238 /* For a SELECT, generate code to put the values for all columns of
3239 ** the first row into an array of registers and return the index of
3240 ** the first register.
3242 ** If this is an EXISTS, write an integer 0 (not exists) or 1 (exists)
3243 ** into a register and return that register number.
3245 ** In both cases, the query is augmented with "LIMIT 1". Any
3246 ** preexisting limit is discarded in place of the new LIMIT 1.
3248 ExplainQueryPlan((pParse
, 1, "%sSCALAR SUBQUERY %d",
3249 addrOnce
?"":"CORRELATED ", pSel
->selId
));
3250 nReg
= pExpr
->op
==TK_SELECT
? pSel
->pEList
->nExpr
: 1;
3251 sqlite3SelectDestInit(&dest
, 0, pParse
->nMem
+1);
3252 pParse
->nMem
+= nReg
;
3253 if( pExpr
->op
==TK_SELECT
){
3254 dest
.eDest
= SRT_Mem
;
3255 dest
.iSdst
= dest
.iSDParm
;
3257 sqlite3VdbeAddOp3(v
, OP_Null
, 0, dest
.iSDParm
, dest
.iSDParm
+nReg
-1);
3258 VdbeComment((v
, "Init subquery result"));
3260 dest
.eDest
= SRT_Exists
;
3261 sqlite3VdbeAddOp2(v
, OP_Integer
, 0, dest
.iSDParm
);
3262 VdbeComment((v
, "Init EXISTS result"));
3265 /* The subquery already has a limit. If the pre-existing limit is X
3266 ** then make the new limit X<>0 so that the new limit is either 1 or 0 */
3267 sqlite3
*db
= pParse
->db
;
3268 pLimit
= sqlite3Expr(db
, TK_INTEGER
, "0");
3270 pLimit
->affExpr
= SQLITE_AFF_NUMERIC
;
3271 pLimit
= sqlite3PExpr(pParse
, TK_NE
,
3272 sqlite3ExprDup(db
, pSel
->pLimit
->pLeft
, 0), pLimit
);
3274 sqlite3ExprDelete(db
, pSel
->pLimit
->pLeft
);
3275 pSel
->pLimit
->pLeft
= pLimit
;
3277 /* If there is no pre-existing limit add a limit of 1 */
3278 pLimit
= sqlite3Expr(pParse
->db
, TK_INTEGER
, "1");
3279 pSel
->pLimit
= sqlite3PExpr(pParse
, TK_LIMIT
, pLimit
, 0);
3282 if( sqlite3Select(pParse
, pSel
, &dest
) ){
3284 pExpr
->op2
= pExpr
->op
;
3285 pExpr
->op
= TK_ERROR
;
3289 pExpr
->iTable
= rReg
= dest
.iSDParm
;
3290 ExprSetVVAProperty(pExpr
, EP_NoReduce
);
3292 sqlite3VdbeJumpHere(v
, addrOnce
);
3295 /* Subroutine return */
3296 assert( ExprUseYSub(pExpr
) );
3297 sqlite3VdbeAddOp1(v
, OP_Return
, pExpr
->y
.sub
.regReturn
);
3298 sqlite3VdbeChangeP1(v
, pExpr
->y
.sub
.iAddr
-1, sqlite3VdbeCurrentAddr(v
)-1);
3299 sqlite3ClearTempRegCache(pParse
);
3302 #endif /* SQLITE_OMIT_SUBQUERY */
3304 #ifndef SQLITE_OMIT_SUBQUERY
3306 ** Expr pIn is an IN(...) expression. This function checks that the
3307 ** sub-select on the RHS of the IN() operator has the same number of
3308 ** columns as the vector on the LHS. Or, if the RHS of the IN() is not
3309 ** a sub-query, that the LHS is a vector of size 1.
3311 int sqlite3ExprCheckIN(Parse
*pParse
, Expr
*pIn
){
3312 int nVector
= sqlite3ExprVectorSize(pIn
->pLeft
);
3313 if( ExprUseXSelect(pIn
) && !pParse
->db
->mallocFailed
){
3314 if( nVector
!=pIn
->x
.pSelect
->pEList
->nExpr
){
3315 sqlite3SubselectError(pParse
, pIn
->x
.pSelect
->pEList
->nExpr
, nVector
);
3318 }else if( nVector
!=1 ){
3319 sqlite3VectorErrorMsg(pParse
, pIn
->pLeft
);
3326 #ifndef SQLITE_OMIT_SUBQUERY
3328 ** Generate code for an IN expression.
3330 ** x IN (SELECT ...)
3331 ** x IN (value, value, ...)
3333 ** The left-hand side (LHS) is a scalar or vector expression. The
3334 ** right-hand side (RHS) is an array of zero or more scalar values, or a
3335 ** subquery. If the RHS is a subquery, the number of result columns must
3336 ** match the number of columns in the vector on the LHS. If the RHS is
3337 ** a list of values, the LHS must be a scalar.
3339 ** The IN operator is true if the LHS value is contained within the RHS.
3340 ** The result is false if the LHS is definitely not in the RHS. The
3341 ** result is NULL if the presence of the LHS in the RHS cannot be
3342 ** determined due to NULLs.
3344 ** This routine generates code that jumps to destIfFalse if the LHS is not
3345 ** contained within the RHS. If due to NULLs we cannot determine if the LHS
3346 ** is contained in the RHS then jump to destIfNull. If the LHS is contained
3347 ** within the RHS then fall through.
3349 ** See the separate in-operator.md documentation file in the canonical
3350 ** SQLite source tree for additional information.
3352 static void sqlite3ExprCodeIN(
3353 Parse
*pParse
, /* Parsing and code generating context */
3354 Expr
*pExpr
, /* The IN expression */
3355 int destIfFalse
, /* Jump here if LHS is not contained in the RHS */
3356 int destIfNull
/* Jump here if the results are unknown due to NULLs */
3358 int rRhsHasNull
= 0; /* Register that is true if RHS contains NULL values */
3359 int eType
; /* Type of the RHS */
3360 int rLhs
; /* Register(s) holding the LHS values */
3361 int rLhsOrig
; /* LHS values prior to reordering by aiMap[] */
3362 Vdbe
*v
; /* Statement under construction */
3363 int *aiMap
= 0; /* Map from vector field to index column */
3364 char *zAff
= 0; /* Affinity string for comparisons */
3365 int nVector
; /* Size of vectors for this IN operator */
3366 int iDummy
; /* Dummy parameter to exprCodeVector() */
3367 Expr
*pLeft
; /* The LHS of the IN operator */
3368 int i
; /* loop counter */
3369 int destStep2
; /* Where to jump when NULLs seen in step 2 */
3370 int destStep6
= 0; /* Start of code for Step 6 */
3371 int addrTruthOp
; /* Address of opcode that determines the IN is true */
3372 int destNotNull
; /* Jump here if a comparison is not true in step 6 */
3373 int addrTop
; /* Top of the step-6 loop */
3374 int iTab
= 0; /* Index to use */
3375 u8 okConstFactor
= pParse
->okConstFactor
;
3377 assert( !ExprHasVVAProperty(pExpr
,EP_Immutable
) );
3378 pLeft
= pExpr
->pLeft
;
3379 if( sqlite3ExprCheckIN(pParse
, pExpr
) ) return;
3380 zAff
= exprINAffinity(pParse
, pExpr
);
3381 nVector
= sqlite3ExprVectorSize(pExpr
->pLeft
);
3382 aiMap
= (int*)sqlite3DbMallocZero(
3383 pParse
->db
, nVector
*(sizeof(int) + sizeof(char)) + 1
3385 if( pParse
->db
->mallocFailed
) goto sqlite3ExprCodeIN_oom_error
;
3387 /* Attempt to compute the RHS. After this step, if anything other than
3388 ** IN_INDEX_NOOP is returned, the table opened with cursor iTab
3389 ** contains the values that make up the RHS. If IN_INDEX_NOOP is returned,
3390 ** the RHS has not yet been coded. */
3392 assert( v
!=0 ); /* OOM detected prior to this routine */
3393 VdbeNoopComment((v
, "begin IN expr"));
3394 eType
= sqlite3FindInIndex(pParse
, pExpr
,
3395 IN_INDEX_MEMBERSHIP
| IN_INDEX_NOOP_OK
,
3396 destIfFalse
==destIfNull
? 0 : &rRhsHasNull
,
3399 assert( pParse
->nErr
|| nVector
==1 || eType
==IN_INDEX_EPH
3400 || eType
==IN_INDEX_INDEX_ASC
|| eType
==IN_INDEX_INDEX_DESC
3403 /* Confirm that aiMap[] contains nVector integer values between 0 and
3405 for(i
=0; i
<nVector
; i
++){
3407 for(cnt
=j
=0; j
<nVector
; j
++) if( aiMap
[j
]==i
) cnt
++;
3412 /* Code the LHS, the <expr> from "<expr> IN (...)". If the LHS is a
3413 ** vector, then it is stored in an array of nVector registers starting
3416 ** sqlite3FindInIndex() might have reordered the fields of the LHS vector
3417 ** so that the fields are in the same order as an existing index. The
3418 ** aiMap[] array contains a mapping from the original LHS field order to
3419 ** the field order that matches the RHS index.
3421 ** Avoid factoring the LHS of the IN(...) expression out of the loop,
3422 ** even if it is constant, as OP_Affinity may be used on the register
3423 ** by code generated below. */
3424 assert( pParse
->okConstFactor
==okConstFactor
);
3425 pParse
->okConstFactor
= 0;
3426 rLhsOrig
= exprCodeVector(pParse
, pLeft
, &iDummy
);
3427 pParse
->okConstFactor
= okConstFactor
;
3428 for(i
=0; i
<nVector
&& aiMap
[i
]==i
; i
++){} /* Are LHS fields reordered? */
3430 /* LHS fields are not reordered */
3433 /* Need to reorder the LHS fields according to aiMap */
3434 rLhs
= sqlite3GetTempRange(pParse
, nVector
);
3435 for(i
=0; i
<nVector
; i
++){
3436 sqlite3VdbeAddOp3(v
, OP_Copy
, rLhsOrig
+i
, rLhs
+aiMap
[i
], 0);
3440 /* If sqlite3FindInIndex() did not find or create an index that is
3441 ** suitable for evaluating the IN operator, then evaluate using a
3442 ** sequence of comparisons.
3444 ** This is step (1) in the in-operator.md optimized algorithm.
3446 if( eType
==IN_INDEX_NOOP
){
3449 int labelOk
= sqlite3VdbeMakeLabel(pParse
);
3453 assert( ExprUseXList(pExpr
) );
3454 pList
= pExpr
->x
.pList
;
3455 pColl
= sqlite3ExprCollSeq(pParse
, pExpr
->pLeft
);
3456 if( destIfNull
!=destIfFalse
){
3457 regCkNull
= sqlite3GetTempReg(pParse
);
3458 sqlite3VdbeAddOp3(v
, OP_BitAnd
, rLhs
, rLhs
, regCkNull
);
3460 for(ii
=0; ii
<pList
->nExpr
; ii
++){
3461 r2
= sqlite3ExprCodeTemp(pParse
, pList
->a
[ii
].pExpr
, ®ToFree
);
3462 if( regCkNull
&& sqlite3ExprCanBeNull(pList
->a
[ii
].pExpr
) ){
3463 sqlite3VdbeAddOp3(v
, OP_BitAnd
, regCkNull
, r2
, regCkNull
);
3465 sqlite3ReleaseTempReg(pParse
, regToFree
);
3466 if( ii
<pList
->nExpr
-1 || destIfNull
!=destIfFalse
){
3467 int op
= rLhs
!=r2
? OP_Eq
: OP_NotNull
;
3468 sqlite3VdbeAddOp4(v
, op
, rLhs
, labelOk
, r2
,
3469 (void*)pColl
, P4_COLLSEQ
);
3470 VdbeCoverageIf(v
, ii
<pList
->nExpr
-1 && op
==OP_Eq
);
3471 VdbeCoverageIf(v
, ii
==pList
->nExpr
-1 && op
==OP_Eq
);
3472 VdbeCoverageIf(v
, ii
<pList
->nExpr
-1 && op
==OP_NotNull
);
3473 VdbeCoverageIf(v
, ii
==pList
->nExpr
-1 && op
==OP_NotNull
);
3474 sqlite3VdbeChangeP5(v
, zAff
[0]);
3476 int op
= rLhs
!=r2
? OP_Ne
: OP_IsNull
;
3477 assert( destIfNull
==destIfFalse
);
3478 sqlite3VdbeAddOp4(v
, op
, rLhs
, destIfFalse
, r2
,
3479 (void*)pColl
, P4_COLLSEQ
);
3480 VdbeCoverageIf(v
, op
==OP_Ne
);
3481 VdbeCoverageIf(v
, op
==OP_IsNull
);
3482 sqlite3VdbeChangeP5(v
, zAff
[0] | SQLITE_JUMPIFNULL
);
3486 sqlite3VdbeAddOp2(v
, OP_IsNull
, regCkNull
, destIfNull
); VdbeCoverage(v
);
3487 sqlite3VdbeGoto(v
, destIfFalse
);
3489 sqlite3VdbeResolveLabel(v
, labelOk
);
3490 sqlite3ReleaseTempReg(pParse
, regCkNull
);
3491 goto sqlite3ExprCodeIN_finished
;
3494 /* Step 2: Check to see if the LHS contains any NULL columns. If the
3495 ** LHS does contain NULLs then the result must be either FALSE or NULL.
3496 ** We will then skip the binary search of the RHS.
3498 if( destIfNull
==destIfFalse
){
3499 destStep2
= destIfFalse
;
3501 destStep2
= destStep6
= sqlite3VdbeMakeLabel(pParse
);
3503 if( pParse
->nErr
) goto sqlite3ExprCodeIN_finished
;
3504 for(i
=0; i
<nVector
; i
++){
3505 Expr
*p
= sqlite3VectorFieldSubexpr(pExpr
->pLeft
, i
);
3506 if( pParse
->db
->mallocFailed
) goto sqlite3ExprCodeIN_oom_error
;
3507 if( sqlite3ExprCanBeNull(p
) ){
3508 sqlite3VdbeAddOp2(v
, OP_IsNull
, rLhs
+i
, destStep2
);
3513 /* Step 3. The LHS is now known to be non-NULL. Do the binary search
3514 ** of the RHS using the LHS as a probe. If found, the result is
3517 if( eType
==IN_INDEX_ROWID
){
3518 /* In this case, the RHS is the ROWID of table b-tree and so we also
3519 ** know that the RHS is non-NULL. Hence, we combine steps 3 and 4
3520 ** into a single opcode. */
3521 sqlite3VdbeAddOp3(v
, OP_SeekRowid
, iTab
, destIfFalse
, rLhs
);
3523 addrTruthOp
= sqlite3VdbeAddOp0(v
, OP_Goto
); /* Return True */
3525 sqlite3VdbeAddOp4(v
, OP_Affinity
, rLhs
, nVector
, 0, zAff
, nVector
);
3526 if( destIfFalse
==destIfNull
){
3527 /* Combine Step 3 and Step 5 into a single opcode */
3528 sqlite3VdbeAddOp4Int(v
, OP_NotFound
, iTab
, destIfFalse
,
3529 rLhs
, nVector
); VdbeCoverage(v
);
3530 goto sqlite3ExprCodeIN_finished
;
3532 /* Ordinary Step 3, for the case where FALSE and NULL are distinct */
3533 addrTruthOp
= sqlite3VdbeAddOp4Int(v
, OP_Found
, iTab
, 0,
3534 rLhs
, nVector
); VdbeCoverage(v
);
3537 /* Step 4. If the RHS is known to be non-NULL and we did not find
3538 ** an match on the search above, then the result must be FALSE.
3540 if( rRhsHasNull
&& nVector
==1 ){
3541 sqlite3VdbeAddOp2(v
, OP_NotNull
, rRhsHasNull
, destIfFalse
);
3545 /* Step 5. If we do not care about the difference between NULL and
3546 ** FALSE, then just return false.
3548 if( destIfFalse
==destIfNull
) sqlite3VdbeGoto(v
, destIfFalse
);
3550 /* Step 6: Loop through rows of the RHS. Compare each row to the LHS.
3551 ** If any comparison is NULL, then the result is NULL. If all
3552 ** comparisons are FALSE then the final result is FALSE.
3554 ** For a scalar LHS, it is sufficient to check just the first row
3557 if( destStep6
) sqlite3VdbeResolveLabel(v
, destStep6
);
3558 addrTop
= sqlite3VdbeAddOp2(v
, OP_Rewind
, iTab
, destIfFalse
);
3561 destNotNull
= sqlite3VdbeMakeLabel(pParse
);
3563 /* For nVector==1, combine steps 6 and 7 by immediately returning
3564 ** FALSE if the first comparison is not NULL */
3565 destNotNull
= destIfFalse
;
3567 for(i
=0; i
<nVector
; i
++){
3570 int r3
= sqlite3GetTempReg(pParse
);
3571 p
= sqlite3VectorFieldSubexpr(pLeft
, i
);
3572 pColl
= sqlite3ExprCollSeq(pParse
, p
);
3573 sqlite3VdbeAddOp3(v
, OP_Column
, iTab
, i
, r3
);
3574 sqlite3VdbeAddOp4(v
, OP_Ne
, rLhs
+i
, destNotNull
, r3
,
3575 (void*)pColl
, P4_COLLSEQ
);
3577 sqlite3ReleaseTempReg(pParse
, r3
);
3579 sqlite3VdbeAddOp2(v
, OP_Goto
, 0, destIfNull
);
3581 sqlite3VdbeResolveLabel(v
, destNotNull
);
3582 sqlite3VdbeAddOp2(v
, OP_Next
, iTab
, addrTop
+1);
3585 /* Step 7: If we reach this point, we know that the result must
3587 sqlite3VdbeAddOp2(v
, OP_Goto
, 0, destIfFalse
);
3590 /* Jumps here in order to return true. */
3591 sqlite3VdbeJumpHere(v
, addrTruthOp
);
3593 sqlite3ExprCodeIN_finished
:
3594 if( rLhs
!=rLhsOrig
) sqlite3ReleaseTempReg(pParse
, rLhs
);
3595 VdbeComment((v
, "end IN expr"));
3596 sqlite3ExprCodeIN_oom_error
:
3597 sqlite3DbFree(pParse
->db
, aiMap
);
3598 sqlite3DbFree(pParse
->db
, zAff
);
3600 #endif /* SQLITE_OMIT_SUBQUERY */
3602 #ifndef SQLITE_OMIT_FLOATING_POINT
3604 ** Generate an instruction that will put the floating point
3605 ** value described by z[0..n-1] into register iMem.
3607 ** The z[] string will probably not be zero-terminated. But the
3608 ** z[n] character is guaranteed to be something that does not look
3609 ** like the continuation of the number.
3611 static void codeReal(Vdbe
*v
, const char *z
, int negateFlag
, int iMem
){
3614 sqlite3AtoF(z
, &value
, sqlite3Strlen30(z
), SQLITE_UTF8
);
3615 assert( !sqlite3IsNaN(value
) ); /* The new AtoF never returns NaN */
3616 if( negateFlag
) value
= -value
;
3617 sqlite3VdbeAddOp4Dup8(v
, OP_Real
, 0, iMem
, 0, (u8
*)&value
, P4_REAL
);
3624 ** Generate an instruction that will put the integer describe by
3625 ** text z[0..n-1] into register iMem.
3627 ** Expr.u.zToken is always UTF8 and zero-terminated.
3629 static void codeInteger(Parse
*pParse
, Expr
*pExpr
, int negFlag
, int iMem
){
3630 Vdbe
*v
= pParse
->pVdbe
;
3631 if( pExpr
->flags
& EP_IntValue
){
3632 int i
= pExpr
->u
.iValue
;
3634 if( negFlag
) i
= -i
;
3635 sqlite3VdbeAddOp2(v
, OP_Integer
, i
, iMem
);
3639 const char *z
= pExpr
->u
.zToken
;
3641 c
= sqlite3DecOrHexToI64(z
, &value
);
3642 if( (c
==3 && !negFlag
) || (c
==2) || (negFlag
&& value
==SMALLEST_INT64
)){
3643 #ifdef SQLITE_OMIT_FLOATING_POINT
3644 sqlite3ErrorMsg(pParse
, "oversized integer: %s%s", negFlag
? "-" : "", z
);
3646 #ifndef SQLITE_OMIT_HEX_INTEGER
3647 if( sqlite3_strnicmp(z
,"0x",2)==0 ){
3648 sqlite3ErrorMsg(pParse
, "hex literal too big: %s%s", negFlag
?"-":"",z
);
3652 codeReal(v
, z
, negFlag
, iMem
);
3656 if( negFlag
){ value
= c
==3 ? SMALLEST_INT64
: -value
; }
3657 sqlite3VdbeAddOp4Dup8(v
, OP_Int64
, 0, iMem
, 0, (u8
*)&value
, P4_INT64
);
3663 /* Generate code that will load into register regOut a value that is
3664 ** appropriate for the iIdxCol-th column of index pIdx.
3666 void sqlite3ExprCodeLoadIndexColumn(
3667 Parse
*pParse
, /* The parsing context */
3668 Index
*pIdx
, /* The index whose column is to be loaded */
3669 int iTabCur
, /* Cursor pointing to a table row */
3670 int iIdxCol
, /* The column of the index to be loaded */
3671 int regOut
/* Store the index column value in this register */
3673 i16 iTabCol
= pIdx
->aiColumn
[iIdxCol
];
3674 if( iTabCol
==XN_EXPR
){
3675 assert( pIdx
->aColExpr
);
3676 assert( pIdx
->aColExpr
->nExpr
>iIdxCol
);
3677 pParse
->iSelfTab
= iTabCur
+ 1;
3678 sqlite3ExprCodeCopy(pParse
, pIdx
->aColExpr
->a
[iIdxCol
].pExpr
, regOut
);
3679 pParse
->iSelfTab
= 0;
3681 sqlite3ExprCodeGetColumnOfTable(pParse
->pVdbe
, pIdx
->pTable
, iTabCur
,
3686 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
3688 ** Generate code that will compute the value of generated column pCol
3689 ** and store the result in register regOut
3691 void sqlite3ExprCodeGeneratedColumn(
3692 Parse
*pParse
, /* Parsing context */
3693 Table
*pTab
, /* Table containing the generated column */
3694 Column
*pCol
, /* The generated column */
3695 int regOut
/* Put the result in this register */
3698 Vdbe
*v
= pParse
->pVdbe
;
3700 assert( pParse
->iSelfTab
!=0 );
3701 if( pParse
->iSelfTab
>0 ){
3702 iAddr
= sqlite3VdbeAddOp3(v
, OP_IfNullRow
, pParse
->iSelfTab
-1, 0, regOut
);
3706 sqlite3ExprCodeCopy(pParse
, sqlite3ColumnExpr(pTab
,pCol
), regOut
);
3707 if( pCol
->affinity
>=SQLITE_AFF_TEXT
){
3708 sqlite3VdbeAddOp4(v
, OP_Affinity
, regOut
, 1, 0, &pCol
->affinity
, 1);
3710 if( iAddr
) sqlite3VdbeJumpHere(v
, iAddr
);
3712 #endif /* SQLITE_OMIT_GENERATED_COLUMNS */
3715 ** Generate code to extract the value of the iCol-th column of a table.
3717 void sqlite3ExprCodeGetColumnOfTable(
3718 Vdbe
*v
, /* Parsing context */
3719 Table
*pTab
, /* The table containing the value */
3720 int iTabCur
, /* The table cursor. Or the PK cursor for WITHOUT ROWID */
3721 int iCol
, /* Index of the column to extract */
3722 int regOut
/* Extract the value into this register */
3727 sqlite3VdbeAddOp3(v
, OP_Column
, iTabCur
, iCol
, regOut
);
3730 if( iCol
<0 || iCol
==pTab
->iPKey
){
3731 sqlite3VdbeAddOp2(v
, OP_Rowid
, iTabCur
, regOut
);
3735 if( IsVirtual(pTab
) ){
3738 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
3739 }else if( (pCol
= &pTab
->aCol
[iCol
])->colFlags
& COLFLAG_VIRTUAL
){
3740 Parse
*pParse
= sqlite3VdbeParser(v
);
3741 if( pCol
->colFlags
& COLFLAG_BUSY
){
3742 sqlite3ErrorMsg(pParse
, "generated column loop on \"%s\"",
3745 int savedSelfTab
= pParse
->iSelfTab
;
3746 pCol
->colFlags
|= COLFLAG_BUSY
;
3747 pParse
->iSelfTab
= iTabCur
+1;
3748 sqlite3ExprCodeGeneratedColumn(pParse
, pTab
, pCol
, regOut
);
3749 pParse
->iSelfTab
= savedSelfTab
;
3750 pCol
->colFlags
&= ~COLFLAG_BUSY
;
3754 }else if( !HasRowid(pTab
) ){
3755 testcase( iCol
!=sqlite3TableColumnToStorage(pTab
, iCol
) );
3756 x
= sqlite3TableColumnToIndex(sqlite3PrimaryKeyIndex(pTab
), iCol
);
3759 x
= sqlite3TableColumnToStorage(pTab
,iCol
);
3760 testcase( x
!=iCol
);
3763 sqlite3VdbeAddOp3(v
, op
, iTabCur
, x
, regOut
);
3764 sqlite3ColumnDefault(v
, pTab
, iCol
, regOut
);
3769 ** Generate code that will extract the iColumn-th column from
3770 ** table pTab and store the column value in register iReg.
3772 ** There must be an open cursor to pTab in iTable when this routine
3773 ** is called. If iColumn<0 then code is generated that extracts the rowid.
3775 int sqlite3ExprCodeGetColumn(
3776 Parse
*pParse
, /* Parsing and code generating context */
3777 Table
*pTab
, /* Description of the table we are reading from */
3778 int iColumn
, /* Index of the table column */
3779 int iTable
, /* The cursor pointing to the table */
3780 int iReg
, /* Store results here */
3781 u8 p5
/* P5 value for OP_Column + FLAGS */
3783 assert( pParse
->pVdbe
!=0 );
3784 sqlite3ExprCodeGetColumnOfTable(pParse
->pVdbe
, pTab
, iTable
, iColumn
, iReg
);
3786 VdbeOp
*pOp
= sqlite3VdbeGetOp(pParse
->pVdbe
,-1);
3787 if( pOp
->opcode
==OP_Column
) pOp
->p5
= p5
;
3793 ** Generate code to move content from registers iFrom...iFrom+nReg-1
3794 ** over to iTo..iTo+nReg-1.
3796 void sqlite3ExprCodeMove(Parse
*pParse
, int iFrom
, int iTo
, int nReg
){
3797 sqlite3VdbeAddOp3(pParse
->pVdbe
, OP_Move
, iFrom
, iTo
, nReg
);
3801 ** Convert a scalar expression node to a TK_REGISTER referencing
3802 ** register iReg. The caller must ensure that iReg already contains
3803 ** the correct value for the expression.
3805 static void exprToRegister(Expr
*pExpr
, int iReg
){
3806 Expr
*p
= sqlite3ExprSkipCollateAndLikely(pExpr
);
3807 if( NEVER(p
==0) ) return;
3809 p
->op
= TK_REGISTER
;
3811 ExprClearProperty(p
, EP_Skip
);
3815 ** Evaluate an expression (either a vector or a scalar expression) and store
3816 ** the result in continguous temporary registers. Return the index of
3817 ** the first register used to store the result.
3819 ** If the returned result register is a temporary scalar, then also write
3820 ** that register number into *piFreeable. If the returned result register
3821 ** is not a temporary or if the expression is a vector set *piFreeable
3824 static int exprCodeVector(Parse
*pParse
, Expr
*p
, int *piFreeable
){
3826 int nResult
= sqlite3ExprVectorSize(p
);
3828 iResult
= sqlite3ExprCodeTemp(pParse
, p
, piFreeable
);
3831 if( p
->op
==TK_SELECT
){
3832 #if SQLITE_OMIT_SUBQUERY
3835 iResult
= sqlite3CodeSubselect(pParse
, p
);
3839 iResult
= pParse
->nMem
+1;
3840 pParse
->nMem
+= nResult
;
3841 assert( ExprUseXList(p
) );
3842 for(i
=0; i
<nResult
; i
++){
3843 sqlite3ExprCodeFactorable(pParse
, p
->x
.pList
->a
[i
].pExpr
, i
+iResult
);
3851 ** If the last opcode is a OP_Copy, then set the do-not-merge flag (p5)
3852 ** so that a subsequent copy will not be merged into this one.
3854 static void setDoNotMergeFlagOnCopy(Vdbe
*v
){
3855 if( sqlite3VdbeGetOp(v
, -1)->opcode
==OP_Copy
){
3856 sqlite3VdbeChangeP5(v
, 1); /* Tag trailing OP_Copy as not mergable */
3861 ** Generate code to implement special SQL functions that are implemented
3862 ** in-line rather than by using the usual callbacks.
3864 static int exprCodeInlineFunction(
3865 Parse
*pParse
, /* Parsing context */
3866 ExprList
*pFarg
, /* List of function arguments */
3867 int iFuncId
, /* Function ID. One of the INTFUNC_... values */
3868 int target
/* Store function result in this register */
3871 Vdbe
*v
= pParse
->pVdbe
;
3874 nFarg
= pFarg
->nExpr
;
3875 assert( nFarg
>0 ); /* All in-line functions have at least one argument */
3877 case INLINEFUNC_coalesce
: {
3878 /* Attempt a direct implementation of the built-in COALESCE() and
3879 ** IFNULL() functions. This avoids unnecessary evaluation of
3880 ** arguments past the first non-NULL argument.
3882 int endCoalesce
= sqlite3VdbeMakeLabel(pParse
);
3885 sqlite3ExprCode(pParse
, pFarg
->a
[0].pExpr
, target
);
3886 for(i
=1; i
<nFarg
; i
++){
3887 sqlite3VdbeAddOp2(v
, OP_NotNull
, target
, endCoalesce
);
3889 sqlite3ExprCode(pParse
, pFarg
->a
[i
].pExpr
, target
);
3891 setDoNotMergeFlagOnCopy(v
);
3892 sqlite3VdbeResolveLabel(v
, endCoalesce
);
3895 case INLINEFUNC_iif
: {
3897 memset(&caseExpr
, 0, sizeof(caseExpr
));
3898 caseExpr
.op
= TK_CASE
;
3899 caseExpr
.x
.pList
= pFarg
;
3900 return sqlite3ExprCodeTarget(pParse
, &caseExpr
, target
);
3904 /* The UNLIKELY() function is a no-op. The result is the value
3905 ** of the first argument.
3907 assert( nFarg
==1 || nFarg
==2 );
3908 target
= sqlite3ExprCodeTarget(pParse
, pFarg
->a
[0].pExpr
, target
);
3912 /***********************************************************************
3913 ** Test-only SQL functions that are only usable if enabled
3914 ** via SQLITE_TESTCTRL_INTERNAL_FUNCTIONS
3916 #if !defined(SQLITE_UNTESTABLE)
3917 case INLINEFUNC_expr_compare
: {
3918 /* Compare two expressions using sqlite3ExprCompare() */
3920 sqlite3VdbeAddOp2(v
, OP_Integer
,
3921 sqlite3ExprCompare(0,pFarg
->a
[0].pExpr
, pFarg
->a
[1].pExpr
,-1),
3926 case INLINEFUNC_expr_implies_expr
: {
3927 /* Compare two expressions using sqlite3ExprImpliesExpr() */
3929 sqlite3VdbeAddOp2(v
, OP_Integer
,
3930 sqlite3ExprImpliesExpr(pParse
,pFarg
->a
[0].pExpr
, pFarg
->a
[1].pExpr
,-1),
3935 case INLINEFUNC_implies_nonnull_row
: {
3936 /* REsult of sqlite3ExprImpliesNonNullRow() */
3939 pA1
= pFarg
->a
[1].pExpr
;
3940 if( pA1
->op
==TK_COLUMN
){
3941 sqlite3VdbeAddOp2(v
, OP_Integer
,
3942 sqlite3ExprImpliesNonNullRow(pFarg
->a
[0].pExpr
,pA1
->iTable
),
3945 sqlite3VdbeAddOp2(v
, OP_Null
, 0, target
);
3950 case INLINEFUNC_affinity
: {
3951 /* The AFFINITY() function evaluates to a string that describes
3952 ** the type affinity of the argument. This is used for testing of
3953 ** the SQLite type logic.
3955 const char *azAff
[] = { "blob", "text", "numeric", "integer", "real" };
3958 aff
= sqlite3ExprAffinity(pFarg
->a
[0].pExpr
);
3959 sqlite3VdbeLoadString(v
, target
,
3960 (aff
<=SQLITE_AFF_NONE
) ? "none" : azAff
[aff
-SQLITE_AFF_BLOB
]);
3963 #endif /* !defined(SQLITE_UNTESTABLE) */
3970 ** Generate code into the current Vdbe to evaluate the given
3971 ** expression. Attempt to store the results in register "target".
3972 ** Return the register where results are stored.
3974 ** With this routine, there is no guarantee that results will
3975 ** be stored in target. The result might be stored in some other
3976 ** register if it is convenient to do so. The calling function
3977 ** must check the return code and move the results to the desired
3980 int sqlite3ExprCodeTarget(Parse
*pParse
, Expr
*pExpr
, int target
){
3981 Vdbe
*v
= pParse
->pVdbe
; /* The VM under construction */
3982 int op
; /* The opcode being coded */
3983 int inReg
= target
; /* Results stored in register inReg */
3984 int regFree1
= 0; /* If non-zero free this temporary register */
3985 int regFree2
= 0; /* If non-zero free this temporary register */
3986 int r1
, r2
; /* Various register numbers */
3987 Expr tempX
; /* Temporary expression node */
3990 assert( target
>0 && target
<=pParse
->nMem
);
3997 assert( !ExprHasVVAProperty(pExpr
,EP_Immutable
) );
4001 case TK_AGG_COLUMN
: {
4002 AggInfo
*pAggInfo
= pExpr
->pAggInfo
;
4003 struct AggInfo_col
*pCol
;
4004 assert( pAggInfo
!=0 );
4005 assert( pExpr
->iAgg
>=0 && pExpr
->iAgg
<pAggInfo
->nColumn
);
4006 pCol
= &pAggInfo
->aCol
[pExpr
->iAgg
];
4007 if( !pAggInfo
->directMode
){
4008 assert( pCol
->iMem
>0 );
4010 }else if( pAggInfo
->useSortingIdx
){
4011 Table
*pTab
= pCol
->pTab
;
4012 sqlite3VdbeAddOp3(v
, OP_Column
, pAggInfo
->sortingIdxPTab
,
4013 pCol
->iSorterColumn
, target
);
4014 if( pCol
->iColumn
<0 ){
4015 VdbeComment((v
,"%s.rowid",pTab
->zName
));
4017 VdbeComment((v
,"%s.%s",
4018 pTab
->zName
, pTab
->aCol
[pCol
->iColumn
].zCnName
));
4019 if( pTab
->aCol
[pCol
->iColumn
].affinity
==SQLITE_AFF_REAL
){
4020 sqlite3VdbeAddOp1(v
, OP_RealAffinity
, target
);
4025 /* Otherwise, fall thru into the TK_COLUMN case */
4026 /* no break */ deliberate_fall_through
4029 int iTab
= pExpr
->iTable
;
4031 if( ExprHasProperty(pExpr
, EP_FixedCol
) ){
4032 /* This COLUMN expression is really a constant due to WHERE clause
4033 ** constraints, and that constant is coded by the pExpr->pLeft
4034 ** expresssion. However, make sure the constant has the correct
4035 ** datatype by applying the Affinity of the table column to the
4039 iReg
= sqlite3ExprCodeTarget(pParse
, pExpr
->pLeft
,target
);
4040 assert( ExprUseYTab(pExpr
) );
4041 if( pExpr
->y
.pTab
){
4042 aff
= sqlite3TableColumnAffinity(pExpr
->y
.pTab
, pExpr
->iColumn
);
4044 aff
= pExpr
->affExpr
;
4046 if( aff
>SQLITE_AFF_BLOB
){
4047 static const char zAff
[] = "B\000C\000D\000E";
4048 assert( SQLITE_AFF_BLOB
=='A' );
4049 assert( SQLITE_AFF_TEXT
=='B' );
4050 sqlite3VdbeAddOp4(v
, OP_Affinity
, iReg
, 1, 0,
4051 &zAff
[(aff
-'B')*2], P4_STATIC
);
4056 if( pParse
->iSelfTab
<0 ){
4057 /* Other columns in the same row for CHECK constraints or
4058 ** generated columns or for inserting into partial index.
4059 ** The row is unpacked into registers beginning at
4060 ** 0-(pParse->iSelfTab). The rowid (if any) is in a register
4061 ** immediately prior to the first column.
4066 int iCol
= pExpr
->iColumn
;
4067 assert( ExprUseYTab(pExpr
) );
4068 pTab
= pExpr
->y
.pTab
;
4070 assert( iCol
>=XN_ROWID
);
4071 assert( iCol
<pTab
->nCol
);
4073 return -1-pParse
->iSelfTab
;
4075 pCol
= pTab
->aCol
+ iCol
;
4076 testcase( iCol
!=sqlite3TableColumnToStorage(pTab
,iCol
) );
4077 iSrc
= sqlite3TableColumnToStorage(pTab
, iCol
) - pParse
->iSelfTab
;
4078 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
4079 if( pCol
->colFlags
& COLFLAG_GENERATED
){
4080 if( pCol
->colFlags
& COLFLAG_BUSY
){
4081 sqlite3ErrorMsg(pParse
, "generated column loop on \"%s\"",
4085 pCol
->colFlags
|= COLFLAG_BUSY
;
4086 if( pCol
->colFlags
& COLFLAG_NOTAVAIL
){
4087 sqlite3ExprCodeGeneratedColumn(pParse
, pTab
, pCol
, iSrc
);
4089 pCol
->colFlags
&= ~(COLFLAG_BUSY
|COLFLAG_NOTAVAIL
);
4092 #endif /* SQLITE_OMIT_GENERATED_COLUMNS */
4093 if( pCol
->affinity
==SQLITE_AFF_REAL
){
4094 sqlite3VdbeAddOp2(v
, OP_SCopy
, iSrc
, target
);
4095 sqlite3VdbeAddOp1(v
, OP_RealAffinity
, target
);
4101 /* Coding an expression that is part of an index where column names
4102 ** in the index refer to the table to which the index belongs */
4103 iTab
= pParse
->iSelfTab
- 1;
4106 assert( ExprUseYTab(pExpr
) );
4107 iReg
= sqlite3ExprCodeGetColumn(pParse
, pExpr
->y
.pTab
,
4108 pExpr
->iColumn
, iTab
, target
,
4110 if( pExpr
->y
.pTab
==0 && pExpr
->affExpr
==SQLITE_AFF_REAL
){
4111 sqlite3VdbeAddOp1(v
, OP_RealAffinity
, iReg
);
4116 codeInteger(pParse
, pExpr
, 0, target
);
4119 case TK_TRUEFALSE
: {
4120 sqlite3VdbeAddOp2(v
, OP_Integer
, sqlite3ExprTruthValue(pExpr
), target
);
4123 #ifndef SQLITE_OMIT_FLOATING_POINT
4125 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
4126 codeReal(v
, pExpr
->u
.zToken
, 0, target
);
4131 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
4132 sqlite3VdbeLoadString(v
, target
, pExpr
->u
.zToken
);
4136 /* Make NULL the default case so that if a bug causes an illegal
4137 ** Expr node to be passed into this function, it will be handled
4138 ** sanely and not crash. But keep the assert() to bring the problem
4139 ** to the attention of the developers. */
4140 assert( op
==TK_NULL
|| op
==TK_ERROR
|| pParse
->db
->mallocFailed
);
4141 sqlite3VdbeAddOp2(v
, OP_Null
, 0, target
);
4144 #ifndef SQLITE_OMIT_BLOB_LITERAL
4149 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
4150 assert( pExpr
->u
.zToken
[0]=='x' || pExpr
->u
.zToken
[0]=='X' );
4151 assert( pExpr
->u
.zToken
[1]=='\'' );
4152 z
= &pExpr
->u
.zToken
[2];
4153 n
= sqlite3Strlen30(z
) - 1;
4154 assert( z
[n
]=='\'' );
4155 zBlob
= sqlite3HexToBlob(sqlite3VdbeDb(v
), z
, n
);
4156 sqlite3VdbeAddOp4(v
, OP_Blob
, n
/2, target
, 0, zBlob
, P4_DYNAMIC
);
4161 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
4162 assert( pExpr
->u
.zToken
!=0 );
4163 assert( pExpr
->u
.zToken
[0]!=0 );
4164 sqlite3VdbeAddOp2(v
, OP_Variable
, pExpr
->iColumn
, target
);
4165 if( pExpr
->u
.zToken
[1]!=0 ){
4166 const char *z
= sqlite3VListNumToName(pParse
->pVList
, pExpr
->iColumn
);
4167 assert( pExpr
->u
.zToken
[0]=='?' || (z
&& !strcmp(pExpr
->u
.zToken
, z
)) );
4168 pParse
->pVList
[0] = 0; /* Indicate VList may no longer be enlarged */
4169 sqlite3VdbeAppendP4(v
, (char*)z
, P4_STATIC
);
4174 return pExpr
->iTable
;
4176 #ifndef SQLITE_OMIT_CAST
4178 /* Expressions of the form: CAST(pLeft AS token) */
4179 inReg
= sqlite3ExprCodeTarget(pParse
, pExpr
->pLeft
, target
);
4180 if( inReg
!=target
){
4181 sqlite3VdbeAddOp2(v
, OP_SCopy
, inReg
, target
);
4184 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
4185 sqlite3VdbeAddOp2(v
, OP_Cast
, target
,
4186 sqlite3AffinityType(pExpr
->u
.zToken
, 0));
4189 #endif /* SQLITE_OMIT_CAST */
4192 op
= (op
==TK_IS
) ? TK_EQ
: TK_NE
;
4201 Expr
*pLeft
= pExpr
->pLeft
;
4202 if( sqlite3ExprIsVector(pLeft
) ){
4203 codeVectorCompare(pParse
, pExpr
, target
, op
, p5
);
4205 r1
= sqlite3ExprCodeTemp(pParse
, pLeft
, ®Free1
);
4206 r2
= sqlite3ExprCodeTemp(pParse
, pExpr
->pRight
, ®Free2
);
4207 sqlite3VdbeAddOp2(v
, OP_Integer
, 1, inReg
);
4208 codeCompare(pParse
, pLeft
, pExpr
->pRight
, op
, r1
, r2
,
4209 sqlite3VdbeCurrentAddr(v
)+2, p5
,
4210 ExprHasProperty(pExpr
,EP_Commuted
));
4211 assert(TK_LT
==OP_Lt
); testcase(op
==OP_Lt
); VdbeCoverageIf(v
,op
==OP_Lt
);
4212 assert(TK_LE
==OP_Le
); testcase(op
==OP_Le
); VdbeCoverageIf(v
,op
==OP_Le
);
4213 assert(TK_GT
==OP_Gt
); testcase(op
==OP_Gt
); VdbeCoverageIf(v
,op
==OP_Gt
);
4214 assert(TK_GE
==OP_Ge
); testcase(op
==OP_Ge
); VdbeCoverageIf(v
,op
==OP_Ge
);
4215 assert(TK_EQ
==OP_Eq
); testcase(op
==OP_Eq
); VdbeCoverageIf(v
,op
==OP_Eq
);
4216 assert(TK_NE
==OP_Ne
); testcase(op
==OP_Ne
); VdbeCoverageIf(v
,op
==OP_Ne
);
4217 if( p5
==SQLITE_NULLEQ
){
4218 sqlite3VdbeAddOp2(v
, OP_Integer
, 0, inReg
);
4220 sqlite3VdbeAddOp3(v
, OP_ZeroOrNull
, r1
, inReg
, r2
);
4222 testcase( regFree1
==0 );
4223 testcase( regFree2
==0 );
4239 assert( TK_AND
==OP_And
); testcase( op
==TK_AND
);
4240 assert( TK_OR
==OP_Or
); testcase( op
==TK_OR
);
4241 assert( TK_PLUS
==OP_Add
); testcase( op
==TK_PLUS
);
4242 assert( TK_MINUS
==OP_Subtract
); testcase( op
==TK_MINUS
);
4243 assert( TK_REM
==OP_Remainder
); testcase( op
==TK_REM
);
4244 assert( TK_BITAND
==OP_BitAnd
); testcase( op
==TK_BITAND
);
4245 assert( TK_BITOR
==OP_BitOr
); testcase( op
==TK_BITOR
);
4246 assert( TK_SLASH
==OP_Divide
); testcase( op
==TK_SLASH
);
4247 assert( TK_LSHIFT
==OP_ShiftLeft
); testcase( op
==TK_LSHIFT
);
4248 assert( TK_RSHIFT
==OP_ShiftRight
); testcase( op
==TK_RSHIFT
);
4249 assert( TK_CONCAT
==OP_Concat
); testcase( op
==TK_CONCAT
);
4250 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free1
);
4251 r2
= sqlite3ExprCodeTemp(pParse
, pExpr
->pRight
, ®Free2
);
4252 sqlite3VdbeAddOp3(v
, op
, r2
, r1
, target
);
4253 testcase( regFree1
==0 );
4254 testcase( regFree2
==0 );
4258 Expr
*pLeft
= pExpr
->pLeft
;
4260 if( pLeft
->op
==TK_INTEGER
){
4261 codeInteger(pParse
, pLeft
, 1, target
);
4263 #ifndef SQLITE_OMIT_FLOATING_POINT
4264 }else if( pLeft
->op
==TK_FLOAT
){
4265 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
4266 codeReal(v
, pLeft
->u
.zToken
, 1, target
);
4270 tempX
.op
= TK_INTEGER
;
4271 tempX
.flags
= EP_IntValue
|EP_TokenOnly
;
4273 ExprClearVVAProperties(&tempX
);
4274 r1
= sqlite3ExprCodeTemp(pParse
, &tempX
, ®Free1
);
4275 r2
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free2
);
4276 sqlite3VdbeAddOp3(v
, OP_Subtract
, r2
, r1
, target
);
4277 testcase( regFree2
==0 );
4283 assert( TK_BITNOT
==OP_BitNot
); testcase( op
==TK_BITNOT
);
4284 assert( TK_NOT
==OP_Not
); testcase( op
==TK_NOT
);
4285 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free1
);
4286 testcase( regFree1
==0 );
4287 sqlite3VdbeAddOp2(v
, op
, r1
, inReg
);
4291 int isTrue
; /* IS TRUE or IS NOT TRUE */
4292 int bNormal
; /* IS TRUE or IS FALSE */
4293 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free1
);
4294 testcase( regFree1
==0 );
4295 isTrue
= sqlite3ExprTruthValue(pExpr
->pRight
);
4296 bNormal
= pExpr
->op2
==TK_IS
;
4297 testcase( isTrue
&& bNormal
);
4298 testcase( !isTrue
&& bNormal
);
4299 sqlite3VdbeAddOp4Int(v
, OP_IsTrue
, r1
, inReg
, !isTrue
, isTrue
^ bNormal
);
4305 assert( TK_ISNULL
==OP_IsNull
); testcase( op
==TK_ISNULL
);
4306 assert( TK_NOTNULL
==OP_NotNull
); testcase( op
==TK_NOTNULL
);
4307 sqlite3VdbeAddOp2(v
, OP_Integer
, 1, target
);
4308 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free1
);
4309 testcase( regFree1
==0 );
4310 addr
= sqlite3VdbeAddOp1(v
, op
, r1
);
4311 VdbeCoverageIf(v
, op
==TK_ISNULL
);
4312 VdbeCoverageIf(v
, op
==TK_NOTNULL
);
4313 sqlite3VdbeAddOp2(v
, OP_Integer
, 0, target
);
4314 sqlite3VdbeJumpHere(v
, addr
);
4317 case TK_AGG_FUNCTION
: {
4318 AggInfo
*pInfo
= pExpr
->pAggInfo
;
4320 || NEVER(pExpr
->iAgg
<0)
4321 || NEVER(pExpr
->iAgg
>=pInfo
->nFunc
)
4323 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
4324 sqlite3ErrorMsg(pParse
, "misuse of aggregate: %s()", pExpr
->u
.zToken
);
4326 return pInfo
->aFunc
[pExpr
->iAgg
].iMem
;
4331 ExprList
*pFarg
; /* List of function arguments */
4332 int nFarg
; /* Number of function arguments */
4333 FuncDef
*pDef
; /* The function definition object */
4334 const char *zId
; /* The function name */
4335 u32 constMask
= 0; /* Mask of function arguments that are constant */
4336 int i
; /* Loop counter */
4337 sqlite3
*db
= pParse
->db
; /* The database connection */
4338 u8 enc
= ENC(db
); /* The text encoding used by this database */
4339 CollSeq
*pColl
= 0; /* A collating sequence */
4341 #ifndef SQLITE_OMIT_WINDOWFUNC
4342 if( ExprHasProperty(pExpr
, EP_WinFunc
) ){
4343 return pExpr
->y
.pWin
->regResult
;
4347 if( ConstFactorOk(pParse
) && sqlite3ExprIsConstantNotJoin(pExpr
) ){
4348 /* SQL functions can be expensive. So try to avoid running them
4349 ** multiple times if we know they always give the same result */
4350 return sqlite3ExprCodeRunJustOnce(pParse
, pExpr
, -1);
4352 assert( !ExprHasProperty(pExpr
, EP_TokenOnly
) );
4353 assert( ExprUseXList(pExpr
) );
4354 pFarg
= pExpr
->x
.pList
;
4355 nFarg
= pFarg
? pFarg
->nExpr
: 0;
4356 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
4357 zId
= pExpr
->u
.zToken
;
4358 pDef
= sqlite3FindFunction(db
, zId
, nFarg
, enc
, 0);
4359 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
4360 if( pDef
==0 && pParse
->explain
){
4361 pDef
= sqlite3FindFunction(db
, "unknown", nFarg
, enc
, 0);
4364 if( pDef
==0 || pDef
->xFinalize
!=0 ){
4365 sqlite3ErrorMsg(pParse
, "unknown function: %s()", zId
);
4368 if( pDef
->funcFlags
& SQLITE_FUNC_INLINE
){
4369 assert( (pDef
->funcFlags
& SQLITE_FUNC_UNSAFE
)==0 );
4370 assert( (pDef
->funcFlags
& SQLITE_FUNC_DIRECT
)==0 );
4371 return exprCodeInlineFunction(pParse
, pFarg
,
4372 SQLITE_PTR_TO_INT(pDef
->pUserData
), target
);
4373 }else if( pDef
->funcFlags
& (SQLITE_FUNC_DIRECT
|SQLITE_FUNC_UNSAFE
) ){
4374 sqlite3ExprFunctionUsable(pParse
, pExpr
, pDef
);
4377 for(i
=0; i
<nFarg
; i
++){
4378 if( i
<32 && sqlite3ExprIsConstant(pFarg
->a
[i
].pExpr
) ){
4380 constMask
|= MASKBIT32(i
);
4382 if( (pDef
->funcFlags
& SQLITE_FUNC_NEEDCOLL
)!=0 && !pColl
){
4383 pColl
= sqlite3ExprCollSeq(pParse
, pFarg
->a
[i
].pExpr
);
4388 r1
= pParse
->nMem
+1;
4389 pParse
->nMem
+= nFarg
;
4391 r1
= sqlite3GetTempRange(pParse
, nFarg
);
4394 /* For length() and typeof() functions with a column argument,
4395 ** set the P5 parameter to the OP_Column opcode to OPFLAG_LENGTHARG
4396 ** or OPFLAG_TYPEOFARG respectively, to avoid unnecessary data
4399 if( (pDef
->funcFlags
& (SQLITE_FUNC_LENGTH
|SQLITE_FUNC_TYPEOF
))!=0 ){
4402 assert( pFarg
->a
[0].pExpr
!=0 );
4403 exprOp
= pFarg
->a
[0].pExpr
->op
;
4404 if( exprOp
==TK_COLUMN
|| exprOp
==TK_AGG_COLUMN
){
4405 assert( SQLITE_FUNC_LENGTH
==OPFLAG_LENGTHARG
);
4406 assert( SQLITE_FUNC_TYPEOF
==OPFLAG_TYPEOFARG
);
4407 testcase( pDef
->funcFlags
& OPFLAG_LENGTHARG
);
4408 pFarg
->a
[0].pExpr
->op2
=
4409 pDef
->funcFlags
& (OPFLAG_LENGTHARG
|OPFLAG_TYPEOFARG
);
4413 sqlite3ExprCodeExprList(pParse
, pFarg
, r1
, 0,
4414 SQLITE_ECEL_DUP
|SQLITE_ECEL_FACTOR
);
4418 #ifndef SQLITE_OMIT_VIRTUALTABLE
4419 /* Possibly overload the function if the first argument is
4420 ** a virtual table column.
4422 ** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the
4423 ** second argument, not the first, as the argument to test to
4424 ** see if it is a column in a virtual table. This is done because
4425 ** the left operand of infix functions (the operand we want to
4426 ** control overloading) ends up as the second argument to the
4427 ** function. The expression "A glob B" is equivalent to
4428 ** "glob(B,A). We want to use the A in "A glob B" to test
4429 ** for function overloading. But we use the B term in "glob(B,A)".
4431 if( nFarg
>=2 && ExprHasProperty(pExpr
, EP_InfixFunc
) ){
4432 pDef
= sqlite3VtabOverloadFunction(db
, pDef
, nFarg
, pFarg
->a
[1].pExpr
);
4433 }else if( nFarg
>0 ){
4434 pDef
= sqlite3VtabOverloadFunction(db
, pDef
, nFarg
, pFarg
->a
[0].pExpr
);
4437 if( pDef
->funcFlags
& SQLITE_FUNC_NEEDCOLL
){
4438 if( !pColl
) pColl
= db
->pDfltColl
;
4439 sqlite3VdbeAddOp4(v
, OP_CollSeq
, 0, 0, 0, (char *)pColl
, P4_COLLSEQ
);
4441 #ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
4442 if( (pDef
->funcFlags
& SQLITE_FUNC_OFFSET
)!=0 && ALWAYS(pFarg
!=0) ){
4443 Expr
*pArg
= pFarg
->a
[0].pExpr
;
4444 if( pArg
->op
==TK_COLUMN
){
4445 sqlite3VdbeAddOp3(v
, OP_Offset
, pArg
->iTable
, pArg
->iColumn
, target
);
4447 sqlite3VdbeAddOp2(v
, OP_Null
, 0, target
);
4452 sqlite3VdbeAddFunctionCall(pParse
, constMask
, r1
, target
, nFarg
,
4457 sqlite3ReleaseTempRange(pParse
, r1
, nFarg
);
4459 sqlite3VdbeReleaseRegisters(pParse
, r1
, nFarg
, constMask
, 1);
4464 #ifndef SQLITE_OMIT_SUBQUERY
4468 testcase( op
==TK_EXISTS
);
4469 testcase( op
==TK_SELECT
);
4470 if( pParse
->db
->mallocFailed
){
4472 }else if( op
==TK_SELECT
4473 && ALWAYS( ExprUseXSelect(pExpr
) )
4474 && (nCol
= pExpr
->x
.pSelect
->pEList
->nExpr
)!=1
4476 sqlite3SubselectError(pParse
, nCol
, 1);
4478 return sqlite3CodeSubselect(pParse
, pExpr
);
4482 case TK_SELECT_COLUMN
: {
4484 if( pExpr
->pLeft
->iTable
==0 ){
4485 pExpr
->pLeft
->iTable
= sqlite3CodeSubselect(pParse
, pExpr
->pLeft
);
4487 assert( pExpr
->pLeft
->op
==TK_SELECT
|| pExpr
->pLeft
->op
==TK_ERROR
);
4488 n
= sqlite3ExprVectorSize(pExpr
->pLeft
);
4489 if( pExpr
->iTable
!=n
){
4490 sqlite3ErrorMsg(pParse
, "%d columns assigned %d values",
4493 return pExpr
->pLeft
->iTable
+ pExpr
->iColumn
;
4496 int destIfFalse
= sqlite3VdbeMakeLabel(pParse
);
4497 int destIfNull
= sqlite3VdbeMakeLabel(pParse
);
4498 sqlite3VdbeAddOp2(v
, OP_Null
, 0, target
);
4499 sqlite3ExprCodeIN(pParse
, pExpr
, destIfFalse
, destIfNull
);
4500 sqlite3VdbeAddOp2(v
, OP_Integer
, 1, target
);
4501 sqlite3VdbeResolveLabel(v
, destIfFalse
);
4502 sqlite3VdbeAddOp2(v
, OP_AddImm
, target
, 0);
4503 sqlite3VdbeResolveLabel(v
, destIfNull
);
4506 #endif /* SQLITE_OMIT_SUBQUERY */
4510 ** x BETWEEN y AND z
4512 ** This is equivalent to
4516 ** X is stored in pExpr->pLeft.
4517 ** Y is stored in pExpr->pList->a[0].pExpr.
4518 ** Z is stored in pExpr->pList->a[1].pExpr.
4521 exprCodeBetween(pParse
, pExpr
, target
, 0, 0);
4527 pExpr
= pExpr
->pLeft
;
4528 goto expr_code_doover
; /* 2018-04-28: Prevent deep recursion. OSSFuzz. */
4532 /* If the opcode is TK_TRIGGER, then the expression is a reference
4533 ** to a column in the new.* or old.* pseudo-tables available to
4534 ** trigger programs. In this case Expr.iTable is set to 1 for the
4535 ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
4536 ** is set to the column of the pseudo-table to read, or to -1 to
4537 ** read the rowid field.
4539 ** The expression is implemented using an OP_Param opcode. The p1
4540 ** parameter is set to 0 for an old.rowid reference, or to (i+1)
4541 ** to reference another column of the old.* pseudo-table, where
4542 ** i is the index of the column. For a new.rowid reference, p1 is
4543 ** set to (n+1), where n is the number of columns in each pseudo-table.
4544 ** For a reference to any other column in the new.* pseudo-table, p1
4545 ** is set to (n+2+i), where n and i are as defined previously. For
4546 ** example, if the table on which triggers are being fired is
4549 ** CREATE TABLE t1(a, b);
4551 ** Then p1 is interpreted as follows:
4553 ** p1==0 -> old.rowid p1==3 -> new.rowid
4554 ** p1==1 -> old.a p1==4 -> new.a
4555 ** p1==2 -> old.b p1==5 -> new.b
4561 assert( ExprUseYTab(pExpr
) );
4562 pTab
= pExpr
->y
.pTab
;
4563 iCol
= pExpr
->iColumn
;
4564 p1
= pExpr
->iTable
* (pTab
->nCol
+1) + 1
4565 + sqlite3TableColumnToStorage(pTab
, iCol
);
4567 assert( pExpr
->iTable
==0 || pExpr
->iTable
==1 );
4568 assert( iCol
>=-1 && iCol
<pTab
->nCol
);
4569 assert( pTab
->iPKey
<0 || iCol
!=pTab
->iPKey
);
4570 assert( p1
>=0 && p1
<(pTab
->nCol
*2+2) );
4572 sqlite3VdbeAddOp2(v
, OP_Param
, p1
, target
);
4573 VdbeComment((v
, "r[%d]=%s.%s", target
,
4574 (pExpr
->iTable
? "new" : "old"),
4575 (pExpr
->iColumn
<0 ? "rowid" : pExpr
->y
.pTab
->aCol
[iCol
].zCnName
)
4578 #ifndef SQLITE_OMIT_FLOATING_POINT
4579 /* If the column has REAL affinity, it may currently be stored as an
4580 ** integer. Use OP_RealAffinity to make sure it is really real.
4582 ** EVIDENCE-OF: R-60985-57662 SQLite will convert the value back to
4583 ** floating point when extracting it from the record. */
4584 if( iCol
>=0 && pTab
->aCol
[iCol
].affinity
==SQLITE_AFF_REAL
){
4585 sqlite3VdbeAddOp1(v
, OP_RealAffinity
, target
);
4592 sqlite3ErrorMsg(pParse
, "row value misused");
4596 /* TK_IF_NULL_ROW Expr nodes are inserted ahead of expressions
4597 ** that derive from the right-hand table of a LEFT JOIN. The
4598 ** Expr.iTable value is the table number for the right-hand table.
4599 ** The expression is only evaluated if that table is not currently
4600 ** on a LEFT JOIN NULL row.
4602 case TK_IF_NULL_ROW
: {
4604 u8 okConstFactor
= pParse
->okConstFactor
;
4605 addrINR
= sqlite3VdbeAddOp1(v
, OP_IfNullRow
, pExpr
->iTable
);
4606 /* Temporarily disable factoring of constant expressions, since
4607 ** even though expressions may appear to be constant, they are not
4608 ** really constant because they originate from the right-hand side
4609 ** of a LEFT JOIN. */
4610 pParse
->okConstFactor
= 0;
4611 inReg
= sqlite3ExprCodeTarget(pParse
, pExpr
->pLeft
, target
);
4612 pParse
->okConstFactor
= okConstFactor
;
4613 sqlite3VdbeJumpHere(v
, addrINR
);
4614 sqlite3VdbeChangeP3(v
, addrINR
, inReg
);
4620 ** CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
4623 ** CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
4625 ** Form A is can be transformed into the equivalent form B as follows:
4626 ** CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ...
4627 ** WHEN x=eN THEN rN ELSE y END
4629 ** X (if it exists) is in pExpr->pLeft.
4630 ** Y is in the last element of pExpr->x.pList if pExpr->x.pList->nExpr is
4631 ** odd. The Y is also optional. If the number of elements in x.pList
4632 ** is even, then Y is omitted and the "otherwise" result is NULL.
4633 ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1].
4635 ** The result of the expression is the Ri for the first matching Ei,
4636 ** or if there is no matching Ei, the ELSE term Y, or if there is
4637 ** no ELSE term, NULL.
4640 int endLabel
; /* GOTO label for end of CASE stmt */
4641 int nextCase
; /* GOTO label for next WHEN clause */
4642 int nExpr
; /* 2x number of WHEN terms */
4643 int i
; /* Loop counter */
4644 ExprList
*pEList
; /* List of WHEN terms */
4645 struct ExprList_item
*aListelem
; /* Array of WHEN terms */
4646 Expr opCompare
; /* The X==Ei expression */
4647 Expr
*pX
; /* The X expression */
4648 Expr
*pTest
= 0; /* X==Ei (form A) or just Ei (form B) */
4650 sqlite3
*db
= pParse
->db
;
4652 assert( ExprUseXList(pExpr
) && pExpr
->x
.pList
!=0 );
4653 assert(pExpr
->x
.pList
->nExpr
> 0);
4654 pEList
= pExpr
->x
.pList
;
4655 aListelem
= pEList
->a
;
4656 nExpr
= pEList
->nExpr
;
4657 endLabel
= sqlite3VdbeMakeLabel(pParse
);
4658 if( (pX
= pExpr
->pLeft
)!=0 ){
4659 pDel
= sqlite3ExprDup(db
, pX
, 0);
4660 if( db
->mallocFailed
){
4661 sqlite3ExprDelete(db
, pDel
);
4664 testcase( pX
->op
==TK_COLUMN
);
4665 exprToRegister(pDel
, exprCodeVector(pParse
, pDel
, ®Free1
));
4666 testcase( regFree1
==0 );
4667 memset(&opCompare
, 0, sizeof(opCompare
));
4668 opCompare
.op
= TK_EQ
;
4669 opCompare
.pLeft
= pDel
;
4671 /* Ticket b351d95f9cd5ef17e9d9dbae18f5ca8611190001:
4672 ** The value in regFree1 might get SCopy-ed into the file result.
4673 ** So make sure that the regFree1 register is not reused for other
4674 ** purposes and possibly overwritten. */
4677 for(i
=0; i
<nExpr
-1; i
=i
+2){
4680 opCompare
.pRight
= aListelem
[i
].pExpr
;
4682 pTest
= aListelem
[i
].pExpr
;
4684 nextCase
= sqlite3VdbeMakeLabel(pParse
);
4685 testcase( pTest
->op
==TK_COLUMN
);
4686 sqlite3ExprIfFalse(pParse
, pTest
, nextCase
, SQLITE_JUMPIFNULL
);
4687 testcase( aListelem
[i
+1].pExpr
->op
==TK_COLUMN
);
4688 sqlite3ExprCode(pParse
, aListelem
[i
+1].pExpr
, target
);
4689 sqlite3VdbeGoto(v
, endLabel
);
4690 sqlite3VdbeResolveLabel(v
, nextCase
);
4693 sqlite3ExprCode(pParse
, pEList
->a
[nExpr
-1].pExpr
, target
);
4695 sqlite3VdbeAddOp2(v
, OP_Null
, 0, target
);
4697 sqlite3ExprDelete(db
, pDel
);
4698 setDoNotMergeFlagOnCopy(v
);
4699 sqlite3VdbeResolveLabel(v
, endLabel
);
4702 #ifndef SQLITE_OMIT_TRIGGER
4704 assert( pExpr
->affExpr
==OE_Rollback
4705 || pExpr
->affExpr
==OE_Abort
4706 || pExpr
->affExpr
==OE_Fail
4707 || pExpr
->affExpr
==OE_Ignore
4709 if( !pParse
->pTriggerTab
&& !pParse
->nested
){
4710 sqlite3ErrorMsg(pParse
,
4711 "RAISE() may only be used within a trigger-program");
4714 if( pExpr
->affExpr
==OE_Abort
){
4715 sqlite3MayAbort(pParse
);
4717 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
4718 if( pExpr
->affExpr
==OE_Ignore
){
4720 v
, OP_Halt
, SQLITE_OK
, OE_Ignore
, 0, pExpr
->u
.zToken
,0);
4723 sqlite3HaltConstraint(pParse
,
4724 pParse
->pTriggerTab
? SQLITE_CONSTRAINT_TRIGGER
: SQLITE_ERROR
,
4725 pExpr
->affExpr
, pExpr
->u
.zToken
, 0, 0);
4732 sqlite3ReleaseTempReg(pParse
, regFree1
);
4733 sqlite3ReleaseTempReg(pParse
, regFree2
);
4738 ** Generate code that will evaluate expression pExpr just one time
4739 ** per prepared statement execution.
4741 ** If the expression uses functions (that might throw an exception) then
4742 ** guard them with an OP_Once opcode to ensure that the code is only executed
4743 ** once. If no functions are involved, then factor the code out and put it at
4744 ** the end of the prepared statement in the initialization section.
4746 ** If regDest>=0 then the result is always stored in that register and the
4747 ** result is not reusable. If regDest<0 then this routine is free to
4748 ** store the value whereever it wants. The register where the expression
4749 ** is stored is returned. When regDest<0, two identical expressions might
4750 ** code to the same register, if they do not contain function calls and hence
4751 ** are factored out into the initialization section at the end of the
4752 ** prepared statement.
4754 int sqlite3ExprCodeRunJustOnce(
4755 Parse
*pParse
, /* Parsing context */
4756 Expr
*pExpr
, /* The expression to code when the VDBE initializes */
4757 int regDest
/* Store the value in this register */
4760 assert( ConstFactorOk(pParse
) );
4761 p
= pParse
->pConstExpr
;
4762 if( regDest
<0 && p
){
4763 struct ExprList_item
*pItem
;
4765 for(pItem
=p
->a
, i
=p
->nExpr
; i
>0; pItem
++, i
--){
4766 if( pItem
->reusable
&& sqlite3ExprCompare(0,pItem
->pExpr
,pExpr
,-1)==0 ){
4767 return pItem
->u
.iConstExprReg
;
4771 pExpr
= sqlite3ExprDup(pParse
->db
, pExpr
, 0);
4772 if( pExpr
!=0 && ExprHasProperty(pExpr
, EP_HasFunc
) ){
4773 Vdbe
*v
= pParse
->pVdbe
;
4776 addr
= sqlite3VdbeAddOp0(v
, OP_Once
); VdbeCoverage(v
);
4777 pParse
->okConstFactor
= 0;
4778 if( !pParse
->db
->mallocFailed
){
4779 if( regDest
<0 ) regDest
= ++pParse
->nMem
;
4780 sqlite3ExprCode(pParse
, pExpr
, regDest
);
4782 pParse
->okConstFactor
= 1;
4783 sqlite3ExprDelete(pParse
->db
, pExpr
);
4784 sqlite3VdbeJumpHere(v
, addr
);
4786 p
= sqlite3ExprListAppend(pParse
, p
, pExpr
);
4788 struct ExprList_item
*pItem
= &p
->a
[p
->nExpr
-1];
4789 pItem
->reusable
= regDest
<0;
4790 if( regDest
<0 ) regDest
= ++pParse
->nMem
;
4791 pItem
->u
.iConstExprReg
= regDest
;
4793 pParse
->pConstExpr
= p
;
4799 ** Generate code to evaluate an expression and store the results
4800 ** into a register. Return the register number where the results
4803 ** If the register is a temporary register that can be deallocated,
4804 ** then write its number into *pReg. If the result register is not
4805 ** a temporary, then set *pReg to zero.
4807 ** If pExpr is a constant, then this routine might generate this
4808 ** code to fill the register in the initialization section of the
4809 ** VDBE program, in order to factor it out of the evaluation loop.
4811 int sqlite3ExprCodeTemp(Parse
*pParse
, Expr
*pExpr
, int *pReg
){
4813 pExpr
= sqlite3ExprSkipCollateAndLikely(pExpr
);
4814 if( ConstFactorOk(pParse
)
4816 && pExpr
->op
!=TK_REGISTER
4817 && sqlite3ExprIsConstantNotJoin(pExpr
)
4820 r2
= sqlite3ExprCodeRunJustOnce(pParse
, pExpr
, -1);
4822 int r1
= sqlite3GetTempReg(pParse
);
4823 r2
= sqlite3ExprCodeTarget(pParse
, pExpr
, r1
);
4827 sqlite3ReleaseTempReg(pParse
, r1
);
4835 ** Generate code that will evaluate expression pExpr and store the
4836 ** results in register target. The results are guaranteed to appear
4837 ** in register target.
4839 void sqlite3ExprCode(Parse
*pParse
, Expr
*pExpr
, int target
){
4842 assert( pExpr
==0 || !ExprHasVVAProperty(pExpr
,EP_Immutable
) );
4843 assert( target
>0 && target
<=pParse
->nMem
);
4844 assert( pParse
->pVdbe
!=0 || pParse
->db
->mallocFailed
);
4845 if( pParse
->pVdbe
==0 ) return;
4846 inReg
= sqlite3ExprCodeTarget(pParse
, pExpr
, target
);
4847 if( inReg
!=target
){
4849 if( ALWAYS(pExpr
) && ExprHasProperty(pExpr
,EP_Subquery
) ){
4854 sqlite3VdbeAddOp2(pParse
->pVdbe
, op
, inReg
, target
);
4859 ** Make a transient copy of expression pExpr and then code it using
4860 ** sqlite3ExprCode(). This routine works just like sqlite3ExprCode()
4861 ** except that the input expression is guaranteed to be unchanged.
4863 void sqlite3ExprCodeCopy(Parse
*pParse
, Expr
*pExpr
, int target
){
4864 sqlite3
*db
= pParse
->db
;
4865 pExpr
= sqlite3ExprDup(db
, pExpr
, 0);
4866 if( !db
->mallocFailed
) sqlite3ExprCode(pParse
, pExpr
, target
);
4867 sqlite3ExprDelete(db
, pExpr
);
4871 ** Generate code that will evaluate expression pExpr and store the
4872 ** results in register target. The results are guaranteed to appear
4873 ** in register target. If the expression is constant, then this routine
4874 ** might choose to code the expression at initialization time.
4876 void sqlite3ExprCodeFactorable(Parse
*pParse
, Expr
*pExpr
, int target
){
4877 if( pParse
->okConstFactor
&& sqlite3ExprIsConstantNotJoin(pExpr
) ){
4878 sqlite3ExprCodeRunJustOnce(pParse
, pExpr
, target
);
4880 sqlite3ExprCodeCopy(pParse
, pExpr
, target
);
4885 ** Generate code that pushes the value of every element of the given
4886 ** expression list into a sequence of registers beginning at target.
4888 ** Return the number of elements evaluated. The number returned will
4889 ** usually be pList->nExpr but might be reduced if SQLITE_ECEL_OMITREF
4892 ** The SQLITE_ECEL_DUP flag prevents the arguments from being
4893 ** filled using OP_SCopy. OP_Copy must be used instead.
4895 ** The SQLITE_ECEL_FACTOR argument allows constant arguments to be
4896 ** factored out into initialization code.
4898 ** The SQLITE_ECEL_REF flag means that expressions in the list with
4899 ** ExprList.a[].u.x.iOrderByCol>0 have already been evaluated and stored
4900 ** in registers at srcReg, and so the value can be copied from there.
4901 ** If SQLITE_ECEL_OMITREF is also set, then the values with u.x.iOrderByCol>0
4902 ** are simply omitted rather than being copied from srcReg.
4904 int sqlite3ExprCodeExprList(
4905 Parse
*pParse
, /* Parsing context */
4906 ExprList
*pList
, /* The expression list to be coded */
4907 int target
, /* Where to write results */
4908 int srcReg
, /* Source registers if SQLITE_ECEL_REF */
4909 u8 flags
/* SQLITE_ECEL_* flags */
4911 struct ExprList_item
*pItem
;
4913 u8 copyOp
= (flags
& SQLITE_ECEL_DUP
) ? OP_Copy
: OP_SCopy
;
4914 Vdbe
*v
= pParse
->pVdbe
;
4917 assert( pParse
->pVdbe
!=0 ); /* Never gets this far otherwise */
4919 if( !ConstFactorOk(pParse
) ) flags
&= ~SQLITE_ECEL_FACTOR
;
4920 for(pItem
=pList
->a
, i
=0; i
<n
; i
++, pItem
++){
4921 Expr
*pExpr
= pItem
->pExpr
;
4922 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
4923 if( pItem
->bSorterRef
){
4928 if( (flags
& SQLITE_ECEL_REF
)!=0 && (j
= pItem
->u
.x
.iOrderByCol
)>0 ){
4929 if( flags
& SQLITE_ECEL_OMITREF
){
4933 sqlite3VdbeAddOp2(v
, copyOp
, j
+srcReg
-1, target
+i
);
4935 }else if( (flags
& SQLITE_ECEL_FACTOR
)!=0
4936 && sqlite3ExprIsConstantNotJoin(pExpr
)
4938 sqlite3ExprCodeRunJustOnce(pParse
, pExpr
, target
+i
);
4940 int inReg
= sqlite3ExprCodeTarget(pParse
, pExpr
, target
+i
);
4941 if( inReg
!=target
+i
){
4944 && (pOp
=sqlite3VdbeGetOp(v
, -1))->opcode
==OP_Copy
4945 && pOp
->p1
+pOp
->p3
+1==inReg
4946 && pOp
->p2
+pOp
->p3
+1==target
+i
4947 && pOp
->p5
==0 /* The do-not-merge flag must be clear */
4951 sqlite3VdbeAddOp2(v
, copyOp
, inReg
, target
+i
);
4960 ** Generate code for a BETWEEN operator.
4962 ** x BETWEEN y AND z
4964 ** The above is equivalent to
4968 ** Code it as such, taking care to do the common subexpression
4969 ** elimination of x.
4971 ** The xJumpIf parameter determines details:
4973 ** NULL: Store the boolean result in reg[dest]
4974 ** sqlite3ExprIfTrue: Jump to dest if true
4975 ** sqlite3ExprIfFalse: Jump to dest if false
4977 ** The jumpIfNull parameter is ignored if xJumpIf is NULL.
4979 static void exprCodeBetween(
4980 Parse
*pParse
, /* Parsing and code generating context */
4981 Expr
*pExpr
, /* The BETWEEN expression */
4982 int dest
, /* Jump destination or storage location */
4983 void (*xJump
)(Parse
*,Expr
*,int,int), /* Action to take */
4984 int jumpIfNull
/* Take the jump if the BETWEEN is NULL */
4986 Expr exprAnd
; /* The AND operator in x>=y AND x<=z */
4987 Expr compLeft
; /* The x>=y term */
4988 Expr compRight
; /* The x<=z term */
4989 int regFree1
= 0; /* Temporary use register */
4991 sqlite3
*db
= pParse
->db
;
4993 memset(&compLeft
, 0, sizeof(Expr
));
4994 memset(&compRight
, 0, sizeof(Expr
));
4995 memset(&exprAnd
, 0, sizeof(Expr
));
4997 assert( ExprUseXList(pExpr
) );
4998 pDel
= sqlite3ExprDup(db
, pExpr
->pLeft
, 0);
4999 if( db
->mallocFailed
==0 ){
5000 exprAnd
.op
= TK_AND
;
5001 exprAnd
.pLeft
= &compLeft
;
5002 exprAnd
.pRight
= &compRight
;
5003 compLeft
.op
= TK_GE
;
5004 compLeft
.pLeft
= pDel
;
5005 compLeft
.pRight
= pExpr
->x
.pList
->a
[0].pExpr
;
5006 compRight
.op
= TK_LE
;
5007 compRight
.pLeft
= pDel
;
5008 compRight
.pRight
= pExpr
->x
.pList
->a
[1].pExpr
;
5009 exprToRegister(pDel
, exprCodeVector(pParse
, pDel
, ®Free1
));
5011 xJump(pParse
, &exprAnd
, dest
, jumpIfNull
);
5013 /* Mark the expression is being from the ON or USING clause of a join
5014 ** so that the sqlite3ExprCodeTarget() routine will not attempt to move
5015 ** it into the Parse.pConstExpr list. We should use a new bit for this,
5016 ** for clarity, but we are out of bits in the Expr.flags field so we
5017 ** have to reuse the EP_FromJoin bit. Bummer. */
5018 pDel
->flags
|= EP_FromJoin
;
5019 sqlite3ExprCodeTarget(pParse
, &exprAnd
, dest
);
5021 sqlite3ReleaseTempReg(pParse
, regFree1
);
5023 sqlite3ExprDelete(db
, pDel
);
5025 /* Ensure adequate test coverage */
5026 testcase( xJump
==sqlite3ExprIfTrue
&& jumpIfNull
==0 && regFree1
==0 );
5027 testcase( xJump
==sqlite3ExprIfTrue
&& jumpIfNull
==0 && regFree1
!=0 );
5028 testcase( xJump
==sqlite3ExprIfTrue
&& jumpIfNull
!=0 && regFree1
==0 );
5029 testcase( xJump
==sqlite3ExprIfTrue
&& jumpIfNull
!=0 && regFree1
!=0 );
5030 testcase( xJump
==sqlite3ExprIfFalse
&& jumpIfNull
==0 && regFree1
==0 );
5031 testcase( xJump
==sqlite3ExprIfFalse
&& jumpIfNull
==0 && regFree1
!=0 );
5032 testcase( xJump
==sqlite3ExprIfFalse
&& jumpIfNull
!=0 && regFree1
==0 );
5033 testcase( xJump
==sqlite3ExprIfFalse
&& jumpIfNull
!=0 && regFree1
!=0 );
5034 testcase( xJump
==0 );
5038 ** Generate code for a boolean expression such that a jump is made
5039 ** to the label "dest" if the expression is true but execution
5040 ** continues straight thru if the expression is false.
5042 ** If the expression evaluates to NULL (neither true nor false), then
5043 ** take the jump if the jumpIfNull flag is SQLITE_JUMPIFNULL.
5045 ** This code depends on the fact that certain token values (ex: TK_EQ)
5046 ** are the same as opcode values (ex: OP_Eq) that implement the corresponding
5047 ** operation. Special comments in vdbe.c and the mkopcodeh.awk script in
5048 ** the make process cause these values to align. Assert()s in the code
5049 ** below verify that the numbers are aligned correctly.
5051 void sqlite3ExprIfTrue(Parse
*pParse
, Expr
*pExpr
, int dest
, int jumpIfNull
){
5052 Vdbe
*v
= pParse
->pVdbe
;
5058 assert( jumpIfNull
==SQLITE_JUMPIFNULL
|| jumpIfNull
==0 );
5059 if( NEVER(v
==0) ) return; /* Existence of VDBE checked by caller */
5060 if( NEVER(pExpr
==0) ) return; /* No way this can happen */
5061 assert( !ExprHasVVAProperty(pExpr
, EP_Immutable
) );
5066 Expr
*pAlt
= sqlite3ExprSimplifiedAndOr(pExpr
);
5068 sqlite3ExprIfTrue(pParse
, pAlt
, dest
, jumpIfNull
);
5069 }else if( op
==TK_AND
){
5070 int d2
= sqlite3VdbeMakeLabel(pParse
);
5071 testcase( jumpIfNull
==0 );
5072 sqlite3ExprIfFalse(pParse
, pExpr
->pLeft
, d2
,
5073 jumpIfNull
^SQLITE_JUMPIFNULL
);
5074 sqlite3ExprIfTrue(pParse
, pExpr
->pRight
, dest
, jumpIfNull
);
5075 sqlite3VdbeResolveLabel(v
, d2
);
5077 testcase( jumpIfNull
==0 );
5078 sqlite3ExprIfTrue(pParse
, pExpr
->pLeft
, dest
, jumpIfNull
);
5079 sqlite3ExprIfTrue(pParse
, pExpr
->pRight
, dest
, jumpIfNull
);
5084 testcase( jumpIfNull
==0 );
5085 sqlite3ExprIfFalse(pParse
, pExpr
->pLeft
, dest
, jumpIfNull
);
5089 int isNot
; /* IS NOT TRUE or IS NOT FALSE */
5090 int isTrue
; /* IS TRUE or IS NOT TRUE */
5091 testcase( jumpIfNull
==0 );
5092 isNot
= pExpr
->op2
==TK_ISNOT
;
5093 isTrue
= sqlite3ExprTruthValue(pExpr
->pRight
);
5094 testcase( isTrue
&& isNot
);
5095 testcase( !isTrue
&& isNot
);
5096 if( isTrue
^ isNot
){
5097 sqlite3ExprIfTrue(pParse
, pExpr
->pLeft
, dest
,
5098 isNot
? SQLITE_JUMPIFNULL
: 0);
5100 sqlite3ExprIfFalse(pParse
, pExpr
->pLeft
, dest
,
5101 isNot
? SQLITE_JUMPIFNULL
: 0);
5107 testcase( op
==TK_IS
);
5108 testcase( op
==TK_ISNOT
);
5109 op
= (op
==TK_IS
) ? TK_EQ
: TK_NE
;
5110 jumpIfNull
= SQLITE_NULLEQ
;
5111 /* no break */ deliberate_fall_through
5118 if( sqlite3ExprIsVector(pExpr
->pLeft
) ) goto default_expr
;
5119 testcase( jumpIfNull
==0 );
5120 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free1
);
5121 r2
= sqlite3ExprCodeTemp(pParse
, pExpr
->pRight
, ®Free2
);
5122 codeCompare(pParse
, pExpr
->pLeft
, pExpr
->pRight
, op
,
5123 r1
, r2
, dest
, jumpIfNull
, ExprHasProperty(pExpr
,EP_Commuted
));
5124 assert(TK_LT
==OP_Lt
); testcase(op
==OP_Lt
); VdbeCoverageIf(v
,op
==OP_Lt
);
5125 assert(TK_LE
==OP_Le
); testcase(op
==OP_Le
); VdbeCoverageIf(v
,op
==OP_Le
);
5126 assert(TK_GT
==OP_Gt
); testcase(op
==OP_Gt
); VdbeCoverageIf(v
,op
==OP_Gt
);
5127 assert(TK_GE
==OP_Ge
); testcase(op
==OP_Ge
); VdbeCoverageIf(v
,op
==OP_Ge
);
5128 assert(TK_EQ
==OP_Eq
); testcase(op
==OP_Eq
);
5129 VdbeCoverageIf(v
, op
==OP_Eq
&& jumpIfNull
==SQLITE_NULLEQ
);
5130 VdbeCoverageIf(v
, op
==OP_Eq
&& jumpIfNull
!=SQLITE_NULLEQ
);
5131 assert(TK_NE
==OP_Ne
); testcase(op
==OP_Ne
);
5132 VdbeCoverageIf(v
, op
==OP_Ne
&& jumpIfNull
==SQLITE_NULLEQ
);
5133 VdbeCoverageIf(v
, op
==OP_Ne
&& jumpIfNull
!=SQLITE_NULLEQ
);
5134 testcase( regFree1
==0 );
5135 testcase( regFree2
==0 );
5140 assert( TK_ISNULL
==OP_IsNull
); testcase( op
==TK_ISNULL
);
5141 assert( TK_NOTNULL
==OP_NotNull
); testcase( op
==TK_NOTNULL
);
5142 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free1
);
5143 sqlite3VdbeAddOp2(v
, op
, r1
, dest
);
5144 VdbeCoverageIf(v
, op
==TK_ISNULL
);
5145 VdbeCoverageIf(v
, op
==TK_NOTNULL
);
5146 testcase( regFree1
==0 );
5150 testcase( jumpIfNull
==0 );
5151 exprCodeBetween(pParse
, pExpr
, dest
, sqlite3ExprIfTrue
, jumpIfNull
);
5154 #ifndef SQLITE_OMIT_SUBQUERY
5156 int destIfFalse
= sqlite3VdbeMakeLabel(pParse
);
5157 int destIfNull
= jumpIfNull
? dest
: destIfFalse
;
5158 sqlite3ExprCodeIN(pParse
, pExpr
, destIfFalse
, destIfNull
);
5159 sqlite3VdbeGoto(v
, dest
);
5160 sqlite3VdbeResolveLabel(v
, destIfFalse
);
5166 if( ExprAlwaysTrue(pExpr
) ){
5167 sqlite3VdbeGoto(v
, dest
);
5168 }else if( ExprAlwaysFalse(pExpr
) ){
5171 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
, ®Free1
);
5172 sqlite3VdbeAddOp3(v
, OP_If
, r1
, dest
, jumpIfNull
!=0);
5174 testcase( regFree1
==0 );
5175 testcase( jumpIfNull
==0 );
5180 sqlite3ReleaseTempReg(pParse
, regFree1
);
5181 sqlite3ReleaseTempReg(pParse
, regFree2
);
5185 ** Generate code for a boolean expression such that a jump is made
5186 ** to the label "dest" if the expression is false but execution
5187 ** continues straight thru if the expression is true.
5189 ** If the expression evaluates to NULL (neither true nor false) then
5190 ** jump if jumpIfNull is SQLITE_JUMPIFNULL or fall through if jumpIfNull
5193 void sqlite3ExprIfFalse(Parse
*pParse
, Expr
*pExpr
, int dest
, int jumpIfNull
){
5194 Vdbe
*v
= pParse
->pVdbe
;
5200 assert( jumpIfNull
==SQLITE_JUMPIFNULL
|| jumpIfNull
==0 );
5201 if( NEVER(v
==0) ) return; /* Existence of VDBE checked by caller */
5202 if( pExpr
==0 ) return;
5203 assert( !ExprHasVVAProperty(pExpr
,EP_Immutable
) );
5205 /* The value of pExpr->op and op are related as follows:
5208 ** --------- ----------
5209 ** TK_ISNULL OP_NotNull
5210 ** TK_NOTNULL OP_IsNull
5218 ** For other values of pExpr->op, op is undefined and unused.
5219 ** The value of TK_ and OP_ constants are arranged such that we
5220 ** can compute the mapping above using the following expression.
5221 ** Assert()s verify that the computation is correct.
5223 op
= ((pExpr
->op
+(TK_ISNULL
&1))^1)-(TK_ISNULL
&1);
5225 /* Verify correct alignment of TK_ and OP_ constants
5227 assert( pExpr
->op
!=TK_ISNULL
|| op
==OP_NotNull
);
5228 assert( pExpr
->op
!=TK_NOTNULL
|| op
==OP_IsNull
);
5229 assert( pExpr
->op
!=TK_NE
|| op
==OP_Eq
);
5230 assert( pExpr
->op
!=TK_EQ
|| op
==OP_Ne
);
5231 assert( pExpr
->op
!=TK_LT
|| op
==OP_Ge
);
5232 assert( pExpr
->op
!=TK_LE
|| op
==OP_Gt
);
5233 assert( pExpr
->op
!=TK_GT
|| op
==OP_Le
);
5234 assert( pExpr
->op
!=TK_GE
|| op
==OP_Lt
);
5236 switch( pExpr
->op
){
5239 Expr
*pAlt
= sqlite3ExprSimplifiedAndOr(pExpr
);
5241 sqlite3ExprIfFalse(pParse
, pAlt
, dest
, jumpIfNull
);
5242 }else if( pExpr
->op
==TK_AND
){
5243 testcase( jumpIfNull
==0 );
5244 sqlite3ExprIfFalse(pParse
, pExpr
->pLeft
, dest
, jumpIfNull
);
5245 sqlite3ExprIfFalse(pParse
, pExpr
->pRight
, dest
, jumpIfNull
);
5247 int d2
= sqlite3VdbeMakeLabel(pParse
);
5248 testcase( jumpIfNull
==0 );
5249 sqlite3ExprIfTrue(pParse
, pExpr
->pLeft
, d2
,
5250 jumpIfNull
^SQLITE_JUMPIFNULL
);
5251 sqlite3ExprIfFalse(pParse
, pExpr
->pRight
, dest
, jumpIfNull
);
5252 sqlite3VdbeResolveLabel(v
, d2
);
5257 testcase( jumpIfNull
==0 );
5258 sqlite3ExprIfTrue(pParse
, pExpr
->pLeft
, dest
, jumpIfNull
);
5262 int isNot
; /* IS NOT TRUE or IS NOT FALSE */
5263 int isTrue
; /* IS TRUE or IS NOT TRUE */
5264 testcase( jumpIfNull
==0 );
5265 isNot
= pExpr
->op2
==TK_ISNOT
;
5266 isTrue
= sqlite3ExprTruthValue(pExpr
->pRight
);
5267 testcase( isTrue
&& isNot
);
5268 testcase( !isTrue
&& isNot
);
5269 if( isTrue
^ isNot
){
5270 /* IS TRUE and IS NOT FALSE */
5271 sqlite3ExprIfFalse(pParse
, pExpr
->pLeft
, dest
,
5272 isNot
? 0 : SQLITE_JUMPIFNULL
);
5275 /* IS FALSE and IS NOT TRUE */
5276 sqlite3ExprIfTrue(pParse
, pExpr
->pLeft
, dest
,
5277 isNot
? 0 : SQLITE_JUMPIFNULL
);
5283 testcase( pExpr
->op
==TK_IS
);
5284 testcase( pExpr
->op
==TK_ISNOT
);
5285 op
= (pExpr
->op
==TK_IS
) ? TK_NE
: TK_EQ
;
5286 jumpIfNull
= SQLITE_NULLEQ
;
5287 /* no break */ deliberate_fall_through
5294 if( sqlite3ExprIsVector(pExpr
->pLeft
) ) goto default_expr
;
5295 testcase( jumpIfNull
==0 );
5296 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free1
);
5297 r2
= sqlite3ExprCodeTemp(pParse
, pExpr
->pRight
, ®Free2
);
5298 codeCompare(pParse
, pExpr
->pLeft
, pExpr
->pRight
, op
,
5299 r1
, r2
, dest
, jumpIfNull
,ExprHasProperty(pExpr
,EP_Commuted
));
5300 assert(TK_LT
==OP_Lt
); testcase(op
==OP_Lt
); VdbeCoverageIf(v
,op
==OP_Lt
);
5301 assert(TK_LE
==OP_Le
); testcase(op
==OP_Le
); VdbeCoverageIf(v
,op
==OP_Le
);
5302 assert(TK_GT
==OP_Gt
); testcase(op
==OP_Gt
); VdbeCoverageIf(v
,op
==OP_Gt
);
5303 assert(TK_GE
==OP_Ge
); testcase(op
==OP_Ge
); VdbeCoverageIf(v
,op
==OP_Ge
);
5304 assert(TK_EQ
==OP_Eq
); testcase(op
==OP_Eq
);
5305 VdbeCoverageIf(v
, op
==OP_Eq
&& jumpIfNull
!=SQLITE_NULLEQ
);
5306 VdbeCoverageIf(v
, op
==OP_Eq
&& jumpIfNull
==SQLITE_NULLEQ
);
5307 assert(TK_NE
==OP_Ne
); testcase(op
==OP_Ne
);
5308 VdbeCoverageIf(v
, op
==OP_Ne
&& jumpIfNull
!=SQLITE_NULLEQ
);
5309 VdbeCoverageIf(v
, op
==OP_Ne
&& jumpIfNull
==SQLITE_NULLEQ
);
5310 testcase( regFree1
==0 );
5311 testcase( regFree2
==0 );
5316 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free1
);
5317 sqlite3VdbeAddOp2(v
, op
, r1
, dest
);
5318 testcase( op
==TK_ISNULL
); VdbeCoverageIf(v
, op
==TK_ISNULL
);
5319 testcase( op
==TK_NOTNULL
); VdbeCoverageIf(v
, op
==TK_NOTNULL
);
5320 testcase( regFree1
==0 );
5324 testcase( jumpIfNull
==0 );
5325 exprCodeBetween(pParse
, pExpr
, dest
, sqlite3ExprIfFalse
, jumpIfNull
);
5328 #ifndef SQLITE_OMIT_SUBQUERY
5331 sqlite3ExprCodeIN(pParse
, pExpr
, dest
, dest
);
5333 int destIfNull
= sqlite3VdbeMakeLabel(pParse
);
5334 sqlite3ExprCodeIN(pParse
, pExpr
, dest
, destIfNull
);
5335 sqlite3VdbeResolveLabel(v
, destIfNull
);
5342 if( ExprAlwaysFalse(pExpr
) ){
5343 sqlite3VdbeGoto(v
, dest
);
5344 }else if( ExprAlwaysTrue(pExpr
) ){
5347 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
, ®Free1
);
5348 sqlite3VdbeAddOp3(v
, OP_IfNot
, r1
, dest
, jumpIfNull
!=0);
5350 testcase( regFree1
==0 );
5351 testcase( jumpIfNull
==0 );
5356 sqlite3ReleaseTempReg(pParse
, regFree1
);
5357 sqlite3ReleaseTempReg(pParse
, regFree2
);
5361 ** Like sqlite3ExprIfFalse() except that a copy is made of pExpr before
5362 ** code generation, and that copy is deleted after code generation. This
5363 ** ensures that the original pExpr is unchanged.
5365 void sqlite3ExprIfFalseDup(Parse
*pParse
, Expr
*pExpr
, int dest
,int jumpIfNull
){
5366 sqlite3
*db
= pParse
->db
;
5367 Expr
*pCopy
= sqlite3ExprDup(db
, pExpr
, 0);
5368 if( db
->mallocFailed
==0 ){
5369 sqlite3ExprIfFalse(pParse
, pCopy
, dest
, jumpIfNull
);
5371 sqlite3ExprDelete(db
, pCopy
);
5375 ** Expression pVar is guaranteed to be an SQL variable. pExpr may be any
5376 ** type of expression.
5378 ** If pExpr is a simple SQL value - an integer, real, string, blob
5379 ** or NULL value - then the VDBE currently being prepared is configured
5380 ** to re-prepare each time a new value is bound to variable pVar.
5382 ** Additionally, if pExpr is a simple SQL value and the value is the
5383 ** same as that currently bound to variable pVar, non-zero is returned.
5384 ** Otherwise, if the values are not the same or if pExpr is not a simple
5385 ** SQL value, zero is returned.
5387 static int exprCompareVariable(
5388 const Parse
*pParse
,
5394 sqlite3_value
*pL
, *pR
= 0;
5396 sqlite3ValueFromExpr(pParse
->db
, pExpr
, SQLITE_UTF8
, SQLITE_AFF_BLOB
, &pR
);
5398 iVar
= pVar
->iColumn
;
5399 sqlite3VdbeSetVarmask(pParse
->pVdbe
, iVar
);
5400 pL
= sqlite3VdbeGetBoundValue(pParse
->pReprepare
, iVar
, SQLITE_AFF_BLOB
);
5402 if( sqlite3_value_type(pL
)==SQLITE_TEXT
){
5403 sqlite3_value_text(pL
); /* Make sure the encoding is UTF-8 */
5405 res
= 0==sqlite3MemCompare(pL
, pR
, 0);
5407 sqlite3ValueFree(pR
);
5408 sqlite3ValueFree(pL
);
5415 ** Do a deep comparison of two expression trees. Return 0 if the two
5416 ** expressions are completely identical. Return 1 if they differ only
5417 ** by a COLLATE operator at the top level. Return 2 if there are differences
5418 ** other than the top-level COLLATE operator.
5420 ** If any subelement of pB has Expr.iTable==(-1) then it is allowed
5421 ** to compare equal to an equivalent element in pA with Expr.iTable==iTab.
5423 ** The pA side might be using TK_REGISTER. If that is the case and pB is
5424 ** not using TK_REGISTER but is otherwise equivalent, then still return 0.
5426 ** Sometimes this routine will return 2 even if the two expressions
5427 ** really are equivalent. If we cannot prove that the expressions are
5428 ** identical, we return 2 just to be safe. So if this routine
5429 ** returns 2, then you do not really know for certain if the two
5430 ** expressions are the same. But if you get a 0 or 1 return, then you
5431 ** can be sure the expressions are the same. In the places where
5432 ** this routine is used, it does not hurt to get an extra 2 - that
5433 ** just might result in some slightly slower code. But returning
5434 ** an incorrect 0 or 1 could lead to a malfunction.
5436 ** If pParse is not NULL then TK_VARIABLE terms in pA with bindings in
5437 ** pParse->pReprepare can be matched against literals in pB. The
5438 ** pParse->pVdbe->expmask bitmask is updated for each variable referenced.
5439 ** If pParse is NULL (the normal case) then any TK_VARIABLE term in
5440 ** Argument pParse should normally be NULL. If it is not NULL and pA or
5441 ** pB causes a return value of 2.
5443 int sqlite3ExprCompare(
5444 const Parse
*pParse
,
5450 if( pA
==0 || pB
==0 ){
5451 return pB
==pA
? 0 : 2;
5453 if( pParse
&& pA
->op
==TK_VARIABLE
&& exprCompareVariable(pParse
, pA
, pB
) ){
5456 combinedFlags
= pA
->flags
| pB
->flags
;
5457 if( combinedFlags
& EP_IntValue
){
5458 if( (pA
->flags
&pB
->flags
&EP_IntValue
)!=0 && pA
->u
.iValue
==pB
->u
.iValue
){
5463 if( pA
->op
!=pB
->op
|| pA
->op
==TK_RAISE
){
5464 if( pA
->op
==TK_COLLATE
&& sqlite3ExprCompare(pParse
, pA
->pLeft
,pB
,iTab
)<2 ){
5467 if( pB
->op
==TK_COLLATE
&& sqlite3ExprCompare(pParse
, pA
,pB
->pLeft
,iTab
)<2 ){
5472 assert( !ExprHasProperty(pA
, EP_IntValue
) );
5473 assert( !ExprHasProperty(pB
, EP_IntValue
) );
5475 if( pA
->op
==TK_FUNCTION
|| pA
->op
==TK_AGG_FUNCTION
){
5476 if( sqlite3StrICmp(pA
->u
.zToken
,pB
->u
.zToken
)!=0 ) return 2;
5477 #ifndef SQLITE_OMIT_WINDOWFUNC
5478 assert( pA
->op
==pB
->op
);
5479 if( ExprHasProperty(pA
,EP_WinFunc
)!=ExprHasProperty(pB
,EP_WinFunc
) ){
5482 if( ExprHasProperty(pA
,EP_WinFunc
) ){
5483 if( sqlite3WindowCompare(pParse
, pA
->y
.pWin
, pB
->y
.pWin
, 1)!=0 ){
5488 }else if( pA
->op
==TK_NULL
){
5490 }else if( pA
->op
==TK_COLLATE
){
5491 if( sqlite3_stricmp(pA
->u
.zToken
,pB
->u
.zToken
)!=0 ) return 2;
5494 && pA
->op
!=TK_COLUMN
5495 && pA
->op
!=TK_AGG_COLUMN
5496 && strcmp(pA
->u
.zToken
,pB
->u
.zToken
)!=0
5501 if( (pA
->flags
& (EP_Distinct
|EP_Commuted
))
5502 != (pB
->flags
& (EP_Distinct
|EP_Commuted
)) ) return 2;
5503 if( ALWAYS((combinedFlags
& EP_TokenOnly
)==0) ){
5504 if( combinedFlags
& EP_xIsSelect
) return 2;
5505 if( (combinedFlags
& EP_FixedCol
)==0
5506 && sqlite3ExprCompare(pParse
, pA
->pLeft
, pB
->pLeft
, iTab
) ) return 2;
5507 if( sqlite3ExprCompare(pParse
, pA
->pRight
, pB
->pRight
, iTab
) ) return 2;
5508 if( sqlite3ExprListCompare(pA
->x
.pList
, pB
->x
.pList
, iTab
) ) return 2;
5509 if( pA
->op
!=TK_STRING
5510 && pA
->op
!=TK_TRUEFALSE
5511 && ALWAYS((combinedFlags
& EP_Reduced
)==0)
5513 if( pA
->iColumn
!=pB
->iColumn
) return 2;
5514 if( pA
->op2
!=pB
->op2
&& pA
->op
==TK_TRUTH
) return 2;
5515 if( pA
->op
!=TK_IN
&& pA
->iTable
!=pB
->iTable
&& pA
->iTable
!=iTab
){
5524 ** Compare two ExprList objects. Return 0 if they are identical, 1
5525 ** if they are certainly different, or 2 if it is not possible to
5526 ** determine if they are identical or not.
5528 ** If any subelement of pB has Expr.iTable==(-1) then it is allowed
5529 ** to compare equal to an equivalent element in pA with Expr.iTable==iTab.
5531 ** This routine might return non-zero for equivalent ExprLists. The
5532 ** only consequence will be disabled optimizations. But this routine
5533 ** must never return 0 if the two ExprList objects are different, or
5534 ** a malfunction will result.
5536 ** Two NULL pointers are considered to be the same. But a NULL pointer
5537 ** always differs from a non-NULL pointer.
5539 int sqlite3ExprListCompare(const ExprList
*pA
, const ExprList
*pB
, int iTab
){
5541 if( pA
==0 && pB
==0 ) return 0;
5542 if( pA
==0 || pB
==0 ) return 1;
5543 if( pA
->nExpr
!=pB
->nExpr
) return 1;
5544 for(i
=0; i
<pA
->nExpr
; i
++){
5546 Expr
*pExprA
= pA
->a
[i
].pExpr
;
5547 Expr
*pExprB
= pB
->a
[i
].pExpr
;
5548 if( pA
->a
[i
].sortFlags
!=pB
->a
[i
].sortFlags
) return 1;
5549 if( (res
= sqlite3ExprCompare(0, pExprA
, pExprB
, iTab
)) ) return res
;
5555 ** Like sqlite3ExprCompare() except COLLATE operators at the top-level
5558 int sqlite3ExprCompareSkip(Expr
*pA
,Expr
*pB
, int iTab
){
5559 return sqlite3ExprCompare(0,
5560 sqlite3ExprSkipCollateAndLikely(pA
),
5561 sqlite3ExprSkipCollateAndLikely(pB
),
5566 ** Return non-zero if Expr p can only be true if pNN is not NULL.
5568 ** Or if seenNot is true, return non-zero if Expr p can only be
5569 ** non-NULL if pNN is not NULL
5571 static int exprImpliesNotNull(
5572 const Parse
*pParse
,/* Parsing context */
5573 const Expr
*p
, /* The expression to be checked */
5574 const Expr
*pNN
, /* The expression that is NOT NULL */
5575 int iTab
, /* Table being evaluated */
5576 int seenNot
/* Return true only if p can be any non-NULL value */
5580 if( sqlite3ExprCompare(pParse
, p
, pNN
, iTab
)==0 ){
5581 return pNN
->op
!=TK_NULL
;
5585 if( seenNot
&& ExprHasProperty(p
, EP_xIsSelect
) ) return 0;
5586 assert( ExprUseXSelect(p
) || (p
->x
.pList
!=0 && p
->x
.pList
->nExpr
>0) );
5587 return exprImpliesNotNull(pParse
, p
->pLeft
, pNN
, iTab
, 1);
5591 assert( ExprUseXList(p
) );
5594 assert( pList
->nExpr
==2 );
5595 if( seenNot
) return 0;
5596 if( exprImpliesNotNull(pParse
, pList
->a
[0].pExpr
, pNN
, iTab
, 1)
5597 || exprImpliesNotNull(pParse
, pList
->a
[1].pExpr
, pNN
, iTab
, 1)
5601 return exprImpliesNotNull(pParse
, p
->pLeft
, pNN
, iTab
, 1);
5616 /* no break */ deliberate_fall_through
5621 if( exprImpliesNotNull(pParse
, p
->pRight
, pNN
, iTab
, seenNot
) ) return 1;
5622 /* no break */ deliberate_fall_through
5628 return exprImpliesNotNull(pParse
, p
->pLeft
, pNN
, iTab
, seenNot
);
5631 if( seenNot
) return 0;
5632 if( p
->op2
!=TK_IS
) return 0;
5633 return exprImpliesNotNull(pParse
, p
->pLeft
, pNN
, iTab
, 1);
5637 return exprImpliesNotNull(pParse
, p
->pLeft
, pNN
, iTab
, 1);
5644 ** Return true if we can prove the pE2 will always be true if pE1 is
5645 ** true. Return false if we cannot complete the proof or if pE2 might
5646 ** be false. Examples:
5648 ** pE1: x==5 pE2: x==5 Result: true
5649 ** pE1: x>0 pE2: x==5 Result: false
5650 ** pE1: x=21 pE2: x=21 OR y=43 Result: true
5651 ** pE1: x!=123 pE2: x IS NOT NULL Result: true
5652 ** pE1: x!=?1 pE2: x IS NOT NULL Result: true
5653 ** pE1: x IS NULL pE2: x IS NOT NULL Result: false
5654 ** pE1: x IS ?2 pE2: x IS NOT NULL Reuslt: false
5656 ** When comparing TK_COLUMN nodes between pE1 and pE2, if pE2 has
5657 ** Expr.iTable<0 then assume a table number given by iTab.
5659 ** If pParse is not NULL, then the values of bound variables in pE1 are
5660 ** compared against literal values in pE2 and pParse->pVdbe->expmask is
5661 ** modified to record which bound variables are referenced. If pParse
5662 ** is NULL, then false will be returned if pE1 contains any bound variables.
5664 ** When in doubt, return false. Returning true might give a performance
5665 ** improvement. Returning false might cause a performance reduction, but
5666 ** it will always give the correct answer and is hence always safe.
5668 int sqlite3ExprImpliesExpr(
5669 const Parse
*pParse
,
5674 if( sqlite3ExprCompare(pParse
, pE1
, pE2
, iTab
)==0 ){
5678 && (sqlite3ExprImpliesExpr(pParse
, pE1
, pE2
->pLeft
, iTab
)
5679 || sqlite3ExprImpliesExpr(pParse
, pE1
, pE2
->pRight
, iTab
) )
5683 if( pE2
->op
==TK_NOTNULL
5684 && exprImpliesNotNull(pParse
, pE1
, pE2
->pLeft
, iTab
, 0)
5692 ** This is the Expr node callback for sqlite3ExprImpliesNonNullRow().
5693 ** If the expression node requires that the table at pWalker->iCur
5694 ** have one or more non-NULL column, then set pWalker->eCode to 1 and abort.
5696 ** This routine controls an optimization. False positives (setting
5697 ** pWalker->eCode to 1 when it should not be) are deadly, but false-negatives
5698 ** (never setting pWalker->eCode) is a harmless missed optimization.
5700 static int impliesNotNullRow(Walker
*pWalker
, Expr
*pExpr
){
5701 testcase( pExpr
->op
==TK_AGG_COLUMN
);
5702 testcase( pExpr
->op
==TK_AGG_FUNCTION
);
5703 if( ExprHasProperty(pExpr
, EP_FromJoin
) ) return WRC_Prune
;
5704 switch( pExpr
->op
){
5715 testcase( pExpr
->op
==TK_ISNOT
);
5716 testcase( pExpr
->op
==TK_ISNULL
);
5717 testcase( pExpr
->op
==TK_NOTNULL
);
5718 testcase( pExpr
->op
==TK_IS
);
5719 testcase( pExpr
->op
==TK_OR
);
5720 testcase( pExpr
->op
==TK_VECTOR
);
5721 testcase( pExpr
->op
==TK_CASE
);
5722 testcase( pExpr
->op
==TK_IN
);
5723 testcase( pExpr
->op
==TK_FUNCTION
);
5724 testcase( pExpr
->op
==TK_TRUTH
);
5727 if( pWalker
->u
.iCur
==pExpr
->iTable
){
5734 if( pWalker
->eCode
==0 ){
5735 sqlite3WalkExpr(pWalker
, pExpr
->pLeft
);
5736 if( pWalker
->eCode
){
5738 sqlite3WalkExpr(pWalker
, pExpr
->pRight
);
5744 if( sqlite3WalkExpr(pWalker
, pExpr
->pLeft
)==WRC_Abort
){
5745 assert( pWalker
->eCode
);
5750 /* Virtual tables are allowed to use constraints like x=NULL. So
5751 ** a term of the form x=y does not prove that y is not null if x
5752 ** is the column of a virtual table */
5759 Expr
*pLeft
= pExpr
->pLeft
;
5760 Expr
*pRight
= pExpr
->pRight
;
5761 testcase( pExpr
->op
==TK_EQ
);
5762 testcase( pExpr
->op
==TK_NE
);
5763 testcase( pExpr
->op
==TK_LT
);
5764 testcase( pExpr
->op
==TK_LE
);
5765 testcase( pExpr
->op
==TK_GT
);
5766 testcase( pExpr
->op
==TK_GE
);
5767 /* The y.pTab=0 assignment in wherecode.c always happens after the
5768 ** impliesNotNullRow() test */
5769 assert( pLeft
->op
!=TK_COLUMN
|| ExprUseYTab(pLeft
) );
5770 assert( pRight
->op
!=TK_COLUMN
|| ExprUseYTab(pRight
) );
5771 if( (pLeft
->op
==TK_COLUMN
5773 && IsVirtual(pLeft
->y
.pTab
))
5774 || (pRight
->op
==TK_COLUMN
5775 && pRight
->y
.pTab
!=0
5776 && IsVirtual(pRight
->y
.pTab
))
5780 /* no break */ deliberate_fall_through
5783 return WRC_Continue
;
5788 ** Return true (non-zero) if expression p can only be true if at least
5789 ** one column of table iTab is non-null. In other words, return true
5790 ** if expression p will always be NULL or false if every column of iTab
5793 ** False negatives are acceptable. In other words, it is ok to return
5794 ** zero even if expression p will never be true of every column of iTab
5795 ** is NULL. A false negative is merely a missed optimization opportunity.
5797 ** False positives are not allowed, however. A false positive may result
5798 ** in an incorrect answer.
5800 ** Terms of p that are marked with EP_FromJoin (and hence that come from
5801 ** the ON or USING clauses of LEFT JOINS) are excluded from the analysis.
5803 ** This routine is used to check if a LEFT JOIN can be converted into
5804 ** an ordinary JOIN. The p argument is the WHERE clause. If the WHERE
5805 ** clause requires that some column of the right table of the LEFT JOIN
5806 ** be non-NULL, then the LEFT JOIN can be safely converted into an
5809 int sqlite3ExprImpliesNonNullRow(Expr
*p
, int iTab
){
5811 p
= sqlite3ExprSkipCollateAndLikely(p
);
5812 if( p
==0 ) return 0;
5813 if( p
->op
==TK_NOTNULL
){
5816 while( p
->op
==TK_AND
){
5817 if( sqlite3ExprImpliesNonNullRow(p
->pLeft
, iTab
) ) return 1;
5821 w
.xExprCallback
= impliesNotNullRow
;
5822 w
.xSelectCallback
= 0;
5823 w
.xSelectCallback2
= 0;
5826 sqlite3WalkExpr(&w
, p
);
5831 ** An instance of the following structure is used by the tree walker
5832 ** to determine if an expression can be evaluated by reference to the
5833 ** index only, without having to do a search for the corresponding
5834 ** table entry. The IdxCover.pIdx field is the index. IdxCover.iCur
5835 ** is the cursor for the table.
5838 Index
*pIdx
; /* The index to be tested for coverage */
5839 int iCur
; /* Cursor number for the table corresponding to the index */
5843 ** Check to see if there are references to columns in table
5844 ** pWalker->u.pIdxCover->iCur can be satisfied using the index
5845 ** pWalker->u.pIdxCover->pIdx.
5847 static int exprIdxCover(Walker
*pWalker
, Expr
*pExpr
){
5848 if( pExpr
->op
==TK_COLUMN
5849 && pExpr
->iTable
==pWalker
->u
.pIdxCover
->iCur
5850 && sqlite3TableColumnToIndex(pWalker
->u
.pIdxCover
->pIdx
, pExpr
->iColumn
)<0
5855 return WRC_Continue
;
5859 ** Determine if an index pIdx on table with cursor iCur contains will
5860 ** the expression pExpr. Return true if the index does cover the
5861 ** expression and false if the pExpr expression references table columns
5862 ** that are not found in the index pIdx.
5864 ** An index covering an expression means that the expression can be
5865 ** evaluated using only the index and without having to lookup the
5866 ** corresponding table entry.
5868 int sqlite3ExprCoveredByIndex(
5869 Expr
*pExpr
, /* The index to be tested */
5870 int iCur
, /* The cursor number for the corresponding table */
5871 Index
*pIdx
/* The index that might be used for coverage */
5874 struct IdxCover xcov
;
5875 memset(&w
, 0, sizeof(w
));
5878 w
.xExprCallback
= exprIdxCover
;
5879 w
.u
.pIdxCover
= &xcov
;
5880 sqlite3WalkExpr(&w
, pExpr
);
5885 /* Structure used to pass information throught the Walker in order to
5886 ** implement sqlite3ReferencesSrcList().
5889 sqlite3
*db
; /* Database connection used for sqlite3DbRealloc() */
5890 SrcList
*pRef
; /* Looking for references to these tables */
5891 i64 nExclude
; /* Number of tables to exclude from the search */
5892 int *aiExclude
; /* Cursor IDs for tables to exclude from the search */
5896 ** Walker SELECT callbacks for sqlite3ReferencesSrcList().
5898 ** When entering a new subquery on the pExpr argument, add all FROM clause
5899 ** entries for that subquery to the exclude list.
5901 ** When leaving the subquery, remove those entries from the exclude list.
5903 static int selectRefEnter(Walker
*pWalker
, Select
*pSelect
){
5904 struct RefSrcList
*p
= pWalker
->u
.pRefSrcList
;
5905 SrcList
*pSrc
= pSelect
->pSrc
;
5908 if( pSrc
->nSrc
==0 ) return WRC_Continue
;
5910 p
->nExclude
+= pSrc
->nSrc
;
5911 piNew
= sqlite3DbRealloc(p
->db
, p
->aiExclude
, p
->nExclude
*sizeof(int));
5916 p
->aiExclude
= piNew
;
5918 for(i
=0; i
<pSrc
->nSrc
; i
++, j
++){
5919 p
->aiExclude
[j
] = pSrc
->a
[i
].iCursor
;
5921 return WRC_Continue
;
5923 static void selectRefLeave(Walker
*pWalker
, Select
*pSelect
){
5924 struct RefSrcList
*p
= pWalker
->u
.pRefSrcList
;
5925 SrcList
*pSrc
= pSelect
->pSrc
;
5927 assert( p
->nExclude
>=pSrc
->nSrc
);
5928 p
->nExclude
-= pSrc
->nSrc
;
5932 /* This is the Walker EXPR callback for sqlite3ReferencesSrcList().
5934 ** Set the 0x01 bit of pWalker->eCode if there is a reference to any
5935 ** of the tables shown in RefSrcList.pRef.
5937 ** Set the 0x02 bit of pWalker->eCode if there is a reference to a
5938 ** table is in neither RefSrcList.pRef nor RefSrcList.aiExclude.
5940 static int exprRefToSrcList(Walker
*pWalker
, Expr
*pExpr
){
5941 if( pExpr
->op
==TK_COLUMN
5942 || pExpr
->op
==TK_AGG_COLUMN
5945 struct RefSrcList
*p
= pWalker
->u
.pRefSrcList
;
5946 SrcList
*pSrc
= p
->pRef
;
5947 int nSrc
= pSrc
? pSrc
->nSrc
: 0;
5948 for(i
=0; i
<nSrc
; i
++){
5949 if( pExpr
->iTable
==pSrc
->a
[i
].iCursor
){
5950 pWalker
->eCode
|= 1;
5951 return WRC_Continue
;
5954 for(i
=0; i
<p
->nExclude
&& p
->aiExclude
[i
]!=pExpr
->iTable
; i
++){}
5955 if( i
>=p
->nExclude
){
5956 pWalker
->eCode
|= 2;
5959 return WRC_Continue
;
5963 ** Check to see if pExpr references any tables in pSrcList.
5964 ** Possible return values:
5966 ** 1 pExpr does references a table in pSrcList.
5968 ** 0 pExpr references some table that is not defined in either
5969 ** pSrcList or in subqueries of pExpr itself.
5971 ** -1 pExpr only references no tables at all, or it only
5972 ** references tables defined in subqueries of pExpr itself.
5974 ** As currently used, pExpr is always an aggregate function call. That
5975 ** fact is exploited for efficiency.
5977 int sqlite3ReferencesSrcList(Parse
*pParse
, Expr
*pExpr
, SrcList
*pSrcList
){
5979 struct RefSrcList x
;
5980 memset(&w
, 0, sizeof(w
));
5981 memset(&x
, 0, sizeof(x
));
5982 w
.xExprCallback
= exprRefToSrcList
;
5983 w
.xSelectCallback
= selectRefEnter
;
5984 w
.xSelectCallback2
= selectRefLeave
;
5985 w
.u
.pRefSrcList
= &x
;
5988 assert( pExpr
->op
==TK_AGG_FUNCTION
);
5989 assert( ExprUseXList(pExpr
) );
5990 sqlite3WalkExprList(&w
, pExpr
->x
.pList
);
5991 #ifndef SQLITE_OMIT_WINDOWFUNC
5992 if( ExprHasProperty(pExpr
, EP_WinFunc
) ){
5993 sqlite3WalkExpr(&w
, pExpr
->y
.pWin
->pFilter
);
5996 sqlite3DbFree(pParse
->db
, x
.aiExclude
);
5997 if( w
.eCode
& 0x01 ){
5999 }else if( w
.eCode
){
6007 ** This is a Walker expression node callback.
6009 ** For Expr nodes that contain pAggInfo pointers, make sure the AggInfo
6010 ** object that is referenced does not refer directly to the Expr. If
6011 ** it does, make a copy. This is done because the pExpr argument is
6012 ** subject to change.
6014 ** The copy is stored on pParse->pConstExpr with a register number of 0.
6015 ** This will cause the expression to be deleted automatically when the
6016 ** Parse object is destroyed, but the zero register number means that it
6017 ** will not generate any code in the preamble.
6019 static int agginfoPersistExprCb(Walker
*pWalker
, Expr
*pExpr
){
6020 if( ALWAYS(!ExprHasProperty(pExpr
, EP_TokenOnly
|EP_Reduced
))
6021 && pExpr
->pAggInfo
!=0
6023 AggInfo
*pAggInfo
= pExpr
->pAggInfo
;
6024 int iAgg
= pExpr
->iAgg
;
6025 Parse
*pParse
= pWalker
->pParse
;
6026 sqlite3
*db
= pParse
->db
;
6027 assert( pExpr
->op
==TK_AGG_COLUMN
|| pExpr
->op
==TK_AGG_FUNCTION
);
6028 if( pExpr
->op
==TK_AGG_COLUMN
){
6029 assert( iAgg
>=0 && iAgg
<pAggInfo
->nColumn
);
6030 if( pAggInfo
->aCol
[iAgg
].pCExpr
==pExpr
){
6031 pExpr
= sqlite3ExprDup(db
, pExpr
, 0);
6033 pAggInfo
->aCol
[iAgg
].pCExpr
= pExpr
;
6034 sqlite3ExprDeferredDelete(pParse
, pExpr
);
6038 assert( iAgg
>=0 && iAgg
<pAggInfo
->nFunc
);
6039 if( pAggInfo
->aFunc
[iAgg
].pFExpr
==pExpr
){
6040 pExpr
= sqlite3ExprDup(db
, pExpr
, 0);
6042 pAggInfo
->aFunc
[iAgg
].pFExpr
= pExpr
;
6043 sqlite3ExprDeferredDelete(pParse
, pExpr
);
6048 return WRC_Continue
;
6052 ** Initialize a Walker object so that will persist AggInfo entries referenced
6053 ** by the tree that is walked.
6055 void sqlite3AggInfoPersistWalkerInit(Walker
*pWalker
, Parse
*pParse
){
6056 memset(pWalker
, 0, sizeof(*pWalker
));
6057 pWalker
->pParse
= pParse
;
6058 pWalker
->xExprCallback
= agginfoPersistExprCb
;
6059 pWalker
->xSelectCallback
= sqlite3SelectWalkNoop
;
6063 ** Add a new element to the pAggInfo->aCol[] array. Return the index of
6064 ** the new element. Return a negative number if malloc fails.
6066 static int addAggInfoColumn(sqlite3
*db
, AggInfo
*pInfo
){
6068 pInfo
->aCol
= sqlite3ArrayAllocate(
6071 sizeof(pInfo
->aCol
[0]),
6079 ** Add a new element to the pAggInfo->aFunc[] array. Return the index of
6080 ** the new element. Return a negative number if malloc fails.
6082 static int addAggInfoFunc(sqlite3
*db
, AggInfo
*pInfo
){
6084 pInfo
->aFunc
= sqlite3ArrayAllocate(
6087 sizeof(pInfo
->aFunc
[0]),
6095 ** This is the xExprCallback for a tree walker. It is used to
6096 ** implement sqlite3ExprAnalyzeAggregates(). See sqlite3ExprAnalyzeAggregates
6097 ** for additional information.
6099 static int analyzeAggregate(Walker
*pWalker
, Expr
*pExpr
){
6101 NameContext
*pNC
= pWalker
->u
.pNC
;
6102 Parse
*pParse
= pNC
->pParse
;
6103 SrcList
*pSrcList
= pNC
->pSrcList
;
6104 AggInfo
*pAggInfo
= pNC
->uNC
.pAggInfo
;
6106 assert( pNC
->ncFlags
& NC_UAggInfo
);
6107 switch( pExpr
->op
){
6110 testcase( pExpr
->op
==TK_AGG_COLUMN
);
6111 testcase( pExpr
->op
==TK_COLUMN
);
6112 /* Check to see if the column is in one of the tables in the FROM
6113 ** clause of the aggregate query */
6114 if( ALWAYS(pSrcList
!=0) ){
6115 SrcItem
*pItem
= pSrcList
->a
;
6116 for(i
=0; i
<pSrcList
->nSrc
; i
++, pItem
++){
6117 struct AggInfo_col
*pCol
;
6118 assert( !ExprHasProperty(pExpr
, EP_TokenOnly
|EP_Reduced
) );
6119 if( pExpr
->iTable
==pItem
->iCursor
){
6120 /* If we reach this point, it means that pExpr refers to a table
6121 ** that is in the FROM clause of the aggregate query.
6123 ** Make an entry for the column in pAggInfo->aCol[] if there
6124 ** is not an entry there already.
6127 pCol
= pAggInfo
->aCol
;
6128 for(k
=0; k
<pAggInfo
->nColumn
; k
++, pCol
++){
6129 if( pCol
->iTable
==pExpr
->iTable
&&
6130 pCol
->iColumn
==pExpr
->iColumn
){
6134 if( (k
>=pAggInfo
->nColumn
)
6135 && (k
= addAggInfoColumn(pParse
->db
, pAggInfo
))>=0
6137 pCol
= &pAggInfo
->aCol
[k
];
6138 assert( ExprUseYTab(pExpr
) );
6139 pCol
->pTab
= pExpr
->y
.pTab
;
6140 pCol
->iTable
= pExpr
->iTable
;
6141 pCol
->iColumn
= pExpr
->iColumn
;
6142 pCol
->iMem
= ++pParse
->nMem
;
6143 pCol
->iSorterColumn
= -1;
6144 pCol
->pCExpr
= pExpr
;
6145 if( pAggInfo
->pGroupBy
){
6147 ExprList
*pGB
= pAggInfo
->pGroupBy
;
6148 struct ExprList_item
*pTerm
= pGB
->a
;
6150 for(j
=0; j
<n
; j
++, pTerm
++){
6151 Expr
*pE
= pTerm
->pExpr
;
6152 if( pE
->op
==TK_COLUMN
&& pE
->iTable
==pExpr
->iTable
&&
6153 pE
->iColumn
==pExpr
->iColumn
){
6154 pCol
->iSorterColumn
= j
;
6159 if( pCol
->iSorterColumn
<0 ){
6160 pCol
->iSorterColumn
= pAggInfo
->nSortingColumn
++;
6163 /* There is now an entry for pExpr in pAggInfo->aCol[] (either
6164 ** because it was there before or because we just created it).
6165 ** Convert the pExpr to be a TK_AGG_COLUMN referring to that
6166 ** pAggInfo->aCol[] entry.
6168 ExprSetVVAProperty(pExpr
, EP_NoReduce
);
6169 pExpr
->pAggInfo
= pAggInfo
;
6170 pExpr
->op
= TK_AGG_COLUMN
;
6171 pExpr
->iAgg
= (i16
)k
;
6173 } /* endif pExpr->iTable==pItem->iCursor */
6174 } /* end loop over pSrcList */
6178 case TK_AGG_FUNCTION
: {
6179 if( (pNC
->ncFlags
& NC_InAggFunc
)==0
6180 && pWalker
->walkerDepth
==pExpr
->op2
6182 /* Check to see if pExpr is a duplicate of another aggregate
6183 ** function that is already in the pAggInfo structure
6185 struct AggInfo_func
*pItem
= pAggInfo
->aFunc
;
6186 for(i
=0; i
<pAggInfo
->nFunc
; i
++, pItem
++){
6187 if( pItem
->pFExpr
==pExpr
) break;
6188 if( sqlite3ExprCompare(0, pItem
->pFExpr
, pExpr
, -1)==0 ){
6192 if( i
>=pAggInfo
->nFunc
){
6193 /* pExpr is original. Make a new entry in pAggInfo->aFunc[]
6195 u8 enc
= ENC(pParse
->db
);
6196 i
= addAggInfoFunc(pParse
->db
, pAggInfo
);
6198 assert( !ExprHasProperty(pExpr
, EP_xIsSelect
) );
6199 pItem
= &pAggInfo
->aFunc
[i
];
6200 pItem
->pFExpr
= pExpr
;
6201 pItem
->iMem
= ++pParse
->nMem
;
6202 assert( ExprUseUToken(pExpr
) );
6203 pItem
->pFunc
= sqlite3FindFunction(pParse
->db
,
6205 pExpr
->x
.pList
? pExpr
->x
.pList
->nExpr
: 0, enc
, 0);
6206 if( pExpr
->flags
& EP_Distinct
){
6207 pItem
->iDistinct
= pParse
->nTab
++;
6209 pItem
->iDistinct
= -1;
6213 /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry
6215 assert( !ExprHasProperty(pExpr
, EP_TokenOnly
|EP_Reduced
) );
6216 ExprSetVVAProperty(pExpr
, EP_NoReduce
);
6217 pExpr
->iAgg
= (i16
)i
;
6218 pExpr
->pAggInfo
= pAggInfo
;
6221 return WRC_Continue
;
6225 return WRC_Continue
;
6229 ** Analyze the pExpr expression looking for aggregate functions and
6230 ** for variables that need to be added to AggInfo object that pNC->pAggInfo
6231 ** points to. Additional entries are made on the AggInfo object as
6234 ** This routine should only be called after the expression has been
6235 ** analyzed by sqlite3ResolveExprNames().
6237 void sqlite3ExprAnalyzeAggregates(NameContext
*pNC
, Expr
*pExpr
){
6239 w
.xExprCallback
= analyzeAggregate
;
6240 w
.xSelectCallback
= sqlite3WalkerDepthIncrease
;
6241 w
.xSelectCallback2
= sqlite3WalkerDepthDecrease
;
6245 assert( pNC
->pSrcList
!=0 );
6246 sqlite3WalkExpr(&w
, pExpr
);
6250 ** Call sqlite3ExprAnalyzeAggregates() for every expression in an
6251 ** expression list. Return the number of errors.
6253 ** If an error is found, the analysis is cut short.
6255 void sqlite3ExprAnalyzeAggList(NameContext
*pNC
, ExprList
*pList
){
6256 struct ExprList_item
*pItem
;
6259 for(pItem
=pList
->a
, i
=0; i
<pList
->nExpr
; i
++, pItem
++){
6260 sqlite3ExprAnalyzeAggregates(pNC
, pItem
->pExpr
);
6266 ** Allocate a single new register for use to hold some intermediate result.
6268 int sqlite3GetTempReg(Parse
*pParse
){
6269 if( pParse
->nTempReg
==0 ){
6270 return ++pParse
->nMem
;
6272 return pParse
->aTempReg
[--pParse
->nTempReg
];
6276 ** Deallocate a register, making available for reuse for some other
6279 void sqlite3ReleaseTempReg(Parse
*pParse
, int iReg
){
6281 sqlite3VdbeReleaseRegisters(pParse
, iReg
, 1, 0, 0);
6282 if( pParse
->nTempReg
<ArraySize(pParse
->aTempReg
) ){
6283 pParse
->aTempReg
[pParse
->nTempReg
++] = iReg
;
6289 ** Allocate or deallocate a block of nReg consecutive registers.
6291 int sqlite3GetTempRange(Parse
*pParse
, int nReg
){
6293 if( nReg
==1 ) return sqlite3GetTempReg(pParse
);
6294 i
= pParse
->iRangeReg
;
6295 n
= pParse
->nRangeReg
;
6297 pParse
->iRangeReg
+= nReg
;
6298 pParse
->nRangeReg
-= nReg
;
6301 pParse
->nMem
+= nReg
;
6305 void sqlite3ReleaseTempRange(Parse
*pParse
, int iReg
, int nReg
){
6307 sqlite3ReleaseTempReg(pParse
, iReg
);
6310 sqlite3VdbeReleaseRegisters(pParse
, iReg
, nReg
, 0, 0);
6311 if( nReg
>pParse
->nRangeReg
){
6312 pParse
->nRangeReg
= nReg
;
6313 pParse
->iRangeReg
= iReg
;
6318 ** Mark all temporary registers as being unavailable for reuse.
6320 ** Always invoke this procedure after coding a subroutine or co-routine
6321 ** that might be invoked from other parts of the code, to ensure that
6322 ** the sub/co-routine does not use registers in common with the code that
6323 ** invokes the sub/co-routine.
6325 void sqlite3ClearTempRegCache(Parse
*pParse
){
6326 pParse
->nTempReg
= 0;
6327 pParse
->nRangeReg
= 0;
6331 ** Validate that no temporary register falls within the range of
6332 ** iFirst..iLast, inclusive. This routine is only call from within assert()
6336 int sqlite3NoTempsInRange(Parse
*pParse
, int iFirst
, int iLast
){
6338 if( pParse
->nRangeReg
>0
6339 && pParse
->iRangeReg
+pParse
->nRangeReg
> iFirst
6340 && pParse
->iRangeReg
<= iLast
6344 for(i
=0; i
<pParse
->nTempReg
; i
++){
6345 if( pParse
->aTempReg
[i
]>=iFirst
&& pParse
->aTempReg
[i
]<=iLast
){
6351 #endif /* SQLITE_DEBUG */